{"version":3,"sources":["webpack:///./node_modules/ramda/src/internal/_curry1.js","webpack:///./node_modules/ramda/src/internal/_isPlaceholder.js","webpack:///./node_modules/ramda/src/internal/_dispatchable.js","webpack:///./node_modules/ramda/src/internal/_xfBase.js","webpack:///./node_modules/ramda/src/internal/_reduce.js","webpack:///./node_modules/ramda/src/internal/_arity.js","webpack:///./node_modules/ramda/src/internal/_has.js","webpack:///./node_modules/ramda/src/internal/_isArray.js","webpack:///./node_modules/ramda/src/internal/_slice.js","webpack:///./node_modules/ramda/src/keys.js","webpack:///./node_modules/ramda/src/curryN.js","webpack:///./node_modules/ramda/src/internal/_curry2.js","webpack:///./node_modules/ramda/src/find.js","webpack:///./node_modules/ramda/src/internal/_isTransformer.js","webpack:///./node_modules/ramda/src/internal/_xfind.js","webpack:///./node_modules/ramda/src/internal/_reduced.js","webpack:///./node_modules/ramda/src/reject.js","webpack:///./node_modules/ramda/src/internal/_complement.js","webpack:///./node_modules/ramda/src/filter.js","webpack:///./node_modules/ramda/src/internal/_filter.js","webpack:///./node_modules/ramda/src/internal/_isObject.js","webpack:///./node_modules/ramda/src/internal/_xwrap.js","webpack:///./node_modules/ramda/src/bind.js","webpack:///./node_modules/ramda/src/isArrayLike.js","webpack:///./node_modules/ramda/src/internal/_isString.js","webpack:///./node_modules/ramda/src/internal/_xfilter.js","webpack:///./node_modules/ramda/src/internal/_isArguments.js","webpack:///./node_modules/ramda/src/addIndex.js","webpack:///./node_modules/ramda/src/internal/_concat.js","webpack:///./node_modules/ramda/src/internal/_curryN.js","webpack:///./node_modules/ramda/src/map.js","webpack:///./node_modules/ramda/src/internal/_map.js","webpack:///./node_modules/ramda/src/internal/_xmap.js","webpack:///./node_modules/ramda/src/toPairs.js","webpack:///./node_modules/ramda/src/reduce.js","webpack:///./node_modules/ramda/src/internal/_curry3.js"],"names":["_isPlaceholder","module","exports","_curry1","fn","f1","a","arguments","length","apply","this","_isArray","_isTransformer","_slice","_dispatchable","methodname","xf","obj","args","transducer","init","result","_xwrap","bind","isArrayLike","_iterableReduce","acc","iter","step","next","done","value","symIterator","Symbol","iterator","_reduce","list","_arrayReduce","idx","len","reduce","_methodReduce","TypeError","_arity","n","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","Error","_has","prop","Object","prototype","hasOwnProperty","call","Array","isArray","val","toString","from","to","Math","max","min","hasEnumBug","nonEnumerableProps","hasArgsEnumBug","contains","_isArguments","propertyIsEnumerable","item","keys","nIdx","ks","checkArgsLength","_curry2","_curryN","curryN","f2","b","_b","_a","_xfind","find","_reduced","_xfBase","XFind","f","found","input","x","_complement","filter","reject","pred","filterable","_filter","_isObject","_xfilter","key","XWrap","thisObj","_isString","nodeType","XFilter","_concat","addIndex","origFn","set1","set2","len1","len2","received","combined","argsIdx","left","combinedIdx","_map","_xmap","map","functor","XMap","toPairs","pairs","_curry3","f3","c","_c"],"mappings":"+EAAA,IAAIA,EAAiB,EAAQ,KAW7BC,EAAOC,QAAU,SAASC,QAAQC,GAChC,OAAO,SAASC,GAAGC,GACjB,OAAyB,IAArBC,UAAUC,QAAgBR,EAAeM,GACpCD,GAEAD,EAAGK,MAAMC,KAAMH,c,kBChB5BN,EAAOC,QAAU,SAASF,eAAeM,GACvC,OAAY,MAALA,GACa,iBAANA,IAC2B,IAAlCA,EAAE,8B,oBCHX,IAAIK,EAAW,EAAQ,KACnBC,EAAiB,EAAQ,KACzBC,EAAS,EAAQ,KAiBrBZ,EAAOC,QAAU,SAASY,cAAcC,EAAYC,EAAIZ,GACtD,OAAO,WACL,IAAII,EAASD,UAAUC,OACvB,GAAe,IAAXA,EACF,OAAOJ,IAET,IAAIa,EAAMV,UAAUC,EAAS,GAC7B,IAAKG,EAASM,GAAM,CAClB,IAAIC,EAAOL,EAAON,UAAW,EAAGC,EAAS,GACzC,GAA+B,mBAApBS,EAAIF,GACb,OAAOE,EAAIF,GAAYN,MAAMQ,EAAKC,GAEpC,GAAIN,EAAeK,GAAM,CACvB,IAAIE,EAAaH,EAAGP,MAAM,KAAMS,GAChC,OAAOC,EAAWF,IAGtB,OAAOb,EAAGK,MAAMC,KAAMH,c,kBCpC1BN,EAAOC,QAAU,CACfkB,KAAM,WACJ,OAAOV,KAAKM,GAAG,wBAEjBK,OAAQ,SAASA,GACf,OAAOX,KAAKM,GAAG,uBAAuBK,M,oBCL1C,IAAIC,EAAS,EAAQ,KACjBC,EAAO,EAAQ,KACfC,EAAc,EAAQ,KAG1BvB,EAAOC,QAAW,WAehB,SAASuB,gBAAgBT,EAAIU,EAAKC,GAEhC,IADA,IAAIC,EAAOD,EAAKE,QACRD,EAAKE,MAAM,CAEjB,IADAJ,EAAMV,EAAG,qBAAqBU,EAAKE,EAAKG,SAC7BL,EAAI,wBAAyB,CACtCA,EAAMA,EAAI,sBACV,MAEFE,EAAOD,EAAKE,OAEd,OAAOb,EAAG,uBAAuBU,GAOnC,IAAIM,EAAiC,oBAAXC,OAA0BA,OAAOC,SAAW,aACtE,OAAO,SAASC,QAAQ/B,EAAIsB,EAAKU,GAI/B,GAHkB,mBAAPhC,IACTA,EAAKkB,EAAOlB,IAEVoB,EAAYY,GACd,OArCJ,SAASC,aAAarB,EAAIU,EAAKU,GAG7B,IAFA,IAAIE,EAAM,EACNC,EAAMH,EAAK5B,OACR8B,EAAMC,GAAK,CAEhB,IADAb,EAAMV,EAAG,qBAAqBU,EAAKU,EAAKE,MAC7BZ,EAAI,wBAAyB,CACtCA,EAAMA,EAAI,sBACV,MAEFY,GAAO,EAET,OAAOtB,EAAG,uBAAuBU,GA0BxBW,CAAajC,EAAIsB,EAAKU,GAE/B,GAA2B,mBAAhBA,EAAKI,OACd,OAbJ,SAASC,cAAczB,EAAIU,EAAKT,GAC9B,OAAOD,EAAG,uBAAuBC,EAAIuB,OAAOjB,EAAKP,EAAG,qBAAsBA,GAAKU,IAYtEe,CAAcrC,EAAIsB,EAAKU,GAEhC,GAAyB,MAArBA,EAAKJ,GACP,OAAOP,gBAAgBrB,EAAIsB,EAAKU,EAAKJ,MAEvC,GAAyB,mBAAdI,EAAKP,KACd,OAAOJ,gBAAgBrB,EAAIsB,EAAKU,GAElC,MAAM,IAAIM,UAAU,2CAjDP,I,kBCLjBzC,EAAOC,QAAU,SAASyC,OAAOC,EAAGxC,GAElC,OAAQwC,GACN,KAAK,EAAG,OAAO,WAAa,OAAOxC,EAAGK,MAAMC,KAAMH,YAClD,KAAK,EAAG,OAAO,SAASsC,GAAM,OAAOzC,EAAGK,MAAMC,KAAMH,YACpD,KAAK,EAAG,OAAO,SAASsC,EAAIC,GAAM,OAAO1C,EAAGK,MAAMC,KAAMH,YACxD,KAAK,EAAG,OAAO,SAASsC,EAAIC,EAAIC,GAAM,OAAO3C,EAAGK,MAAMC,KAAMH,YAC5D,KAAK,EAAG,OAAO,SAASsC,EAAIC,EAAIC,EAAIC,GAAM,OAAO5C,EAAGK,MAAMC,KAAMH,YAChE,KAAK,EAAG,OAAO,SAASsC,EAAIC,EAAIC,EAAIC,EAAIC,GAAM,OAAO7C,EAAGK,MAAMC,KAAMH,YACpE,KAAK,EAAG,OAAO,SAASsC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAAM,OAAO9C,EAAGK,MAAMC,KAAMH,YACxE,KAAK,EAAG,OAAO,SAASsC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAAM,OAAO/C,EAAGK,MAAMC,KAAMH,YAC5E,KAAK,EAAG,OAAO,SAASsC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAAM,OAAOhD,EAAGK,MAAMC,KAAMH,YAChF,KAAK,EAAG,OAAO,SAASsC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAAM,OAAOjD,EAAGK,MAAMC,KAAMH,YACpF,KAAK,GAAI,OAAO,SAASsC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAAM,OAAOlD,EAAGK,MAAMC,KAAMH,YACzF,QAAS,MAAM,IAAIgD,MAAM,kF,kBCd7BtD,EAAOC,QAAU,SAASsD,KAAKC,EAAMxC,GACnC,OAAOyC,OAAOC,UAAUC,eAAeC,KAAK5C,EAAKwC,K,kBCWnDxD,EAAOC,QAAU4D,MAAMC,SAAW,SAASpD,SAASqD,GAClD,OAAe,MAAPA,GACAA,EAAIxD,QAAU,GAC0B,mBAAxCkD,OAAOC,UAAUM,SAASJ,KAAKG,K,kBCEzC/D,EAAOC,QAAU,SAASW,OAAOK,EAAMgD,EAAMC,GAC3C,OAAQ5D,UAAUC,QAChB,KAAK,EAAG,OAAOK,OAAOK,EAAM,EAAGA,EAAKV,QACpC,KAAK,EAAG,OAAOK,OAAOK,EAAMgD,EAAMhD,EAAKV,QACvC,QAIE,IAHA,IAAI4B,EAAO,GACPE,EAAM,EACNC,EAAM6B,KAAKC,IAAI,EAAGD,KAAKE,IAAIpD,EAAKV,OAAQ2D,GAAMD,GAC3C5B,EAAMC,GACXH,EAAKE,GAAOpB,EAAKgD,EAAO5B,GACxBA,GAAO,EAET,OAAOF,K,oBC7Bb,IAwBMmC,EACAC,EAGAC,EAKAC,EAjCFvE,EAAU,EAAQ,KAClBqD,EAAO,EAAQ,KACfmB,EAAe,EAAQ,KAoB3B1E,EAAOC,SAEDqE,GAAc,CAAEN,SAAU,MAAOW,qBAAqB,YACtDJ,EAAqB,CAAC,cAAe,UAAW,gBAAiB,WAC3C,uBAAwB,iBAAkB,kBAEhEC,EAAkB,WACpB,aACA,OAAOlE,UAAUqE,qBAAqB,UAFnB,GAKjBF,EAAW,SAASA,SAAStC,EAAMyC,GAErC,IADA,IAAIvC,EAAM,EACHA,EAAMF,EAAK5B,QAAQ,CACxB,GAAI4B,EAAKE,KAASuC,EAChB,OAAO,EAETvC,GAAO,EAET,OAAO,GAGqB,mBAAhBoB,OAAOoB,MAAwBL,EAI3CtE,GAAQ,SAAS2E,KAAK7D,GACpB,GAAIyC,OAAOzC,KAASA,EAClB,MAAO,GAET,IAAIwC,EAAMsB,EACNC,EAAK,GACLC,EAAkBR,GAAkBE,EAAa1D,GACrD,IAAKwC,KAAQxC,GACPuC,EAAKC,EAAMxC,IAAUgE,GAA4B,WAATxB,IAC1CuB,EAAGA,EAAGxE,QAAUiD,GAGpB,GAAIc,EAEF,IADAQ,EAAOP,EAAmBhE,OAAS,EAC5BuE,GAAQ,GAETvB,EADJC,EAAOe,EAAmBO,GACX9D,KAASyD,EAASM,EAAIvB,KACnCuB,EAAGA,EAAGxE,QAAUiD,GAElBsB,GAAQ,EAGZ,OAAOC,KAzBT7E,GAAQ,SAAS2E,KAAK7D,GACpB,OAAOyC,OAAOzC,KAASA,EAAM,GAAKyC,OAAOoB,KAAK7D,Q,oBC9CpD,IAAI0B,EAAS,EAAQ,KACjBxC,EAAU,EAAQ,KAClB+E,EAAU,EAAQ,IAClBC,EAAU,EAAQ,KA6CtBlF,EAAOC,QAAUgF,GAAQ,SAASE,OAAO5E,EAAQJ,GAC/C,OAAe,IAAXI,EACKL,EAAQC,GAEVuC,EAAOnC,EAAQ2E,EAAQ3E,EAAQ,GAAIJ,Q,mBCpD5C,IAAID,EAAU,EAAQ,KAClBH,EAAiB,EAAQ,KAW7BC,EAAOC,QAAU,SAASgF,QAAQ9E,GAChC,OAAO,SAASiF,GAAG/E,EAAGgF,GACpB,OAAQ/E,UAAUC,QAChB,KAAK,EACH,OAAO6E,GACT,KAAK,EACH,OAAOrF,EAAeM,GAAK+E,GACpBlF,GAAQ,SAASoF,GAAM,OAAOnF,EAAGE,EAAGiF,MAC7C,QACE,OAAOvF,EAAeM,IAAMN,EAAesF,GAAKD,GACzCrF,EAAeM,GAAKH,GAAQ,SAASqF,GAAM,OAAOpF,EAAGoF,EAAIF,MACzDtF,EAAesF,GAAKnF,GAAQ,SAASoF,GAAM,OAAOnF,EAAGE,EAAGiF,MACxDnF,EAAGE,EAAGgF,O,oBCxBrB,IAAIJ,EAAU,EAAQ,IAClBpE,EAAgB,EAAQ,KACxB2E,EAAS,EAAQ,KA2BrBxF,EAAOC,QAAUgF,EAAQpE,EAAc,OAAQ2E,GAAQ,SAASC,KAAKtF,EAAIgC,GAGvE,IAFA,IAAIE,EAAM,EACNC,EAAMH,EAAK5B,OACR8B,EAAMC,GAAK,CAChB,GAAInC,EAAGgC,EAAKE,IACV,OAAOF,EAAKE,GAEdA,GAAO,Q,kBCpCXrC,EAAOC,QAAU,SAASU,eAAeK,GACvC,MAA2C,mBAA7BA,EAAI,uB,oBCDpB,IAAIiE,EAAU,EAAQ,IAClBS,EAAW,EAAQ,KACnBC,EAAU,EAAQ,KAGtB3F,EAAOC,QAAW,WAChB,SAAS2F,MAAMC,EAAG9E,GAChBN,KAAKM,GAAKA,EACVN,KAAKoF,EAAIA,EACTpF,KAAKqF,OAAQ,EAiBf,OAfAF,MAAMlC,UAAU,qBAAuBiC,EAAQxE,KAC/CyE,MAAMlC,UAAU,uBAAyB,SAAStC,GAIhD,OAHKX,KAAKqF,QACR1E,EAASX,KAAKM,GAAG,qBAAqBK,OAAQ,IAEzCX,KAAKM,GAAG,uBAAuBK,IAExCwE,MAAMlC,UAAU,qBAAuB,SAAStC,EAAQ2E,GAKtD,OAJItF,KAAKoF,EAAEE,KACTtF,KAAKqF,OAAQ,EACb1E,EAASsE,EAASjF,KAAKM,GAAG,qBAAqBK,EAAQ2E,KAElD3E,GAGF6D,GAAQ,SAASO,OAAOK,EAAG9E,GAAM,OAAO,IAAI6E,MAAMC,EAAG9E,MArB7C,I,kBCLjBf,EAAOC,QAAU,SAASyF,SAASM,GACjC,OAAOA,GAAKA,EAAE,wBAA0BA,EACtC,CACE,qBAAsBA,EACtB,wBAAwB,K,oBCJ9B,IAAIC,EAAc,EAAQ,KACtBhB,EAAU,EAAQ,IAClBiB,EAAS,EAAQ,KAyBrBlG,EAAOC,QAAUgF,GAAQ,SAASkB,OAAOC,EAAMC,GAC7C,OAAOH,EAAOD,EAAYG,GAAOC,O,kBC5BnCrG,EAAOC,QAAU,SAASgG,YAAYJ,GACpC,OAAO,WACL,OAAQA,EAAErF,MAAMC,KAAMH,c,oBCF1B,IAAI2E,EAAU,EAAQ,IAClBpE,EAAgB,EAAQ,KACxByF,EAAU,EAAQ,KAClBC,EAAY,EAAQ,KACpBrE,EAAU,EAAQ,KAClBsE,EAAW,EAAQ,KACnB3B,EAAO,EAAQ,KA6BnB7E,EAAOC,QAAUgF,EAAQpE,EAAc,SAAU2F,GAAU,SAASJ,EAAMC,GACxE,OACEE,EAAUF,GACRnE,GAAQ,SAAST,EAAKgF,GAIpB,OAHIL,EAAKC,EAAWI,MAClBhF,EAAIgF,GAAOJ,EAAWI,IAEjBhF,IACN,GAAIoD,EAAKwB,IAEZC,EAAQF,EAAMC,Q,kBC7CpBrG,EAAOC,QAAU,SAASqG,QAAQnG,EAAIgC,GAKpC,IAJA,IAAIE,EAAM,EACNC,EAAMH,EAAK5B,OACXa,EAAS,GAENiB,EAAMC,GACPnC,EAAGgC,EAAKE,MACVjB,EAAOA,EAAOb,QAAU4B,EAAKE,IAE/BA,GAAO,EAET,OAAOjB,I,kBCXTpB,EAAOC,QAAU,SAASsG,UAAUP,GAClC,MAA6C,oBAAtCvC,OAAOC,UAAUM,SAASJ,KAAKoC,K,kBCDxChG,EAAOC,QAAW,WAChB,SAASyG,MAAMvG,GACbM,KAAKoF,EAAI1F,EAUX,OARAuG,MAAMhD,UAAU,qBAAuB,WACrC,MAAM,IAAIJ,MAAM,kCAElBoD,MAAMhD,UAAU,uBAAyB,SAASjC,GAAO,OAAOA,GAChEiF,MAAMhD,UAAU,qBAAuB,SAASjC,EAAKuE,GACnD,OAAOvF,KAAKoF,EAAEpE,EAAKuE,IAGd,SAAS3E,OAAOlB,GAAM,OAAO,IAAIuG,MAAMvG,IAZ/B,I,oBCAjB,IAAIuC,EAAS,EAAQ,KACjBuC,EAAU,EAAQ,IAwBtBjF,EAAOC,QAAUgF,GAAQ,SAAS3D,KAAKnB,EAAIwG,GACzC,OAAOjE,EAAOvC,EAAGI,QAAQ,WACvB,OAAOJ,EAAGK,MAAMmG,EAASrG,kB,oBC3B7B,IAAIJ,EAAU,EAAQ,KAClBQ,EAAW,EAAQ,KACnBkG,EAAY,EAAQ,KAsBxB5G,EAAOC,QAAUC,GAAQ,SAASqB,YAAYyE,GAC5C,QAAItF,EAASsF,MACRA,IACY,iBAANA,KACPY,EAAUZ,KACK,IAAfA,EAAEa,WAA2Bb,EAAEzF,OAClB,IAAbyF,EAAEzF,QACFyF,EAAEzF,OAAS,IACNyF,EAAErC,eAAe,IAAMqC,EAAErC,eAAeqC,EAAEzF,OAAS,W,kBChC9DP,EAAOC,QAAU,SAAS2G,UAAUZ,GAClC,MAA6C,oBAAtCvC,OAAOC,UAAUM,SAASJ,KAAKoC,K,oBCDxC,IAAIf,EAAU,EAAQ,IAClBU,EAAU,EAAQ,KAGtB3F,EAAOC,QAAW,WAChB,SAAS6G,QAAQjB,EAAG9E,GAClBN,KAAKM,GAAKA,EACVN,KAAKoF,EAAIA,EAQX,OANAiB,QAAQpD,UAAU,qBAAuBiC,EAAQxE,KACjD2F,QAAQpD,UAAU,uBAAyBiC,EAAQvE,OACnD0F,QAAQpD,UAAU,qBAAuB,SAAStC,EAAQ2E,GACxD,OAAOtF,KAAKoF,EAAEE,GAAStF,KAAKM,GAAG,qBAAqBK,EAAQ2E,GAAS3E,GAGhE6D,GAAQ,SAASuB,SAASX,EAAG9E,GAAM,OAAO,IAAI+F,QAAQjB,EAAG9E,MAXjD,I,oBCJjB,IAAIwC,EAAO,EAAQ,KAGnBvD,EAAOC,QAAW,WAChB,IAAI+D,EAAWP,OAAOC,UAAUM,SAChC,MAAoC,uBAA7BA,EAASJ,KAAKtD,WACnB,SAASoE,aAAasB,GAAK,MAA4B,uBAArBhC,EAASJ,KAAKoC,IAChD,SAAStB,aAAasB,GAAK,OAAOzC,EAAK,SAAUyC,IAJpC,I,oBCHjB,IAAIe,EAAU,EAAQ,KAClB7G,EAAU,EAAQ,KAClBU,EAAS,EAAQ,KACjBuE,EAAS,EAAQ,KA2BrBnF,EAAOC,QAAUC,GAAQ,SAAS8G,SAAS7G,GACzC,OAAOgF,EAAOhF,EAAGI,QAAQ,WACvB,IAAI8B,EAAM,EACN4E,EAAS3G,UAAU,GACnB6B,EAAO7B,UAAUA,UAAUC,OAAS,GACpCU,EAAOL,EAAON,WAMlB,OALAW,EAAK,GAAK,WACR,IAAIG,EAAS6F,EAAOzG,MAAMC,KAAMsG,EAAQzG,UAAW,CAAC+B,EAAKF,KAEzD,OADAE,GAAO,EACAjB,GAEFjB,EAAGK,MAAMC,KAAMQ,U,kBC9B1BjB,EAAOC,QAAU,SAAS8G,QAAQG,EAAMC,GAGtC,IAAI9E,EADJ8E,EAAOA,GAAQ,GAEf,IAAIC,GAHJF,EAAOA,GAAQ,IAGC3G,OACZ8G,EAAOF,EAAK5G,OACZa,EAAS,GAGb,IADAiB,EAAM,EACCA,EAAM+E,GACXhG,EAAOA,EAAOb,QAAU2G,EAAK7E,GAC7BA,GAAO,EAGT,IADAA,EAAM,EACCA,EAAMgF,GACXjG,EAAOA,EAAOb,QAAU4G,EAAK9E,GAC7BA,GAAO,EAET,OAAOjB,I,oBC7BT,IAAIsB,EAAS,EAAQ,KACjB3C,EAAiB,EAAQ,KAa7BC,EAAOC,QAAU,SAASiF,QAAQ3E,EAAQ+G,EAAUnH,GAClD,OAAO,WAKL,IAJA,IAAIoH,EAAW,GACXC,EAAU,EACVC,EAAOlH,EACPmH,EAAc,EACXA,EAAcJ,EAAS/G,QAAUiH,EAAUlH,UAAUC,QAAQ,CAClE,IAAIa,EACAsG,EAAcJ,EAAS/G,UACrBR,EAAeuH,EAASI,KACzBF,GAAWlH,UAAUC,QACxBa,EAASkG,EAASI,IAElBtG,EAASd,UAAUkH,GACnBA,GAAW,GAEbD,EAASG,GAAetG,EACnBrB,EAAeqB,KAClBqG,GAAQ,GAEVC,GAAe,EAEjB,OAAOD,GAAQ,EAAItH,EAAGK,MAAMC,KAAM8G,GACf7E,EAAO+E,EAAMvC,QAAQ3E,EAAQgH,EAAUpH,O,oBCrC9D,IAAI8E,EAAU,EAAQ,IAClBpE,EAAgB,EAAQ,KACxB8G,EAAO,EAAQ,KACfzF,EAAU,EAAQ,KAClB0F,EAAQ,EAAQ,KAChBzC,EAAS,EAAQ,KACjBN,EAAO,EAAQ,KAmCnB7E,EAAOC,QAAUgF,EAAQpE,EAAc,MAAO+G,GAAO,SAASC,IAAI1H,EAAI2H,GACpE,OAAQrE,OAAOC,UAAUM,SAASJ,KAAKkE,IACrC,IAAK,oBACH,OAAO3C,EAAO2C,EAAQvH,QAAQ,WAC5B,OAAOJ,EAAGyD,KAAKnD,KAAMqH,EAAQtH,MAAMC,KAAMH,eAE7C,IAAK,kBACH,OAAO4B,GAAQ,SAAST,EAAKgF,GAE3B,OADAhF,EAAIgF,GAAOtG,EAAG2H,EAAQrB,IACfhF,IACN,GAAIoD,EAAKiD,IACd,QACE,OAAOH,EAAKxH,EAAI2H,S,kBCrDtB9H,EAAOC,QAAU,SAAS0H,KAAKxH,EAAI2H,GAIjC,IAHA,IAAIzF,EAAM,EACNC,EAAMwF,EAAQvH,OACda,EAASyC,MAAMvB,GACZD,EAAMC,GACXlB,EAAOiB,GAAOlC,EAAG2H,EAAQzF,IACzBA,GAAO,EAET,OAAOjB,I,oBCRT,IAAI6D,EAAU,EAAQ,IAClBU,EAAU,EAAQ,KAGtB3F,EAAOC,QAAW,WAChB,SAAS8H,KAAKlC,EAAG9E,GACfN,KAAKM,GAAKA,EACVN,KAAKoF,EAAIA,EAQX,OANAkC,KAAKrE,UAAU,qBAAuBiC,EAAQxE,KAC9C4G,KAAKrE,UAAU,uBAAyBiC,EAAQvE,OAChD2G,KAAKrE,UAAU,qBAAuB,SAAStC,EAAQ2E,GACrD,OAAOtF,KAAKM,GAAG,qBAAqBK,EAAQX,KAAKoF,EAAEE,KAG9Cd,GAAQ,SAAS2C,MAAM/B,EAAG9E,GAAM,OAAO,IAAIgH,KAAKlC,EAAG9E,MAX3C,I,oBCJjB,IAAIb,EAAU,EAAQ,KAClBqD,EAAO,EAAQ,KAqBnBvD,EAAOC,QAAUC,GAAQ,SAAS8H,QAAQhH,GACxC,IAAIiH,EAAQ,GACZ,IAAK,IAAIzE,KAAQxC,EACXuC,EAAKC,EAAMxC,KACbiH,EAAMA,EAAM1H,QAAU,CAACiD,EAAMxC,EAAIwC,KAGrC,OAAOyE,M,oBC7BT,IAAIC,EAAU,EAAQ,KAClBhG,EAAU,EAAQ,KAoCtBlC,EAAOC,QAAUiI,EAAQhG,I,oBCrCzB,IAAIhC,EAAU,EAAQ,KAClB+E,EAAU,EAAQ,IAClBlF,EAAiB,EAAQ,KAW7BC,EAAOC,QAAU,SAASiI,QAAQ/H,GAChC,OAAO,SAASgI,GAAG9H,EAAGgF,EAAG+C,GACvB,OAAQ9H,UAAUC,QAChB,KAAK,EACH,OAAO4H,GACT,KAAK,EACH,OAAOpI,EAAeM,GAAK8H,GACpBlD,GAAQ,SAASK,EAAI+C,GAAM,OAAOlI,EAAGE,EAAGiF,EAAI+C,MACrD,KAAK,EACH,OAAOtI,EAAeM,IAAMN,EAAesF,GAAK8C,GACzCpI,EAAeM,GAAK4E,GAAQ,SAASM,EAAI8C,GAAM,OAAOlI,EAAGoF,EAAIF,EAAGgD,MAChEtI,EAAesF,GAAKJ,GAAQ,SAASK,EAAI+C,GAAM,OAAOlI,EAAGE,EAAGiF,EAAI+C,MAChEnI,GAAQ,SAASmI,GAAM,OAAOlI,EAAGE,EAAGgF,EAAGgD,MAChD,QACE,OAAOtI,EAAeM,IAAMN,EAAesF,IAAMtF,EAAeqI,GAAKD,GAC9DpI,EAAeM,IAAMN,EAAesF,GAAKJ,GAAQ,SAASM,EAAID,GAAM,OAAOnF,EAAGoF,EAAID,EAAI8C,MACtFrI,EAAeM,IAAMN,EAAeqI,GAAKnD,GAAQ,SAASM,EAAI8C,GAAM,OAAOlI,EAAGoF,EAAIF,EAAGgD,MACrFtI,EAAesF,IAAMtF,EAAeqI,GAAKnD,GAAQ,SAASK,EAAI+C,GAAM,OAAOlI,EAAGE,EAAGiF,EAAI+C,MACrFtI,EAAeM,GAAKH,GAAQ,SAASqF,GAAM,OAAOpF,EAAGoF,EAAIF,EAAG+C,MAC5DrI,EAAesF,GAAKnF,GAAQ,SAASoF,GAAM,OAAOnF,EAAGE,EAAGiF,EAAI8C,MAC5DrI,EAAeqI,GAAKlI,GAAQ,SAASmI,GAAM,OAAOlI,EAAGE,EAAGgF,EAAGgD,MAC3DlI,EAAGE,EAAGgF,EAAG+C","file":"npm.ramda-bcbbedb2a63e78edab81.js","sourcesContent":["var _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal one-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry1(fn) {\n  return function f1(a) {\n    if (arguments.length === 0 || _isPlaceholder(a)) {\n      return f1;\n    } else {\n      return fn.apply(this, arguments);\n    }\n  };\n};\n","module.exports = function _isPlaceholder(a) {\n  return a != null &&\n         typeof a === 'object' &&\n         a['@@functional/placeholder'] === true;\n};\n","var _isArray = require('./_isArray');\nvar _isTransformer = require('./_isTransformer');\nvar _slice = require('./_slice');\n\n\n/**\n * Returns a function that dispatches with different strategies based on the\n * object in list position (last argument). If it is an array, executes [fn].\n * Otherwise, if it has a function with [methodname], it will execute that\n * function (functor case). Otherwise, if it is a transformer, uses transducer\n * [xf] to return a new transformer (transducer case). Otherwise, it will\n * default to executing [fn].\n *\n * @private\n * @param {String} methodname property to check for a custom implementation\n * @param {Function} xf transducer to initialize if object is transformer\n * @param {Function} fn default ramda implementation\n * @return {Function} A function that dispatches on object in list position\n */\nmodule.exports = function _dispatchable(methodname, xf, fn) {\n  return function() {\n    var length = arguments.length;\n    if (length === 0) {\n      return fn();\n    }\n    var obj = arguments[length - 1];\n    if (!_isArray(obj)) {\n      var args = _slice(arguments, 0, length - 1);\n      if (typeof obj[methodname] === 'function') {\n        return obj[methodname].apply(obj, args);\n      }\n      if (_isTransformer(obj)) {\n        var transducer = xf.apply(null, args);\n        return transducer(obj);\n      }\n    }\n    return fn.apply(this, arguments);\n  };\n};\n","module.exports = {\n  init: function() {\n    return this.xf['@@transducer/init']();\n  },\n  result: function(result) {\n    return this.xf['@@transducer/result'](result);\n  }\n};\n","var _xwrap = require('./_xwrap');\nvar bind = require('../bind');\nvar isArrayLike = require('../isArrayLike');\n\n\nmodule.exports = (function() {\n  function _arrayReduce(xf, acc, list) {\n    var idx = 0;\n    var len = list.length;\n    while (idx < len) {\n      acc = xf['@@transducer/step'](acc, list[idx]);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      idx += 1;\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _iterableReduce(xf, acc, iter) {\n    var step = iter.next();\n    while (!step.done) {\n      acc = xf['@@transducer/step'](acc, step.value);\n      if (acc && acc['@@transducer/reduced']) {\n        acc = acc['@@transducer/value'];\n        break;\n      }\n      step = iter.next();\n    }\n    return xf['@@transducer/result'](acc);\n  }\n\n  function _methodReduce(xf, acc, obj) {\n    return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));\n  }\n\n  var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';\n  return function _reduce(fn, acc, list) {\n    if (typeof fn === 'function') {\n      fn = _xwrap(fn);\n    }\n    if (isArrayLike(list)) {\n      return _arrayReduce(fn, acc, list);\n    }\n    if (typeof list.reduce === 'function') {\n      return _methodReduce(fn, acc, list);\n    }\n    if (list[symIterator] != null) {\n      return _iterableReduce(fn, acc, list[symIterator]());\n    }\n    if (typeof list.next === 'function') {\n      return _iterableReduce(fn, acc, list);\n    }\n    throw new TypeError('reduce: list must be array or iterable');\n  };\n}());\n","module.exports = function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0: return function() { return fn.apply(this, arguments); };\n    case 1: return function(a0) { return fn.apply(this, arguments); };\n    case 2: return function(a0, a1) { return fn.apply(this, arguments); };\n    case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };\n    case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };\n    case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };\n    case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };\n    case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };\n    case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };\n    case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };\n    case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };\n    default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n};\n","module.exports = function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n};\n","/**\n * Tests whether or not an object is an array.\n *\n * @private\n * @param {*} val The object to test.\n * @return {Boolean} `true` if `val` is an array, `false` otherwise.\n * @example\n *\n *      _isArray([]); //=> true\n *      _isArray(null); //=> false\n *      _isArray({}); //=> false\n */\nmodule.exports = Array.isArray || function _isArray(val) {\n  return (val != null &&\n          val.length >= 0 &&\n          Object.prototype.toString.call(val) === '[object Array]');\n};\n","/**\n * An optimized, private array `slice` implementation.\n *\n * @private\n * @param {Arguments|Array} args The array or arguments object to consider.\n * @param {Number} [from=0] The array index to slice from, inclusive.\n * @param {Number} [to=args.length] The array index to slice to, exclusive.\n * @return {Array} A new, sliced array.\n * @example\n *\n *      _slice([1, 2, 3, 4, 5], 1, 3); //=> [2, 3]\n *\n *      var firstThreeArgs = function(a, b, c, d) {\n *        return _slice(arguments, 0, 3);\n *      };\n *      firstThreeArgs(1, 2, 3, 4); //=> [1, 2, 3]\n */\nmodule.exports = function _slice(args, from, to) {\n  switch (arguments.length) {\n    case 1: return _slice(args, 0, args.length);\n    case 2: return _slice(args, from, args.length);\n    default:\n      var list = [];\n      var idx = 0;\n      var len = Math.max(0, Math.min(args.length, to) - from);\n      while (idx < len) {\n        list[idx] = args[from + idx];\n        idx += 1;\n      }\n      return list;\n  }\n};\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\nvar _isArguments = require('./internal/_isArguments');\n\n\n/**\n * Returns a list containing the names of all the enumerable own properties of\n * the supplied object.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Object\n * @sig {k: v} -> [k]\n * @param {Object} obj The object to extract properties from\n * @return {Array} An array of the object's own properties.\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nmodule.exports = (function() {\n  // cover IE < 9 keys issues\n  var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',\n                            'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n  // Safari bug\n  var hasArgsEnumBug = (function() {\n    'use strict';\n    return arguments.propertyIsEnumerable('length');\n  }());\n\n  var contains = function contains(list, item) {\n    var idx = 0;\n    while (idx < list.length) {\n      if (list[idx] === item) {\n        return true;\n      }\n      idx += 1;\n    }\n    return false;\n  };\n\n  return typeof Object.keys === 'function' && !hasArgsEnumBug ?\n    _curry1(function keys(obj) {\n      return Object(obj) !== obj ? [] : Object.keys(obj);\n    }) :\n    _curry1(function keys(obj) {\n      if (Object(obj) !== obj) {\n        return [];\n      }\n      var prop, nIdx;\n      var ks = [];\n      var checkArgsLength = hasArgsEnumBug && _isArguments(obj);\n      for (prop in obj) {\n        if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {\n          ks[ks.length] = prop;\n        }\n      }\n      if (hasEnumBug) {\n        nIdx = nonEnumerableProps.length - 1;\n        while (nIdx >= 0) {\n          prop = nonEnumerableProps[nIdx];\n          if (_has(prop, obj) && !contains(ks, prop)) {\n            ks[ks.length] = prop;\n          }\n          nIdx -= 1;\n        }\n      }\n      return ks;\n    });\n}());\n","var _arity = require('./internal/_arity');\nvar _curry1 = require('./internal/_curry1');\nvar _curry2 = require('./internal/_curry2');\nvar _curryN = require('./internal/_curryN');\n\n\n/**\n * Returns a curried equivalent of the provided function, with the specified\n * arity. The curried function has two unusual capabilities. First, its\n * arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the\n * following are equivalent:\n *\n *   - `g(1)(2)(3)`\n *   - `g(1)(2, 3)`\n *   - `g(1, 2)(3)`\n *   - `g(1, 2, 3)`\n *\n * Secondly, the special placeholder value `R.__` may be used to specify\n * \"gaps\", allowing partial application of any combination of arguments,\n * regardless of their positions. If `g` is as above and `_` is `R.__`, the\n * following are equivalent:\n *\n *   - `g(1, 2, 3)`\n *   - `g(_, 2, 3)(1)`\n *   - `g(_, _, 3)(1)(2)`\n *   - `g(_, _, 3)(1, 2)`\n *   - `g(_, 2)(1)(3)`\n *   - `g(_, 2)(1, 3)`\n *   - `g(_, 2)(_, 3)(1)`\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Function\n * @sig Number -> (* -> a) -> (* -> a)\n * @param {Number} length The arity for the returned function.\n * @param {Function} fn The function to curry.\n * @return {Function} A new, curried function.\n * @see R.curry\n * @example\n *\n *      var sumArgs = (...args) => R.sum(args);\n *\n *      var curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      var f = curriedAddFourNumbers(1, 2);\n *      var g = f(3);\n *      g(4); //=> 10\n */\nmodule.exports = _curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\n","var _curry1 = require('./_curry1');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal two-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry2(fn) {\n  return function f2(a, b) {\n    switch (arguments.length) {\n      case 0:\n        return f2;\n      case 1:\n        return _isPlaceholder(a) ? f2\n             : _curry1(function(_b) { return fn(a, _b); });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2\n             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); })\n             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); })\n             : fn(a, b);\n    }\n  };\n};\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _xfind = require('./internal/_xfind');\n\n\n/**\n * Returns the first element of the list which matches the predicate, or\n * `undefined` if no element matches.\n *\n * Dispatches to the `find` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig (a -> Boolean) -> [a] -> a | undefined\n * @param {Function} fn The predicate function used to determine if the element is the\n *        desired one.\n * @param {Array} list The array to consider.\n * @return {Object} The element found, or `undefined`.\n * @see R.transduce\n * @example\n *\n *      var xs = [{a: 1}, {a: 2}, {a: 3}];\n *      R.find(R.propEq('a', 2))(xs); //=> {a: 2}\n *      R.find(R.propEq('a', 4))(xs); //=> undefined\n */\nmodule.exports = _curry2(_dispatchable('find', _xfind, function find(fn, list) {\n  var idx = 0;\n  var len = list.length;\n  while (idx < len) {\n    if (fn(list[idx])) {\n      return list[idx];\n    }\n    idx += 1;\n  }\n}));\n","module.exports = function _isTransformer(obj) {\n  return typeof obj['@@transducer/step'] === 'function';\n};\n","var _curry2 = require('./_curry2');\nvar _reduced = require('./_reduced');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFind(f, xf) {\n    this.xf = xf;\n    this.f = f;\n    this.found = false;\n  }\n  XFind.prototype['@@transducer/init'] = _xfBase.init;\n  XFind.prototype['@@transducer/result'] = function(result) {\n    if (!this.found) {\n      result = this.xf['@@transducer/step'](result, void 0);\n    }\n    return this.xf['@@transducer/result'](result);\n  };\n  XFind.prototype['@@transducer/step'] = function(result, input) {\n    if (this.f(input)) {\n      this.found = true;\n      result = _reduced(this.xf['@@transducer/step'](result, input));\n    }\n    return result;\n  };\n\n  return _curry2(function _xfind(f, xf) { return new XFind(f, xf); });\n}());\n","module.exports = function _reduced(x) {\n  return x && x['@@transducer/reduced'] ? x :\n    {\n      '@@transducer/value': x,\n      '@@transducer/reduced': true\n    };\n};\n","var _complement = require('./internal/_complement');\nvar _curry2 = require('./internal/_curry2');\nvar filter = require('./filter');\n\n\n/**\n * The complement of `filter`.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array}\n * @see R.filter, R.transduce, R.addIndex\n * @example\n *\n *      var isOdd = (n) => n % 2 === 1;\n *\n *      R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]\n *\n *      R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\nmodule.exports = _curry2(function reject(pred, filterable) {\n  return filter(_complement(pred), filterable);\n});\n","module.exports = function _complement(f) {\n  return function() {\n    return !f.apply(this, arguments);\n  };\n};\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _filter = require('./internal/_filter');\nvar _isObject = require('./internal/_isObject');\nvar _reduce = require('./internal/_reduce');\nvar _xfilter = require('./internal/_xfilter');\nvar keys = require('./keys');\n\n\n/**\n * Takes a predicate and a \"filterable\", and returns a new filterable of the\n * same type containing the members of the given filterable which satisfy the\n * given predicate.\n *\n * Dispatches to the `filter` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Filterable f => (a -> Boolean) -> f a -> f a\n * @param {Function} pred\n * @param {Array} filterable\n * @return {Array}\n * @see R.reject, R.transduce, R.addIndex\n * @example\n *\n *      var isEven = n => n % 2 === 0;\n *\n *      R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]\n *\n *      R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}\n */\nmodule.exports = _curry2(_dispatchable('filter', _xfilter, function(pred, filterable) {\n  return (\n    _isObject(filterable) ?\n      _reduce(function(acc, key) {\n        if (pred(filterable[key])) {\n          acc[key] = filterable[key];\n        }\n        return acc;\n      }, {}, keys(filterable)) :\n    // else\n      _filter(pred, filterable)\n  );\n}));\n","module.exports = function _filter(fn, list) {\n  var idx = 0;\n  var len = list.length;\n  var result = [];\n\n  while (idx < len) {\n    if (fn(list[idx])) {\n      result[result.length] = list[idx];\n    }\n    idx += 1;\n  }\n  return result;\n};\n","module.exports = function _isObject(x) {\n  return Object.prototype.toString.call(x) === '[object Object]';\n};\n","module.exports = (function() {\n  function XWrap(fn) {\n    this.f = fn;\n  }\n  XWrap.prototype['@@transducer/init'] = function() {\n    throw new Error('init not implemented on XWrap');\n  };\n  XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };\n  XWrap.prototype['@@transducer/step'] = function(acc, x) {\n    return this.f(acc, x);\n  };\n\n  return function _xwrap(fn) { return new XWrap(fn); };\n}());\n","var _arity = require('./internal/_arity');\nvar _curry2 = require('./internal/_curry2');\n\n\n/**\n * Creates a function that is bound to a context.\n * Note: `R.bind` does not provide the additional argument-binding capabilities of\n * [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).\n *\n * @func\n * @memberOf R\n * @since v0.6.0\n * @category Function\n * @category Object\n * @sig (* -> *) -> {*} -> (* -> *)\n * @param {Function} fn The function to bind to context\n * @param {Object} thisObj The context to bind `fn` to\n * @return {Function} A function that will execute in the context of `thisObj`.\n * @see R.partial\n * @example\n *\n *      var log = R.bind(console.log, console);\n *      R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}\n *      // logs {a: 2}\n */\nmodule.exports = _curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function() {\n    return fn.apply(thisObj, arguments);\n  });\n});\n","var _curry1 = require('./internal/_curry1');\nvar _isArray = require('./internal/_isArray');\nvar _isString = require('./internal/_isString');\n\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @func\n * @memberOf R\n * @since v0.5.0\n * @category Type\n * @category List\n * @sig * -> Boolean\n * @param {*} x The object to test.\n * @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.\n * @example\n *\n *      R.isArrayLike([]); //=> true\n *      R.isArrayLike(true); //=> false\n *      R.isArrayLike({}); //=> false\n *      R.isArrayLike({length: 10}); //=> false\n *      R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\nmodule.exports = _curry1(function isArrayLike(x) {\n  if (_isArray(x)) { return true; }\n  if (!x) { return false; }\n  if (typeof x !== 'object') { return false; }\n  if (_isString(x)) { return false; }\n  if (x.nodeType === 1) { return !!x.length; }\n  if (x.length === 0) { return true; }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\n","module.exports = function _isString(x) {\n  return Object.prototype.toString.call(x) === '[object String]';\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XFilter(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XFilter.prototype['@@transducer/init'] = _xfBase.init;\n  XFilter.prototype['@@transducer/result'] = _xfBase.result;\n  XFilter.prototype['@@transducer/step'] = function(result, input) {\n    return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;\n  };\n\n  return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });\n}());\n","var _has = require('./_has');\n\n\nmodule.exports = (function() {\n  var toString = Object.prototype.toString;\n  return toString.call(arguments) === '[object Arguments]' ?\n    function _isArguments(x) { return toString.call(x) === '[object Arguments]'; } :\n    function _isArguments(x) { return _has('callee', x); };\n}());\n","var _concat = require('./internal/_concat');\nvar _curry1 = require('./internal/_curry1');\nvar _slice = require('./internal/_slice');\nvar curryN = require('./curryN');\n\n\n/**\n * Creates a new list iteration function from an existing one by adding two new\n * parameters to its callback function: the current index, and the entire list.\n *\n * This would turn, for instance, Ramda's simple `map` function into one that\n * more closely resembles `Array.prototype.map`. Note that this will only work\n * for functions in which the iteration callback function is the first\n * parameter, and where the list is the last parameter. (This latter might be\n * unimportant if the list parameter is not used.)\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Function\n * @category List\n * @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)\n * @param {Function} fn A list iteration function that does not pass index or list to its callback\n * @return {Function} An altered list iteration function that passes (item, index, list) to its callback\n * @example\n *\n *      var mapIndexed = R.addIndex(R.map);\n *      mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);\n *      //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']\n */\nmodule.exports = _curry1(function addIndex(fn) {\n  return curryN(fn.length, function() {\n    var idx = 0;\n    var origFn = arguments[0];\n    var list = arguments[arguments.length - 1];\n    var args = _slice(arguments);\n    args[0] = function() {\n      var result = origFn.apply(this, _concat(arguments, [idx, list]));\n      idx += 1;\n      return result;\n    };\n    return fn.apply(this, args);\n  });\n});\n","/**\n * Private `concat` function to merge two array-like objects.\n *\n * @private\n * @param {Array|Arguments} [set1=[]] An array-like object.\n * @param {Array|Arguments} [set2=[]] An array-like object.\n * @return {Array} A new, merged array.\n * @example\n *\n *      _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]\n */\nmodule.exports = function _concat(set1, set2) {\n  set1 = set1 || [];\n  set2 = set2 || [];\n  var idx;\n  var len1 = set1.length;\n  var len2 = set2.length;\n  var result = [];\n\n  idx = 0;\n  while (idx < len1) {\n    result[result.length] = set1[idx];\n    idx += 1;\n  }\n  idx = 0;\n  while (idx < len2) {\n    result[result.length] = set2[idx];\n    idx += 1;\n  }\n  return result;\n};\n","var _arity = require('./_arity');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Internal curryN function.\n *\n * @private\n * @category Function\n * @param {Number} length The arity of the curried function.\n * @param {Array} received An array of arguments received thus far.\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curryN(length, received, fn) {\n  return function() {\n    var combined = [];\n    var argsIdx = 0;\n    var left = length;\n    var combinedIdx = 0;\n    while (combinedIdx < received.length || argsIdx < arguments.length) {\n      var result;\n      if (combinedIdx < received.length &&\n          (!_isPlaceholder(received[combinedIdx]) ||\n           argsIdx >= arguments.length)) {\n        result = received[combinedIdx];\n      } else {\n        result = arguments[argsIdx];\n        argsIdx += 1;\n      }\n      combined[combinedIdx] = result;\n      if (!_isPlaceholder(result)) {\n        left -= 1;\n      }\n      combinedIdx += 1;\n    }\n    return left <= 0 ? fn.apply(this, combined)\n                     : _arity(left, _curryN(length, combined, fn));\n  };\n};\n","var _curry2 = require('./internal/_curry2');\nvar _dispatchable = require('./internal/_dispatchable');\nvar _map = require('./internal/_map');\nvar _reduce = require('./internal/_reduce');\nvar _xmap = require('./internal/_xmap');\nvar curryN = require('./curryN');\nvar keys = require('./keys');\n\n\n/**\n * Takes a function and\n * a [functor](https://github.com/fantasyland/fantasy-land#functor),\n * applies the function to each of the functor's values, and returns\n * a functor of the same shape.\n *\n * Ramda provides suitable `map` implementations for `Array` and `Object`,\n * so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.\n *\n * Dispatches to the `map` method of the second argument, if present.\n *\n * Acts as a transducer if a transformer is given in list position.\n *\n * Also treats functions as functors and will compose them together.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig Functor f => (a -> b) -> f a -> f b\n * @param {Function} fn The function to be called on every element of the input `list`.\n * @param {Array} list The list to be iterated over.\n * @return {Array} The new list.\n * @see R.transduce, R.addIndex\n * @example\n *\n *      var double = x => x * 2;\n *\n *      R.map(double, [1, 2, 3]); //=> [2, 4, 6]\n *\n *      R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}\n */\nmodule.exports = _curry2(_dispatchable('map', _xmap, function map(fn, functor) {\n  switch (Object.prototype.toString.call(functor)) {\n    case '[object Function]':\n      return curryN(functor.length, function() {\n        return fn.call(this, functor.apply(this, arguments));\n      });\n    case '[object Object]':\n      return _reduce(function(acc, key) {\n        acc[key] = fn(functor[key]);\n        return acc;\n      }, {}, keys(functor));\n    default:\n      return _map(fn, functor);\n  }\n}));\n","module.exports = function _map(fn, functor) {\n  var idx = 0;\n  var len = functor.length;\n  var result = Array(len);\n  while (idx < len) {\n    result[idx] = fn(functor[idx]);\n    idx += 1;\n  }\n  return result;\n};\n","var _curry2 = require('./_curry2');\nvar _xfBase = require('./_xfBase');\n\n\nmodule.exports = (function() {\n  function XMap(f, xf) {\n    this.xf = xf;\n    this.f = f;\n  }\n  XMap.prototype['@@transducer/init'] = _xfBase.init;\n  XMap.prototype['@@transducer/result'] = _xfBase.result;\n  XMap.prototype['@@transducer/step'] = function(result, input) {\n    return this.xf['@@transducer/step'](result, this.f(input));\n  };\n\n  return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });\n}());\n","var _curry1 = require('./internal/_curry1');\nvar _has = require('./internal/_has');\n\n\n/**\n * Converts an object into an array of key, value arrays. Only the object's\n * own properties are used.\n * Note that the order of the output array is not guaranteed to be consistent\n * across different JS platforms.\n *\n * @func\n * @memberOf R\n * @since v0.4.0\n * @category Object\n * @sig {String: *} -> [[String,*]]\n * @param {Object} obj The object to extract from\n * @return {Array} An array of key, value arrays from the object's own properties.\n * @see R.fromPairs\n * @example\n *\n *      R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]\n */\nmodule.exports = _curry1(function toPairs(obj) {\n  var pairs = [];\n  for (var prop in obj) {\n    if (_has(prop, obj)) {\n      pairs[pairs.length] = [prop, obj[prop]];\n    }\n  }\n  return pairs;\n});\n","var _curry3 = require('./internal/_curry3');\nvar _reduce = require('./internal/_reduce');\n\n\n/**\n * Returns a single item by iterating through the list, successively calling\n * the iterator function and passing it an accumulator value and the current\n * value from the array, and then passing the result to the next call.\n *\n * The iterator function receives two values: *(acc, value)*. It may use\n * `R.reduced` to shortcut the iteration.\n *\n * Note: `R.reduce` does not skip deleted or unassigned indices (sparse\n * arrays), unlike the native `Array.prototype.reduce` method. For more details\n * on this behavior, see:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description\n *\n * Dispatches to the `reduce` method of the third argument, if present.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig ((a, b) -> a) -> a -> [b] -> a\n * @param {Function} fn The iterator function. Receives two values, the accumulator and the\n *        current element from the array.\n * @param {*} acc The accumulator value.\n * @param {Array} list The list to iterate over.\n * @return {*} The final, accumulated value.\n * @see R.reduced, R.addIndex\n * @example\n *\n *      var numbers = [1, 2, 3];\n *      var plus = (a, b) => a + b;\n *\n *      R.reduce(plus, 10, numbers); //=> 16\n */\nmodule.exports = _curry3(_reduce);\n","var _curry1 = require('./_curry1');\nvar _curry2 = require('./_curry2');\nvar _isPlaceholder = require('./_isPlaceholder');\n\n\n/**\n * Optimized internal three-arity curry function.\n *\n * @private\n * @category Function\n * @param {Function} fn The function to curry.\n * @return {Function} The curried function.\n */\nmodule.exports = function _curry3(fn) {\n  return function f3(a, b, c) {\n    switch (arguments.length) {\n      case 0:\n        return f3;\n      case 1:\n        return _isPlaceholder(a) ? f3\n             : _curry2(function(_b, _c) { return fn(a, _b, _c); });\n      case 2:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f3\n             : _isPlaceholder(a) ? _curry2(function(_a, _c) { return fn(_a, b, _c); })\n             : _isPlaceholder(b) ? _curry2(function(_b, _c) { return fn(a, _b, _c); })\n             : _curry1(function(_c) { return fn(a, b, _c); });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3\n             : _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function(_a, _b) { return fn(_a, _b, c); })\n             : _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function(_a, _c) { return fn(_a, b, _c); })\n             : _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function(_b, _c) { return fn(a, _b, _c); })\n             : _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b, c); })\n             : _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b, c); })\n             : _isPlaceholder(c) ? _curry1(function(_c) { return fn(a, b, _c); })\n             : fn(a, b, c);\n    }\n  };\n};\n"],"sourceRoot":""}