{"version":3,"sources":["webpack:///./node_modules/ramda/src/internal/_isPlaceholder.js","webpack:///./node_modules/ramda/src/internal/_has.js","webpack:///./node_modules/ramda/src/internal/_arity.js","webpack:///./node_modules/ramda/src/keys.js","webpack:///./node_modules/ramda/src/internal/_isArrayLike.js","webpack:///./node_modules/ramda/src/internal/_isArray.js","webpack:///./node_modules/ramda/src/uniq.js","webpack:///./node_modules/ramda/src/flatten.js","webpack:///./node_modules/ramda/src/map.js","webpack:///./node_modules/ramda/src/identity.js","webpack:///./node_modules/ramda/src/internal/_identity.js","webpack:///./node_modules/ramda/src/uniqBy.js","webpack:///./node_modules/ramda/src/internal/_Set.js","webpack:///./node_modules/ramda/src/internal/_includes.js","webpack:///./node_modules/ramda/src/internal/_indexOf.js","webpack:///./node_modules/ramda/src/equals.js","webpack:///./node_modules/ramda/src/internal/_equals.js","webpack:///./node_modules/ramda/src/internal/_arrayFromIterator.js","webpack:///./node_modules/ramda/src/internal/_includesWith.js","webpack:///./node_modules/ramda/src/internal/_functionName.js","webpack:///./node_modules/ramda/src/internal/_objectIs.js","webpack:///./node_modules/ramda/src/internal/_isArguments.js","webpack:///./node_modules/ramda/src/type.js","webpack:///./node_modules/ramda/src/internal/_makeFlat.js","webpack:///./node_modules/ramda/src/internal/_isString.js","webpack:///./node_modules/ramda/src/internal/_dispatchable.js","webpack:///./node_modules/ramda/src/internal/_isTransformer.js","webpack:///./node_modules/ramda/src/internal/_map.js","webpack:///./node_modules/ramda/src/internal/_reduce.js","webpack:///./node_modules/ramda/src/internal/_xwrap.js","webpack:///./node_modules/ramda/src/bind.js","webpack:///./node_modules/ramda/src/internal/_xmap.js","webpack:///./node_modules/ramda/src/internal/_xfBase.js","webpack:///./node_modules/ramda/src/curryN.js","webpack:///./node_modules/ramda/src/internal/_curryN.js","webpack:///./node_modules/ramda/src/internal/_curry1.js","webpack:///./node_modules/ramda/src/internal/_curry2.js"],"names":["module","exports","a","prop","obj","Object","prototype","hasOwnProperty","call","n","fn","apply","this","arguments","a0","a1","a2","a3","a4","a5","a6","a7","a8","a9","Error","_curry1","_has","_isArguments","hasEnumBug","toString","propertyIsEnumerable","nonEnumerableProps","hasArgsEnumBug","contains","list","item","idx","length","keys","nIdx","ks","checkArgsLength","_isArray","_isString","_isArrayLike","x","nodeType","Array","isArray","val","identity","uniq","uniqBy","flatten","_makeFlat","_curry2","_dispatchable","_map","_reduce","_xmap","curryN","map","functor","acc","key","_Set","appliedItem","set","result","add","push","_includes","_nativeSet","Set","_items","hasOrAdd","has","shouldAdd","prevSize","type","Infinity","size","bIdx","_indexOf","equals","inf","indexOf","_equals","b","_arrayFromIterator","_includesWith","_functionName","_objectIs","_uniqContentEquals","aIterator","bIterator","stackA","stackB","eq","_a","_b","slice","aItem","typeA","constructor","valueOf","name","message","source","global","ignoreCase","multiline","sticky","unicode","entries","concat","values","keysA","extendedStackA","extendedStackB","iter","next","done","value","pred","len","f","match","String","is","undefined","recursive","flatt","jlen","j","ilen","_isTransformer","methodNames","xf","args","pop","transducer","_xwrap","bind","_iterableReduce","step","_methodReduce","methodName","symIterator","Symbol","iterator","_arrayReduce","reduce","TypeError","XWrap","_arity","thisObj","_xfBase","XMap","init","input","_curryN","_isPlaceholder","received","combined","argsIdx","left","combinedIdx","f1","f2"],"mappings":"4EAGAA,EAAOC,QAHP,SAAwBC,GACjB,OAAY,MAALA,GAA0B,iBAANA,IAAoD,IAAlCA,EAAE,8B,kBCEtDF,EAAOC,QAHP,SAAcE,EAAMC,GAClB,OAAOC,OAAOC,UAAUC,eAAeC,KAAKJ,EAAKD,K,kBCkDnDH,EAAOC,QAnDP,SAAgBQ,EAAGC,GAEjB,OAAQD,GACN,KAAK,EACH,OAAO,WACL,OAAOC,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,EACH,OAAO,SAAUC,GACf,OAAOJ,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,EACH,OAAO,SAAUC,EAAIC,GACnB,OAAOL,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,EACH,OAAO,SAAUC,EAAIC,EAAIC,GACvB,OAAON,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,EACH,OAAO,SAAUC,EAAIC,EAAIC,EAAIC,GAC3B,OAAOP,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,EACH,OAAO,SAAUC,EAAIC,EAAIC,EAAIC,EAAIC,GAC/B,OAAOR,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,EACH,OAAO,SAAUC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GACnC,OAAOT,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,EACH,OAAO,SAAUC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GACvC,OAAOV,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,EACH,OAAO,SAAUC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAC3C,OAAOX,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,EACH,OAAO,SAAUC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GAC/C,OAAOZ,EAAGC,MAAMC,KAAMC,YAE1B,KAAK,GACH,OAAO,SAAUC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,GACnD,OAAOb,EAAGC,MAAMC,KAAMC,YAE1B,QACE,MAAM,IAAIW,MAAM,kF,oBChDtB,IAAIC,EAAuB,EAAQ,IAE/BC,EAAoB,EAAQ,KAE5BC,EAA4B,EAAQ,KAKpCC,GAA4B,CAAEC,SAAU,MAAOC,qBAAqB,YACpEC,EAAqB,CAAC,cAAe,UAAW,gBAAiB,WAAY,uBAAwB,iBAAkB,kBAEvHC,EAA8B,WAChC,aAEA,OAAOnB,UAAUiB,qBAAqB,UAHN,GAM9BG,EAAW,SAAkBC,EAAMC,GAErC,IADA,IAAIC,EAAM,EACHA,EAAMF,EAAKG,QAAQ,CACxB,GAAIH,EAAKE,KAASD,EAChB,OAAO,EAETC,GAAO,EAET,OAAO,GAqBLE,EAA8B,mBAAhBjC,OAAOiC,MAAwBN,EAE/BP,GAAQ,SAAcrB,GACtC,GAAIC,OAAOD,KAASA,EAClB,MAAO,GAET,IAAID,EAAMoC,EACNC,EAAK,GACLC,EAAkBT,GAAkBL,EAAavB,GACrD,IAAKD,KAAQC,GACPsB,EAAKvB,EAAMC,IAAUqC,GAA4B,WAATtC,IAC1CqC,EAAGA,EAAGH,QAAUlC,GAGpB,GAAIyB,EAEF,IADAW,EAAOR,EAAmBM,OAAS,EAC5BE,GAAQ,GAETb,EADJvB,EAAO4B,EAAmBQ,GACXnC,KAAS6B,EAASO,EAAIrC,KACnCqC,EAAGA,EAAGH,QAAUlC,GAElBoC,GAAQ,EAGZ,OAAOC,KAxBsEf,GAAQ,SAAcrB,GACnG,OAAOC,OAAOD,KAASA,EAAM,GAAKC,OAAOiC,KAAKlC,MAyBhDJ,EAAOC,QAAUqC,G,oBCzEjB,IAAIb,EAAuB,EAAQ,IAE/BiB,EAAwB,EAAQ,KAEhCC,EAAyB,EAAQ,KAqBjCC,EAA4BnB,GAAQ,SAAqBoB,GAC3D,QAAIH,EAASG,MAGRA,IAGY,iBAANA,KAGPF,EAAUE,KAGK,IAAfA,EAAEC,WACKD,EAAER,OAEI,IAAbQ,EAAER,QAGFQ,EAAER,OAAS,IACNQ,EAAEtC,eAAe,IAAMsC,EAAEtC,eAAesC,EAAER,OAAS,UAI9DrC,EAAOC,QAAU2C,G,kBCrCjB5C,EAAOC,QAAU8C,MAAMC,SAAW,SAAkBC,GAClD,OAAc,MAAPA,GAAeA,EAAIZ,QAAU,GAA6C,mBAAxChC,OAAOC,UAAUuB,SAASrB,KAAKyC,K,oBCb1E,IAAIC,EAAwB,EAAQ,KAuBhCC,EArBsB,EAAQ,IAqBVC,CAAOF,GAC/BlD,EAAOC,QAAUkD,G,oBCxBjB,IAuBIE,EAvBuB,EAAQ,GAuBR5B,CArBE,EAAQ,IAqBY6B,EAAU,IAC3DtD,EAAOC,QAAUoD,G,oBCxBjB,IAAIE,EAAuB,EAAQ,IAE/BC,EAA6B,EAAQ,KAErCC,EAAoB,EAAQ,KAE5BC,EAAuB,EAAQ,KAE/BC,EAAqB,EAAQ,KAE7BC,EAAsB,EAAQ,KAE9BtB,EAAoB,EAAQ,KAuC5BuB,EAAmBN,EAAsBC,EAAc,CAAC,mBAAoB,OAAQG,GAAO,SAAajD,EAAIoD,GAC9G,OAAQzD,OAAOC,UAAUuB,SAASrB,KAAKsD,IACrC,IAAK,oBACH,OAAOF,EAAOE,EAAQzB,QAAQ,WAC5B,OAAO3B,EAAGF,KAAKI,KAAMkD,EAAQnD,MAAMC,KAAMC,eAE7C,IAAK,kBACH,OAAO6C,GAAQ,SAAUK,EAAKC,GAE5B,OADAD,EAAIC,GAAOtD,EAAGoD,EAAQE,IACfD,IACN,GAAIzB,EAAKwB,IACd,QACE,OAAOL,EAAK/C,EAAIoD,QAGtB9D,EAAOC,QAAU4D,G,oBClEjB,IAyBIX,EAzBuB,EAAQ,GAyBPzB,CAvBC,EAAQ,MAwBrCzB,EAAOC,QAAUiD,G,kBCvBjBlD,EAAOC,QAHP,SAAmB4C,GACjB,OAAOA,I,oBCDT,IAAIoB,EAAoB,EAAQ,KAwB5Bb,EAtBuB,EAAQ,GAsBTG,EAAQ,SAAgB7C,EAAIwB,GAMpD,IALA,IAGIgC,EAAa/B,EAHbgC,EAAM,IAAIF,EACVG,EAAS,GACThC,EAAM,EAGHA,EAAMF,EAAKG,QAEhB6B,EAAcxD,EADdyB,EAAOD,EAAKE,IAER+B,EAAIE,IAAIH,IACVE,EAAOE,KAAKnC,GAEdC,GAAO,EAET,OAAOgC,KAETpE,EAAOC,QAAUmD,G,oBCxCjB,IAAImB,EAAyB,EAAQ,KAEjCN,EAAoB,WAEtB,SAASA,IAEPrD,KAAK4D,WAA4B,mBAARC,IAAqB,IAAIA,IAAQ,KAC1D7D,KAAK8D,OAAS,GA6BhB,OAtBAT,EAAK3D,UAAU+D,IAAM,SAAUlC,GAC7B,OAAQwC,EAASxC,GAAM,EAAMvB,OAO/BqD,EAAK3D,UAAUsE,IAAM,SAAUzC,GAC7B,OAAOwC,EAASxC,GAAM,EAAOvB,OAaxBqD,EAlCe,GAqCxB,SAASU,EAASxC,EAAM0C,EAAWV,GACjC,IACIW,EADAC,SAAc5C,EAElB,OAAQ4C,GACN,IAAK,SACL,IAAK,SAEH,OAAa,IAAT5C,GAAc,EAAIA,IAAU6C,MAC1Bb,EAAIO,OAAO,QAGTG,IACFV,EAAIO,OAAO,OAAQ,IAEd,GAIY,OAAnBP,EAAIK,WACFK,GACFC,EAAWX,EAAIK,WAAWS,KAC1Bd,EAAIK,WAAWH,IAAIlC,GACTgC,EAAIK,WAAWS,OACNH,GAEZX,EAAIK,WAAWI,IAAIzC,GAGtB4C,KAAQZ,EAAIO,OAMPvC,KAAQgC,EAAIO,OAAOK,KAGxBF,IACFV,EAAIO,OAAOK,GAAM5C,IAAQ,IAEpB,IAXH0C,IACFV,EAAIO,OAAOK,GAAQ,GACnBZ,EAAIO,OAAOK,GAAM5C,IAAQ,IAEpB,GAWb,IAAK,UAGH,GAAI4C,KAAQZ,EAAIO,OAAQ,CACtB,IAAIQ,EAAO/C,EAAO,EAAI,EACtB,QAAIgC,EAAIO,OAAOK,GAAMG,KAGfL,IACFV,EAAIO,OAAOK,GAAMG,IAAQ,IAEpB,GAMT,OAHIL,IACFV,EAAIO,OAAOK,GAAQ5C,EAAO,EAAC,GAAO,GAAQ,EAAC,GAAM,KAE5C,EAGX,IAAK,WAEH,OAAuB,OAAnBgC,EAAIK,WACFK,GACFC,EAAWX,EAAIK,WAAWS,KAC1Bd,EAAIK,WAAWH,IAAIlC,GACTgC,EAAIK,WAAWS,OACNH,GAEZX,EAAIK,WAAWI,IAAIzC,GAGtB4C,KAAQZ,EAAIO,SAMbH,EAAUpC,EAAMgC,EAAIO,OAAOK,MAC1BF,GACFV,EAAIO,OAAOK,GAAMT,KAAKnC,IAEjB,IATH0C,IACFV,EAAIO,OAAOK,GAAQ,CAAC5C,KAEf,GAWb,IAAK,YACH,QAAIgC,EAAIO,OAAOK,KAGTF,IACFV,EAAIO,OAAOK,IAAQ,IAEd,GAGX,IAAK,SACH,GAAa,OAAT5C,EACF,QAAKgC,EAAIO,OAAa,OAChBG,IACFV,EAAIO,OAAa,MAAI,IAEhB,GAKb,QAIE,OADAK,EAAO1E,OAAOC,UAAUuB,SAASrB,KAAK2B,MACxBgC,EAAIO,SAObH,EAAUpC,EAAMgC,EAAIO,OAAOK,MAC1BF,GACFV,EAAIO,OAAOK,GAAMT,KAAKnC,IAEjB,IAVH0C,IACFV,EAAIO,OAAOK,GAAQ,CAAC5C,KAEf,IAcfnC,EAAOC,QAAUgE,G,oBC7KjB,IAAIkB,EAAwB,EAAQ,KAKpCnF,EAAOC,QAHP,SAAmBC,EAAGgC,GACpB,OAAOiD,EAASjD,EAAMhC,EAAG,IAAM,I,oBCHjC,IAAIkF,EAAsB,EAAQ,KAwDlCpF,EAAOC,QAtDP,SAAkBiC,EAAMhC,EAAGkC,GACzB,IAAIiD,EAAKlD,EAET,GAA4B,mBAAjBD,EAAKoD,QACd,cAAepF,GACb,IAAK,SACH,GAAU,IAANA,EAAS,CAGX,IADAmF,EAAM,EAAInF,EACHkC,EAAMF,EAAKG,QAAQ,CAExB,GAAa,KADbF,EAAOD,EAAKE,KACM,EAAID,IAASkD,EAC7B,OAAOjD,EAETA,GAAO,EAET,OAAQ,EACH,GAAIlC,GAAMA,EAAG,CAElB,KAAOkC,EAAMF,EAAKG,QAAQ,CAExB,GAAoB,iBADpBF,EAAOD,EAAKE,KACoBD,GAASA,EACvC,OAAOC,EAETA,GAAO,EAET,OAAQ,EAGV,OAAOF,EAAKoD,QAAQpF,EAAGkC,GAGzB,IAAK,SACL,IAAK,UACL,IAAK,WACL,IAAK,YACH,OAAOF,EAAKoD,QAAQpF,EAAGkC,GAEzB,IAAK,SACH,GAAU,OAANlC,EAEF,OAAOgC,EAAKoD,QAAQpF,EAAGkC,GAK/B,KAAOA,EAAMF,EAAKG,QAAQ,CACxB,GAAI+C,EAAOlD,EAAKE,GAAMlC,GACpB,OAAOkC,EAETA,GAAO,EAET,OAAQ,I,oBCtDV,IAAImB,EAAuB,EAAQ,IAE/BgC,EAAuB,EAAQ,KA6B/BH,EAAsB7B,GAAQ,SAAgBrD,EAAGsF,GACnD,OAAOD,EAAQrF,EAAGsF,EAAG,GAAI,OAE3BxF,EAAOC,QAAUmF,G,oBClCjB,IAAIK,EAAkC,EAAQ,KAE1CC,EAA6B,EAAQ,KAErCC,EAA6B,EAAQ,KAErCjE,EAAoB,EAAQ,KAE5BkE,EAAyB,EAAQ,KAEjCtD,EAAoB,EAAQ,KAE5ByC,EAAoB,EAAQ,KAahC,SAASc,EAAmBC,EAAWC,EAAWC,EAAQC,GACxD,IAAI/F,EAAIuF,EAAmBK,GACvBN,EAAIC,EAAmBM,GAE3B,SAASG,EAAGC,EAAIC,GACd,OAAOb,EAAQY,EAAIC,EAAIJ,EAAOK,QAASJ,EAAOI,SAIhD,OAAQX,GAAc,SAAUF,EAAGc,GACjC,OAAQZ,EAAcQ,EAAII,EAAOd,KAChCA,EAAGtF,GAGR,SAASqF,EAAQrF,EAAGsF,EAAGQ,EAAQC,GAC7B,GAAIL,EAAU1F,EAAGsF,GACf,OAAO,EAGT,IAAIe,EAAQxB,EAAK7E,GAEjB,GAAIqG,IAAUxB,EAAKS,GACjB,OAAO,EAGT,GAAS,MAALtF,GAAkB,MAALsF,EACf,OAAO,EAGT,GAAwC,mBAA7BtF,EAAE,wBAA6E,mBAA7BsF,EAAE,uBAC7D,MAA2C,mBAA7BtF,EAAE,wBAAyCA,EAAE,uBAAuBsF,IAA0C,mBAA7BA,EAAE,wBAAyCA,EAAE,uBAAuBtF,GAGrK,GAAwB,mBAAbA,EAAEkF,QAA6C,mBAAbI,EAAEJ,OAC7C,MAA2B,mBAAblF,EAAEkF,QAAyBlF,EAAEkF,OAAOI,IAA0B,mBAAbA,EAAEJ,QAAyBI,EAAEJ,OAAOlF,GAGrG,OAAQqG,GACN,IAAK,YACL,IAAK,QACL,IAAK,SACH,GAA6B,mBAAlBrG,EAAEsG,aAA+D,YAAjCb,EAAczF,EAAEsG,aACzD,OAAOtG,IAAMsF,EAEf,MACF,IAAK,UACL,IAAK,SACL,IAAK,SACH,UAAatF,UAAasF,IAAKI,EAAU1F,EAAEuG,UAAWjB,EAAEiB,WACtD,OAAO,EAET,MACF,IAAK,OACH,IAAKb,EAAU1F,EAAEuG,UAAWjB,EAAEiB,WAC5B,OAAO,EAET,MACF,IAAK,QACH,OAAOvG,EAAEwG,OAASlB,EAAEkB,MAAQxG,EAAEyG,UAAYnB,EAAEmB,QAC9C,IAAK,SACH,GAAMzG,EAAE0G,SAAWpB,EAAEoB,QAAU1G,EAAE2G,SAAWrB,EAAEqB,QAAU3G,EAAE4G,aAAetB,EAAEsB,YAAc5G,EAAE6G,YAAcvB,EAAEuB,WAAa7G,EAAE8G,SAAWxB,EAAEwB,QAAU9G,EAAE+G,UAAYzB,EAAEyB,QAC/J,OAAO,EAMb,IADA,IAAI7E,EAAM4D,EAAO3D,OAAS,EACnBD,GAAO,GAAG,CACf,GAAI4D,EAAO5D,KAASlC,EAClB,OAAO+F,EAAO7D,KAASoD,EAEzBpD,GAAO,EAGT,OAAQmE,GACN,IAAK,MACH,OAAIrG,EAAE+E,OAASO,EAAEP,MAIVY,EAAmB3F,EAAEgH,UAAW1B,EAAE0B,UAAWlB,EAAOmB,OAAO,CAACjH,IAAK+F,EAAOkB,OAAO,CAAC3B,KACzF,IAAK,MACH,OAAItF,EAAE+E,OAASO,EAAEP,MAIVY,EAAmB3F,EAAEkH,SAAU5B,EAAE4B,SAAUpB,EAAOmB,OAAO,CAACjH,IAAK+F,EAAOkB,OAAO,CAAC3B,KACvF,IAAK,YACL,IAAK,QACL,IAAK,SACL,IAAK,UACL,IAAK,SACL,IAAK,SACL,IAAK,OACL,IAAK,QACL,IAAK,SACL,IAAK,YACL,IAAK,aACL,IAAK,oBACL,IAAK,aACL,IAAK,cACL,IAAK,aACL,IAAK,cACL,IAAK,eACL,IAAK,eACL,IAAK,cACH,MACF,QAEE,OAAO,EAGX,IAAI6B,EAAQ/E,EAAKpC,GACjB,GAAImH,EAAMhF,SAAWC,EAAKkD,GAAGnD,OAC3B,OAAO,EAGT,IAAIiF,EAAiBtB,EAAOmB,OAAO,CAACjH,IAChCqH,EAAiBtB,EAAOkB,OAAO,CAAC3B,IAGpC,IADApD,EAAMiF,EAAMhF,OAAS,EACdD,GAAO,GAAG,CACf,IAAI4B,EAAMqD,EAAMjF,GAChB,IAAMV,EAAKsC,EAAKwB,KAAMD,EAAQC,EAAExB,GAAM9D,EAAE8D,GAAMsD,EAAgBC,GAC5D,OAAO,EAETnF,GAAO,EAET,OAAO,EAETpC,EAAOC,QAAUsF,G,kBCnJjBvF,EAAOC,QARP,SAA4BuH,GAG1B,IAFA,IACIC,EADAvF,EAAO,KAEFuF,EAAOD,EAAKC,QAAQC,MAC3BxF,EAAKoC,KAAKmD,EAAKE,OAEjB,OAAOzF,I,kBCMTlC,EAAOC,QAZP,SAAuB2H,EAAM/E,EAAGX,GAI9B,IAHA,IAAIE,EAAM,EACNyF,EAAM3F,EAAKG,OAERD,EAAMyF,GAAK,CAChB,GAAID,EAAK/E,EAAGX,EAAKE,IACf,OAAO,EAETA,GAAO,EAET,OAAO,I,kBCLTpC,EAAOC,QALP,SAAuB6H,GAErB,IAAIC,EAAQC,OAAOF,GAAGC,MAAM,mBAC5B,OAAgB,MAATA,EAAgB,GAAKA,EAAM,K,kBCUpC/H,EAAOC,QAA+B,mBAAdI,OAAO4H,GAAoB5H,OAAO4H,GAZ1D,SAAmB/H,EAAGsF,GAEpB,OAAItF,IAAMsF,EAGK,IAANtF,GAAW,EAAIA,GAAM,EAAIsF,EAGzBtF,GAAMA,GAAKsF,GAAMA,I,oBCT5B,IAAI9D,EAAoB,EAAQ,KAE5BG,EAAWxB,OAAOC,UAAUuB,SAC5BF,EAA4B,WAC9B,MAAoC,uBAA7BE,EAASrB,KAAKK,WAAsC,SAAsBgC,GAC/E,MAA4B,uBAArBhB,EAASrB,KAAKqC,IACnB,SAAsBA,GACxB,OAAOnB,EAAK,SAAUmB,IAJM,GAQhC7C,EAAOC,QAAU0B,G,oBCXjB,IA6BIoD,EA7BuB,EAAQ,GA6BXtD,EAAQ,SAAcwB,GAC5C,OAAe,OAARA,EAAe,YAAiBiF,IAARjF,EAAoB,YAAc5C,OAAOC,UAAUuB,SAASrB,KAAKyC,GAAKoD,MAAM,GAAI,MAEjHrG,EAAOC,QAAU8E,G,oBChCjB,IAAInC,EAA4B,EAAQ,KAkCxC5C,EAAOC,QAxBP,SAAmBkI,GACjB,OAAO,SAASC,EAAMlG,GAMpB,IALA,IAAIyF,EAAOU,EAAMC,EACblE,EAAS,GACThC,EAAM,EACNmG,EAAOrG,EAAKG,OAETD,EAAMmG,GAAM,CACjB,GAAI3F,EAAaV,EAAKE,IAIpB,IAFAkG,EAAI,EACJD,GAFAV,EAAQQ,EAAYC,EAAMlG,EAAKE,IAAQF,EAAKE,IAE/BC,OACNiG,EAAID,GACTjE,EAAOA,EAAO/B,QAAUsF,EAAMW,GAC9BA,GAAK,OAGPlE,EAAOA,EAAO/B,QAAUH,EAAKE,GAE/BA,GAAO,EAET,OAAOgC,K,kBC5BXpE,EAAOC,QAHP,SAAmB4C,GACjB,MAA6C,oBAAtCxC,OAAOC,UAAUuB,SAASrB,KAAKqC,K,oBCDxC,IAAIH,EAAwB,EAAQ,KAEhC8F,EAA8B,EAAQ,KAyC1CxI,EAAOC,QAvBP,SAAuBwI,EAAaC,EAAIhI,GACtC,OAAO,WACL,GAAyB,IAArBG,UAAUwB,OACZ,OAAO3B,IAET,IAAIiI,EAAO5F,MAAMzC,UAAU+F,MAAM7F,KAAKK,UAAW,GAC7CT,EAAMuI,EAAKC,MACf,IAAKlG,EAAStC,GAAM,CAElB,IADA,IAAIgC,EAAM,EACHA,EAAMqG,EAAYpG,QAAQ,CAC/B,GAAqC,mBAA1BjC,EAAIqI,EAAYrG,IACzB,OAAOhC,EAAIqI,EAAYrG,IAAMzB,MAAMP,EAAKuI,GAE1CvG,GAAO,EAET,GAAIoG,EAAepI,GAAM,CACvB,IAAIyI,EAAaH,EAAG/H,MAAM,KAAMgI,GAChC,OAAOE,EAAWzI,IAGtB,OAAOM,EAAGC,MAAMC,KAAMC,c,kBCrC1Bb,EAAOC,QAHP,SAAwBG,GACtB,OAAc,MAAPA,GAAmD,mBAA7BA,EAAI,uB,kBCSnCJ,EAAOC,QAVP,SAAcS,EAAIoD,GAIhB,IAHA,IAAI1B,EAAM,EACNyF,EAAM/D,EAAQzB,OACd+B,EAASrB,MAAM8E,GACZzF,EAAMyF,GACXzD,EAAOhC,GAAO1B,EAAGoD,EAAQ1B,IACzBA,GAAO,EAET,OAAOgC,I,oBCRT,IAAIxB,EAA4B,EAAQ,KAEpCkG,EAAsB,EAAQ,KAE9BC,EAAoB,EAAQ,KAgBhC,SAASC,EAAgBN,EAAI3E,EAAKyD,GAEhC,IADA,IAAIyB,EAAOzB,EAAKC,QACRwB,EAAKvB,MAAM,CAEjB,IADA3D,EAAM2E,EAAG,qBAAqB3E,EAAKkF,EAAKtB,SAC7B5D,EAAI,wBAAyB,CACtCA,EAAMA,EAAI,sBACV,MAEFkF,EAAOzB,EAAKC,OAEd,OAAOiB,EAAG,uBAAuB3E,GAGnC,SAASmF,EAAcR,EAAI3E,EAAK3D,EAAK+I,GACnC,OAAOT,EAAG,uBAAuBtI,EAAI+I,GAAYJ,EAAKL,EAAG,qBAAsBA,GAAK3E,IAGtF,IAAIqF,EAAgC,oBAAXC,OAAyBA,OAAOC,SAAW,aAwBpEtJ,EAAOC,QAtBP,SAAiBS,EAAIqD,EAAK7B,GAIxB,GAHkB,mBAAPxB,IACTA,EAAKoI,EAAOpI,IAEVkC,EAAaV,GACf,OAtCJ,SAAsBwG,EAAI3E,EAAK7B,GAG7B,IAFA,IAAIE,EAAM,EACNyF,EAAM3F,EAAKG,OACRD,EAAMyF,GAAK,CAEhB,IADA9D,EAAM2E,EAAG,qBAAqB3E,EAAK7B,EAAKE,MAC7B2B,EAAI,wBAAyB,CACtCA,EAAMA,EAAI,sBACV,MAEF3B,GAAO,EAET,OAAOsG,EAAG,uBAAuB3E,GA2BxBwF,CAAa7I,EAAIqD,EAAK7B,GAE/B,GAA2C,mBAAhCA,EAAK,uBACd,OAAOgH,EAAcxI,EAAIqD,EAAK7B,EAAM,uBAEtC,GAAyB,MAArBA,EAAKkH,GACP,OAAOJ,EAAgBtI,EAAIqD,EAAK7B,EAAKkH,MAEvC,GAAyB,mBAAdlH,EAAKuF,KACd,OAAOuB,EAAgBtI,EAAIqD,EAAK7B,GAElC,GAA2B,mBAAhBA,EAAKsH,OACd,OAAON,EAAcxI,EAAIqD,EAAK7B,EAAM,UAGtC,MAAM,IAAIuH,UAAU,4C,kBC3DtB,IAAIC,EAAqB,WACvB,SAASA,EAAMhJ,GACbE,KAAKkH,EAAIpH,EAYX,OAVAgJ,EAAMpJ,UAAU,qBAAuB,WACrC,MAAM,IAAIkB,MAAM,kCAElBkI,EAAMpJ,UAAU,uBAAyB,SAAUyD,GACjD,OAAOA,GAET2F,EAAMpJ,UAAU,qBAAuB,SAAUyD,EAAKlB,GACpD,OAAOjC,KAAKkH,EAAE/D,EAAKlB,IAGd6G,EAdgB,GAoBzB1J,EAAOC,QAHP,SAAgBS,GACd,OAAO,IAAIgJ,EAAMhJ,K,oBClBnB,IAAIiJ,EAAsB,EAAQ,KA4B9BZ,EA1BuB,EAAQ,GA0BXxF,EAAQ,SAAc7C,EAAIkJ,GAChD,OAAOD,EAAOjJ,EAAG2B,QAAQ,WACvB,OAAO3B,EAAGC,MAAMiJ,EAAS/I,iBAG7Bb,EAAOC,QAAU8I,G,oBCjCjB,IAAIxF,EAAuB,EAAQ,IAE/BsG,EAAuB,EAAQ,KAE/BC,EAAoB,WAEtB,SAASA,EAAKhC,EAAGY,GACf9H,KAAK8H,GAAKA,EACV9H,KAAKkH,EAAIA,EAQX,OANAgC,EAAKxJ,UAAU,qBAAuBuJ,EAAQE,KAC9CD,EAAKxJ,UAAU,uBAAyBuJ,EAAQzF,OAChD0F,EAAKxJ,UAAU,qBAAuB,SAAU8D,EAAQ4F,GACtD,OAAOpJ,KAAK8H,GAAG,qBAAqBtE,EAAQxD,KAAKkH,EAAEkC,KAG9CF,EAZe,GAepBnG,EAAqBJ,GAAQ,SAAeuE,EAAGY,GACjD,OAAO,IAAIoB,EAAKhC,EAAGY,MAErB1I,EAAOC,QAAU0D,G,kBCtBjB3D,EAAOC,QAAU,CACf8J,KAAM,WACJ,OAAOnJ,KAAK8H,GAAG,wBAEjBtE,OAAQ,SAAUA,GAChB,OAAOxD,KAAK8H,GAAG,uBAAuBtE,M,oBCL1C,IAAIuF,EAAsB,EAAQ,KAE9BlI,EAAuB,EAAQ,IAE/B8B,EAAuB,EAAQ,IAE/B0G,EAAuB,EAAQ,KA8C/BrG,EAAsBL,GAAQ,SAAgBlB,EAAQ3B,GACxD,OAAe,IAAX2B,EACKZ,EAAQf,GAEViJ,EAAOtH,EAAQ4H,EAAQ5H,EAAQ,GAAI3B,OAE5CV,EAAOC,QAAU2D,G,oBC1DjB,IAAI+F,EAAsB,EAAQ,KAE9BO,EAA8B,EAAQ,KAqC1ClK,EAAOC,QAvBP,SAASgK,EAAQ5H,EAAQ8H,EAAUzJ,GACjC,OAAO,WAKL,IAJA,IAAI0J,EAAW,GACXC,EAAU,EACVC,EAAOjI,EACPkI,EAAc,EACXA,EAAcJ,EAAS9H,QAAUgI,EAAUxJ,UAAUwB,QAAQ,CAClE,IAAI+B,EACAmG,EAAcJ,EAAS9H,UAAY6H,EAAeC,EAASI,KAAiBF,GAAWxJ,UAAUwB,QACnG+B,EAAS+F,EAASI,IAElBnG,EAASvD,UAAUwJ,GACnBA,GAAW,GAEbD,EAASG,GAAenG,EACnB8F,EAAe9F,KAClBkG,GAAQ,GAEVC,GAAe,EAEjB,OAAOD,GAAQ,EAAI5J,EAAGC,MAAMC,KAAMwJ,GAAYT,EAAOW,EAAML,EAAQ5H,EAAQ+H,EAAU1J,O,mBCpCzF,IAAIwJ,EAA8B,EAAQ,KAqB1ClK,EAAOC,QATP,SAAiBS,GACf,OAAO,SAAS8J,EAAGtK,GACjB,OAAyB,IAArBW,UAAUwB,QAAgB6H,EAAehK,GACpCsK,EAEA9J,EAAGC,MAAMC,KAAMC,c,mBCjB5B,IAAIY,EAAuB,EAAQ,IAE/ByI,EAA8B,EAAQ,KA8B1ClK,EAAOC,QAlBP,SAAiBS,GACf,OAAO,SAAS+J,EAAGvK,EAAGsF,GACpB,OAAQ3E,UAAUwB,QAChB,KAAK,EACH,OAAOoI,EACT,KAAK,EACH,OAAOP,EAAehK,GAAKuK,EAAKhJ,GAAQ,SAAU2E,GAChD,OAAO1F,EAAGR,EAAGkG,MAEjB,QACE,OAAO8D,EAAehK,IAAMgK,EAAe1E,GAAKiF,EAAKP,EAAehK,GAAKuB,GAAQ,SAAU0E,GACzF,OAAOzF,EAAGyF,EAAIX,MACX0E,EAAe1E,GAAK/D,GAAQ,SAAU2E,GACzC,OAAO1F,EAAGR,EAAGkG,MACV1F,EAAGR,EAAGsF","file":"npm.ramda.c920b4ddeb9b68365139.js","sourcesContent":["function _isPlaceholder(a) {\n       return a != null && typeof a === 'object' && a['@@functional/placeholder'] === true;\n}\nmodule.exports = _isPlaceholder;","function _has(prop, obj) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\nmodule.exports = _has;","function _arity(n, fn) {\n  /* eslint-disable no-unused-vars */\n  switch (n) {\n    case 0:\n      return function () {\n        return fn.apply(this, arguments);\n      };\n    case 1:\n      return function (a0) {\n        return fn.apply(this, arguments);\n      };\n    case 2:\n      return function (a0, a1) {\n        return fn.apply(this, arguments);\n      };\n    case 3:\n      return function (a0, a1, a2) {\n        return fn.apply(this, arguments);\n      };\n    case 4:\n      return function (a0, a1, a2, a3) {\n        return fn.apply(this, arguments);\n      };\n    case 5:\n      return function (a0, a1, a2, a3, a4) {\n        return fn.apply(this, arguments);\n      };\n    case 6:\n      return function (a0, a1, a2, a3, a4, a5) {\n        return fn.apply(this, arguments);\n      };\n    case 7:\n      return function (a0, a1, a2, a3, a4, a5, a6) {\n        return fn.apply(this, arguments);\n      };\n    case 8:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7) {\n        return fn.apply(this, arguments);\n      };\n    case 9:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8) {\n        return fn.apply(this, arguments);\n      };\n    case 10:\n      return function (a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {\n        return fn.apply(this, arguments);\n      };\n    default:\n      throw new Error('First argument to _arity must be a non-negative integer no greater than ten');\n  }\n}\nmodule.exports = _arity;","var _curry1 = /*#__PURE__*/require('./internal/_curry1');\n\nvar _has = /*#__PURE__*/require('./internal/_has');\n\nvar _isArguments = /*#__PURE__*/require('./internal/_isArguments');\n\n// cover IE < 9 keys issues\n\n\nvar hasEnumBug = ! /*#__PURE__*/{ toString: null }.propertyIsEnumerable('toString');\nvar nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n// Safari bug\nvar hasArgsEnumBug = /*#__PURE__*/function () {\n  'use strict';\n\n  return arguments.propertyIsEnumerable('length');\n}();\n\nvar 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/**\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 * @see R.keysIn, R.values\n * @example\n *\n *      R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']\n */\nvar keys = typeof Object.keys === 'function' && !hasArgsEnumBug ? /*#__PURE__*/_curry1(function keys(obj) {\n  return Object(obj) !== obj ? [] : Object.keys(obj);\n}) : /*#__PURE__*/_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});\nmodule.exports = keys;","var _curry1 = /*#__PURE__*/require('./_curry1');\n\nvar _isArray = /*#__PURE__*/require('./_isArray');\n\nvar _isString = /*#__PURE__*/require('./_isString');\n\n/**\n * Tests whether or not an object is similar to an array.\n *\n * @private\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 *      _isArrayLike([]); //=> true\n *      _isArrayLike(true); //=> false\n *      _isArrayLike({}); //=> false\n *      _isArrayLike({length: 10}); //=> false\n *      _isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true\n */\n\n\nvar _isArrayLike = /*#__PURE__*/_curry1(function isArrayLike(x) {\n  if (_isArray(x)) {\n    return true;\n  }\n  if (!x) {\n    return false;\n  }\n  if (typeof x !== 'object') {\n    return false;\n  }\n  if (_isString(x)) {\n    return false;\n  }\n  if (x.nodeType === 1) {\n    return !!x.length;\n  }\n  if (x.length === 0) {\n    return true;\n  }\n  if (x.length > 0) {\n    return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);\n  }\n  return false;\n});\nmodule.exports = _isArrayLike;","/**\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 && val.length >= 0 && Object.prototype.toString.call(val) === '[object Array]';\n};","var identity = /*#__PURE__*/require('./identity');\n\nvar uniqBy = /*#__PURE__*/require('./uniqBy');\n\n/**\n * Returns a new list containing only one copy of each element in the original\n * list. [`R.equals`](#equals) is used to determine equality.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [a]\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n *      R.uniq([1, 1, 2, 1]); //=> [1, 2]\n *      R.uniq([1, '1']);     //=> [1, '1']\n *      R.uniq([[42], [42]]); //=> [[42]]\n */\n\n\nvar uniq = /*#__PURE__*/uniqBy(identity);\nmodule.exports = uniq;","var _curry1 = /*#__PURE__*/require('./internal/_curry1');\n\nvar _makeFlat = /*#__PURE__*/require('./internal/_makeFlat');\n\n/**\n * Returns a new list by pulling every item out of it (and all its sub-arrays)\n * and putting them in a new array, depth-first.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category List\n * @sig [a] -> [b]\n * @param {Array} list The array to consider.\n * @return {Array} The flattened list.\n * @see R.unnest\n * @example\n *\n *      R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);\n *      //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n */\n\n\nvar flatten = /*#__PURE__*/_curry1( /*#__PURE__*/_makeFlat(true));\nmodule.exports = flatten;","var _curry2 = /*#__PURE__*/require('./internal/_curry2');\n\nvar _dispatchable = /*#__PURE__*/require('./internal/_dispatchable');\n\nvar _map = /*#__PURE__*/require('./internal/_map');\n\nvar _reduce = /*#__PURE__*/require('./internal/_reduce');\n\nvar _xmap = /*#__PURE__*/require('./internal/_xmap');\n\nvar curryN = /*#__PURE__*/require('./curryN');\n\nvar keys = /*#__PURE__*/require('./keys');\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 *      const 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 * @symb R.map(f, [a, b]) = [f(a), f(b)]\n * @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }\n * @symb R.map(f, functor_o) = functor_o.map(f)\n */\n\n\nvar map = /*#__PURE__*/_curry2( /*#__PURE__*/_dispatchable(['fantasy-land/map', '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}));\nmodule.exports = map;","var _curry1 = /*#__PURE__*/require('./internal/_curry1');\n\nvar _identity = /*#__PURE__*/require('./internal/_identity');\n\n/**\n * A function that does nothing but return the parameter supplied to it. Good\n * as a default or placeholder function.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> a\n * @param {*} x The value to return.\n * @return {*} The input value, `x`.\n * @example\n *\n *      R.identity(1); //=> 1\n *\n *      const obj = {};\n *      R.identity(obj) === obj; //=> true\n * @symb R.identity(a) = a\n */\n\n\nvar identity = /*#__PURE__*/_curry1(_identity);\nmodule.exports = identity;","function _identity(x) {\n  return x;\n}\nmodule.exports = _identity;","var _Set = /*#__PURE__*/require('./internal/_Set');\n\nvar _curry2 = /*#__PURE__*/require('./internal/_curry2');\n\n/**\n * Returns a new list containing only one copy of each element in the original\n * list, based upon the value returned by applying the supplied function to\n * each list element. Prefers the first item if the supplied function produces\n * the same value on two items. [`R.equals`](#equals) is used for comparison.\n *\n * @func\n * @memberOf R\n * @since v0.16.0\n * @category List\n * @sig (a -> b) -> [a] -> [a]\n * @param {Function} fn A function used to produce a value to use during comparisons.\n * @param {Array} list The array to consider.\n * @return {Array} The list of unique items.\n * @example\n *\n *      R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]\n */\n\n\nvar uniqBy = /*#__PURE__*/_curry2(function uniqBy(fn, list) {\n  var set = new _Set();\n  var result = [];\n  var idx = 0;\n  var appliedItem, item;\n\n  while (idx < list.length) {\n    item = list[idx];\n    appliedItem = fn(item);\n    if (set.add(appliedItem)) {\n      result.push(item);\n    }\n    idx += 1;\n  }\n  return result;\n});\nmodule.exports = uniqBy;","var _includes = /*#__PURE__*/require('./_includes');\n\nvar _Set = /*#__PURE__*/function () {\n\n  function _Set() {\n    /* globals Set */\n    this._nativeSet = typeof Set === 'function' ? new Set() : null;\n    this._items = {};\n  }\n\n  // until we figure out why jsdoc chokes on this\n  // @param item The item to add to the Set\n  // @returns {boolean} true if the item did not exist prior, otherwise false\n  //\n  _Set.prototype.add = function (item) {\n    return !hasOrAdd(item, true, this);\n  };\n\n  //\n  // @param item The item to check for existence in the Set\n  // @returns {boolean} true if the item exists in the Set, otherwise false\n  //\n  _Set.prototype.has = function (item) {\n    return hasOrAdd(item, false, this);\n  };\n\n  //\n  // Combines the logic for checking whether an item is a member of the set and\n  // for adding a new item to the set.\n  //\n  // @param item       The item to check or add to the Set instance.\n  // @param shouldAdd  If true, the item will be added to the set if it doesn't\n  //                   already exist.\n  // @param set        The set instance to check or add to.\n  // @return {boolean} true if the item already existed, otherwise false.\n  //\n  return _Set;\n}();\n\nfunction hasOrAdd(item, shouldAdd, set) {\n  var type = typeof item;\n  var prevSize, newSize;\n  switch (type) {\n    case 'string':\n    case 'number':\n      // distinguish between +0 and -0\n      if (item === 0 && 1 / item === -Infinity) {\n        if (set._items['-0']) {\n          return true;\n        } else {\n          if (shouldAdd) {\n            set._items['-0'] = true;\n          }\n          return false;\n        }\n      }\n      // these types can all utilise the native Set\n      if (set._nativeSet !== null) {\n        if (shouldAdd) {\n          prevSize = set._nativeSet.size;\n          set._nativeSet.add(item);\n          newSize = set._nativeSet.size;\n          return newSize === prevSize;\n        } else {\n          return set._nativeSet.has(item);\n        }\n      } else {\n        if (!(type in set._items)) {\n          if (shouldAdd) {\n            set._items[type] = {};\n            set._items[type][item] = true;\n          }\n          return false;\n        } else if (item in set._items[type]) {\n          return true;\n        } else {\n          if (shouldAdd) {\n            set._items[type][item] = true;\n          }\n          return false;\n        }\n      }\n\n    case 'boolean':\n      // set._items['boolean'] holds a two element array\n      // representing [ falseExists, trueExists ]\n      if (type in set._items) {\n        var bIdx = item ? 1 : 0;\n        if (set._items[type][bIdx]) {\n          return true;\n        } else {\n          if (shouldAdd) {\n            set._items[type][bIdx] = true;\n          }\n          return false;\n        }\n      } else {\n        if (shouldAdd) {\n          set._items[type] = item ? [false, true] : [true, false];\n        }\n        return false;\n      }\n\n    case 'function':\n      // compare functions for reference equality\n      if (set._nativeSet !== null) {\n        if (shouldAdd) {\n          prevSize = set._nativeSet.size;\n          set._nativeSet.add(item);\n          newSize = set._nativeSet.size;\n          return newSize === prevSize;\n        } else {\n          return set._nativeSet.has(item);\n        }\n      } else {\n        if (!(type in set._items)) {\n          if (shouldAdd) {\n            set._items[type] = [item];\n          }\n          return false;\n        }\n        if (!_includes(item, set._items[type])) {\n          if (shouldAdd) {\n            set._items[type].push(item);\n          }\n          return false;\n        }\n        return true;\n      }\n\n    case 'undefined':\n      if (set._items[type]) {\n        return true;\n      } else {\n        if (shouldAdd) {\n          set._items[type] = true;\n        }\n        return false;\n      }\n\n    case 'object':\n      if (item === null) {\n        if (!set._items['null']) {\n          if (shouldAdd) {\n            set._items['null'] = true;\n          }\n          return false;\n        }\n        return true;\n      }\n    /* falls through */\n    default:\n      // reduce the search size of heterogeneous sets by creating buckets\n      // for each type.\n      type = Object.prototype.toString.call(item);\n      if (!(type in set._items)) {\n        if (shouldAdd) {\n          set._items[type] = [item];\n        }\n        return false;\n      }\n      // scan through all previously applied items\n      if (!_includes(item, set._items[type])) {\n        if (shouldAdd) {\n          set._items[type].push(item);\n        }\n        return false;\n      }\n      return true;\n  }\n}\n\n// A simple Set type that honours R.equals semantics\nmodule.exports = _Set;","var _indexOf = /*#__PURE__*/require('./_indexOf');\n\nfunction _includes(a, list) {\n  return _indexOf(list, a, 0) >= 0;\n}\nmodule.exports = _includes;","var equals = /*#__PURE__*/require('../equals');\n\nfunction _indexOf(list, a, idx) {\n  var inf, item;\n  // Array.prototype.indexOf doesn't exist below IE9\n  if (typeof list.indexOf === 'function') {\n    switch (typeof a) {\n      case 'number':\n        if (a === 0) {\n          // manually crawl the list to distinguish between +0 and -0\n          inf = 1 / a;\n          while (idx < list.length) {\n            item = list[idx];\n            if (item === 0 && 1 / item === inf) {\n              return idx;\n            }\n            idx += 1;\n          }\n          return -1;\n        } else if (a !== a) {\n          // NaN\n          while (idx < list.length) {\n            item = list[idx];\n            if (typeof item === 'number' && item !== item) {\n              return idx;\n            }\n            idx += 1;\n          }\n          return -1;\n        }\n        // non-zero numbers can utilise Set\n        return list.indexOf(a, idx);\n\n      // all these types can utilise Set\n      case 'string':\n      case 'boolean':\n      case 'function':\n      case 'undefined':\n        return list.indexOf(a, idx);\n\n      case 'object':\n        if (a === null) {\n          // null can utilise Set\n          return list.indexOf(a, idx);\n        }\n    }\n  }\n  // anything else not covered above, defer to R.equals\n  while (idx < list.length) {\n    if (equals(list[idx], a)) {\n      return idx;\n    }\n    idx += 1;\n  }\n  return -1;\n}\nmodule.exports = _indexOf;","var _curry2 = /*#__PURE__*/require('./internal/_curry2');\n\nvar _equals = /*#__PURE__*/require('./internal/_equals');\n\n/**\n * Returns `true` if its arguments are equivalent, `false` otherwise. Handles\n * cyclical data structures.\n *\n * Dispatches symmetrically to the `equals` methods of both arguments, if\n * present.\n *\n * @func\n * @memberOf R\n * @since v0.15.0\n * @category Relation\n * @sig a -> b -> Boolean\n * @param {*} a\n * @param {*} b\n * @return {Boolean}\n * @example\n *\n *      R.equals(1, 1); //=> true\n *      R.equals(1, '1'); //=> false\n *      R.equals([1, 2, 3], [1, 2, 3]); //=> true\n *\n *      const a = {}; a.v = a;\n *      const b = {}; b.v = b;\n *      R.equals(a, b); //=> true\n */\n\n\nvar equals = /*#__PURE__*/_curry2(function equals(a, b) {\n  return _equals(a, b, [], []);\n});\nmodule.exports = equals;","var _arrayFromIterator = /*#__PURE__*/require('./_arrayFromIterator');\n\nvar _includesWith = /*#__PURE__*/require('./_includesWith');\n\nvar _functionName = /*#__PURE__*/require('./_functionName');\n\nvar _has = /*#__PURE__*/require('./_has');\n\nvar _objectIs = /*#__PURE__*/require('./_objectIs');\n\nvar keys = /*#__PURE__*/require('../keys');\n\nvar type = /*#__PURE__*/require('../type');\n\n/**\n * private _uniqContentEquals function.\n * That function is checking equality of 2 iterator contents with 2 assumptions\n * - iterators lengths are the same\n * - iterators values are unique\n *\n * false-positive result will be returned for comparision of, e.g.\n * - [1,2,3] and [1,2,3,4]\n * - [1,1,1] and [1,2,3]\n * */\n\nfunction _uniqContentEquals(aIterator, bIterator, stackA, stackB) {\n  var a = _arrayFromIterator(aIterator);\n  var b = _arrayFromIterator(bIterator);\n\n  function eq(_a, _b) {\n    return _equals(_a, _b, stackA.slice(), stackB.slice());\n  }\n\n  // if *a* array contains any element that is not included in *b*\n  return !_includesWith(function (b, aItem) {\n    return !_includesWith(eq, aItem, b);\n  }, b, a);\n}\n\nfunction _equals(a, b, stackA, stackB) {\n  if (_objectIs(a, b)) {\n    return true;\n  }\n\n  var typeA = type(a);\n\n  if (typeA !== type(b)) {\n    return false;\n  }\n\n  if (a == null || b == null) {\n    return false;\n  }\n\n  if (typeof a['fantasy-land/equals'] === 'function' || typeof b['fantasy-land/equals'] === 'function') {\n    return typeof a['fantasy-land/equals'] === 'function' && a['fantasy-land/equals'](b) && typeof b['fantasy-land/equals'] === 'function' && b['fantasy-land/equals'](a);\n  }\n\n  if (typeof a.equals === 'function' || typeof b.equals === 'function') {\n    return typeof a.equals === 'function' && a.equals(b) && typeof b.equals === 'function' && b.equals(a);\n  }\n\n  switch (typeA) {\n    case 'Arguments':\n    case 'Array':\n    case 'Object':\n      if (typeof a.constructor === 'function' && _functionName(a.constructor) === 'Promise') {\n        return a === b;\n      }\n      break;\n    case 'Boolean':\n    case 'Number':\n    case 'String':\n      if (!(typeof a === typeof b && _objectIs(a.valueOf(), b.valueOf()))) {\n        return false;\n      }\n      break;\n    case 'Date':\n      if (!_objectIs(a.valueOf(), b.valueOf())) {\n        return false;\n      }\n      break;\n    case 'Error':\n      return a.name === b.name && a.message === b.message;\n    case 'RegExp':\n      if (!(a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.sticky === b.sticky && a.unicode === b.unicode)) {\n        return false;\n      }\n      break;\n  }\n\n  var idx = stackA.length - 1;\n  while (idx >= 0) {\n    if (stackA[idx] === a) {\n      return stackB[idx] === b;\n    }\n    idx -= 1;\n  }\n\n  switch (typeA) {\n    case 'Map':\n      if (a.size !== b.size) {\n        return false;\n      }\n\n      return _uniqContentEquals(a.entries(), b.entries(), stackA.concat([a]), stackB.concat([b]));\n    case 'Set':\n      if (a.size !== b.size) {\n        return false;\n      }\n\n      return _uniqContentEquals(a.values(), b.values(), stackA.concat([a]), stackB.concat([b]));\n    case 'Arguments':\n    case 'Array':\n    case 'Object':\n    case 'Boolean':\n    case 'Number':\n    case 'String':\n    case 'Date':\n    case 'Error':\n    case 'RegExp':\n    case 'Int8Array':\n    case 'Uint8Array':\n    case 'Uint8ClampedArray':\n    case 'Int16Array':\n    case 'Uint16Array':\n    case 'Int32Array':\n    case 'Uint32Array':\n    case 'Float32Array':\n    case 'Float64Array':\n    case 'ArrayBuffer':\n      break;\n    default:\n      // Values of other types are only equal if identical.\n      return false;\n  }\n\n  var keysA = keys(a);\n  if (keysA.length !== keys(b).length) {\n    return false;\n  }\n\n  var extendedStackA = stackA.concat([a]);\n  var extendedStackB = stackB.concat([b]);\n\n  idx = keysA.length - 1;\n  while (idx >= 0) {\n    var key = keysA[idx];\n    if (!(_has(key, b) && _equals(b[key], a[key], extendedStackA, extendedStackB))) {\n      return false;\n    }\n    idx -= 1;\n  }\n  return true;\n}\nmodule.exports = _equals;","function _arrayFromIterator(iter) {\n  var list = [];\n  var next;\n  while (!(next = iter.next()).done) {\n    list.push(next.value);\n  }\n  return list;\n}\nmodule.exports = _arrayFromIterator;","function _includesWith(pred, x, list) {\n  var idx = 0;\n  var len = list.length;\n\n  while (idx < len) {\n    if (pred(x, list[idx])) {\n      return true;\n    }\n    idx += 1;\n  }\n  return false;\n}\nmodule.exports = _includesWith;","function _functionName(f) {\n  // String(x => x) evaluates to \"x => x\", so the pattern may not match.\n  var match = String(f).match(/^function (\\w*)/);\n  return match == null ? '' : match[1];\n}\nmodule.exports = _functionName;","// Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\nfunction _objectIs(a, b) {\n  // SameValue algorithm\n  if (a === b) {\n    // Steps 1-5, 7-10\n    // Steps 6.b-6.e: +0 != -0\n    return a !== 0 || 1 / a === 1 / b;\n  } else {\n    // Step 6.a: NaN == NaN\n    return a !== a && b !== b;\n  }\n}\n\nmodule.exports = typeof Object.is === 'function' ? Object.is : _objectIs;","var _has = /*#__PURE__*/require('./_has');\n\nvar toString = Object.prototype.toString;\nvar _isArguments = /*#__PURE__*/function () {\n  return toString.call(arguments) === '[object Arguments]' ? function _isArguments(x) {\n    return toString.call(x) === '[object Arguments]';\n  } : function _isArguments(x) {\n    return _has('callee', x);\n  };\n}();\n\nmodule.exports = _isArguments;","var _curry1 = /*#__PURE__*/require('./internal/_curry1');\n\n/**\n * Gives a single-word string description of the (native) type of a value,\n * returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not\n * attempt to distinguish user Object types any further, reporting them all as\n * 'Object'.\n *\n * @func\n * @memberOf R\n * @since v0.8.0\n * @category Type\n * @sig (* -> {*}) -> String\n * @param {*} val The value to test\n * @return {String}\n * @example\n *\n *      R.type({}); //=> \"Object\"\n *      R.type(1); //=> \"Number\"\n *      R.type(false); //=> \"Boolean\"\n *      R.type('s'); //=> \"String\"\n *      R.type(null); //=> \"Null\"\n *      R.type([]); //=> \"Array\"\n *      R.type(/[A-z]/); //=> \"RegExp\"\n *      R.type(() => {}); //=> \"Function\"\n *      R.type(undefined); //=> \"Undefined\"\n */\n\n\nvar type = /*#__PURE__*/_curry1(function type(val) {\n  return val === null ? 'Null' : val === undefined ? 'Undefined' : Object.prototype.toString.call(val).slice(8, -1);\n});\nmodule.exports = type;","var _isArrayLike = /*#__PURE__*/require('./_isArrayLike');\n\n/**\n * `_makeFlat` is a helper function that returns a one-level or fully recursive\n * function based on the flag passed in.\n *\n * @private\n */\n\n\nfunction _makeFlat(recursive) {\n  return function flatt(list) {\n    var value, jlen, j;\n    var result = [];\n    var idx = 0;\n    var ilen = list.length;\n\n    while (idx < ilen) {\n      if (_isArrayLike(list[idx])) {\n        value = recursive ? flatt(list[idx]) : list[idx];\n        j = 0;\n        jlen = value.length;\n        while (j < jlen) {\n          result[result.length] = value[j];\n          j += 1;\n        }\n      } else {\n        result[result.length] = list[idx];\n      }\n      idx += 1;\n    }\n    return result;\n  };\n}\nmodule.exports = _makeFlat;","function _isString(x) {\n  return Object.prototype.toString.call(x) === '[object String]';\n}\nmodule.exports = _isString;","var _isArray = /*#__PURE__*/require('./_isArray');\n\nvar _isTransformer = /*#__PURE__*/require('./_isTransformer');\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 one of the given method names, it will\n * execute that function (functor case). Otherwise, if it is a transformer,\n * uses transducer [xf] to return a new transformer (transducer case).\n * Otherwise, it will default to executing [fn].\n *\n * @private\n * @param {Array} methodNames properties 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 */\n\n\nfunction _dispatchable(methodNames, xf, fn) {\n  return function () {\n    if (arguments.length === 0) {\n      return fn();\n    }\n    var args = Array.prototype.slice.call(arguments, 0);\n    var obj = args.pop();\n    if (!_isArray(obj)) {\n      var idx = 0;\n      while (idx < methodNames.length) {\n        if (typeof obj[methodNames[idx]] === 'function') {\n          return obj[methodNames[idx]].apply(obj, args);\n        }\n        idx += 1;\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}\nmodule.exports = _dispatchable;","function _isTransformer(obj) {\n  return obj != null && typeof obj['@@transducer/step'] === 'function';\n}\nmodule.exports = _isTransformer;","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}\nmodule.exports = _map;","var _isArrayLike = /*#__PURE__*/require('./_isArrayLike');\n\nvar _xwrap = /*#__PURE__*/require('./_xwrap');\n\nvar bind = /*#__PURE__*/require('../bind');\n\nfunction _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\nfunction _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\nfunction _methodReduce(xf, acc, obj, methodName) {\n  return xf['@@transducer/result'](obj[methodName](bind(xf['@@transducer/step'], xf), acc));\n}\n\nvar symIterator = typeof Symbol !== 'undefined' ? Symbol.iterator : '@@iterator';\n\nfunction _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['fantasy-land/reduce'] === 'function') {\n    return _methodReduce(fn, acc, list, 'fantasy-land/reduce');\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  if (typeof list.reduce === 'function') {\n    return _methodReduce(fn, acc, list, 'reduce');\n  }\n\n  throw new TypeError('reduce: list must be array or iterable');\n}\nmodule.exports = _reduce;","var XWrap = /*#__PURE__*/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) {\n    return acc;\n  };\n  XWrap.prototype['@@transducer/step'] = function (acc, x) {\n    return this.f(acc, x);\n  };\n\n  return XWrap;\n}();\n\nfunction _xwrap(fn) {\n  return new XWrap(fn);\n}\nmodule.exports = _xwrap;","var _arity = /*#__PURE__*/require('./internal/_arity');\n\nvar _curry2 = /*#__PURE__*/require('./internal/_curry2');\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 *      const 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 * @symb R.bind(f, o)(a, b) = f.call(o, a, b)\n */\n\n\nvar bind = /*#__PURE__*/_curry2(function bind(fn, thisObj) {\n  return _arity(fn.length, function () {\n    return fn.apply(thisObj, arguments);\n  });\n});\nmodule.exports = bind;","var _curry2 = /*#__PURE__*/require('./_curry2');\n\nvar _xfBase = /*#__PURE__*/require('./_xfBase');\n\nvar XMap = /*#__PURE__*/function () {\n\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 XMap;\n}();\n\nvar _xmap = /*#__PURE__*/_curry2(function _xmap(f, xf) {\n  return new XMap(f, xf);\n});\nmodule.exports = _xmap;","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};","var _arity = /*#__PURE__*/require('./internal/_arity');\n\nvar _curry1 = /*#__PURE__*/require('./internal/_curry1');\n\nvar _curry2 = /*#__PURE__*/require('./internal/_curry2');\n\nvar _curryN = /*#__PURE__*/require('./internal/_curryN');\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.__`](#__),\n * the 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 *      const sumArgs = (...args) => R.sum(args);\n *\n *      const curriedAddFourNumbers = R.curryN(4, sumArgs);\n *      const f = curriedAddFourNumbers(1, 2);\n *      const g = f(3);\n *      g(4); //=> 10\n */\n\n\nvar curryN = /*#__PURE__*/_curry2(function curryN(length, fn) {\n  if (length === 1) {\n    return _curry1(fn);\n  }\n  return _arity(length, _curryN(length, [], fn));\n});\nmodule.exports = curryN;","var _arity = /*#__PURE__*/require('./_arity');\n\nvar _isPlaceholder = /*#__PURE__*/require('./_isPlaceholder');\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 */\n\n\nfunction _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 && (!_isPlaceholder(received[combinedIdx]) || 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) : _arity(left, _curryN(length, combined, fn));\n  };\n}\nmodule.exports = _curryN;","var _isPlaceholder = /*#__PURE__*/require('./_isPlaceholder');\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 */\n\n\nfunction _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}\nmodule.exports = _curry1;","var _curry1 = /*#__PURE__*/require('./_curry1');\n\nvar _isPlaceholder = /*#__PURE__*/require('./_isPlaceholder');\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 */\n\n\nfunction _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 : _curry1(function (_b) {\n          return fn(a, _b);\n        });\n      default:\n        return _isPlaceholder(a) && _isPlaceholder(b) ? f2 : _isPlaceholder(a) ? _curry1(function (_a) {\n          return fn(_a, b);\n        }) : _isPlaceholder(b) ? _curry1(function (_b) {\n          return fn(a, _b);\n        }) : fn(a, b);\n    }\n  };\n}\nmodule.exports = _curry2;"],"sourceRoot":""}