{"version":3,"sources":["jsdelivr-header.js","/npm/babel-plugin-flow-react-proptypes@26.0.0/lib/index.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,ACNA,aAEA,IAAI,MAAQ,QAAQ,UAEhB,oBAAsB,uBAAuB,QAAQ,yBAErD,kBAAoB,QAAQ,sBAEhC,SAAS,uBAAuB,GAAO,OAAO,GAAO,EAAI,WAAa,EAAM,CAAE,QAAW,EAAO,CAEhG,SAAS,2BAA2B,GAAK,GAAsB,oBAAX,QAAgD,MAAtB,EAAE,OAAO,UAAmB,CAAE,GAAI,MAAM,QAAQ,KAAO,EAAI,4BAA4B,IAAK,CAAE,IAAI,EAAI,EAAO,EAAI,WAAc,EAAG,MAAO,CAAE,EAAG,EAAG,EAAG,WAAe,OAAI,GAAK,EAAE,OAAe,CAAE,MAAM,GAAe,CAAE,MAAM,EAAO,MAAO,EAAE,KAAQ,EAAG,EAAG,SAAW,GAAO,MAAM,CAAK,EAAG,EAAG,EAAK,CAAE,MAAM,IAAI,UAAU,wIAA0I,CAAE,IAAI,EAA6C,EAAzC,GAAmB,EAAM,GAAS,EAAY,MAAO,CAAE,EAAG,WAAe,EAAK,EAAE,OAAO,WAAa,EAAG,EAAG,WAAe,IAAI,EAAO,EAAG,OAAsC,OAA9B,EAAmB,EAAK,KAAa,CAAM,EAAG,EAAG,SAAW,GAAO,GAAS,EAAM,EAAM,CAAK,EAAG,EAAG,WAAe,IAAW,GAAoC,MAAhB,EAAW,QAAW,EAAW,QAAK,CAAE,QAAU,GAAI,EAAQ,MAAM,CAAK,CAAE,EAAK,CAE14B,SAAS,eAAe,EAAK,GAAK,OAAO,gBAAgB,IAAQ,sBAAsB,EAAK,IAAM,4BAA4B,EAAK,IAAM,kBAAoB,CAE7J,SAAS,mBAAqB,MAAM,IAAI,UAAU,4IAA8I,CAEhM,SAAS,4BAA4B,EAAG,GAAU,GAAK,EAAL,CAAgB,GAAiB,iBAAN,EAAgB,OAAO,kBAAkB,EAAG,GAAS,IAAI,EAAI,OAAO,UAAU,SAAS,KAAK,GAAG,MAAM,GAAI,GAAiE,MAAnD,WAAN,GAAkB,EAAE,cAAa,EAAI,EAAE,YAAY,MAAgB,QAAN,GAAqB,QAAN,EAAoB,MAAM,KAAK,GAAc,cAAN,GAAqB,2CAA2C,KAAK,GAAW,kBAAkB,EAAG,QAAzG,CAA7O,CAA+V,CAE/Z,SAAS,kBAAkB,EAAK,IAAkB,MAAP,GAAe,EAAM,EAAI,UAAQ,EAAM,EAAI,QAAQ,IAAK,IAAI,EAAI,EAAG,EAAO,IAAI,MAAM,GAAM,EAAI,EAAK,IAAO,EAAK,GAAK,EAAI,GAAM,OAAO,CAAM,CAEtL,SAAS,sBAAsB,EAAK,GAAK,GAAsB,oBAAX,QAA4B,OAAO,YAAY,OAAO,GAAjE,CAAgF,IAAI,EAAO,GAAQ,GAAK,EAAU,GAAK,EAAW,OAAK,EAAW,IAAM,IAAK,IAAiC,EAA7B,EAAK,EAAI,OAAO,cAAmB,GAAM,EAAK,EAAG,QAAQ,QAAoB,EAAK,KAAK,EAAG,QAAY,GAAK,EAAK,SAAW,GAA3D,GAAK,GAAkE,CAAE,MAAO,GAAO,GAAK,EAAM,EAAK,CAAK,CAAE,QAAU,IAAW,GAAsB,MAAhB,EAAW,QAAW,EAAW,QAAK,CAAE,QAAU,GAAI,EAAI,MAAM,CAAI,CAAE,CAAE,OAAO,CAA3W,CAAiX,CAExe,SAAS,gBAAgB,GAAO,GAAI,MAAM,QAAQ,GAAM,OAAO,CAAK,CAGpE,IAAI,cAAgB,CAAC,EAEjB,cAAgB,CAAC,EAEjB,aAAe,CAAC,EAChB,cAAgB,CAAC,EACjB,UAAW,EACX,uBAAwB,EACxB,gBAAkB,uCAIlB,YAAc,wCAOd,KAAO,cAEP,uBAAyB,SAAgC,GAC3D,OAAO,EAAI,oBAA6B,SAAG,EAAM,cAAe,cAClE,EAEI,0BAA4B,SAAmC,GACjE,IAAI,EAAQ,KAEZ,GAAI,EAAe,YAAsC,0BAAxB,EAAe,MAA4D,+BAAxB,EAAe,MAAiE,sBAAxB,EAAe,KACzJ,EAAQ,uBAAuB,OAC1B,IAAiC,MAA7B,EAAe,YAA6C,MAAvB,EAAe,KAG7D,MAAM,IAAI,MAAM,yDAAyD,OAAO,MAAM,eAFtF,EAAI,MAAM,QAAQ,kEAAmE,EAGvF,CAEA,OAAO,CACT,EAkrBA,SAAS,kBAAkB,GACzB,IAAK,EAAM,OAAO,KAClB,IAAK,EAAK,oBAAqB,OAAO,KACtC,IAAI,EAAa,EAAK,oBAEtB,OAAiC,IAA7B,EAAW,OAAO,QAEkB,IAA7B,EAAW,OAAO,QAEW,IAA7B,EAAW,OAAO,OAHpB,EAAW,OAAO,GAOpB,IACT,CAEA,SAAS,oBAAoB,GAC3B,IAAK,EAAM,OAAO,KAClB,IAAK,EAAK,oBAAqB,OAAO,KACtC,IAAI,EAAa,EAAK,oBAEtB,OAAiC,IAA7B,EAAW,OAAO,OACb,EAAW,OAAO,GAGpB,IACT,CA1sBA,OAAO,QAAU,SAA4B,GAC3C,IAAI,EAAI,EAAM,MACV,EAAO,CAAC,EAEZ,SAAS,IACP,OAA6B,IAAtB,EAAK,eAA0B,EAAK,QAC7C,CAEA,IAAI,EAAe,CACjB,MAAO,EAAM,SAAS,oCAAqC,CACzD,WAAY,WAEd,QAAS,EAAM,SAAS,8CAA+C,CACrE,WAAY,WAEd,QAAW,EAAM,SAAS,+BAAgC,CACxD,WAAY,WAEd,eAAgB,EAAM,SAAS,iBAC/B,aAAc,EAAM,SAAS,uBAG/B,SAAS,EAAc,EAAM,GAC3B,IAAI,EAAY,EAAK,KACjB,OAAqB,IAAd,EAAuB,UAAY,EAC1C,EAAO,EAAK,KACZ,EAAa,EAAK,MAClB,OAAuB,IAAf,EAAwB,EAAO,EACvC,EAAW,EAAK,SAChB,EAAM,EAAE,WACR,EAAO,EAAE,cACT,EAAM,QAAQ,OAAO,EAAU,KAAK,OAAO,GAE/C,GAAI,IAAmB,CACrB,IAAK,aAAa,GAAM,CACtB,IAAI,EAAY,EAAM,QAAQ,iBAAkB,KAC5C,EAAa,EAAK,QAAQ,iBAAkB,KAChD,aAAa,GAAO,EACpB,IAAI,EAAQ,KAmBZ,GAjBa,YAAT,EACF,EAAQ,EAAsB,QAAE,CAC9B,KAAM,EAAI,KAEM,UAAT,IAEP,EADE,IAAc,EACR,EAAa,MAAM,CACzB,MAAO,EAAI,KAGL,EAAa,QAAQ,CAC3B,MAAO,EAAI,GACX,OAAQ,EAAI,MAKd,EAAO,CACT,EAAM,OAAO,MAAQ,EACrB,IAAI,EAAQ,EAEZ,GACE,GAAI,EAAM,MAA4B,YAApB,EAAM,KAAK,KAAoB,YAC1C,EAAQ,EAAM,YAEnB,GAAS,EAAM,KAAK,MACtB,EAAM,KAAK,KAAK,KAAK,EAEzB,CACF,CAEA,OAAO,EAAI,aAAa,GAC1B,CACE,MAAa,YAAT,EACK,EAAa,eAAe,CACjC,KAAM,EAAK,KACV,WACe,UAAT,EACF,EAAa,aAAa,CAC/B,KAAM,EAAK,GACX,KAAM,EAAI,KACT,gBAJE,CAOX,CAEA,SAAS,EAAuB,EAAM,EAAM,GAC1C,IAAI,EAAS,EAAc,EAAM,CAC/B,KAAM,UACN,KAAM,YACN,SAAU,eAEZ,IAAK,EAAM,OAAO,EAClB,IAAI,EAAa,EAAE,iBAAiB,EAAQ,EAAE,WAAW,IACzD,OAAK,EACE,EAAE,iBAAiB,EAAY,EAAE,WAAW,eAD3B,CAE1B,CAEA,SAAS,EAAkB,EAAM,GAC/B,IAAI,EAAkB,UAAU,OAAS,QAAsB,IAAjB,UAAU,GAAmB,UAAU,GAAK,KAM1F,GAJK,IACH,EAAkB,EAAE,WAAW,KAG5B,EAAK,UAAY,IAAmB,CACvC,IAAK,EAAK,WAAW,YAAa,OAClC,IAAI,EAAO,EAAK,WAAW,KAAK,KAC5B,EAAY,EAAE,uBAAuB,KAAM,CAAC,EAAE,gBAAgB,EAAE,WAAW,GAAa,KAC5F,EAAU,OAAQ,EAClB,EAAK,KAAK,EACZ,KAAO,CAEL,IAAI,EAAa,EAAE,oBAAoB,EAAE,eAAe,EAAE,iBAAiB,EAAE,WAAW,UAAW,EAAE,WAAW,mBAAoB,CAAC,EAAE,WAAW,WAAY,EAAE,cAAc,GAAa,EAAE,iBAAiB,CAAC,EAAE,eAAe,EAAE,WAAW,SAAU,GAAkB,EAAE,eAAe,EAAE,WAAW,gBAAiB,EAAE,gBAAe,SAGrU,EAD0B,EAAE,iBAAiB,MAAO,EAAE,gBAAgB,SAAU,EAAE,WAAW,YAAa,EAAE,cAAc,cAG9H,GAAI,EAAK,SAAU,CACjB,IAAI,EAAiB,EAAE,gBAAgB,IAAK,KAC5C,EAAS,EAAE,kBAAkB,KAAM,EAAgB,EACrD,CAEA,IAAI,EAAwB,EAAE,YAAY,EAAQ,GAClD,EAAK,YAAY,EACnB,CACF,CAEA,IAAI,EAAiB,CAAC,EAEtB,SAAS,IAIP,IAAK,EAAK,SAAU,OAAO,KAE3B,IAAI,EAAwC,iBAAlB,EAAK,SAAwB,EAAK,SAAW,YAWvE,OATK,EAAe,KAClB,EAAe,GAAgB,EAAM,SAAS,EAAc,CAC1D,oBAAoB,KAKR,EAAe,GAAc,CAAC,GAAG,UAGnD,CAEA,SAAS,EAAe,GACtB,IAAI,EAAY,IAChB,OAAK,EACa,EAAE,sBAAsB,EAAW,EAAE,cAAe,GAD/C,CAGzB,CAEA,IAiBI,EAAuB,SAA8B,EAAM,EAAY,GACzE,IAAI,EAAW,KACX,EAAW,KAyBf,OAxBA,EAAK,SAAS,CACZ,cAAe,SAAuB,GAChC,EAAK,KAAK,KAAO,EAAK,KAAK,IAAI,OAAS,IAC1C,EAAW,EAAK,KAAK,MACrB,EAAW,EAEf,IAGG,GACH,EAAK,WAAW,SAAS,CACvB,oBAAqB,SAA6B,GAC3C,EAAK,KAAK,YAAe,EAAK,KAAK,WAAW,MAI/C,EAAK,KAAK,WAAW,KAAK,QAAU,EAAK,KAAK,WAAW,KAAK,UAAY,EAAK,KAAK,WAAW,KAAK,OAAO,OAAS,GAAc,EAAK,KAAK,WAAW,KAAK,SAAS,OAAS,IAChL,EAAW,EAAK,KAAK,WAAW,MAChC,EAAW,EAEf,IAIG,CAAC,EAAU,EACpB,EA+DI,EAAsB,SAA6B,EAAM,EAAM,EAAW,GAC5E,IAAI,EAEA,EAAY,KAEhB,GAA0B,iBAAf,GAGT,GAFA,EAAY,EAAE,WAAW,GAErB,EAAM,CACR,IAAI,EAAQ,EAAE,qBAAqB,IAAK,EAAE,iBAAiB,EAAE,WAAW,GAAO,EAAE,WAAW,IAAa,GAEvF,cAAd,IACF,EAAQ,EAAe,IAGzB,EAAqB,EAAE,oBAAoB,EAC7C,MAEG,CACD,IAAI,GAAe,EAAI,kBAAkB,wCAAwC,GAEjF,GAAoB,MAAhB,EACF,OAGF,EAAY,EAEM,cAAd,IACF,EAAY,EAAe,IAEb,aACZ,EAAU,WA5FS,SAAgC,EAAqB,EAAM,GACtF,IACI,EAAyB,eADD,EAAqB,EAAM,EAAM,aACM,GAC/D,EAAmB,EAAuB,GAC1C,EAAmB,EAAuB,GAE9C,IAAK,IAAqB,EAAiB,WACzC,OAAO,EAGT,IAAI,EAAiC,EAAoB,OAAO,EAAiB,YAAY,QAAO,SAAU,EAAK,GAMjH,MALe,mBAAX,EAAE,KACJ,EAAI,EAAE,IAAI,MAAQ,EACT,EAAE,KAGN,CACT,GAAG,CAAC,GACA,EAAkB,OAAO,KAAK,GAAgC,KAAI,SAAU,GAC9E,IAAI,EAAW,EAA+B,GAI9C,cAFO,EAAS,aACT,EAAS,IACT,CACT,IAEA,OADA,EAAiB,SACV,CACT,CAiEiC,CAAuB,EAAU,WAAY,EAAM,IAI9E,EAAqB,EAAE,oBAAoB,EAAE,qBAAqB,IAAK,EAAE,iBAAiB,EAAE,WAAW,GAAO,EAAE,WAAW,IAAa,GAC1I,CAEF,GAAK,EAAK,UAA2B,qBAAd,EAAK,MAA6C,oBAAd,EAAK,KAIrD,GACT,EAAK,YAAY,OAL0E,CAC3F,IAAI,EAAU,EAAE,cAAc,EAAE,WAAW,GAAY,GACvD,EAAgB,QAAI,EACpB,EAAK,KAAK,KAAK,KAAK,KAAK,EAC3B,CAGF,EAcI,EAAW,SAAkB,EAAM,GACrC,IAEI,EAFA,EAAe,UAAU,OAAS,QAAsB,IAAjB,UAAU,GAAmB,UAAU,GAAK,KACnF,EAAO,KAGX,GAAK,EAAK,UAA2B,qBAAd,EAAK,MAA6C,oBAAd,EAAK,KASzD,GAAkB,4BAAd,EAAK,MAAoD,uBAAd,EAAK,KAA+B,CACxF,EAAO,EAAK,OAAO,GAAG,KACtB,IAAI,EAAW,EAAK,WAAW,WAC/B,EAAa,EAAE,oBAAoB,EAAS,QAAU,EAAS,WAAa,CAC9E,KAAO,KAAI,EAAK,KAAK,GAInB,MAAM,IAAI,MAAM,iGAHhB,EAAO,EAAK,KAAK,GAAG,KACpB,EAAa,CAAC,UAAW,kBAAkB,QAAQ,EAAK,OAAO,OAAS,EAAI,EAAO,EAAK,UAG1F,MAhBI,EADE,EAAK,KAAK,GACL,EAAK,KAAK,GAAG,KAGb,GAGT,EAAa,EAYX,IACE,EAAW,aACb,EAAW,WAtHa,SAAiC,EAAqB,EAAM,GACxF,IAEI,EADyB,eADA,EAAqB,EAAM,EAAM,gBACM,GACvB,GAE7C,IAAK,IAAoB,EAAgB,WACvC,OAAO,EAGT,IAAI,EAAe,EAAgB,WAAW,KAAI,SAAU,GAC1D,OAAO,EAAK,IAAI,IAClB,IACA,OAAO,EAAoB,KAAI,SAAU,GAKvC,OAJI,EAAa,SAAS,EAAK,OAC7B,EAAK,MAAM,YAAa,GAGnB,CACT,GACF,CAmG8B,CAAwB,EAAW,WAAY,EAAY,IAGrF,EAAoB,EAAY,EAAM,YAAa,IAGjD,GACF,EAAoB,EAAY,EAAM,eAAgB,EAE1D,EAWI,EAAkB,SAAyB,GAC7C,GAvN+B,SAAoC,GACnE,UAAmB,4BAAd,EAAK,MAAoD,uBAAd,EAAK,MAAmC,EAAK,OAAO,OAKhG,EAAI,MAAM,qCAAqC,EAAK,SAIpD,EAAI,MAAM,sBAAsB,EAAK,MAK3C,CAwMO,CAA2B,GAAhC,CAKA,IAaI,EAbA,EAAa,EAAK,KAAK,OAAO,GAC9B,EAAiB,GAAc,EAAW,gBAAkB,EAAW,eAAe,eAEtF,EAAc,EAAK,KAAK,OAAO,GAC/B,EAAoB,GAAe,EAAY,gBAAkB,EAAY,eAAe,eAC5F,EAAa,KAEZ,EAGH,EAAa,EAAe,IAAM,cAAc,EAAe,GAAG,MAAQ,cAAc,EAAe,GAAG,MAAQ,0BAA0B,IAF5I,EAAI,MAAM,QAAQ,qDAQlB,EADE,EACa,EAAkB,IAAM,cAAc,EAAkB,GAAG,MAAQ,cAAc,EAAkB,GAAG,MAAQ,0BAA0B,GAExI,KAGb,GACF,EAAS,EAAM,EAAY,EAzB7B,CA2BF,EAEA,MAAO,CACL,QAAS,CACP,QAAS,SAAiB,EAAM,GAC9B,IAAI,EAAQ,EAAM,KAClB,EAAO,EACP,cAAgB,CAAC,EACjB,cAAgB,CAAC,EACjB,cAAgB,CAAC,EACjB,aAAe,CAAC,GAChB,EAAI,kBAAkB,4BAA2B,WAC/C,OAAO,EAAuB,EAChC,IACA,UAAW,EACX,sBAAwB,EAAK,wBAAyB,EACtD,IAAI,EAAa,EAAK,KAAK,WAE3B,GAAI,GAAc,EAAW,OAAQ,CACnC,IAAI,EAAY,EAAW,GAEvB,EAAU,OAAS,EAAU,MAAM,QAAU,kBAC/C,UAAW,EAEf,CAEI,KAAK,MAAQ,KAAK,KAAK,MAAQ,KAAK,KAAK,KAAK,UAC5C,KAAK,KAAK,KAAK,SAAS,QAAQ,iBAAmB,IAGrD,SAAW,EAAK,kBAGtB,EACA,4CAA6C,SAAiD,GAC5F,IAAI,SAAJ,EACA,EAAI,MAAM,QAAQ,mDAClB,IAAI,EAAgB,EAAK,KAAK,GAAG,KAEjC,IAAK,EACH,MAAM,IAAI,MAAM,oCAGlB,IAAI,EAAY,uBAAuB,EAAK,MAC5C,cAAc,GAAiB,CATX,CAUtB,EACA,mCAAoC,SAAyC,GAC3E,KAAI,EAAK,UAA+B,oBAAnB,EAAK,KAAK,MAC3B,EAAK,KAAK,QACd,EAAK,KAAK,OAAQ,EACd,WAAJ,CACA,IAAI,EAAa,EAAK,KAAK,WAEvB,EAAwB,GAAkC,qBAApB,EAAW,MAA0D,UAA3B,EAAW,OAAO,OAAkD,cAA7B,EAAW,SAAS,MAAqD,kBAA7B,EAAW,SAAS,MACvL,EAAmB,GAAkC,eAApB,EAAW,OAA8C,cAApB,EAAW,MAA4C,kBAApB,EAAW,MAExH,GAAK,GAA0B,EAA/B,CAKA,IAAI,EAAY,KACZ,EAAe,KAEnB,EAAK,KAAK,KAAK,KAAK,SAAQ,SAAU,GACpC,GAAI,GAAkC,UAAtB,EAAS,IAAI,MAAoB,EAAS,eAA1D,CACE,IAAI,EAAa,EAAS,eAAe,eACrC,EAAQ,0BAA0B,GAEtC,IAAK,EACH,MAAM,IAAI,UAAU,4CAGtB,EAAY,CAEd,MAEA,GAAI,GAAkC,YAAtB,EAAS,IAAI,MAAsB,EAAS,eAAgB,CAC1E,IAAI,EAAc,EAAS,eAAe,eACtC,EAAU,0BAA0B,GAExC,IAAK,EACH,MAAM,IAAI,UAAU,8CAGtB,EAAe,CACjB,CACF,IAEA,IAAI,EAAmB,kBAAkB,EAAK,MAE9C,GAAI,GAA8C,0BAA1B,EAAiB,KAAkC,CACzE,IAAI,EAAgB,EAAiB,GAAG,KACxC,GAAsB,WAAlB,EAA4B,OAChC,IAAI,EAAQ,cAAc,IAAkB,cAAc,IAAkB,cAAc,GAAe,WAEzG,IAAK,EAEH,YADA,EAAI,MAAM,QAAQ,wBAAwB,OAAO,EAAe,MAIlE,EAAY,CACd,EAEI,GAA+C,yBAA1B,EAAiB,MAA6D,+BAA1B,EAAiB,OAC5F,GAAY,EAAI,oBAA6B,SAAG,EAAkB,cAAe,gBAGnF,IAAI,EAAkB,oBAAoB,EAAK,MAE/C,GAAI,GAA4C,0BAAzB,EAAgB,KAAkC,CACvE,IAAI,EAAiB,EAAgB,GAAG,KACxC,GAAuB,WAAnB,EAA6B,OAEjC,IAAI,EAAS,cAAc,IAAmB,cAAc,IAAmB,cAAc,GAAgB,WAE7G,IAAK,EACH,MAAM,IAAI,UAAU,wBAAwB,OAAO,EAAgB,MAGrE,EAAe,CACjB,CAEA,EAAS,EAAM,EAAW,EAhE1B,MAFE,EAAI,MAAM,QAAQ,6CAA+C,EAP/C,CA0EtB,EACA,mBAAoB,SAA4B,GAC9C,IAAI,SACJ,OAAO,EAAgB,EACzB,EACA,oBAAqB,SAA6B,GAChD,IAAI,SACJ,OAAO,EAAgB,EACzB,EACA,wBAAyB,SAAiC,GACxD,IAAI,SACJ,OAAO,EAAgB,EACzB,EAYA,uBAAwB,SAAgC,GACtD,IAAI,SAAJ,CACA,IAAI,EAAO,EAAK,KAEhB,GAAwB,SAApB,EAAK,YAAyB,EAAK,QAAU,EAAK,OAAO,MAA7D,CACE,IACI,EADA,EAAY,2BAA2B,EAAK,YAGhD,IACE,IAAK,EAAU,MAAO,EAAQ,EAAU,KAAK,MAAO,CAClD,IACI,EADO,EAAM,MACG,MAAM,KAC1B,EAAc,EAAM,CAClB,KAAM,QACN,MAAM,EAAI,MAAM,sBAAsB,GACtC,SAAU,EAAK,OAAO,QAExB,EAAkB,GAAM,EAAI,MAAM,sBAAsB,GAC1D,CACF,CAAE,MAAO,GACP,EAAU,EAAE,EACd,CAAE,QACA,EAAU,GACZ,CAGF,MAEA,GAAwB,SAApB,EAAK,YAA0B,EAAK,QAAW,EAAK,YAAxD,CA2BA,IAAI,EAAoB,KACxB,GAAK,EAAK,cAEoB,cAA1B,EAAK,YAAY,OACnB,EAAoB,EAAK,YAAY,OAGT,eAA1B,EAAK,YAAY,OACnB,EAAoB,EAAK,YAAY,UAGT,yBAA1B,EAAK,YAAY,OACnB,EAAoB,EAAK,YAAY,MAGlC,GAAL,CACA,IAAI,EAAO,EAAK,YAAY,GAAG,KAC3B,EAAY,uBAAuB,GACvC,cAAc,GAAQ,EACtB,IAAI,GAAe,EAAI,kBAAkB,2BAA2B,GAEhE,GAAa,EAAI,MAAM,sBAAsB,GACjD,cAAc,GAAQ,EACtB,IAAI,EAAyB,EAAE,oBAAoB,MAAO,CAAC,EAAE,mBAAmB,EAAE,WAAW,GAAa,EAAe,MAGzH,GAFA,EAAK,aAAa,IAEb,sBAAuB,CAC1B,GAAI,EAAK,KAAK,MAAO,OACrB,EAAkB,EAAM,EAC1B,CAd8B,CAjB9B,KAzBA,CACE,IACI,EADA,EAAa,2BAA2B,EAAK,YAGjD,IACE,IAAK,EAAW,MAAO,EAAS,EAAW,KAAK,MAAO,CACrD,IAAI,EAAQ,EAAO,MACnB,GAAK,EAAE,aAAa,EAAM,OAA1B,CACA,IAAI,EAAW,cAAc,EAAM,MAAM,MACpC,GAED,EAAM,MAAM,OAAS,EAAM,SAAS,MAKxC,EAAkB,GAAM,EAAI,MAAM,sBAAsB,EAAM,MAAM,MAAO,EAAS,WAT1C,CAU5C,CACF,CAAE,MAAO,GACP,EAAW,EAAE,EACf,CAAE,QACA,EAAW,GACb,CAGF,CApDoB,CAoFtB,EACA,kBAAmB,SAA2B,GAC5C,IAAI,SAAJ,CACA,IAAI,EAAO,EAAK,KACZ,QAAQ,KAAK,EAAK,OAAO,QAAgC,UAAtB,EAAK,OAAO,OAKnD,EAAK,WAAW,SAAQ,SAAU,GAChC,GAAwB,SAApB,EAAK,YAAkD,SAAzB,EAAU,WAA5C,CACA,IAAI,EAAW,EAAU,MAAM,KAC3B,EAAsC,2BAAnB,EAAU,KAAoC,EAAW,EAAU,SAAS,KAgBnG,GANA,cAAc,GAAY,CACxB,UAAW,EACX,YAAY,EAAI,MAAM,sBAAsB,GAC5C,WAAY,MAGY,UAAtB,EAAK,OAAO,OAAkC,kBAAb,EAMrC,GAA0B,UAAtB,EAAK,OAAO,OAAkC,SAAb,EAArC,CAOA,IAAI,EAAa,EAAc,EAAM,CACnC,KAAM,QACN,MAAM,EAAI,MAAM,sBAAsB,GACtC,OAAO,EAAI,MAAM,sBAAsB,GACvC,SAAU,EAAK,OAAO,QAExB,cAAc,GAAU,WAAa,CARrC,KALA,CACE,IAAI,EAAU,EAAuB,EAAM,QAE3C,cAAc,GAAU,WAAa,CAEvC,KAXA,CACE,IAAI,EAAS,EAAuB,EAAM,QAC1C,cAAc,GAAU,WAAa,CAEvC,CAtByE,CAsC3E,GA9CoB,CA+CtB,GAGN","file":"/npm/babel-plugin-flow-react-proptypes@26.0.0/lib/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.37.0.\n * Original file: /npm/babel-plugin-flow-react-proptypes@26.0.0/lib/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\n\nvar _util = require(\"./util\");\n\nvar _convertToPropTypes = _interopRequireDefault(require(\"./convertToPropTypes\"));\n\nvar _makePropTypesAst = require(\"./makePropTypesAst\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _createForOfIteratorHelper(o) { if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { 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(_e2) { throw _e2; }, 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 it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _iterableToArrayLimit(arr, i) { if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\n// maps between type alias name to prop types\nvar internalTypes = {}; // maps between type alias to import alias\n\nvar importedTypes = {}; // maps from imported-name+location to the local name\n\nvar addedImports = {};\nvar exportedTypes = {};\nvar suppress = false;\nvar omitRuntimeTypeExport = false;\nvar SUPPRESS_STRING = 'no babel-plugin-flow-react-proptypes'; // The template to use for the dead code elimination check\n// if it passes, the prop types will be removed\n// currently the 'deadCode' option is off by default, but this may change\n\nvar DEFAULT_DCE = \"process.env.NODE_ENV === 'production'\"; // General control flow:\n// Parse flow type annotations in index.js\n// Convert to intermediate representation via convertToPropTypes.js\n// Convert to prop-types AST in makePropTypesAst.js\n// Indicates we shouldn't handle a node again\n// TODO: use a Symbol or WeakMap\n\nvar SKIP = \"BPFRPT_SKIP\";\n\nvar convertNodeToPropTypes = function convertNodeToPropTypes(node) {\n  return (0, _convertToPropTypes[\"default\"])(node, importedTypes, internalTypes);\n};\n\nvar getPropsForTypeAnnotation = function getPropsForTypeAnnotation(typeAnnotation) {\n  var props = null;\n\n  if (typeAnnotation.properties || typeAnnotation.type === 'GenericTypeAnnotation' || typeAnnotation.type === 'IntersectionTypeAnnotation' || typeAnnotation.type === 'AnyTypeAnnotation') {\n    props = convertNodeToPropTypes(typeAnnotation);\n  } else if (typeAnnotation.properties != null || typeAnnotation.type != null) {\n    (0, _util.$debug)('typeAnnotation not of expected type, not generating propTypes: ', typeAnnotation);\n  } else {\n    throw new Error(\"Expected prop types, but found none. This is a bug in \".concat(_util.PLUGIN_NAME));\n  }\n\n  return props;\n};\n\nmodule.exports = function flowReactPropTypes(babel) {\n  var t = babel.types;\n  var opts = {};\n\n  function shouldUseImport() {\n    return opts.useESModules === true || !opts.deadCode;\n  }\n\n  var impTemplates = {\n    named: babel.template(\"import { LOCAL } from 'change me'\", {\n      sourceType: 'module'\n    }),\n    renamed: babel.template(\"import { SOURCE as LOCAL } from 'change me'\", {\n      sourceType: 'module'\n    }),\n    \"default\": babel.template(\"import NAME from 'change me'\", {\n      sourceType: 'module'\n    }),\n    requireDefault: babel.template(\"require(PATH)\"),\n    requireNamed: babel.template(\"require(PATH).NAME\")\n  };\n\n  function getFromModule(path, _ref) {\n    var _ref$type = _ref.type,\n        type = _ref$type === void 0 ? 'default' : _ref$type,\n        name = _ref.name,\n        _ref$local = _ref.local,\n        local = _ref$local === void 0 ? name : _ref$local,\n        location = _ref.location;\n    var tid = t.identifier;\n    var tstr = t.stringLiteral;\n    var key = \"name:\".concat(location, \":\").concat(name);\n\n    if (shouldUseImport()) {\n      if (!addedImports[key]) {\n        var localName = local.replace(/[^a-zA-Z0-9]+/g, '_');\n        var sourceName = name.replace(/[^a-zA-Z0-9]+/g, '_');\n        addedImports[key] = localName;\n        var toAdd = null;\n\n        if (type === 'default') {\n          toAdd = impTemplates[\"default\"]({\n            NAME: tid(localName)\n          });\n        } else if (type === 'named') {\n          if (localName === sourceName) {\n            toAdd = impTemplates.named({\n              LOCAL: tid(localName)\n            });\n          } else {\n            toAdd = impTemplates.renamed({\n              LOCAL: tid(localName),\n              SOURCE: tid(sourceName)\n            });\n          }\n        }\n\n        if (toAdd) {\n          toAdd.source.value = location;\n          var ppath = path;\n\n          do {\n            if (ppath.node && ppath.node.type === 'Program') break;\n          } while (ppath = ppath.parentPath);\n\n          if (ppath && ppath.node.body) {\n            ppath.node.body.push(toAdd);\n          }\n        }\n      }\n\n      return tid(addedImports[key]);\n    } else {\n      if (type === 'default') {\n        return impTemplates.requireDefault({\n          PATH: tstr(location)\n        }).expression;\n      } else if (type === 'named') {\n        return impTemplates.requireNamed({\n          PATH: tstr(location),\n          NAME: tid(name)\n        }).expression;\n      }\n    }\n  }\n\n  function getFromPropTypesModule(path, name, isRequired) {\n    var ptNode = getFromModule(path, {\n      type: 'default',\n      name: 'PropTypes',\n      location: 'prop-types'\n    });\n    if (!name) return ptNode;\n    var ptOptional = t.memberExpression(ptNode, t.identifier(name));\n    if (!isRequired) return ptOptional;\n    return t.memberExpression(ptOptional, t.identifier('isRequired'));\n  }\n\n  function addExportTypeDecl(path, exportName) {\n    var exportValueNode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\n    if (!exportValueNode) {\n      exportValueNode = t.identifier(exportName);\n    }\n\n    if (!opts.deadCode || shouldUseImport()) {\n      if (!path.parentPath.isProgram()) return;\n      var body = path.parentPath.node.body;\n      var exportAst = t.exportNamedDeclaration(null, [t.exportSpecifier(t.identifier(exportName), exportValueNode)]);\n      exportAst[SKIP] = true;\n      body.push(exportAst);\n    } else {\n      // add the variable to the exports\n      var _exportAst = t.expressionStatement(t.callExpression(t.memberExpression(t.identifier('Object'), t.identifier('defineProperty')), [t.identifier('exports'), t.stringLiteral(exportName), t.objectExpression([t.objectProperty(t.identifier('value'), exportValueNode), t.objectProperty(t.identifier('configurable'), t.booleanLiteral(true))])]));\n\n      var exportsDefinedCondition = t.binaryExpression('!==', t.unaryExpression('typeof', t.identifier('exports')), t.stringLiteral('undefined'));\n      var ifCond = exportsDefinedCondition;\n\n      if (opts.deadCode) {\n        var dceConditional = t.unaryExpression('!', getDcePredicate());\n        ifCond = t.logicalExpression('&&', dceConditional, ifCond);\n      }\n\n      var conditionalExportsAst = t.ifStatement(ifCond, _exportAst);\n      path.insertAfter(conditionalExportsAst);\n    }\n  }\n\n  var _templateCache = {};\n\n  function getDcePredicate() {\n    // opts.deadCode could be a boolean (true for DEFAULT_DCE), or a string to be\n    // used as a template\n    // if it's falsy, then just return node without any wrapper\n    if (!opts.deadCode) return null; // cache the template since it's going to be used a lot\n\n    var templateCode = typeof opts.deadCode === 'string' ? opts.deadCode : DEFAULT_DCE;\n\n    if (!_templateCache[templateCode]) {\n      _templateCache[templateCode] = babel.template(templateCode, {\n        placeholderPattern: false\n      });\n    } // return a ternary\n\n\n    var predicate = _templateCache[templateCode]({}).expression;\n\n    return predicate;\n  }\n\n  function wrapInDceCheck(node) {\n    var predicate = getDcePredicate(node);\n    if (!predicate) return node;\n    var conditional = t.conditionalExpression(predicate, t.nullLiteral(), node);\n    return conditional;\n  }\n\n  var isFunctionalReactComponent = function isFunctionalReactComponent(path) {\n    if ((path.type === 'ArrowFunctionExpression' || path.type === 'FunctionExpression') && !path.parent.id) {\n      // Could be functions inside a React component\n      return false;\n    }\n\n    if ((0, _util.hasReactElementTypeAnnotationReturn)(path.node)) {\n      return true;\n    }\n\n    if ((0, _util.containsReactElement)(path.node)) {\n      return true;\n    }\n\n    return false;\n  };\n\n  var findPresetProperties = function findPresetProperties(path, objectName, propertyName) {\n    var propNode = null;\n    var propPath = null;\n    path.traverse({\n      ClassProperty: function ClassProperty(path) {\n        if (path.node.key && path.node.key.name === propertyName) {\n          propNode = path.node.value;\n          propPath = path;\n        }\n      }\n    });\n\n    if (!propNode) {\n      path.parentPath.traverse({\n        ExpressionStatement: function ExpressionStatement(path) {\n          if (!path.node.expression || !path.node.expression.left) {\n            return;\n          }\n\n          if (path.node.expression.left.object && path.node.expression.left.property && path.node.expression.left.object.name === objectName && path.node.expression.left.property.name === propertyName) {\n            propNode = path.node.expression.right;\n            propPath = path;\n          }\n        }\n      });\n    }\n\n    return [propNode, propPath];\n  };\n\n  var mergeExplicitPropTypes = function mergeExplicitPropTypes(generatedProperties, path, name) {\n    var _findPresetProperties = findPresetProperties(path, name, 'propTypes'),\n        _findPresetProperties2 = _slicedToArray(_findPresetProperties, 2),\n        explicitPropNode = _findPresetProperties2[0],\n        explicitPropPath = _findPresetProperties2[1];\n\n    if (!explicitPropNode || !explicitPropNode.properties) {\n      return generatedProperties;\n    }\n\n    var generatedAndExplicitProperties = generatedProperties.concat(explicitPropNode.properties).reduce(function (acc, i) {\n      if (i.type === 'ObjectProperty') {\n        acc[i.key.name] = i;\n      } else if (i.type === 'SpreadProperty') {// ignore it for now\n      }\n\n      return acc;\n    }, {});\n    var mergedPropTypes = Object.keys(generatedAndExplicitProperties).map(function (k) {\n      var original = generatedAndExplicitProperties[k]; // delete original line locations to avoid extra new lines\n\n      delete original.start;\n      delete original.end;\n      return original;\n    });\n    explicitPropPath.remove();\n    return mergedPropTypes;\n  };\n\n  var setDefaultPropsOptional = function setDefaultPropsOptional(generatedProperties, path, name) {\n    var _findPresetProperties3 = findPresetProperties(path, name, 'defaultProps'),\n        _findPresetProperties4 = _slicedToArray(_findPresetProperties3, 1),\n        defaultPropNode = _findPresetProperties4[0];\n\n    if (!defaultPropNode || !defaultPropNode.properties) {\n      return generatedProperties;\n    }\n\n    var defaultProps = defaultPropNode.properties.map(function (prop) {\n      return prop.key.name;\n    });\n    return generatedProperties.map(function (prop) {\n      if (defaultProps.includes(prop.key)) {\n        prop.value.isRequired = false;\n      }\n\n      return prop;\n    });\n  };\n  /**\n   * Adds propTypes or contextTypes annotations to code\n   *\n   * Extracts some shared logic from `annotate`.\n   *\n   * @param path\n   * @param name\n   * @param attribute - target member name ('propTypes' or 'contextTypes')\n   * @param typesOrVar - propsOrVar / contextOrVar value\n   */\n\n\n  var addAnnotationsToAST = function addAnnotationsToAST(path, name, attribute, typesOrVar) {\n    var attachPropTypesAST; // if type was exported, use the declared variable\n\n    var valueNode = null;\n\n    if (typeof typesOrVar === 'string') {\n      valueNode = t.identifier(typesOrVar);\n\n      if (name) {\n        var inner = t.assignmentExpression('=', t.memberExpression(t.identifier(name), t.identifier(attribute)), valueNode);\n\n        if (attribute === 'propTypes') {\n          inner = wrapInDceCheck(inner);\n        }\n\n        attachPropTypesAST = t.expressionStatement(inner);\n      }\n    } // type was not exported, generate\n    else {\n        var propTypesAST = (0, _makePropTypesAst.makePropTypesAstForPropTypesAssignment)(typesOrVar);\n\n        if (propTypesAST == null) {\n          return;\n        }\n\n        valueNode = propTypesAST;\n\n        if (attribute === 'propTypes') {\n          valueNode = wrapInDceCheck(valueNode);\n\n          if (valueNode.properties) {\n            valueNode.properties = mergeExplicitPropTypes(valueNode.properties, path, name);\n          }\n        }\n\n        attachPropTypesAST = t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.identifier(name), t.identifier(attribute)), valueNode));\n      }\n\n    if (!opts.noStatic && (path.type === 'ClassDeclaration' || path.type === 'ClassExpression')) {\n      var newNode = t.classProperty(t.identifier(attribute), valueNode);\n      newNode[\"static\"] = true;\n      path.node.body.body.push(newNode);\n    } else if (attachPropTypesAST) {\n      path.insertAfter(attachPropTypesAST);\n    }\n  };\n  /**\n   * Called when visiting a node.\n   *\n   * Converts the props param to AST and attaches it at the proper location,\n   * depending on the path param.\n   *\n   *\n   * @param path\n   * @param propsOrVar - props or exported props variable reference\n   * @param contextOrVar - context or exported context variable reference\n   */\n\n\n  var annotate = function annotate(path, propsOrVar) {\n    var contextOrVar = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n    var name = null;\n    var targetPath;\n\n    if (!opts.noStatic && (path.type === 'ClassDeclaration' || path.type === 'ClassExpression')) {\n      if (path.node.id) {\n        name = path.node.id.name;\n      } else {\n        // It's an anonymous class but addAnnotationsToAST() needs `name` to be a string anyway\n        name = \"\";\n      }\n\n      targetPath = path;\n    } else if (path.type === 'ArrowFunctionExpression' || path.type === 'FunctionExpression') {\n      name = path.parent.id.name;\n      var basePath = path.parentPath.parentPath;\n      targetPath = t.isExportDeclaration(basePath.parent) ? basePath.parentPath : basePath;\n    } else if (path.node.id) {\n      name = path.node.id.name;\n      targetPath = ['Program', 'BlockStatement'].indexOf(path.parent.type) >= 0 ? path : path.parentPath;\n    } else {\n      throw new Error(\"babel-plugin-flow-react-proptypes attempted to add propTypes to a function/class with no name\");\n    }\n\n    if (propsOrVar) {\n      if (propsOrVar.properties) {\n        propsOrVar.properties = setDefaultPropsOptional(propsOrVar.properties, targetPath, name);\n      }\n\n      addAnnotationsToAST(targetPath, name, 'propTypes', propsOrVar);\n    }\n\n    if (contextOrVar) {\n      addAnnotationsToAST(targetPath, name, 'contextTypes', contextOrVar);\n    }\n  };\n  /**\n   * Visitor for functions.\n   *\n   * Determines if a function is a functional react component and\n   * inserts the proptypes and contexttypes AST via `annotate`.\n   *\n   * @param path\n   */\n\n\n  var functionVisitor = function functionVisitor(path) {\n    if (!isFunctionalReactComponent(path)) {\n      return;\n    } // Check if this looks like a stateless react component with PropType reference:\n\n\n    var firstParam = path.node.params[0];\n    var typeAnnotation = firstParam && firstParam.typeAnnotation && firstParam.typeAnnotation.typeAnnotation; // Check if the component has context annotations\n\n    var secondParam = path.node.params[1];\n    var contextAnnotation = secondParam && secondParam.typeAnnotation && secondParam.typeAnnotation.typeAnnotation;\n    var propsOrVar = null;\n\n    if (!typeAnnotation) {\n      (0, _util.$debug)('Found stateless component without type definition');\n    } else {\n      propsOrVar = typeAnnotation.id && exportedTypes[typeAnnotation.id.name] ? exportedTypes[typeAnnotation.id.name] : getPropsForTypeAnnotation(typeAnnotation);\n    }\n\n    var contextOrVar;\n\n    if (contextAnnotation) {\n      contextOrVar = contextAnnotation.id && exportedTypes[contextAnnotation.id.name] ? exportedTypes[contextAnnotation.id.name] : getPropsForTypeAnnotation(contextAnnotation);\n    } else {\n      contextOrVar = null;\n    }\n\n    if (propsOrVar) {\n      annotate(path, propsOrVar, contextOrVar);\n    }\n  };\n\n  return {\n    visitor: {\n      Program: function Program(path, _ref2) {\n        var _opts = _ref2.opts;\n        opts = _opts;\n        internalTypes = {};\n        importedTypes = {};\n        exportedTypes = {};\n        addedImports = {};\n        (0, _makePropTypesAst.setMakePropTypeImportNode)(function () {\n          return getFromPropTypesModule(path);\n        });\n        suppress = false;\n        omitRuntimeTypeExport = opts.omitRuntimeTypeExport || false;\n        var directives = path.node.directives;\n\n        if (directives && directives.length) {\n          var directive = directives[0];\n\n          if (directive.value && directive.value.value === SUPPRESS_STRING) {\n            suppress = true;\n          }\n        }\n\n        if (this.file && this.file.opts && this.file.opts.filename) {\n          if (this.file.opts.filename.indexOf('node_modules') >= 0) {\n            // Suppress any file that lives in node_modules IF the\n            // ignoreNodeModules setting is true\n            suppress = opts.ignoreNodeModules;\n          }\n        }\n      },\n      \"TypeAlias|InterfaceDeclaration|OpaqueType\": function TypeAliasInterfaceDeclarationOpaqueType(path) {\n        if (suppress) return;\n        (0, _util.$debug)('TypeAlias/InterfaceDeclaration/OpaqueType found');\n        var typeAliasName = path.node.id.name;\n\n        if (!typeAliasName) {\n          throw new Error('Did not find name for type alias');\n        }\n\n        var propTypes = convertNodeToPropTypes(path.node);\n        internalTypes[typeAliasName] = propTypes;\n      },\n      \"ClassExpression|ClassDeclaration\": function ClassExpressionClassDeclaration(path) {\n        if (opts.noStatic && path.node.type === 'ClassExpression') return;\n        if (path.node[SKIP]) return;\n        path.node[SKIP] = true;\n        if (suppress) return;\n        var superClass = path.node.superClass; // check if we're extending React.Compoennt\n\n        var extendsReactComponent = superClass && superClass.type === 'MemberExpression' && superClass.object.name === 'React' && (superClass.property.name === 'Component' || superClass.property.name === 'PureComponent');\n        var extendsComponent = superClass && superClass.type === 'Identifier' && (superClass.name === 'Component' || superClass.name === 'PureComponent');\n\n        if (!extendsReactComponent && !extendsComponent) {\n          (0, _util.$debug)('Found a class that isn\\'t a react component', superClass);\n          return;\n        }\n\n        var propTypes = null,\n            contextTypes = null; // And have type as property annotations\n\n        path.node.body.body.forEach(function (bodyNode) {\n          if (bodyNode && bodyNode.key.name === 'props' && bodyNode.typeAnnotation) {\n            var annotation = bodyNode.typeAnnotation.typeAnnotation;\n            var props = getPropsForTypeAnnotation(annotation);\n\n            if (!props) {\n              throw new TypeError('Couldn\\'t process \\`class { props: This }`');\n            }\n\n            propTypes = props;\n            return;\n          }\n\n          if (bodyNode && bodyNode.key.name === 'context' && bodyNode.typeAnnotation) {\n            var _annotation = bodyNode.typeAnnotation.typeAnnotation;\n            var context = getPropsForTypeAnnotation(_annotation);\n\n            if (!context) {\n              throw new TypeError('Couldn\\'t process \\`class { context: This }`');\n            }\n\n            contextTypes = context;\n          }\n        }); // or Component<void, Props, Context>\n\n        var secondSuperParam = getPropsTypeParam(path.node);\n\n        if (secondSuperParam && secondSuperParam.type === 'GenericTypeAnnotation') {\n          var typeAliasName = secondSuperParam.id.name;\n          if (typeAliasName === 'Object') return;\n          var props = internalTypes[typeAliasName] || importedTypes[typeAliasName] && importedTypes[typeAliasName].accessNode;\n\n          if (!props) {\n            (0, _util.$debug)(\"Couldn't find type \\\"\".concat(typeAliasName, \"\\\"\"));\n            return;\n          }\n\n          propTypes = props;\n        }\n\n        if (secondSuperParam && (secondSuperParam.type === 'ObjectTypeAnnotation' || secondSuperParam.type === 'IntersectionTypeAnnotation')) {\n          propTypes = (0, _convertToPropTypes[\"default\"])(secondSuperParam, importedTypes, internalTypes);\n        }\n\n        var thirdSuperParam = getContextTypeParam(path.node);\n\n        if (thirdSuperParam && thirdSuperParam.type === 'GenericTypeAnnotation') {\n          var _typeAliasName = thirdSuperParam.id.name;\n          if (_typeAliasName === 'Object') return;\n\n          var _props = internalTypes[_typeAliasName] || importedTypes[_typeAliasName] && importedTypes[_typeAliasName].accessNode;\n\n          if (!_props) {\n            throw new TypeError(\"Couldn't find type \\\"\".concat(_typeAliasName, \"\\\"\"));\n          }\n\n          contextTypes = _props;\n        }\n\n        annotate(path, propTypes, contextTypes);\n      },\n      FunctionExpression: function FunctionExpression(path) {\n        if (suppress) return;\n        return functionVisitor(path);\n      },\n      FunctionDeclaration: function FunctionDeclaration(path) {\n        if (suppress) return;\n        return functionVisitor(path);\n      },\n      ArrowFunctionExpression: function ArrowFunctionExpression(path) {\n        if (suppress) return;\n        return functionVisitor(path);\n      },\n      // See issue:\n\n      /**\n       * Processes exported type aliases.\n       *\n       * This function also adds something to the AST directly, instead\n       * of invoking annotate.\n       *\n       * @param path\n       * @constructor\n       */\n      ExportNamedDeclaration: function ExportNamedDeclaration(path) {\n        if (suppress) return;\n        var node = path.node;\n\n        if (node.exportKind === 'type' && node.source && node.source.value) {\n          var _iterator = _createForOfIteratorHelper(node.specifiers),\n              _step;\n\n          try {\n            for (_iterator.s(); !(_step = _iterator.n()).done;) {\n              var spec = _step.value;\n              var typeName = spec.local.name;\n              getFromModule(path, {\n                type: 'named',\n                name: (0, _util.getExportNameForType)(typeName),\n                location: node.source.value\n              });\n              addExportTypeDecl(path, (0, _util.getExportNameForType)(typeName));\n            }\n          } catch (err) {\n            _iterator.e(err);\n          } finally {\n            _iterator.f();\n          }\n\n          return;\n        }\n\n        if (node.exportKind === 'type' && !node.source && !node.declaration) {\n          var _iterator2 = _createForOfIteratorHelper(node.specifiers),\n              _step2;\n\n          try {\n            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n              var _spec = _step2.value;\n              if (!t.isIdentifier(_spec.local)) continue;\n              var imported = importedTypes[_spec.local.name];\n              if (!imported) continue;\n\n              if (_spec.local.name !== _spec.exported.name) {\n                // TODO: handle this properly\n                continue;\n              }\n\n              addExportTypeDecl(path, (0, _util.getExportNameForType)(_spec.local.name), imported.accessNode);\n            }\n          } catch (err) {\n            _iterator2.e(err);\n          } finally {\n            _iterator2.f();\n          }\n\n          return;\n        }\n\n        var declarationObject = null;\n        if (!node.declaration) return;\n\n        if (node.declaration.type === 'TypeAlias') {\n          declarationObject = node.declaration.right;\n        }\n\n        if (node.declaration.type === 'OpaqueType') {\n          declarationObject = node.declaration.impltype;\n        }\n\n        if (node.declaration.type === 'InterfaceDeclaration') {\n          declarationObject = node.declaration.body;\n        }\n\n        if (!declarationObject) return;\n        var name = node.declaration.id.name;\n        var propTypes = convertNodeToPropTypes(declarationObject);\n        internalTypes[name] = propTypes;\n        var propTypesAst = (0, _makePropTypesAst.makePropTypesAstForExport)(propTypes); // create a variable for reuse\n\n        var exportName = (0, _util.getExportNameForType)(name);\n        exportedTypes[name] = exportName;\n        var variableDeclarationAst = t.variableDeclaration('var', [t.variableDeclarator(t.identifier(exportName), wrapInDceCheck(propTypesAst))]);\n        path.insertBefore(variableDeclarationAst);\n\n        if (!omitRuntimeTypeExport) {\n          if (path.node[SKIP]) return;\n          addExportTypeDecl(path, exportName);\n        }\n      },\n      ImportDeclaration: function ImportDeclaration(path) {\n        if (suppress) return;\n        var node = path.node;\n        if (/^@?\\w/.test(node.source.value) && node.source.value !== 'react') return; // https://github.com/brigand/babel-plugin-flow-react-proptypes/issues/62\n        // if (node.source.value[0] !== '.') {\n        //   return;\n        // }\n\n        node.specifiers.forEach(function (specifier) {\n          if (node.importKind !== 'type' && specifier.importKind !== 'type') return;\n          var typeName = specifier.local.name;\n          var originalTypeName = specifier.type === 'ImportDefaultSpecifier' ? typeName : specifier.imported.name; // Store the name the type so we can use it later. We do\n          // mark it as importedTypes because we do handle these\n          // differently than internalTypes.\n          // imported types are basically realized as imports;\n          // because we can be somewhat sure that we generated\n          // the proper exported propTypes in the imported file\n          // Later, we will check importedTypes to determine if\n          // we want to put this as a 'raw' type in our internal\n          // representation\n\n          importedTypes[typeName] = {\n            localName: originalTypeName,\n            exportName: (0, _util.getExportNameForType)(originalTypeName),\n            accessNode: null\n          }; // https://github.com/brigand/babel-plugin-flow-react-proptypes/issues/129\n\n          if (node.source.value === 'react' && typeName === 'ComponentType') {\n            var ptFunc = getFromPropTypesModule(path, 'func');\n            importedTypes[typeName].accessNode = ptFunc;\n            return;\n          }\n\n          if (node.source.value === 'react' && typeName === 'Node') {\n            var _ptFunc = getFromPropTypesModule(path, 'node');\n\n            importedTypes[typeName].accessNode = _ptFunc;\n            return;\n          }\n\n          var accessNode = getFromModule(path, {\n            type: 'named',\n            name: (0, _util.getExportNameForType)(originalTypeName),\n            local: (0, _util.getExportNameForType)(typeName),\n            location: node.source.value\n          });\n          importedTypes[typeName].accessNode = accessNode;\n        });\n      }\n    }\n  };\n};\n\nfunction getPropsTypeParam(node) {\n  if (!node) return null;\n  if (!node.superTypeParameters) return null;\n  var superTypes = node.superTypeParameters;\n\n  if (superTypes.params.length === 2) {\n    return superTypes.params[0];\n  } else if (superTypes.params.length === 3) {\n    return superTypes.params[0];\n  } else if (superTypes.params.length === 1) {\n    return superTypes.params[0];\n  }\n\n  return null;\n}\n\nfunction getContextTypeParam(node) {\n  if (!node) return null;\n  if (!node.superTypeParameters) return null;\n  var superTypes = node.superTypeParameters;\n\n  if (superTypes.params.length === 3) {\n    return superTypes.params[2];\n  }\n\n  return null;\n}"]}