{"version":3,"sources":["webpack:///frontend.js","webpack:///webpack/bootstrap caccfa6032bf26e21698?034d","webpack:///./assets/src/frontend/frontend.js","webpack:///./~/underscore/underscore.js?31a5"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","id","loaded","call","m","c","p",0,"onStorageEvent","$","length","items","JSON","parse","localStorage","getItem","show","hide","resultTemplate","_","template","html","resultingHtml","allPostIds","forEach","value","push","postId","pageUrl","data","attr","join","on","e","preventDefault","this","allPosts","window","checkIndex","_underscore","findIndex","splice","setItem","stringify","next","jQuery","postTitle","postThumb","postLink","newPost","ALIKE","max_compare","alert","LANG","YOU_CAN_COMPARE_MAXIMUM_BETWEEN_S_ITEMS","addEventListener",199,"__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","_typeof","Symbol","iterator","obj","constructor","createReduce","dir","iteratee","memo","keys","index","currentKey","context","optimizeCb","isArrayLike","arguments","createPredicateIndexFinder","array","predicate","cb","getLength","createIndexFinder","predicateFind","sortedIndex","item","idx","i","Math","max","min","slice","isNaN","collectNonEnumProps","nonEnumIdx","nonEnumerableProps","proto","isFunction","prototype","ObjProto","prop","has","contains","root","previousUnderscore","ArrayProto","Array","Object","FuncProto","Function","toString","hasOwnProperty","nativeIsArray","isArray","nativeKeys","nativeBind","bind","nativeCreate","create","Ctor","_wrapped","VERSION","func","argCount","other","collection","accumulator","apply","identity","isObject","matcher","property","Infinity","createAssigner","keysFunc","undefinedOnly","source","l","key","baseCreate","result","MAX_ARRAY_INDEX","pow","each","map","collect","results","reduce","foldl","inject","reduceRight","foldr","find","detect","findKey","filter","select","list","reject","negate","every","all","some","any","includes","include","fromIndex","guard","values","indexOf","invoke","method","args","isFunc","pluck","where","attrs","findWhere","computed","lastComputed","shuffle","rand","set","shuffled","random","sample","n","sortBy","criteria","sort","left","right","a","b","group","behavior","groupBy","indexBy","countBy","toArray","size","partition","pass","fail","first","head","take","initial","last","rest","tail","drop","compact","flatten","input","shallow","strict","startIndex","output","isArguments","j","len","without","difference","uniq","unique","isSorted","isBoolean","seen","union","intersection","argsLength","zip","unzip","object","findLastIndex","low","high","mid","floor","lastIndexOf","range","start","stop","step","ceil","executeBound","sourceFunc","boundFunc","callingContext","self","TypeError","bound","concat","partial","boundArgs","position","bindAll","Error","memoize","hasher","cache","address","delay","wait","setTimeout","defer","throttle","options","timeout","previous","later","leading","now","remaining","clearTimeout","trailing","debounce","immediate","timestamp","callNow","wrap","wrapper","compose","after","times","before","once","hasEnumBug","propertyIsEnumerable","allKeys","mapObject","pairs","invert","functions","methods","names","extend","extendOwn","assign","pick","oiteratee","omit","String","defaults","props","clone","tap","interceptor","isMatch","eq","aStack","bStack","className","areArrays","aCtor","bCtor","pop","isEqual","isEmpty","isString","isElement","nodeType","type","name","Int8Array","isFinite","parseFloat","isNumber","isNull","isUndefined","noConflict","constant","noop","propertyOf","matches","accum","Date","getTime","escapeMap","&","<",">","\"","'","`","unescapeMap","createEscaper","escaper","match","testRegexp","RegExp","replaceRegexp","string","test","replace","escape","unescape","fallback","idCounter","uniqueId","prefix","templateSettings","evaluate","interpolate","noMatch","escapes","\\","\r","\n","
","
","escapeChar","text","settings","oldSettings","offset","variable","render","argument","chain","instance","_chain","mixin","valueOf","toJSON","undefined"],"mappings":"CAAS,SAAUA,GCInB,QAAAC,GAAAC,GAGA,GAAAC,EAAAD,GACA,MAAAC,GAAAD,GAAAE,OAGA,IAAAC,GAAAF,EAAAD,IACAE,WACAE,GAAAJ,EACAK,QAAA,EAUA,OANAP,GAAAE,GAAAM,KAAAH,EAAAD,QAAAC,IAAAD,QAAAH,GAGAI,EAAAE,QAAA,EAGAF,EAAAD,QAvBA,GAAAD,KAqCA,OATAF,GAAAQ,EAAAT,EAGAC,EAAAS,EAAAP,EAGAF,EAAAU,EAAA,GAGAV,EAAA,KDMMW,EACA,SAASP,EAAQD,EAASH,GAE/B,YEPD,SAASY,KACHC,EAAE,iBAAiBC,OAAS,IFoD7B,WEnDD,GAAMC,GAA2D,OAAnDC,KAAMC,MAAMC,aAAaC,QAAQ,cAA0BH,KAAKC,MAAMC,aAAaC,QAAQ,gBACrGJ,GAAMD,OAAS,EACjBD,EAAE,0BAA0BO,OAE5BP,EAAE,0BAA0BQ,MAG9B,IAAMC,GAAiBC,EAAEC,SAASX,EAAE,eAAeY,QAC7CC,EAAgBJ,GAAiBP,UACjCY,IACNZ,GAAMa,QAAQ,SAAUC,GACtBF,EAAWG,KAAKD,EAAME,SAExB,IAAMC,GAAUnB,EAAE,yBAAyBoB,KAAK,WAChDpB,GAAE,yBAAyBqB,KAAK,OAAQF,EAAU,SAAWL,EAAWQ,MAAM,OAE9EtB,EAAE,iBAAiBY,KAAKC,GAAeU,GAAG,QAAS,uBAAwB,SAAUC,GACnFA,EAAEC,gBACF,IAAMP,GAASlB,EAAE0B,MAAMN,KAAK,WACtBO,EAAWxB,KAAKC,MAAMwB,OAAOvB,aAAaC,QAAQ,cAClDuB,GAAa,EAAAC,EAAAC,WAAUJ,GAAYT,UAEtB,MAAfW,IACFF,EAASK,OAAOH,EAAY,GAC5BD,OAAOvB,aAAa4B,QAAQ,YAAa9B,KAAK+B,UAAUP,IAExD5B,OAEDoC,KAAK,0BAA0BZ,GAAG,QAAS,sBAAuB,SAAUC,GAC7EA,EAAEC,iBACFG,OAAOvB,aAAa4B,QAAQ,YAAa,MACzClC,SFxBL,GAAI+B,GAAc3C,EAAoB,KEjDjCa,EAAIoC,MAGVpC,GAAE,iBAAiBuB,GAAG,QAAS,SAAUC,GACvCA,EAAEC,gBACF,IAAMP,GAASlB,EAAE0B,MAAMN,KAAK,WACtBiB,EAAYrC,EAAE0B,MAAMN,KAAK,cACzBkB,EAAYtC,EAAE0B,MAAMN,KAAK,cACzBmB,EAAWvC,EAAE0B,MAAMN,KAAK,aAExBO,EAAWC,OAAOvB,aAAaC,QAAQ,aAAeH,KAAKC,MAAMwB,OAAOvB,aAAaC,QAAQ,iBAE7FuB,GAAa,EAAAC,EAAAC,WAAUJ,GAAYT,UAEzC,IAAmB,KAAfW,EAAmB,CACrB,GAAMW,IACJtB,SAAQmB,YAAWC,YAAWC,WAE5BZ,GAAS1B,OAASwC,MAAMC,YAC1Bf,EAASV,KAAKuB,GAEdG,MAAMF,MAAMG,KAAKC,yCAIrBjB,OAAOvB,aAAa4B,QAAQ,YAAa9B,KAAK+B,UAAUP,IACxD3B,EAAE,0BAA0BO,OAC5BR,MAGFC,EAAE4B,QAAQL,GAAG,OAAQ,WACnB,GAAMrB,GAA2D,OAAnDC,KAAMC,MAAMC,aAAaC,QAAQ,cAA0BH,KAAKC,MAAMC,aAAaC,QAAQ,gBACrGJ,GAAMD,OAAS,EACjBD,EAAE,0BAA0BO,OAE5BP,EAAE,0BAA0BQ,OAE9BT,MAwCF6B,OAAOkB,iBAAiB,UAAW/C,GAAgB,IFyD7CgD,IACA,SAASxD,EAAQD,EAASH,GAE/B,GAAI6D,GAA8BC,EAE9BC,EAA4B,kBAAXC,SAAoD,gBAApBA,QAAOC,SAAwB,SAAUC,GAAO,aAAcA,IAAS,SAAUA,GAAO,MAAOA,IAAyB,kBAAXF,SAAyBE,EAAIC,cAAgBH,OAAS,eAAkBE,KGtI3O,WAAY,QA4KDE,GAAaC,GAGpB,QAASJ,GAASC,EAAKI,EAAUC,EAAMC,EAAMC,EAAO3D,GAClD,KAAO2D,GAAS,GAAa3D,EAAR2D,EAAgBA,GAASJ,EAAK,CACjD,GAAIK,GAAaF,EAAOA,EAAKC,GAASA,CACtCF,GAAOD,EAASC,EAAML,EAAIQ,GAAaA,EAAYR,GAErD,MAAOK,GAGT,MAAO,UAASL,EAAKI,EAAUC,EAAMI,GACnCL,EAAWM,EAAWN,EAAUK,EAAS,EACzC,IAAIH,IAAQK,EAAYX,IAAQ3C,EAAEiD,KAAKN,GACnCpD,GAAU0D,GAAQN,GAAKpD,OACvB2D,EAAQJ,EAAM,EAAI,EAAIvD,EAAS,CAMnC,OAJIgE,WAAUhE,OAAS,IACrByD,EAAOL,EAAIM,EAAOA,EAAKC,GAASA,GAChCA,GAASJ,GAEJJ,EAASC,EAAKI,EAAUC,EAAMC,EAAMC,EAAO3D,IAjM5C,QAgmBDiE,GAA2BV,GAClC,MAAO,UAASW,EAAOC,EAAWN,GAChCM,EAAYC,EAAGD,EAAWN,EAG1B,KAFA,GAAI7D,GAASqE,EAAUH,GACnBP,EAAQJ,EAAM,EAAI,EAAIvD,EAAS,EAC5B2D,GAAS,GAAa3D,EAAR2D,EAAgBA,GAASJ,EAC5C,GAAIY,EAAUD,EAAMP,GAAQA,EAAOO,GAAQ,MAAOP,EAEpD,OAAO,IAxmBD,QA8nBDW,GAAkBf,EAAKgB,EAAeC,GAC7C,MAAO,UAASN,EAAOO,EAAMC,GAC3B,GAAIC,GAAI,EAAG3E,EAASqE,EAAUH,EAC9B,IAAkB,gBAAPQ,GACLnB,EAAM,EACNoB,EAAID,GAAO,EAAIA,EAAME,KAAKC,IAAIH,EAAM1E,EAAQ2E,GAE5C3E,EAAS0E,GAAO,EAAIE,KAAKE,IAAIJ,EAAM,EAAG1E,GAAU0E,EAAM1E,EAAS,MAE9D,IAAIwE,GAAeE,GAAO1E,EAE/B,MADA0E,GAAMF,EAAYN,EAAOO,GAClBP,EAAMQ,KAASD,EAAOC,EAAM,EAErC,IAAID,IAASA,EAEX,MADAC,GAAMH,EAAcQ,EAAMtF,KAAKyE,EAAOS,EAAG3E,GAASS,EAAEuE,OAC7CN,GAAO,EAAIA,EAAMC,EAAI,EAE9B,KAAKD,EAAMnB,EAAM,EAAIoB,EAAI3E,EAAS,EAAG0E,GAAO,GAAW1E,EAAN0E,EAAcA,GAAOnB,EACpE,GAAIW,EAAMQ,KAASD,EAAM,MAAOC,EAElC,OAAO,IAqPX,QAASO,GAAoB7B,EAAKM,GAChC,GAAIwB,GAAaC,EAAmBnF,OAChCqD,EAAcD,EAAIC,YAClB+B,EAAQ3E,EAAG4E,WAAWhC,IAAgBA,EAAYiC,WAAcC,EAGhEC,EAAO,aAGX,KAFI/E,EAAEgF,IAAIrC,EAAKoC,KAAU/E,EAAEiF,SAAShC,EAAM8B,IAAO9B,EAAK1C,KAAKwE,GAEpDN,KACLM,EAAOL,EAAmBD,GACtBM,IAAQpC,IAAOA,EAAIoC,KAAUJ,EAAMI,KAAU/E,EAAEiF,SAAShC,EAAM8B,IAChE9B,EAAK1C,KAAKwE,GA74BhB,GAAIG,GAAOlE,KAGPmE,EAAqBD,EAAKlF,EAG1BoF,EAAaC,MAAMR,UAAWC,EAAWQ,OAAOT,UAAWU,EAAYC,SAASX,UAIlFtE,EAAmB6E,EAAW7E,KAC9B+D,EAAmBc,EAAWd,MAC9BmB,EAAmBX,EAASW,SAC5BC,EAAmBZ,EAASY,eAK5BC,EAAqBN,MAAMO,QAC3BC,EAAqBP,OAAOrC,KAC5B6C,EAAqBP,EAAUQ,KAC/BC,EAAqBV,OAAOW,OAG1BC,EAAO,aAGPlG,EAAI,QAAJA,GAAa2C,GACf,MAAIA,aAAe3C,GAAU2C,EACvB3B,eAAgBhB,QACtBgB,KAAKmF,SAAWxD,GADiB,GAAI3C,GAAE2C,GAQjB,oBAAX9D,IAA0BA,EAAOD,UAC1CA,EAAUC,EAAOD,QAAUoB,GAE7BpB,EAAQoB,EAAIA,EA9CJA,EAoDRoG,QAAU,OApDF,IAyDN/C,GAAa,SAASgD,EAAMjD,EAASkD,GACvC,GAAgB,SAAZlD,EAAoB,MAAOiD,EAC/B,QAAoB,MAAZC,EAAmB,EAAIA,GAC7B,IAAK,GAAG,MAAO,UAAShG,GACtB,MAAO+F,GAAKrH,KAAKoE,EAAS9C,GAF9B,KAIO,GAAG,MAAO,UAASA,EAAOiG,GAC7B,MAAOF,GAAKrH,KAAKoE,EAAS9C,EAAOiG,GALrC,KAOO,GAAG,MAAO,UAASjG,EAAO4C,EAAOsD,GACpC,MAAOH,GAAKrH,KAAKoE,EAAS9C,EAAO4C,EAAOsD,GAR5C,KAUO,GAAG,MAAO,UAASC,EAAanG,EAAO4C,EAAOsD,GACjD,MAAOH,GAAKrH,KAAKoE,EAASqD,EAAanG,EAAO4C,EAAOsD,IAGzD,MAAO,YACL,MAAOH,GAAKK,MAAMtD,EAASG,aAO3BI,EAAK,SAASrD,EAAO8C,EAASkD,GAChC,MAAa,OAAThG,EAAsBN,EAAE2G,SACxB3G,EAAE4E,WAAWtE,GAAe+C,EAAW/C,EAAO8C,EAASkD,GACvDtG,EAAE4G,SAAStG,GAAeN,EAAE6G,QAAQvG,GACjCN,EAAE8G,SAASxG,GAEpBN,GAAE+C,SAAW,SAASzC,EAAO8C,GAC3B,MAAOO,GAAGrD,EAAO8C,EAAS2D,KAxFlB,IA4FNC,GAAiB,SAASC,EAAUC,GACtC,MAAO,UAASvE,GACd,GAAIpD,GAASgE,UAAUhE,MACvB,IAAa,EAATA,GAAqB,MAAPoD,EAAa,MAAOA,EACtC,KAAK,GAAIO,GAAQ,EAAW3D,EAAR2D,EAAgBA,IAIlC,IAAK,GAHDiE,GAAS5D,UAAUL,GACnBD,EAAOgE,EAASE,GAChBC,EAAInE,EAAK1D,OACJ2E,EAAI,EAAOkD,EAAJlD,EAAOA,IAAK,CAC1B,GAAImD,GAAMpE,EAAKiB,EACVgD,IAA8B,SAAbvE,EAAI0E,KAAiB1E,EAAI0E,GAAOF,EAAOE,IAGjE,MAAO1E,KAKP2E,EAAa,SAASzC,GACxB,IAAK7E,EAAE4G,SAAS/B,GAAY,QAC5B,IAAImB,EAAc,MAAOA,GAAanB,EACtCqB,GAAKrB,UAAYA,CACjB,IAAI0C,GAAS,GAAIrB,EAEjB,OADAA,GAAKrB,UAAY,KACV0C,GAGLT,EAAW,SAASO,GACtB,MAAO,UAAS1E,GACd,MAAc,OAAPA,EAAc,OAASA,EAAI0E,KAQlCG,EAAkBrD,KAAKsD,IAAI,EAAG,IAAM,EACpC7D,EAAYkD,EAAS,UACrBxD,EAAc,SAASkD,GACzB,GAAIjH,GAASqE,EAAU4C,EACvB,OAAwB,gBAAVjH,IAAsBA,GAAU,GAAeiI,GAAVjI,EArI3CS,GA8IR0H,KAAO1H,EAAEK,QAAU,SAASsC,EAAKI,EAAUK,GAC3CL,EAAWM,EAAWN,EAAUK,EAChC,IAAIc,GAAG3E,CACP,IAAI+D,EAAYX,GACd,IAAKuB,EAAI,EAAG3E,EAASoD,EAAIpD,OAAYA,EAAJ2E,EAAYA,IAC3CnB,EAASJ,EAAIuB,GAAIA,EAAGvB,OAEjB,CACL,GAAIM,GAAOjD,EAAEiD,KAAKN,EAClB,KAAKuB,EAAI,EAAG3E,EAAS0D,EAAK1D,OAAYA,EAAJ2E,EAAYA,IAC5CnB,EAASJ,EAAIM,EAAKiB,IAAKjB,EAAKiB,GAAIvB,GAGpC,MAAOA,IA3JC3C,EA+JR2H,IAAM3H,EAAE4H,QAAU,SAASjF,EAAKI,EAAUK,GAC1CL,EAAWY,EAAGZ,EAAUK,EAIxB,KAAK,GAHDH,IAAQK,EAAYX,IAAQ3C,EAAEiD,KAAKN,GACnCpD,GAAU0D,GAAQN,GAAKpD,OACvBsI,EAAUxC,MAAM9F,GACX2D,EAAQ,EAAW3D,EAAR2D,EAAgBA,IAAS,CAC3C,GAAIC,GAAaF,EAAOA,EAAKC,GAASA,CACtC2E,GAAQ3E,GAASH,EAASJ,EAAIQ,GAAaA,EAAYR,GAEzD,MAAOkF,IAxKC7H,EAuMR8H,OAAS9H,EAAE+H,MAAQ/H,EAAEgI,OAASnF,EAAa,GAvMnC7C,EA0MRiI,YAAcjI,EAAEkI,MAAQrF,EAAa,IA1M7B7C,EA6MRmI,KAAOnI,EAAEoI,OAAS,SAASzF,EAAKe,EAAWN,GAC3C,GAAIiE,EAMJ,OAJEA,GADE/D,EAAYX,GACR3C,EAAEqB,UAAUsB,EAAKe,EAAWN,GAE5BpD,EAAEqI,QAAQ1F,EAAKe,EAAWN,GAEtB,SAARiE,GAA0B,KAARA,EAAmB1E,EAAI0E,GAA7C,QApNQrH,EAyNRsI,OAAStI,EAAEuI,OAAS,SAAS5F,EAAKe,EAAWN,GAC7C,GAAIyE,KAKJ,OAJAnE,GAAYC,EAAGD,EAAWN,GAC1BpD,EAAE0H,KAAK/E,EAAK,SAASrC,EAAO4C,EAAOsF,GAC7B9E,EAAUpD,EAAO4C,EAAOsF,IAAOX,EAAQtH,KAAKD,KAE3CuH,GA/NC7H,EAmORyI,OAAS,SAAS9F,EAAKe,EAAWN,GAClC,MAAOpD,GAAEsI,OAAO3F,EAAK3C,EAAE0I,OAAO/E,EAAGD,IAAaN,IApOtCpD,EAyOR2I,MAAQ3I,EAAE4I,IAAM,SAASjG,EAAKe,EAAWN,GACzCM,EAAYC,EAAGD,EAAWN,EAG1B,KAAK,GAFDH,IAAQK,EAAYX,IAAQ3C,EAAEiD,KAAKN,GACnCpD,GAAU0D,GAAQN,GAAKpD,OAClB2D,EAAQ,EAAW3D,EAAR2D,EAAgBA,IAAS,CAC3C,GAAIC,GAAaF,EAAOA,EAAKC,GAASA,CACtC,KAAKQ,EAAUf,EAAIQ,GAAaA,EAAYR,GAAM,OAAO,EAE3D,OAAO,GAjPC3C,EAsPR6I,KAAO7I,EAAE8I,IAAM,SAASnG,EAAKe,EAAWN,GACxCM,EAAYC,EAAGD,EAAWN,EAG1B,KAAK,GAFDH,IAAQK,EAAYX,IAAQ3C,EAAEiD,KAAKN,GACnCpD,GAAU0D,GAAQN,GAAKpD,OAClB2D,EAAQ,EAAW3D,EAAR2D,EAAgBA,IAAS,CAC3C,GAAIC,GAAaF,EAAOA,EAAKC,GAASA,CACtC,IAAIQ,EAAUf,EAAIQ,GAAaA,EAAYR,GAAM,OAAO,EAE1D,OAAO,GA9PC3C,EAmQRiF,SAAWjF,EAAE+I,SAAW/I,EAAEgJ,QAAU,SAASrG,EAAKqB,EAAMiF,EAAWC,GAGnE,MAFK5F,GAAYX,KAAMA,EAAM3C,EAAEmJ,OAAOxG,KACd,gBAAbsG,IAAyBC,KAAOD,EAAY,GAChDjJ,EAAEoJ,QAAQzG,EAAKqB,EAAMiF,IAAc,GAtQlCjJ,EA0QRqJ,OAAS,SAAS1G,EAAK2G,GACvB,GAAIC,GAAOjF,EAAMtF,KAAKuE,UAAW,GAC7BiG,EAASxJ,EAAE4E,WAAW0E,EAC1B,OAAOtJ,GAAE2H,IAAIhF,EAAK,SAASrC,GACzB,GAAI+F,GAAOmD,EAASF,EAAShJ,EAAMgJ,EACnC,OAAe,OAARjD,EAAeA,EAAOA,EAAKK,MAAMpG,EAAOiJ,MA/QzCvJ,EAoRRyJ,MAAQ,SAAS9G,EAAK0E,GACtB,MAAOrH,GAAE2H,IAAIhF,EAAK3C,EAAE8G,SAASO,KArRrBrH,EA0RR0J,MAAQ,SAAS/G,EAAKgH,GACtB,MAAO3J,GAAEsI,OAAO3F,EAAK3C,EAAE6G,QAAQ8C,KA3RvB3J,EAgSR4J,UAAY,SAASjH,EAAKgH,GAC1B,MAAO3J,GAAEmI,KAAKxF,EAAK3C,EAAE6G,QAAQ8C,KAjSrB3J,EAqSRoE,IAAM,SAASzB,EAAKI,EAAUK,GAC9B,GACI9C,GAAOuJ,EADPtC,IAAUR,KAAU+C,IAAgB/C,IAExC,IAAgB,MAAZhE,GAA2B,MAAPJ,EAAa,CACnCA,EAAMW,EAAYX,GAAOA,EAAM3C,EAAEmJ,OAAOxG,EACxC,KAAK,GAAIuB,GAAI,EAAG3E,EAASoD,EAAIpD,OAAYA,EAAJ2E,EAAYA,IAC/C5D,EAAQqC,EAAIuB,GACR5D,EAAQiH,IACVA,EAASjH,OAIbyC,GAAWY,EAAGZ,EAAUK,GACxBpD,EAAE0H,KAAK/E,EAAK,SAASrC,EAAO4C,EAAOsF,GACjCqB,EAAW9G,EAASzC,EAAO4C,EAAOsF,IAC9BqB,EAAWC,GAAgBD,MAAc9C,MAAYQ,MAAYR,QACnEQ,EAASjH,EACTwJ,EAAeD,IAIrB,OAAOtC,IA1TCvH,EA8TRqE,IAAM,SAAS1B,EAAKI,EAAUK,GAC9B,GACI9C,GAAOuJ,EADPtC,EAASR,IAAU+C,EAAe/C,GAEtC,IAAgB,MAAZhE,GAA2B,MAAPJ,EAAa,CACnCA,EAAMW,EAAYX,GAAOA,EAAM3C,EAAEmJ,OAAOxG,EACxC,KAAK,GAAIuB,GAAI,EAAG3E,EAASoD,EAAIpD,OAAYA,EAAJ2E,EAAYA,IAC/C5D,EAAQqC,EAAIuB,GACAqD,EAARjH,IACFiH,EAASjH,OAIbyC,GAAWY,EAAGZ,EAAUK,GACxBpD,EAAE0H,KAAK/E,EAAK,SAASrC,EAAO4C,EAAOsF,GACjCqB,EAAW9G,EAASzC,EAAO4C,EAAOsF,IACnBsB,EAAXD,GAA2BA,IAAa9C,KAAYQ,IAAWR,OACjEQ,EAASjH,EACTwJ,EAAeD,IAIrB,OAAOtC,IAnVCvH,EAwVR+J,QAAU,SAASpH,GAInB,IAAK,GAAeqH,GAHhBC,EAAM3G,EAAYX,GAAOA,EAAM3C,EAAEmJ,OAAOxG,GACxCpD,EAAS0K,EAAI1K,OACb2K,EAAW7E,MAAM9F,GACZ2D,EAAQ,EAAiB3D,EAAR2D,EAAgBA,IACxC8G,EAAOhK,EAAEmK,OAAO,EAAGjH,GACf8G,IAAS9G,IAAOgH,EAAShH,GAASgH,EAASF,IAC/CE,EAASF,GAAQC,EAAI/G,EAEvB,OAAOgH,IAjWClK,EAuWRoK,OAAS,SAASzH,EAAK0H,EAAGnB,GAC1B,MAAS,OAALmB,GAAanB,GACV5F,EAAYX,KAAMA,EAAM3C,EAAEmJ,OAAOxG,IAC/BA,EAAI3C,EAAEmK,OAAOxH,EAAIpD,OAAS,KAE5BS,EAAE+J,QAAQpH,GAAK2B,MAAM,EAAGH,KAAKC,IAAI,EAAGiG,KA5WnCrK,EAgXRsK,OAAS,SAAS3H,EAAKI,EAAUK,GAEjC,MADAL,GAAWY,EAAGZ,EAAUK,GACjBpD,EAAEyJ,MAAMzJ,EAAE2H,IAAIhF,EAAK,SAASrC,EAAO4C,EAAOsF,GAC/C,OACElI,MAAOA,EACP4C,MAAOA,EACPqH,SAAUxH,EAASzC,EAAO4C,EAAOsF,MAElCgC,KAAK,SAASC,EAAMC,GACrB,GAAIC,GAAIF,EAAKF,SACTK,EAAIF,EAAMH,QACd,IAAII,IAAMC,EAAG,CACX,GAAID,EAAIC,GAAW,SAAND,EAAc,MAAO,EAClC,IAAQC,EAAJD,GAAe,SAANC,EAAc,MAAO,GAEpC,MAAOH,GAAKvH,MAAQwH,EAAMxH,QACxB,SAhYI,IAoYN2H,GAAQ,SAASC,GACnB,MAAO,UAASnI,EAAKI,EAAUK,GAC7B,GAAImE,KAMJ,OALAxE,GAAWY,EAAGZ,EAAUK,GACxBpD,EAAE0H,KAAK/E,EAAK,SAASrC,EAAO4C,GAC1B,GAAImE,GAAMtE,EAASzC,EAAO4C,EAAOP,EACjCmI,GAASvD,EAAQjH,EAAO+G,KAEnBE,GA5YDvH,GAkZR+K,QAAUF,EAAM,SAAStD,EAAQjH,EAAO+G,GACpCrH,EAAEgF,IAAIuC,EAAQF,GAAME,EAAOF,GAAK9G,KAAKD,GAAaiH,EAAOF,IAAQ/G,KAnZ7DN,EAwZRgL,QAAUH,EAAM,SAAStD,EAAQjH,EAAO+G,GACxCE,EAAOF,GAAO/G,IAzZNN,EA+ZRiL,QAAUJ,EAAM,SAAStD,EAAQjH,EAAO+G,GACpCrH,EAAEgF,IAAIuC,EAAQF,GAAME,EAAOF,KAAaE,EAAOF,GAAO,IAhalDrH,EAoaRkL,QAAU,SAASvI,GACnB,MAAKA,GACD3C,EAAE4F,QAAQjD,GAAa2B,EAAMtF,KAAK2D,GAClCW,EAAYX,GAAa3C,EAAE2H,IAAIhF,EAAK3C,EAAE2G,UACnC3G,EAAEmJ,OAAOxG,OAxaR3C,EA4aRmL,KAAO,SAASxI,GAChB,MAAW,OAAPA,EAAoB,EACjBW,EAAYX,GAAOA,EAAIpD,OAASS,EAAEiD,KAAKN,GAAKpD,QA9a3CS,EAmbRoL,UAAY,SAASzI,EAAKe,EAAWN,GACrCM,EAAYC,EAAGD,EAAWN,EAC1B,IAAIiI,MAAWC,IAIf,OAHAtL,GAAE0H,KAAK/E,EAAK,SAASrC,EAAO+G,EAAK1E,IAC9Be,EAAUpD,EAAO+G,EAAK1E,GAAO0I,EAAOC,GAAM/K,KAAKD,MAE1C+K,EAAMC,IAzbNtL,EAkcRuL,MAAQvL,EAAEwL,KAAOxL,EAAEyL,KAAO,SAAShI,EAAO4G,EAAGnB,GAC7C,MAAa,OAATzF,EACK,MAAL4G,GAAanB,EAAczF,EAAM,GAC9BzD,EAAE0L,QAAQjI,EAAOA,EAAMlE,OAAS8K,GAFvC,QAncQrK,EA2cR0L,QAAU,SAASjI,EAAO4G,EAAGnB,GAC7B,MAAO5E,GAAMtF,KAAKyE,EAAO,EAAGU,KAAKC,IAAI,EAAGX,EAAMlE,QAAe,MAAL8K,GAAanB,EAAQ,EAAImB,MA5czErK,EAidR2L,KAAO,SAASlI,EAAO4G,EAAGnB,GAC1B,MAAa,OAATzF,EACK,MAAL4G,GAAanB,EAAczF,EAAMA,EAAMlE,OAAS,GAC7CS,EAAE4L,KAAKnI,EAAOU,KAAKC,IAAI,EAAGX,EAAMlE,OAAS8K,IAFhD,QAldQrK,EA0dR4L,KAAO5L,EAAE6L,KAAO7L,EAAE8L,KAAO,SAASrI,EAAO4G,EAAGnB,GAC5C,MAAO5E,GAAMtF,KAAKyE,EAAY,MAAL4G,GAAanB,EAAQ,EAAImB,IA3d1CrK,EA+dR+L,QAAU,SAAStI,GACnB,MAAOzD,GAAEsI,OAAO7E,EAAOzD,EAAE2G,UAhejB,IAoeNqF,GAAU,QAAVA,GAAmBC,EAAOC,EAASC,EAAQC,GAE7C,IAAK,GADDC,MAAapI,EAAM,EACdC,EAAIkI,GAAc,EAAG7M,EAASqE,EAAUqI,GAAY1M,EAAJ2E,EAAYA,IAAK,CACxE,GAAI5D,GAAQ2L,EAAM/H,EAClB,IAAIZ,EAAYhD,KAAWN,EAAE4F,QAAQtF,IAAUN,EAAEsM,YAAYhM,IAAS,CAE/D4L,IAAS5L,EAAQ0L,EAAQ1L,EAAO4L,EAASC,GAC9C,IAAII,GAAI,EAAGC,EAAMlM,EAAMf,MAEvB,KADA8M,EAAO9M,QAAUiN,EACNA,EAAJD,GACLF,EAAOpI,KAAS3D,EAAMiM,SAEdJ,KACVE,EAAOpI,KAAS3D,GAGpB,MAAO+L,GApfCrM,GAwfRgM,QAAU,SAASvI,EAAOyI,GAC1B,MAAOF,GAAQvI,EAAOyI,GAAS,IAzfvBlM,EA6fRyM,QAAU,SAAShJ,GACnB,MAAOzD,GAAE0M,WAAWjJ,EAAOa,EAAMtF,KAAKuE,UAAW,KA9fzCvD,EAogBR2M,KAAO3M,EAAE4M,OAAS,SAASnJ,EAAOoJ,EAAU9J,EAAUK,GACjDpD,EAAE8M,UAAUD,KACfzJ,EAAUL,EACVA,EAAW8J,EACXA,GAAW,GAEG,MAAZ9J,IAAkBA,EAAWY,EAAGZ,EAAUK,GAG9C,KAAK,GAFDmE,MACAwF,KACK7I,EAAI,EAAG3E,EAASqE,EAAUH,GAAYlE,EAAJ2E,EAAYA,IAAK,CAC1D,GAAI5D,GAAQmD,EAAMS,GACd2F,EAAW9G,EAAWA,EAASzC,EAAO4D,EAAGT,GAASnD,CAClDuM,IACG3I,GAAK6I,IAASlD,GAAUtC,EAAOhH,KAAKD,GACzCyM,EAAOlD,GACE9G,EACJ/C,EAAEiF,SAAS8H,EAAMlD,KACpBkD,EAAKxM,KAAKsJ,GACVtC,EAAOhH,KAAKD,IAEJN,EAAEiF,SAASsC,EAAQjH,IAC7BiH,EAAOhH,KAAKD,GAGhB,MAAOiH,IA5hBCvH,EAiiBRgN,MAAQ,WACR,MAAOhN,GAAE2M,KAAKX,EAAQzI,WAAW,GAAM,KAliB/BvD,EAuiBRiN,aAAe,SAASxJ,GAGxB,IAAK,GAFD8D,MACA2F,EAAa3J,UAAUhE,OAClB2E,EAAI,EAAG3E,EAASqE,EAAUH,GAAYlE,EAAJ2E,EAAYA,IAAK,CAC1D,GAAIF,GAAOP,EAAMS,EACjB,KAAIlE,EAAEiF,SAASsC,EAAQvD,GAAvB,CACA,IAAK,GAAIuI,GAAI,EAAOW,EAAJX,GACTvM,EAAEiF,SAAS1B,UAAUgJ,GAAIvI,GADAuI,KAG5BA,IAAMW,GAAY3F,EAAOhH,KAAKyD,IAEpC,MAAOuD,IAljBCvH,EAujBR0M,WAAa,SAASjJ,GACtB,GAAImI,GAAOI,EAAQzI,WAAW,GAAM,EAAM,EAC1C,OAAOvD,GAAEsI,OAAO7E,EAAO,SAASnD,GAC9B,OAAQN,EAAEiF,SAAS2G,EAAMtL,MA1jBnBN,EAgkBRmN,IAAM,WACN,MAAOnN,GAAEoN,MAAM7J,YAjkBPvD,EAskBRoN,MAAQ,SAAS3J,GAIjB,IAAK,GAHDlE,GAASkE,GAASzD,EAAEoE,IAAIX,EAAOG,GAAWrE,QAAU,EACpDgI,EAASlC,MAAM9F,GAEV2D,EAAQ,EAAW3D,EAAR2D,EAAgBA,IAClCqE,EAAOrE,GAASlD,EAAEyJ,MAAMhG,EAAOP,EAEjC,OAAOqE,IA7kBCvH,EAmlBRqN,OAAS,SAAS7E,EAAMW,GAExB,IAAK,GADD5B,MACKrD,EAAI,EAAG3E,EAASqE,EAAU4E,GAAWjJ,EAAJ2E,EAAYA,IAChDiF,EACF5B,EAAOiB,EAAKtE,IAAMiF,EAAOjF,GAEzBqD,EAAOiB,EAAKtE,GAAG,IAAMsE,EAAKtE,GAAG,EAGjC,OAAOqD,IA5lBCvH,EA6mBRqB,UAAYmC,EAA2B,GACzCxD,EAAEsN,cAAgB9J,EAA2B,IA9mBnCxD,EAknBR+D,YAAc,SAASN,EAAOd,EAAKI,EAAUK,GAC7CL,EAAWY,EAAGZ,EAAUK,EAAS,EAGjC,KAFA,GAAI9C,GAAQyC,EAASJ,GACjB4K,EAAM,EAAGC,EAAO5J,EAAUH,GACjB+J,EAAND,GAAY,CACjB,GAAIE,GAAMtJ,KAAKuJ,OAAOH,EAAMC,GAAQ,EAChCzK,GAASU,EAAMgK,IAAQnN,EAAOiN,EAAME,EAAM,EAAQD,EAAOC,EAE/D,MAAOF,IA1nBCvN,EA0pBRoJ,QAAUvF,EAAkB,EAAG7D,EAAEqB,UAAWrB,EAAE+D,aAChD/D,EAAE2N,YAAc9J,EAAkB,GAAI7D,EAAEsN,eA3pB9BtN,EAgqBR4N,MAAQ,SAASC,EAAOC,EAAMC,GAClB,MAARD,IACFA,EAAOD,GAAS,EAChBA,EAAQ,GAEVE,EAAOA,GAAQ,CAKf,KAAK,GAHDxO,GAAS4E,KAAKC,IAAID,KAAK6J,MAAMF,EAAOD,GAASE,GAAO,GACpDH,EAAQvI,MAAM9F,GAET0E,EAAM,EAAS1E,EAAN0E,EAAcA,IAAO4J,GAASE,EAC9CH,EAAM3J,GAAO4J,CAGf,OAAOD,GA9qBC,IAsrBNK,GAAe,SAASC,EAAYC,EAAW/K,EAASgL,EAAgB7E,GAC1E,KAAM6E,YAA0BD,IAAY,MAAOD,GAAWxH,MAAMtD,EAASmG,EAC7E,IAAI8E,GAAO/G,EAAW4G,EAAWrJ,WAC7B0C,EAAS2G,EAAWxH,MAAM2H,EAAM9E,EACpC,OAAIvJ,GAAE4G,SAASW,GAAgBA,EACxB8G,EA3rBCrO,GAisBR+F,KAAO,SAASM,EAAMjD,GACtB,GAAI0C,GAAcO,EAAKN,OAASD,EAAY,MAAOA,GAAWY,MAAML,EAAM/B,EAAMtF,KAAKuE,UAAW,GAChG,KAAKvD,EAAE4E,WAAWyB,GAAO,KAAM,IAAIiI,WAAU,oCAC7C,IAAI/E,GAAOjF,EAAMtF,KAAKuE,UAAW,GAC7BgL,EAAQ,QAARA,KACF,MAAON,GAAa5H,EAAMkI,EAAOnL,EAASpC,KAAMuI,EAAKiF,OAAOlK,EAAMtF,KAAKuE,aAEzE,OAAOgL,IAxsBCvO,EA8sBRyO,QAAU,SAASpI,GACnB,GAAIqI,GAAYpK,EAAMtF,KAAKuE,UAAW,GAClCgL,EAAQ,QAARA,KAGF,IAAK,GAFDI,GAAW,EAAGpP,EAASmP,EAAUnP,OACjCgK,EAAOlE,MAAM9F,GACR2E,EAAI,EAAO3E,EAAJ2E,EAAYA,IAC1BqF,EAAKrF,GAAKwK,EAAUxK,KAAOlE,EAAIuD,UAAUoL,KAAcD,EAAUxK,EAEnE,MAAOyK,EAAWpL,UAAUhE,QAAQgK,EAAKhJ,KAAKgD,UAAUoL,KAAxD,OACOV,GAAa5H,EAAMkI,EAAOvN,KAAMA,KAAMuI,GAE/C,OAAOgF,IAztBCvO,EA+tBR4O,QAAU,SAASjM,GACnB,GAAIuB,GAA8BmD,EAA3B9H,EAASgE,UAAUhE,MAC1B,IAAc,GAAVA,EAAa,KAAM,IAAIsP,OAAM,wCACjC,KAAK3K,EAAI,EAAO3E,EAAJ2E,EAAYA,IACtBmD,EAAM9D,UAAUW,GAChBvB,EAAI0E,GAAOrH,EAAE+F,KAAKpD,EAAI0E,GAAM1E,EAE9B,OAAOA,IAtuBC3C,EA0uBR8O,QAAU,SAASzI,EAAM0I,GACzB,GAAID,GAAU,QAAVA,GAAmBzH,GACrB,GAAI2H,GAAQF,EAAQE,MAChBC,EAAU,IAAMF,EAASA,EAAOrI,MAAM1F,KAAMuC,WAAa8D,EAE7D,OADKrH,GAAEgF,IAAIgK,EAAOC,KAAUD,EAAMC,GAAW5I,EAAKK,MAAM1F,KAAMuC,YACvDyL,EAAMC,GAGf,OADAH,GAAQE,SACDF,GAlvBC9O,EAuvBRkP,MAAQ,SAAS7I,EAAM8I,GACvB,GAAI5F,GAAOjF,EAAMtF,KAAKuE,UAAW,EACjC,OAAO6L,YAAW,WAChB,MAAO/I,GAAKK,MAAM,KAAM6C,IACvB4F,IA3vBKnP,EAgwBRqP,MAAQrP,EAAEyO,QAAQzO,EAAEkP,MAAOlP,EAAG,GAhwBtBA,EAuwBRsP,SAAW,SAASjJ,EAAM8I,EAAMI,GAChC,GAAInM,GAASmG,EAAMhC,EACfiI,EAAU,KACVC,EAAW,CACVF,KAASA,KACd,IAAIG,GAAQ,WACVD,EAAWF,EAAQI,WAAY,EAAQ,EAAI3P,EAAE4P,MAC7CJ,EAAU,KACVjI,EAASlB,EAAKK,MAAMtD,EAASmG,GACxBiG,IAASpM,EAAUmG,EAAO,MAEjC,OAAO,YACL,GAAIqG,GAAM5P,EAAE4P,KACPH,IAAYF,EAAQI,WAAY,IAAOF,EAAWG,EACvD,IAAIC,GAAYV,GAAQS,EAAMH,EAc9B,OAbArM,GAAUpC,KACVuI,EAAOhG,UACU,GAAbsM,GAAkBA,EAAYV,GAC5BK,IACFM,aAAaN,GACbA,EAAU,MAEZC,EAAWG,EACXrI,EAASlB,EAAKK,MAAMtD,EAASmG,GACxBiG,IAASpM,EAAUmG,EAAO,OACrBiG,GAAWD,EAAQQ,YAAa,IAC1CP,EAAUJ,WAAWM,EAAOG,IAEvBtI,IAnyBDvH,EA2yBRgQ,SAAW,SAAS3J,EAAM8I,EAAMc,GAChC,GAAIT,GAASjG,EAAMnG,EAAS8M,EAAW3I,EAEnCmI,EAAQ,QAARA,KACF,GAAI/D,GAAO3L,EAAE4P,MAAQM,CAEVf,GAAPxD,GAAeA,GAAQ,EACzB6D,EAAUJ,WAAWM,EAAOP,EAAOxD,IAEnC6D,EAAU,KACLS,IACH1I,EAASlB,EAAKK,MAAMtD,EAASmG,GACxBiG,IAASpM,EAAUmG,EAAO,QAKrC,OAAO,YACLnG,EAAUpC,KACVuI,EAAOhG,UACP2M,EAAYlQ,EAAE4P,KACd,IAAIO,GAAUF,IAAcT,CAO5B,OANKA,KAASA,EAAUJ,WAAWM,EAAOP,IACtCgB,IACF5I,EAASlB,EAAKK,MAAMtD,EAASmG,GAC7BnG,EAAUmG,EAAO,MAGZhC,IAv0BDvH,EA80BRoQ,KAAO,SAAS/J,EAAMgK,GACtB,MAAOrQ,GAAEyO,QAAQ4B,EAAShK,IA/0BlBrG,EAm1BR0I,OAAS,SAAShF,GAClB,MAAO,YACL,OAAQA,EAAUgD,MAAM1F,KAAMuC,aAr1BxBvD,EA21BRsQ,QAAU,WACV,GAAI/G,GAAOhG,UACPsK,EAAQtE,EAAKhK,OAAS,CAC1B,OAAO,YAGL,IAFA,GAAI2E,GAAI2J,EACJtG,EAASgC,EAAKsE,GAAOnH,MAAM1F,KAAMuC,WAC9BW,KAAKqD,EAASgC,EAAKrF,GAAGlF,KAAKgC,KAAMuG,EAAxC,OACOA,KAl2BDvH,EAu2BRuQ,MAAQ,SAASC,EAAOnK,GACxB,MAAO,YACL,QAAMmK,EAAQ,EACLnK,EAAKK,MAAM1F,KAAMuC,WAD1B,SAz2BMvD,EAg3BRyQ,OAAS,SAASD,EAAOnK,GACzB,GAAIrD,EACJ,OAAO,YAKL,QAJMwN,EAAQ,IACZxN,EAAOqD,EAAKK,MAAM1F,KAAMuC,YAEb,GAATiN,IAAYnK,EAAO,MAChBrD,IAv3BDhD,EA63BR0Q,KAAO1Q,EAAEyO,QAAQzO,EAAEyQ,OAAQ,EA73BnB,IAm4BNE,KAAelL,SAAU,MAAMmL,qBAAqB,YACpDlM,GAAsB,UAAW,gBAAiB,WAClC,uBAAwB,iBAAkB,iBAr4BpD1E,GA05BRiD,KAAO,SAASN,GAChB,IAAK3C,EAAE4G,SAASjE,GAAM,QACtB,IAAIkD,EAAY,MAAOA,GAAWlD,EAClC,IAAIM,KACJ,KAAK,GAAIoE,KAAO1E,GAAS3C,EAAEgF,IAAIrC,EAAK0E,IAAMpE,EAAK1C,KAAK8G,EAGpD,OADIsJ,IAAYnM,EAAoB7B,EAAKM,GAClCA,GAj6BCjD,EAq6BR6Q,QAAU,SAASlO,GACnB,IAAK3C,EAAE4G,SAASjE,GAAM,QACtB,IAAIM,KACJ,KAAK,GAAIoE,KAAO1E,GAAKM,EAAK1C,KAAK8G,EAG/B,OADIsJ,IAAYnM,EAAoB7B,EAAKM,GAClCA,GA36BCjD,EA+6BRmJ,OAAS,SAASxG,GAIlB,IAAK,GAHDM,GAAOjD,EAAEiD,KAAKN,GACdpD,EAAS0D,EAAK1D,OACd4J,EAAS9D,MAAM9F,GACV2E,EAAI,EAAO3E,EAAJ2E,EAAYA,IAC1BiF,EAAOjF,GAAKvB,EAAIM,EAAKiB,GAEvB,OAAOiF,IAt7BCnJ,EA27BR8Q,UAAY,SAASnO,EAAKI,EAAUK,GACpCL,EAAWY,EAAGZ,EAAUK,EAKtB,KAAK,GADDD,GAHFF,EAAQjD,EAAEiD,KAAKN,GACbpD,EAAS0D,EAAK1D,OACdsI,KAEK3E,EAAQ,EAAW3D,EAAR2D,EAAgBA,IAClCC,EAAaF,EAAKC,GAClB2E,EAAQ1E,GAAcJ,EAASJ,EAAIQ,GAAaA,EAAYR,EAE9D,OAAOkF,IAr8BD7H,EAy8BR+Q,MAAQ,SAASpO,GAIjB,IAAK,GAHDM,GAAOjD,EAAEiD,KAAKN,GACdpD,EAAS0D,EAAK1D,OACdwR,EAAQ1L,MAAM9F,GACT2E,EAAI,EAAO3E,EAAJ2E,EAAYA,IAC1B6M,EAAM7M,IAAMjB,EAAKiB,GAAIvB,EAAIM,EAAKiB,IAEhC,OAAO6M,IAh9BC/Q,EAo9BRgR,OAAS,SAASrO,GAGlB,IAAK,GAFD4E,MACAtE,EAAOjD,EAAEiD,KAAKN,GACTuB,EAAI,EAAG3E,EAAS0D,EAAK1D,OAAYA,EAAJ2E,EAAYA,IAChDqD,EAAO5E,EAAIM,EAAKiB,KAAOjB,EAAKiB,EAE9B,OAAOqD,IA19BCvH,EA+9BRiR,UAAYjR,EAAEkR,QAAU,SAASvO,GACjC,GAAIwO,KACJ,KAAK,GAAI9J,KAAO1E,GACV3C,EAAE4E,WAAWjC,EAAI0E,KAAO8J,EAAM5Q,KAAK8G,EAEzC,OAAO8J,GAAM3G,QAp+BLxK,EAw+BRoR,OAASpK,EAAehH,EAAE6Q,SAx+BlB7Q,EA4+BRqR,UAAYrR,EAAEsR,OAAStK,EAAehH,EAAEiD,MA5+BhCjD,EA++BRqI,QAAU,SAAS1F,EAAKe,EAAWN,GACnCM,EAAYC,EAAGD,EAAWN,EAE1B,KAAK,GADmBiE,GAApBpE,EAAOjD,EAAEiD,KAAKN,GACTuB,EAAI,EAAG3E,EAAS0D,EAAK1D,OAAYA,EAAJ2E,EAAYA,IAEhD,GADAmD,EAAMpE,EAAKiB,GACPR,EAAUf,EAAI0E,GAAMA,EAAK1E,GAAM,MAAO0E,IAp/BpCrH,EAy/BRuR,KAAO,SAASlE,EAAQmE,EAAWpO,GACnC,GAA+BL,GAAUE,EAArCsE,KAAa5E,EAAM0K,CACvB,IAAW,MAAP1K,EAAa,MAAO4E,EACpBvH,GAAE4E,WAAW4M,IACfvO,EAAOjD,EAAE6Q,QAAQlO,GACjBI,EAAWM,EAAWmO,EAAWpO,KAEjCH,EAAO+I,EAAQzI,WAAW,GAAO,EAAO,GACxCR,EAAW,SAASzC,EAAO+G,EAAK1E,GAAO,MAAO0E,KAAO1E,IACrDA,EAAM2C,OAAO3C,GAEf,KAAK,GAAIuB,GAAI,EAAG3E,EAAS0D,EAAK1D,OAAYA,EAAJ2E,EAAYA,IAAK,CACrD,GAAImD,GAAMpE,EAAKiB,GACX5D,EAAQqC,EAAI0E,EACZtE,GAASzC,EAAO+G,EAAK1E,KAAM4E,EAAOF,GAAO/G,GAE/C,MAAOiH,IAzgCCvH,EA6gCRyR,KAAO,SAAS9O,EAAKI,EAAUK,GAC/B,GAAIpD,EAAE4E,WAAW7B,GACfA,EAAW/C,EAAE0I,OAAO3F,OACf,CACL,GAAIE,GAAOjD,EAAE2H,IAAIqE,EAAQzI,WAAW,GAAO,EAAO,GAAImO,OACtD3O,GAAW,SAASzC,EAAO+G,GACzB,OAAQrH,EAAEiF,SAAShC,EAAMoE,IAG7B,MAAOrH,GAAEuR,KAAK5O,EAAKI,EAAUK,IAthCrBpD,EA0hCR2R,SAAW3K,EAAehH,EAAE6Q,SAAS,GA1hC7B7Q,EA+hCRiG,OAAS,SAASpB,EAAW+M,GAC7B,GAAIrK,GAASD,EAAWzC,EAExB,OADI+M,IAAO5R,EAAEqR,UAAU9J,EAAQqK,GACxBrK,GAliCCvH,EAsiCR6R,MAAQ,SAASlP,GACjB,MAAK3C,GAAE4G,SAASjE,GACT3C,EAAE4F,QAAQjD,GAAOA,EAAI2B,QAAUtE,EAAEoR,UAAWzO,GADtBA,GAviCrB3C,EA8iCR8R,IAAM,SAASnP,EAAKoP,GAEpB,MADAA,GAAYpP,GACLA,GAhjCC3C,EAojCRgS,QAAU,SAAS3E,EAAQ1D,GAC3B,GAAI1G,GAAOjD,EAAEiD,KAAK0G,GAAQpK,EAAS0D,EAAK1D,MACxC,IAAc,MAAV8N,EAAgB,OAAQ9N,CAE5B,KAAK,GADDoD,GAAM2C,OAAO+H,GACRnJ,EAAI,EAAO3E,EAAJ2E,EAAYA,IAAK,CAC/B,GAAImD,GAAMpE,EAAKiB,EACf,IAAIyF,EAAMtC,KAAS1E,EAAI0E,MAAUA,IAAO1E,IAAM,OAAO,EAEvD,OAAO,EA5jCC,IAikCNsP,GAAK,QAALA,GAActH,EAAGC,EAAGsH,EAAQC,GAG9B,GAAIxH,IAAMC,EAAG,MAAa,KAAND,GAAW,EAAIA,IAAM,EAAIC,CAHP,IAK7B,MAALD,GAAkB,MAALC,EAAW,MAAOD,KAAMC,CAErCD,aAAa3K,KAAG2K,EAAIA,EAAExE,UACtByE,YAAa5K,KAAG4K,EAAIA,EAAEzE,SARY,IAUlCiM,GAAY3M,EAASzG,KAAK2L,EAC9B,IAAIyH,IAAc3M,EAASzG,KAAK4L,GAAI,OAAO,CAC3C,QAAQwH,GAEN,IAAK,kBAFP,IAIO,kBAGH,MAAO,GAAKzH,GAAM,GAAKC,CAP3B,KAQO,kBAGH,OAAKD,KAAOA,GAAWC,KAAOA,EAEhB,KAAND,EAAU,GAAKA,IAAM,EAAIC,GAAKD,KAAOC,CAbjD,KAcO,gBACL,IAAK,mBAIH,OAAQD,KAAOC,EAGnB,GAAIyH,GAA0B,mBAAdD,CAChB,KAAKC,EAAW,CACd,GAAgB,WAAL,mBAAA1H,GAAA,YAAAnI,EAAAmI,KAA6B,WAAL,mBAAAC,GAAA,YAAApI,EAAAoI,IAAe,OAAO,CAD3C,IAKV0H,GAAQ3H,EAAE/H,YAAa2P,EAAQ3H,EAAEhI,WACrC,IAAI0P,IAAUC,KAAWvS,EAAE4E,WAAW0N,IAAUA,YAAiBA,IACxCtS,EAAE4E,WAAW2N,IAAUA,YAAiBA,KACzC,eAAiB5H,IAAK,eAAiBC,GAC7D,OAAO,EA5C2BsH,EAoD7BA,MACTC,EAASA,KAET,KADA,GAAI5S,GAAS2S,EAAO3S,OACbA,KAGL,GAAI2S,EAAO3S,KAAYoL,EAAG,MAAOwH,GAAO5S,KAAYqL,CA1DhB,IAAAsH,EA8D/B3R,KAAKoK,GACZwH,EAAO5R,KAAKqK,GAGRyH,EAAW,CAGb,GADA9S,EAASoL,EAAEpL,OACPA,IAAWqL,EAAErL,OAAQ,OAAO,CAHnB,MAKNA,KACL,IAAK0S,EAAGtH,EAAEpL,GAASqL,EAAErL,GAAS2S,EAAQC,GAAS,OAAO,MAEnD,CAEL,GAAsB9K,GAAlBpE,EAAOjD,EAAEiD,KAAK0H,EAFb,IAGLpL,EAAS0D,EAAK1D,OAEVS,EAAEiD,KAAK2H,GAAGrL,SAAWA,EAAQ,OAAO,CACxC,MAAOA,KAGL,GADA8H,EAAMpE,EAAK1D,IACLS,EAAEgF,IAAI4F,EAAGvD,KAAQ4K,EAAGtH,EAAEtD,GAAMuD,EAAEvD,GAAM6K,EAAQC,GAAU,OAAO,EAMvE,MAzFsCD,GAuF/BM,MACPL,EAAOK,OACA,EA1pCCxS,GA8pCRyS,QAAU,SAAS9H,EAAGC,GACtB,MAAOqH,GAAGtH,EAAGC,IA/pCL5K,EAoqCR0S,QAAU,SAAS/P,GACnB,MAAW,OAAPA,GAAoB,EACpBW,EAAYX,KAAS3C,EAAE4F,QAAQjD,IAAQ3C,EAAE2S,SAAShQ,IAAQ3C,EAAEsM,YAAY3J,IAA6B,IAAfA,EAAIpD,OAChE,IAAvBS,EAAEiD,KAAKN,GAAKpD,QAvqCXS,EA2qCR4S,UAAY,SAASjQ,GACrB,SAAUA,GAAwB,IAAjBA,EAAIkQ,WA5qCb7S,EAirCR4F,QAAUD,GAAiB,SAAShD,GACpC,MAA8B,mBAAvB8C,EAASzG,KAAK2D,IAlrCb3C,EAsrCR4G,SAAW,SAASjE,GACpB,GAAImQ,GAAc,mBAAAnQ,GAAA,YAAAH,EAAAG,EAClB,OAAgB,aAATmQ,GAAgC,WAATA,KAAuBnQ,GAxrC7C3C,EA4rCR0H,MAAM,YAAa,WAAY,SAAU,SAAU,OAAQ,SAAU,SAAU,SAASqL,GACxF/S,EAAE,KAAO+S,GAAQ,SAASpQ,GACxB,MAAO8C,GAASzG,KAAK2D,KAAS,WAAaoQ,EAAO,OAMjD/S,EAAEsM,YAAY/I,aACjBvD,EAAEsM,YAAc,SAAS3J,GACvB,MAAO3C,GAAEgF,IAAIrC,EAAK,YAMJ,kBAAP,KAAyC,WAAb,mBAAAqQ,WAAA,YAAAxQ,EAAAwQ,cACrChT,EAAE4E,WAAa,SAASjC,GACtB,MAAqB,kBAAPA,KAAqB,IA9sC7B3C,EAmtCRiT,SAAW,SAAStQ,GACpB,MAAOsQ,UAAStQ,KAAS4B,MAAM2O,WAAWvQ,KAptClC3C,EAwtCRuE,MAAQ,SAAS5B,GACjB,MAAO3C,GAAEmT,SAASxQ,IAAQA,KAASA,GAztC3B3C,EA6tCR8M,UAAY,SAASnK,GACrB,MAAOA,MAAQ,GAAQA,KAAQ,GAAgC,qBAAvB8C,EAASzG,KAAK2D,IA9tC9C3C,EAkuCRoT,OAAS,SAASzQ,GAClB,MAAe,QAARA,GAnuCC3C,EAuuCRqT,YAAc,SAAS1Q,GACvB,MAAe,UAARA,GAxuCC3C,EA6uCRgF,IAAM,SAASrC,EAAK0E,GACpB,MAAc,OAAP1E,GAAe+C,EAAe1G,KAAK2D,EAAK0E,IA9uCvCrH,EAsvCRsT,WAAa,WAEb,MADApO,GAAKlF,EAAImF,EACFnE,MAxvCChB,EA4vCR2G,SAAW,SAASrG,GACpB,MAAOA,IA7vCCN,EAiwCRuT,SAAW,SAASjT,GACpB,MAAO,YACL,MAAOA,KAIXN,EAAEwT,KAAO,aAETxT,EAAE8G,SAAWA,EAzwCH9G,EA4wCRyT,WAAa,SAAS9Q,GACtB,MAAc,OAAPA,EAAc,aAAe,SAAS0E,GAC3C,MAAO1E,GAAI0E,KA9wCLrH,EAoxCR6G,QAAU7G,EAAE0T,QAAU,SAAS/J,GAE/B,MADAA,GAAQ3J,EAAEqR,aAAc1H,GACjB,SAAShH,GACd,MAAO3C,GAAEgS,QAAQrP,EAAKgH,KAvxChB3J,EA4xCRwQ,MAAQ,SAASnG,EAAGtH,EAAUK,GAC9B,GAAIuQ,GAAQtO,MAAMlB,KAAKC,IAAI,EAAGiG,GAC9BtH,GAAWM,EAAWN,EAAUK,EAAS,EACzC,KAAK,GAAIc,GAAI,EAAOmG,EAAJnG,EAAOA,IAAKyP,EAAMzP,GAAKnB,EAASmB,EAAhD,OACOyP,IAhyCC3T,EAoyCRmK,OAAS,SAAS9F,EAAKD,GAKvB,MAJW,OAAPA,IACFA,EAAMC,EACNA,EAAM,GAEDA,EAAMF,KAAKuJ,MAAMvJ,KAAKgG,UAAY/F,EAAMC,EAAM,KAzyC7CrE,EA6yCR4P,IAAMgE,KAAKhE,KAAO,WAClB,OAAO,GAAIgE,OAAOC,UA9yCV,IAkzCNC,IACFC,IAAK,QACLC,IAAK,OACLC,IAAK,OACLC,IAAK,SACLC,IAAK,SACLC,IAAK,UAEHC,EAAcrU,EAAEgR,OAAO8C,GAGvBQ,EAAgB,SAAS3M,GAC3B,GAAI4M,GAAU,SAASC,GACrB,MAAO7M,GAAI6M,IAGTrN,EAAS,MAAQnH,EAAEiD,KAAK0E,GAAK/G,KAAK,KAAO,IACzC6T,EAAaC,OAAOvN,GACpBwN,EAAgBD,OAAOvN,EAAQ,IACnC,OAAO,UAASyN,GAEd,MADAA,GAAmB,MAAVA,EAAiB,GAAK,GAAKA,EAC7BH,EAAWI,KAAKD,GAAUA,EAAOE,QAAQH,EAAeJ,GAAWK,GAG9E5U,GAAE+U,OAAST,EAAcR,GACzB9T,EAAEgV,SAAWV,EAAcD,GA30CjBrU,EA+0CRuH,OAAS,SAAS8F,EAAQvG,EAAUmO,GACpC,GAAI3U,GAAkB,MAAV+M,EAAiB,OAASA,EAAOvG,EAI7C,OAHc,UAAVxG,IACFA,EAAQ2U,GAEHjV,EAAE4E,WAAWtE,GAASA,EAAMtB,KAAKqO,GAAU/M,EAp1C1C,IAy1CN4U,GAAY,CAChBlV,GAAEmV,SAAW,SAASC,GACpB,GAAItW,KAAOoW,EAAY,EACvB,OAAOE,GAASA,EAAStW,EAAKA,GA51CtBkB,EAi2CRqV,kBACAC,SAAc,kBACdC,YAAc,mBACdR,OAAc,mBAp2CN,IA02CNS,GAAU,OAIVC,GACFtB,IAAU,IACVuB,KAAU,KACVC,KAAU,IACVC,KAAU,IACVC,SAAU,QACVC,SAAU,SAGRvB,EAAU,4BAEVwB,EAAa,SAASvB,GACxB,MAAO,KAAOiB,EAAQjB,GA13CdxU,GAi4CRC,SAAW,SAAS+V,EAAMC,EAAUC,IAC/BD,GAAYC,IAAaD,EAAWC,GACzCD,EAAWjW,EAAE2R,YAAasE,EAAUjW,EAAEqV,iBAFW,IAK7CxO,GAAU6N,SACXuB,EAASlB,QAAUS,GAASrO,QAC5B8O,EAASV,aAAeC,GAASrO,QACjC8O,EAASX,UAAYE,GAASrO,QAC/BvG,KAAK,KAAO,KAAM,KAGhBsC,EAAQ,EACRiE,EAAS,QACb6O,GAAKlB,QAAQjO,EAAS,SAAS2N,EAAOO,EAAQQ,EAAaD,EAAUa,GAAQ,MAC3EhP,IAAU6O,EAAK1R,MAAMpB,EAAOiT,GAAQrB,QAAQP,EAASwB,GACrD7S,EAAQiT,EAAS3B,EAAMjV,OAEnBwV,EACF5N,GAAU,cAAgB4N,EAAS,iCAC1BQ,EACTpO,GAAU,cAAgBoO,EAAc,uBAC/BD,IACTnO,GAAU,OAASmO,EAAW,YAIzBd,IAETrN,GAAU,OAGL8O,EAASG,WAAUjP,EAAS,mBAAqBA,EAAS,OAE/DA,EAAS,4FAEPA,EAAS,eAEX,KACE,GAAIkP,GAAS,GAAI7Q,UAASyQ,EAASG,UAAY,MAAO,IAAKjP,GAC3D,MAAOrG,GAEP,KADAA,GAAEqG,OAASA,EACLrG,EAGR,GAAIb,GAAW,SAASS,GACtB,MAAO2V,GAAOrX,KAAKgC,KAAMN,EAAMV,IAI7BsW,EAAWL,EAASG,UAAY,KAGpC,OAFAnW,GAASkH,OAAS,YAAcmP,EAAW,OAASnP,EAAS,IAEtDlH,GAt7CCD,EA07CRuW,MAAQ,SAAS5T,GACjB,GAAI6T,GAAWxW,EAAE2C,EAEjB,OADA6T,GAASC,QAAS,EACXD,EA77CC,IAu8CNjP,GAAS,SAASiP,EAAU7T,GAC9B,MAAO6T,GAASC,OAASzW,EAAE2C,GAAK4T,QAAU5T,EAx8ClC3C,GA48CR0W,MAAQ,SAAS/T,GACjB3C,EAAE0H,KAAK1H,EAAEiR,UAAUtO,GAAM,SAASoQ,GAChC,GAAI1M,GAAOrG,EAAE+S,GAAQpQ,EAAIoQ,EACzB/S,GAAE6E,UAAUkO,GAAQ,WAClB,GAAIxJ,IAAQvI,KAAKmF,SAEjB,OADA5F,GAAKmG,MAAM6C,EAAMhG,WACVgE,EAAOvG,KAAMqF,EAAKK,MAAM1G,EAAGuJ,QAl9C9BvJ,EAw9CR0W,MAAM1W,GAx9CEA,EA29CR0H,MAAM,MAAO,OAAQ,UAAW,QAAS,OAAQ,SAAU,WAAY,SAASqL,GAChF,GAAIzJ,GAASlE,EAAW2N,EACxB/S,GAAE6E,UAAUkO,GAAQ,WAClB,GAAIpQ,GAAM3B,KAAKmF,QAGf,OAFAmD,GAAO5C,MAAM/D,EAAKY,WACJ,UAATwP,GAA6B,WAATA,GAAqC,IAAfpQ,EAAIpD,cAAqBoD,GAAI,GACrE4E,EAAOvG,KAAM2B,MAj+Cd3C,EAs+CR0H,MAAM,SAAU,OAAQ,SAAU,SAASqL,GAC3C,GAAIzJ,GAASlE,EAAW2N,EACxB/S,GAAE6E,UAAUkO,GAAQ,WAClB,MAAOxL,GAAOvG,KAAMsI,EAAO5C,MAAM1F,KAAKmF,SAAU5C,eAz+C1CvD,EA8+CR6E,UAAUvE,MAAQ,WAClB,MAAOU,MAAKmF,UA/+CJnG,EAo/CR6E,UAAU8R,QAAU3W,EAAE6E,UAAU+R,OAAS5W,EAAE6E,UAAUvE,MAEvDN,EAAE6E,UAAUY,SAAW,WACrB,MAAO,GAAKzE,KAAKmF,UAWjB7D,KAAAC,EAAyB,WACvB,MAAOvC,IADgB0G,MAAA9H,EAAA0D,KAAAuU,SAAAtU,IAAA1D,EAAAD,QAAA2D,MAI3BvD,KAtgDD6X","file":"frontend.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ({\n\n/***/ 0:\n/***/ function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\tvar _underscore = __webpack_require__(199);\n\t\n\tvar $ = jQuery;\n\t\n\t\n\t$('.alike-button').on('click', function (e) {\n\t e.preventDefault();\n\t var postId = $(this).data('post-id');\n\t var postTitle = $(this).data('post-title');\n\t var postThumb = $(this).data('post-thumb');\n\t var postLink = $(this).data('post-link');\n\t\n\t var allPosts = window.localStorage.getItem('alikeData') ? JSON.parse(window.localStorage.getItem('alikeData')) : [];\n\t\n\t var checkIndex = (0, _underscore.findIndex)(allPosts, { postId: postId });\n\t\n\t if (checkIndex === -1) {\n\t var newPost = {\n\t postId: postId, postTitle: postTitle, postThumb: postThumb, postLink: postLink\n\t };\n\t if (allPosts.length < ALIKE.max_compare) {\n\t allPosts.push(newPost);\n\t } else {\n\t alert(ALIKE.LANG.YOU_CAN_COMPARE_MAXIMUM_BETWEEN_S_ITEMS);\n\t }\n\t }\n\t\n\t window.localStorage.setItem('alikeData', JSON.stringify(allPosts));\n\t $('.alike-widget-btn-wrap').show();\n\t onStorageEvent();\n\t});\n\t\n\t$(window).on('load', function () {\n\t var items = JSON.parse(localStorage.getItem('alikeData')) !== null ? JSON.parse(localStorage.getItem('alikeData')) : [];\n\t if (items.length > 0) {\n\t $('.alike-widget-btn-wrap').show();\n\t } else {\n\t $('.alike-widget-btn-wrap').hide();\n\t }\n\t onStorageEvent();\n\t});\n\t\n\tfunction onStorageEvent() {\n\t if ($('.alike-widget').length > 0) {\n\t (function () {\n\t var items = JSON.parse(localStorage.getItem('alikeData')) !== null ? JSON.parse(localStorage.getItem('alikeData')) : [];\n\t if (items.length > 0) {\n\t $('.alike-widget-btn-wrap').show();\n\t } else {\n\t $('.alike-widget-btn-wrap').hide();\n\t }\n\t\n\t var resultTemplate = _.template($('.alike-list').html());\n\t var resultingHtml = resultTemplate({ items: items });\n\t var allPostIds = [];\n\t items.forEach(function (value) {\n\t allPostIds.push(value.postId);\n\t });\n\t var pageUrl = $('.alike-button-compare').data('page-url');\n\t $('.alike-button-compare').attr('href', pageUrl + '/?ids=' + allPostIds.join([',']));\n\t\n\t $('.alike-widget').html(resultingHtml).on('click', '.alike-widget-remove', function (e) {\n\t e.preventDefault();\n\t var postId = $(this).data('post-id');\n\t var allPosts = JSON.parse(window.localStorage.getItem('alikeData'));\n\t var checkIndex = (0, _underscore.findIndex)(allPosts, { postId: postId });\n\t\n\t if (checkIndex !== -1) {\n\t allPosts.splice(checkIndex, 1);\n\t window.localStorage.setItem('alikeData', JSON.stringify(allPosts));\n\t\n\t onStorageEvent();\n\t }\n\t }).next('.alike-widget-btn-wrap').on('click', '.alike-button-clear', function (e) {\n\t e.preventDefault();\n\t window.localStorage.setItem('alikeData', '[]');\n\t onStorageEvent();\n\t });\n\t })();\n\t }\n\t}\n\twindow.addEventListener('storage', onStorageEvent, false);\n\n/***/ },\n\n/***/ 199:\n/***/ function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;'use strict';\n\t\n\tvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol ? \"symbol\" : typeof obj; };\n\t\n\t// Underscore.js 1.8.3\n\t// http://underscorejs.org\n\t// (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n\t// Underscore may be freely distributed under the MIT license.\n\t\n\t(function () {\n\t\n\t // Baseline setup\n\t // --------------\n\t\n\t // Establish the root object, `window` in the browser, or `exports` on the server.\n\t var root = this;\n\t\n\t // Save the previous value of the `_` variable.\n\t var previousUnderscore = root._;\n\t\n\t // Save bytes in the minified (but not gzipped) version:\n\t var ArrayProto = Array.prototype,\n\t ObjProto = Object.prototype,\n\t FuncProto = Function.prototype;\n\t\n\t // Create quick reference variables for speed access to core prototypes.\n\t var push = ArrayProto.push,\n\t slice = ArrayProto.slice,\n\t toString = ObjProto.toString,\n\t hasOwnProperty = ObjProto.hasOwnProperty;\n\t\n\t // All **ECMAScript 5** native function implementations that we hope to use\n\t // are declared here.\n\t var nativeIsArray = Array.isArray,\n\t nativeKeys = Object.keys,\n\t nativeBind = FuncProto.bind,\n\t nativeCreate = Object.create;\n\t\n\t // Naked function reference for surrogate-prototype-swapping.\n\t var Ctor = function Ctor() {};\n\t\n\t // Create a safe reference to the Underscore object for use below.\n\t var _ = function _(obj) {\n\t if (obj instanceof _) return obj;\n\t if (!(this instanceof _)) return new _(obj);\n\t this._wrapped = obj;\n\t };\n\t\n\t // Export the Underscore object for **Node.js**, with\n\t // backwards-compatibility for the old `require()` API. If we're in\n\t // the browser, add `_` as a global object.\n\t if (true) {\n\t if (typeof module !== 'undefined' && module.exports) {\n\t exports = module.exports = _;\n\t }\n\t exports._ = _;\n\t } else {\n\t root._ = _;\n\t }\n\t\n\t // Current version.\n\t _.VERSION = '1.8.3';\n\t\n\t // Internal function that returns an efficient (for current engines) version\n\t // of the passed-in callback, to be repeatedly applied in other Underscore\n\t // functions.\n\t var optimizeCb = function optimizeCb(func, context, argCount) {\n\t if (context === void 0) return func;\n\t switch (argCount == null ? 3 : argCount) {\n\t case 1:\n\t return function (value) {\n\t return func.call(context, value);\n\t };\n\t case 2:\n\t return function (value, other) {\n\t return func.call(context, value, other);\n\t };\n\t case 3:\n\t return function (value, index, collection) {\n\t return func.call(context, value, index, collection);\n\t };\n\t case 4:\n\t return function (accumulator, value, index, collection) {\n\t return func.call(context, accumulator, value, index, collection);\n\t };\n\t }\n\t return function () {\n\t return func.apply(context, arguments);\n\t };\n\t };\n\t\n\t // A mostly-internal function to generate callbacks that can be applied\n\t // to each element in a collection, returning the desired result — either\n\t // identity, an arbitrary callback, a property matcher, or a property accessor.\n\t var cb = function cb(value, context, argCount) {\n\t if (value == null) return _.identity;\n\t if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n\t if (_.isObject(value)) return _.matcher(value);\n\t return _.property(value);\n\t };\n\t _.iteratee = function (value, context) {\n\t return cb(value, context, Infinity);\n\t };\n\t\n\t // An internal function for creating assigner functions.\n\t var createAssigner = function createAssigner(keysFunc, undefinedOnly) {\n\t return function (obj) {\n\t var length = arguments.length;\n\t if (length < 2 || obj == null) return obj;\n\t for (var index = 1; index < length; index++) {\n\t var source = arguments[index],\n\t keys = keysFunc(source),\n\t l = keys.length;\n\t for (var i = 0; i < l; i++) {\n\t var key = keys[i];\n\t if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\n\t }\n\t }\n\t return obj;\n\t };\n\t };\n\t\n\t // An internal function for creating a new object that inherits from another.\n\t var baseCreate = function baseCreate(prototype) {\n\t if (!_.isObject(prototype)) return {};\n\t if (nativeCreate) return nativeCreate(prototype);\n\t Ctor.prototype = prototype;\n\t var result = new Ctor();\n\t Ctor.prototype = null;\n\t return result;\n\t };\n\t\n\t var property = function property(key) {\n\t return function (obj) {\n\t return obj == null ? void 0 : obj[key];\n\t };\n\t };\n\t\n\t // Helper for collection methods to determine whether a collection\n\t // should be iterated as an array or as an object\n\t // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n\t // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n\t var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n\t var getLength = property('length');\n\t var isArrayLike = function isArrayLike(collection) {\n\t var length = getLength(collection);\n\t return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n\t };\n\t\n\t // Collection Functions\n\t // --------------------\n\t\n\t // The cornerstone, an `each` implementation, aka `forEach`.\n\t // Handles raw objects in addition to array-likes. Treats all\n\t // sparse array-likes as if they were dense.\n\t _.each = _.forEach = function (obj, iteratee, context) {\n\t iteratee = optimizeCb(iteratee, context);\n\t var i, length;\n\t if (isArrayLike(obj)) {\n\t for (i = 0, length = obj.length; i < length; i++) {\n\t iteratee(obj[i], i, obj);\n\t }\n\t } else {\n\t var keys = _.keys(obj);\n\t for (i = 0, length = keys.length; i < length; i++) {\n\t iteratee(obj[keys[i]], keys[i], obj);\n\t }\n\t }\n\t return obj;\n\t };\n\t\n\t // Return the results of applying the iteratee to each element.\n\t _.map = _.collect = function (obj, iteratee, context) {\n\t iteratee = cb(iteratee, context);\n\t var keys = !isArrayLike(obj) && _.keys(obj),\n\t length = (keys || obj).length,\n\t results = Array(length);\n\t for (var index = 0; index < length; index++) {\n\t var currentKey = keys ? keys[index] : index;\n\t results[index] = iteratee(obj[currentKey], currentKey, obj);\n\t }\n\t return results;\n\t };\n\t\n\t // Create a reducing function iterating left or right.\n\t function createReduce(dir) {\n\t // Optimized iterator function as using arguments.length\n\t // in the main function will deoptimize the, see #1991.\n\t function iterator(obj, iteratee, memo, keys, index, length) {\n\t for (; index >= 0 && index < length; index += dir) {\n\t var currentKey = keys ? keys[index] : index;\n\t memo = iteratee(memo, obj[currentKey], currentKey, obj);\n\t }\n\t return memo;\n\t }\n\t\n\t return function (obj, iteratee, memo, context) {\n\t iteratee = optimizeCb(iteratee, context, 4);\n\t var keys = !isArrayLike(obj) && _.keys(obj),\n\t length = (keys || obj).length,\n\t index = dir > 0 ? 0 : length - 1;\n\t // Determine the initial value if none is provided.\n\t if (arguments.length < 3) {\n\t memo = obj[keys ? keys[index] : index];\n\t index += dir;\n\t }\n\t return iterator(obj, iteratee, memo, keys, index, length);\n\t };\n\t }\n\t\n\t // **Reduce** builds up a single result from a list of values, aka `inject`,\n\t // or `foldl`.\n\t _.reduce = _.foldl = _.inject = createReduce(1);\n\t\n\t // The right-associative version of reduce, also known as `foldr`.\n\t _.reduceRight = _.foldr = createReduce(-1);\n\t\n\t // Return the first value which passes a truth test. Aliased as `detect`.\n\t _.find = _.detect = function (obj, predicate, context) {\n\t var key;\n\t if (isArrayLike(obj)) {\n\t key = _.findIndex(obj, predicate, context);\n\t } else {\n\t key = _.findKey(obj, predicate, context);\n\t }\n\t if (key !== void 0 && key !== -1) return obj[key];\n\t };\n\t\n\t // Return all the elements that pass a truth test.\n\t // Aliased as `select`.\n\t _.filter = _.select = function (obj, predicate, context) {\n\t var results = [];\n\t predicate = cb(predicate, context);\n\t _.each(obj, function (value, index, list) {\n\t if (predicate(value, index, list)) results.push(value);\n\t });\n\t return results;\n\t };\n\t\n\t // Return all the elements for which a truth test fails.\n\t _.reject = function (obj, predicate, context) {\n\t return _.filter(obj, _.negate(cb(predicate)), context);\n\t };\n\t\n\t // Determine whether all of the elements match a truth test.\n\t // Aliased as `all`.\n\t _.every = _.all = function (obj, predicate, context) {\n\t predicate = cb(predicate, context);\n\t var keys = !isArrayLike(obj) && _.keys(obj),\n\t length = (keys || obj).length;\n\t for (var index = 0; index < length; index++) {\n\t var currentKey = keys ? keys[index] : index;\n\t if (!predicate(obj[currentKey], currentKey, obj)) return false;\n\t }\n\t return true;\n\t };\n\t\n\t // Determine if at least one element in the object matches a truth test.\n\t // Aliased as `any`.\n\t _.some = _.any = function (obj, predicate, context) {\n\t predicate = cb(predicate, context);\n\t var keys = !isArrayLike(obj) && _.keys(obj),\n\t length = (keys || obj).length;\n\t for (var index = 0; index < length; index++) {\n\t var currentKey = keys ? keys[index] : index;\n\t if (predicate(obj[currentKey], currentKey, obj)) return true;\n\t }\n\t return false;\n\t };\n\t\n\t // Determine if the array or object contains a given item (using `===`).\n\t // Aliased as `includes` and `include`.\n\t _.contains = _.includes = _.include = function (obj, item, fromIndex, guard) {\n\t if (!isArrayLike(obj)) obj = _.values(obj);\n\t if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n\t return _.indexOf(obj, item, fromIndex) >= 0;\n\t };\n\t\n\t // Invoke a method (with arguments) on every item in a collection.\n\t _.invoke = function (obj, method) {\n\t var args = slice.call(arguments, 2);\n\t var isFunc = _.isFunction(method);\n\t return _.map(obj, function (value) {\n\t var func = isFunc ? method : value[method];\n\t return func == null ? func : func.apply(value, args);\n\t });\n\t };\n\t\n\t // Convenience version of a common use case of `map`: fetching a property.\n\t _.pluck = function (obj, key) {\n\t return _.map(obj, _.property(key));\n\t };\n\t\n\t // Convenience version of a common use case of `filter`: selecting only objects\n\t // containing specific `key:value` pairs.\n\t _.where = function (obj, attrs) {\n\t return _.filter(obj, _.matcher(attrs));\n\t };\n\t\n\t // Convenience version of a common use case of `find`: getting the first object\n\t // containing specific `key:value` pairs.\n\t _.findWhere = function (obj, attrs) {\n\t return _.find(obj, _.matcher(attrs));\n\t };\n\t\n\t // Return the maximum element (or element-based computation).\n\t _.max = function (obj, iteratee, context) {\n\t var result = -Infinity,\n\t lastComputed = -Infinity,\n\t value,\n\t computed;\n\t if (iteratee == null && obj != null) {\n\t obj = isArrayLike(obj) ? obj : _.values(obj);\n\t for (var i = 0, length = obj.length; i < length; i++) {\n\t value = obj[i];\n\t if (value > result) {\n\t result = value;\n\t }\n\t }\n\t } else {\n\t iteratee = cb(iteratee, context);\n\t _.each(obj, function (value, index, list) {\n\t computed = iteratee(value, index, list);\n\t if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n\t result = value;\n\t lastComputed = computed;\n\t }\n\t });\n\t }\n\t return result;\n\t };\n\t\n\t // Return the minimum element (or element-based computation).\n\t _.min = function (obj, iteratee, context) {\n\t var result = Infinity,\n\t lastComputed = Infinity,\n\t value,\n\t computed;\n\t if (iteratee == null && obj != null) {\n\t obj = isArrayLike(obj) ? obj : _.values(obj);\n\t for (var i = 0, length = obj.length; i < length; i++) {\n\t value = obj[i];\n\t if (value < result) {\n\t result = value;\n\t }\n\t }\n\t } else {\n\t iteratee = cb(iteratee, context);\n\t _.each(obj, function (value, index, list) {\n\t computed = iteratee(value, index, list);\n\t if (computed < lastComputed || computed === Infinity && result === Infinity) {\n\t result = value;\n\t lastComputed = computed;\n\t }\n\t });\n\t }\n\t return result;\n\t };\n\t\n\t // Shuffle a collection, using the modern version of the\n\t // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n\t _.shuffle = function (obj) {\n\t var set = isArrayLike(obj) ? obj : _.values(obj);\n\t var length = set.length;\n\t var shuffled = Array(length);\n\t for (var index = 0, rand; index < length; index++) {\n\t rand = _.random(0, index);\n\t if (rand !== index) shuffled[index] = shuffled[rand];\n\t shuffled[rand] = set[index];\n\t }\n\t return shuffled;\n\t };\n\t\n\t // Sample **n** random values from a collection.\n\t // If **n** is not specified, returns a single random element.\n\t // The internal `guard` argument allows it to work with `map`.\n\t _.sample = function (obj, n, guard) {\n\t if (n == null || guard) {\n\t if (!isArrayLike(obj)) obj = _.values(obj);\n\t return obj[_.random(obj.length - 1)];\n\t }\n\t return _.shuffle(obj).slice(0, Math.max(0, n));\n\t };\n\t\n\t // Sort the object's values by a criterion produced by an iteratee.\n\t _.sortBy = function (obj, iteratee, context) {\n\t iteratee = cb(iteratee, context);\n\t return _.pluck(_.map(obj, function (value, index, list) {\n\t return {\n\t value: value,\n\t index: index,\n\t criteria: iteratee(value, index, list)\n\t };\n\t }).sort(function (left, right) {\n\t var a = left.criteria;\n\t var b = right.criteria;\n\t if (a !== b) {\n\t if (a > b || a === void 0) return 1;\n\t if (a < b || b === void 0) return -1;\n\t }\n\t return left.index - right.index;\n\t }), 'value');\n\t };\n\t\n\t // An internal function used for aggregate \"group by\" operations.\n\t var group = function group(behavior) {\n\t return function (obj, iteratee, context) {\n\t var result = {};\n\t iteratee = cb(iteratee, context);\n\t _.each(obj, function (value, index) {\n\t var key = iteratee(value, index, obj);\n\t behavior(result, value, key);\n\t });\n\t return result;\n\t };\n\t };\n\t\n\t // Groups the object's values by a criterion. Pass either a string attribute\n\t // to group by, or a function that returns the criterion.\n\t _.groupBy = group(function (result, value, key) {\n\t if (_.has(result, key)) result[key].push(value);else result[key] = [value];\n\t });\n\t\n\t // Indexes the object's values by a criterion, similar to `groupBy`, but for\n\t // when you know that your index values will be unique.\n\t _.indexBy = group(function (result, value, key) {\n\t result[key] = value;\n\t });\n\t\n\t // Counts instances of an object that group by a certain criterion. Pass\n\t // either a string attribute to count by, or a function that returns the\n\t // criterion.\n\t _.countBy = group(function (result, value, key) {\n\t if (_.has(result, key)) result[key]++;else result[key] = 1;\n\t });\n\t\n\t // Safely create a real, live array from anything iterable.\n\t _.toArray = function (obj) {\n\t if (!obj) return [];\n\t if (_.isArray(obj)) return slice.call(obj);\n\t if (isArrayLike(obj)) return _.map(obj, _.identity);\n\t return _.values(obj);\n\t };\n\t\n\t // Return the number of elements in an object.\n\t _.size = function (obj) {\n\t if (obj == null) return 0;\n\t return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n\t };\n\t\n\t // Split a collection into two arrays: one whose elements all satisfy the given\n\t // predicate, and one whose elements all do not satisfy the predicate.\n\t _.partition = function (obj, predicate, context) {\n\t predicate = cb(predicate, context);\n\t var pass = [],\n\t fail = [];\n\t _.each(obj, function (value, key, obj) {\n\t (predicate(value, key, obj) ? pass : fail).push(value);\n\t });\n\t return [pass, fail];\n\t };\n\t\n\t // Array Functions\n\t // ---------------\n\t\n\t // Get the first element of an array. Passing **n** will return the first N\n\t // values in the array. Aliased as `head` and `take`. The **guard** check\n\t // allows it to work with `_.map`.\n\t _.first = _.head = _.take = function (array, n, guard) {\n\t if (array == null) return void 0;\n\t if (n == null || guard) return array[0];\n\t return _.initial(array, array.length - n);\n\t };\n\t\n\t // Returns everything but the last entry of the array. Especially useful on\n\t // the arguments object. Passing **n** will return all the values in\n\t // the array, excluding the last N.\n\t _.initial = function (array, n, guard) {\n\t return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n\t };\n\t\n\t // Get the last element of an array. Passing **n** will return the last N\n\t // values in the array.\n\t _.last = function (array, n, guard) {\n\t if (array == null) return void 0;\n\t if (n == null || guard) return array[array.length - 1];\n\t return _.rest(array, Math.max(0, array.length - n));\n\t };\n\t\n\t // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n\t // Especially useful on the arguments object. Passing an **n** will return\n\t // the rest N values in the array.\n\t _.rest = _.tail = _.drop = function (array, n, guard) {\n\t return slice.call(array, n == null || guard ? 1 : n);\n\t };\n\t\n\t // Trim out all falsy values from an array.\n\t _.compact = function (array) {\n\t return _.filter(array, _.identity);\n\t };\n\t\n\t // Internal implementation of a recursive `flatten` function.\n\t var flatten = function flatten(input, shallow, strict, startIndex) {\n\t var output = [],\n\t idx = 0;\n\t for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\n\t var value = input[i];\n\t if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n\t //flatten current level of array or arguments object\n\t if (!shallow) value = flatten(value, shallow, strict);\n\t var j = 0,\n\t len = value.length;\n\t output.length += len;\n\t while (j < len) {\n\t output[idx++] = value[j++];\n\t }\n\t } else if (!strict) {\n\t output[idx++] = value;\n\t }\n\t }\n\t return output;\n\t };\n\t\n\t // Flatten out an array, either recursively (by default), or just one level.\n\t _.flatten = function (array, shallow) {\n\t return flatten(array, shallow, false);\n\t };\n\t\n\t // Return a version of the array that does not contain the specified value(s).\n\t _.without = function (array) {\n\t return _.difference(array, slice.call(arguments, 1));\n\t };\n\t\n\t // Produce a duplicate-free version of the array. If the array has already\n\t // been sorted, you have the option of using a faster algorithm.\n\t // Aliased as `unique`.\n\t _.uniq = _.unique = function (array, isSorted, iteratee, context) {\n\t if (!_.isBoolean(isSorted)) {\n\t context = iteratee;\n\t iteratee = isSorted;\n\t isSorted = false;\n\t }\n\t if (iteratee != null) iteratee = cb(iteratee, context);\n\t var result = [];\n\t var seen = [];\n\t for (var i = 0, length = getLength(array); i < length; i++) {\n\t var value = array[i],\n\t computed = iteratee ? iteratee(value, i, array) : value;\n\t if (isSorted) {\n\t if (!i || seen !== computed) result.push(value);\n\t seen = computed;\n\t } else if (iteratee) {\n\t if (!_.contains(seen, computed)) {\n\t seen.push(computed);\n\t result.push(value);\n\t }\n\t } else if (!_.contains(result, value)) {\n\t result.push(value);\n\t }\n\t }\n\t return result;\n\t };\n\t\n\t // Produce an array that contains the union: each distinct element from all of\n\t // the passed-in arrays.\n\t _.union = function () {\n\t return _.uniq(flatten(arguments, true, true));\n\t };\n\t\n\t // Produce an array that contains every item shared between all the\n\t // passed-in arrays.\n\t _.intersection = function (array) {\n\t var result = [];\n\t var argsLength = arguments.length;\n\t for (var i = 0, length = getLength(array); i < length; i++) {\n\t var item = array[i];\n\t if (_.contains(result, item)) continue;\n\t for (var j = 1; j < argsLength; j++) {\n\t if (!_.contains(arguments[j], item)) break;\n\t }\n\t if (j === argsLength) result.push(item);\n\t }\n\t return result;\n\t };\n\t\n\t // Take the difference between one array and a number of other arrays.\n\t // Only the elements present in just the first array will remain.\n\t _.difference = function (array) {\n\t var rest = flatten(arguments, true, true, 1);\n\t return _.filter(array, function (value) {\n\t return !_.contains(rest, value);\n\t });\n\t };\n\t\n\t // Zip together multiple lists into a single array -- elements that share\n\t // an index go together.\n\t _.zip = function () {\n\t return _.unzip(arguments);\n\t };\n\t\n\t // Complement of _.zip. Unzip accepts an array of arrays and groups\n\t // each array's elements on shared indices\n\t _.unzip = function (array) {\n\t var length = array && _.max(array, getLength).length || 0;\n\t var result = Array(length);\n\t\n\t for (var index = 0; index < length; index++) {\n\t result[index] = _.pluck(array, index);\n\t }\n\t return result;\n\t };\n\t\n\t // Converts lists into objects. Pass either a single array of `[key, value]`\n\t // pairs, or two parallel arrays of the same length -- one of keys, and one of\n\t // the corresponding values.\n\t _.object = function (list, values) {\n\t var result = {};\n\t for (var i = 0, length = getLength(list); i < length; i++) {\n\t if (values) {\n\t result[list[i]] = values[i];\n\t } else {\n\t result[list[i][0]] = list[i][1];\n\t }\n\t }\n\t return result;\n\t };\n\t\n\t // Generator function to create the findIndex and findLastIndex functions\n\t function createPredicateIndexFinder(dir) {\n\t return function (array, predicate, context) {\n\t predicate = cb(predicate, context);\n\t var length = getLength(array);\n\t var index = dir > 0 ? 0 : length - 1;\n\t for (; index >= 0 && index < length; index += dir) {\n\t if (predicate(array[index], index, array)) return index;\n\t }\n\t return -1;\n\t };\n\t }\n\t\n\t // Returns the first index on an array-like that passes a predicate test\n\t _.findIndex = createPredicateIndexFinder(1);\n\t _.findLastIndex = createPredicateIndexFinder(-1);\n\t\n\t // Use a comparator function to figure out the smallest index at which\n\t // an object should be inserted so as to maintain order. Uses binary search.\n\t _.sortedIndex = function (array, obj, iteratee, context) {\n\t iteratee = cb(iteratee, context, 1);\n\t var value = iteratee(obj);\n\t var low = 0,\n\t high = getLength(array);\n\t while (low < high) {\n\t var mid = Math.floor((low + high) / 2);\n\t if (iteratee(array[mid]) < value) low = mid + 1;else high = mid;\n\t }\n\t return low;\n\t };\n\t\n\t // Generator function to create the indexOf and lastIndexOf functions\n\t function createIndexFinder(dir, predicateFind, sortedIndex) {\n\t return function (array, item, idx) {\n\t var i = 0,\n\t length = getLength(array);\n\t if (typeof idx == 'number') {\n\t if (dir > 0) {\n\t i = idx >= 0 ? idx : Math.max(idx + length, i);\n\t } else {\n\t length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n\t }\n\t } else if (sortedIndex && idx && length) {\n\t idx = sortedIndex(array, item);\n\t return array[idx] === item ? idx : -1;\n\t }\n\t if (item !== item) {\n\t idx = predicateFind(slice.call(array, i, length), _.isNaN);\n\t return idx >= 0 ? idx + i : -1;\n\t }\n\t for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n\t if (array[idx] === item) return idx;\n\t }\n\t return -1;\n\t };\n\t }\n\t\n\t // Return the position of the first occurrence of an item in an array,\n\t // or -1 if the item is not included in the array.\n\t // If the array is large and already in sort order, pass `true`\n\t // for **isSorted** to use binary search.\n\t _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n\t _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\t\n\t // Generate an integer Array containing an arithmetic progression. A port of\n\t // the native Python `range()` function. See\n\t // [the Python documentation](http://docs.python.org/library/functions.html#range).\n\t _.range = function (start, stop, step) {\n\t if (stop == null) {\n\t stop = start || 0;\n\t start = 0;\n\t }\n\t step = step || 1;\n\t\n\t var length = Math.max(Math.ceil((stop - start) / step), 0);\n\t var range = Array(length);\n\t\n\t for (var idx = 0; idx < length; idx++, start += step) {\n\t range[idx] = start;\n\t }\n\t\n\t return range;\n\t };\n\t\n\t // Function (ahem) Functions\n\t // ------------------\n\t\n\t // Determines whether to execute a function as a constructor\n\t // or a normal function with the provided arguments\n\t var executeBound = function executeBound(sourceFunc, boundFunc, context, callingContext, args) {\n\t if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n\t var self = baseCreate(sourceFunc.prototype);\n\t var result = sourceFunc.apply(self, args);\n\t if (_.isObject(result)) return result;\n\t return self;\n\t };\n\t\n\t // Create a function bound to a given object (assigning `this`, and arguments,\n\t // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n\t // available.\n\t _.bind = function (func, context) {\n\t if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n\t if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n\t var args = slice.call(arguments, 2);\n\t var bound = function bound() {\n\t return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\n\t };\n\t return bound;\n\t };\n\t\n\t // Partially apply a function by creating a version that has had some of its\n\t // arguments pre-filled, without changing its dynamic `this` context. _ acts\n\t // as a placeholder, allowing any combination of arguments to be pre-filled.\n\t _.partial = function (func) {\n\t var boundArgs = slice.call(arguments, 1);\n\t var bound = function bound() {\n\t var position = 0,\n\t length = boundArgs.length;\n\t var args = Array(length);\n\t for (var i = 0; i < length; i++) {\n\t args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\n\t }\n\t while (position < arguments.length) {\n\t args.push(arguments[position++]);\n\t }return executeBound(func, bound, this, this, args);\n\t };\n\t return bound;\n\t };\n\t\n\t // Bind a number of an object's methods to that object. Remaining arguments\n\t // are the method names to be bound. Useful for ensuring that all callbacks\n\t // defined on an object belong to it.\n\t _.bindAll = function (obj) {\n\t var i,\n\t length = arguments.length,\n\t key;\n\t if (length <= 1) throw new Error('bindAll must be passed function names');\n\t for (i = 1; i < length; i++) {\n\t key = arguments[i];\n\t obj[key] = _.bind(obj[key], obj);\n\t }\n\t return obj;\n\t };\n\t\n\t // Memoize an expensive function by storing its results.\n\t _.memoize = function (func, hasher) {\n\t var memoize = function memoize(key) {\n\t var cache = memoize.cache;\n\t var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n\t if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n\t return cache[address];\n\t };\n\t memoize.cache = {};\n\t return memoize;\n\t };\n\t\n\t // Delays a function for the given number of milliseconds, and then calls\n\t // it with the arguments supplied.\n\t _.delay = function (func, wait) {\n\t var args = slice.call(arguments, 2);\n\t return setTimeout(function () {\n\t return func.apply(null, args);\n\t }, wait);\n\t };\n\t\n\t // Defers a function, scheduling it to run after the current call stack has\n\t // cleared.\n\t _.defer = _.partial(_.delay, _, 1);\n\t\n\t // Returns a function, that, when invoked, will only be triggered at most once\n\t // during a given window of time. Normally, the throttled function will run\n\t // as much as it can, without ever going more than once per `wait` duration;\n\t // but if you'd like to disable the execution on the leading edge, pass\n\t // `{leading: false}`. To disable execution on the trailing edge, ditto.\n\t _.throttle = function (func, wait, options) {\n\t var context, args, result;\n\t var timeout = null;\n\t var previous = 0;\n\t if (!options) options = {};\n\t var later = function later() {\n\t previous = options.leading === false ? 0 : _.now();\n\t timeout = null;\n\t result = func.apply(context, args);\n\t if (!timeout) context = args = null;\n\t };\n\t return function () {\n\t var now = _.now();\n\t if (!previous && options.leading === false) previous = now;\n\t var remaining = wait - (now - previous);\n\t context = this;\n\t args = arguments;\n\t if (remaining <= 0 || remaining > wait) {\n\t if (timeout) {\n\t clearTimeout(timeout);\n\t timeout = null;\n\t }\n\t previous = now;\n\t result = func.apply(context, args);\n\t if (!timeout) context = args = null;\n\t } else if (!timeout && options.trailing !== false) {\n\t timeout = setTimeout(later, remaining);\n\t }\n\t return result;\n\t };\n\t };\n\t\n\t // Returns a function, that, as long as it continues to be invoked, will not\n\t // be triggered. The function will be called after it stops being called for\n\t // N milliseconds. If `immediate` is passed, trigger the function on the\n\t // leading edge, instead of the trailing.\n\t _.debounce = function (func, wait, immediate) {\n\t var timeout, args, context, timestamp, result;\n\t\n\t var later = function later() {\n\t var last = _.now() - timestamp;\n\t\n\t if (last < wait && last >= 0) {\n\t timeout = setTimeout(later, wait - last);\n\t } else {\n\t timeout = null;\n\t if (!immediate) {\n\t result = func.apply(context, args);\n\t if (!timeout) context = args = null;\n\t }\n\t }\n\t };\n\t\n\t return function () {\n\t context = this;\n\t args = arguments;\n\t timestamp = _.now();\n\t var callNow = immediate && !timeout;\n\t if (!timeout) timeout = setTimeout(later, wait);\n\t if (callNow) {\n\t result = func.apply(context, args);\n\t context = args = null;\n\t }\n\t\n\t return result;\n\t };\n\t };\n\t\n\t // Returns the first function passed as an argument to the second,\n\t // allowing you to adjust arguments, run code before and after, and\n\t // conditionally execute the original function.\n\t _.wrap = function (func, wrapper) {\n\t return _.partial(wrapper, func);\n\t };\n\t\n\t // Returns a negated version of the passed-in predicate.\n\t _.negate = function (predicate) {\n\t return function () {\n\t return !predicate.apply(this, arguments);\n\t };\n\t };\n\t\n\t // Returns a function that is the composition of a list of functions, each\n\t // consuming the return value of the function that follows.\n\t _.compose = function () {\n\t var args = arguments;\n\t var start = args.length - 1;\n\t return function () {\n\t var i = start;\n\t var result = args[start].apply(this, arguments);\n\t while (i--) {\n\t result = args[i].call(this, result);\n\t }return result;\n\t };\n\t };\n\t\n\t // Returns a function that will only be executed on and after the Nth call.\n\t _.after = function (times, func) {\n\t return function () {\n\t if (--times < 1) {\n\t return func.apply(this, arguments);\n\t }\n\t };\n\t };\n\t\n\t // Returns a function that will only be executed up to (but not including) the Nth call.\n\t _.before = function (times, func) {\n\t var memo;\n\t return function () {\n\t if (--times > 0) {\n\t memo = func.apply(this, arguments);\n\t }\n\t if (times <= 1) func = null;\n\t return memo;\n\t };\n\t };\n\t\n\t // Returns a function that will be executed at most one time, no matter how\n\t // often you call it. Useful for lazy initialization.\n\t _.once = _.partial(_.before, 2);\n\t\n\t // Object Functions\n\t // ----------------\n\t\n\t // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n\t var hasEnumBug = !{ toString: null }.propertyIsEnumerable('toString');\n\t var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString', 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\t\n\t function collectNonEnumProps(obj, keys) {\n\t var nonEnumIdx = nonEnumerableProps.length;\n\t var constructor = obj.constructor;\n\t var proto = _.isFunction(constructor) && constructor.prototype || ObjProto;\n\t\n\t // Constructor is a special case.\n\t var prop = 'constructor';\n\t if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\t\n\t while (nonEnumIdx--) {\n\t prop = nonEnumerableProps[nonEnumIdx];\n\t if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n\t keys.push(prop);\n\t }\n\t }\n\t }\n\t\n\t // Retrieve the names of an object's own properties.\n\t // Delegates to **ECMAScript 5**'s native `Object.keys`\n\t _.keys = function (obj) {\n\t if (!_.isObject(obj)) return [];\n\t if (nativeKeys) return nativeKeys(obj);\n\t var keys = [];\n\t for (var key in obj) {\n\t if (_.has(obj, key)) keys.push(key);\n\t } // Ahem, IE < 9.\n\t if (hasEnumBug) collectNonEnumProps(obj, keys);\n\t return keys;\n\t };\n\t\n\t // Retrieve all the property names of an object.\n\t _.allKeys = function (obj) {\n\t if (!_.isObject(obj)) return [];\n\t var keys = [];\n\t for (var key in obj) {\n\t keys.push(key);\n\t } // Ahem, IE < 9.\n\t if (hasEnumBug) collectNonEnumProps(obj, keys);\n\t return keys;\n\t };\n\t\n\t // Retrieve the values of an object's properties.\n\t _.values = function (obj) {\n\t var keys = _.keys(obj);\n\t var length = keys.length;\n\t var values = Array(length);\n\t for (var i = 0; i < length; i++) {\n\t values[i] = obj[keys[i]];\n\t }\n\t return values;\n\t };\n\t\n\t // Returns the results of applying the iteratee to each element of the object\n\t // In contrast to _.map it returns an object\n\t _.mapObject = function (obj, iteratee, context) {\n\t iteratee = cb(iteratee, context);\n\t var keys = _.keys(obj),\n\t length = keys.length,\n\t results = {},\n\t currentKey;\n\t for (var index = 0; index < length; index++) {\n\t currentKey = keys[index];\n\t results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n\t }\n\t return results;\n\t };\n\t\n\t // Convert an object into a list of `[key, value]` pairs.\n\t _.pairs = function (obj) {\n\t var keys = _.keys(obj);\n\t var length = keys.length;\n\t var pairs = Array(length);\n\t for (var i = 0; i < length; i++) {\n\t pairs[i] = [keys[i], obj[keys[i]]];\n\t }\n\t return pairs;\n\t };\n\t\n\t // Invert the keys and values of an object. The values must be serializable.\n\t _.invert = function (obj) {\n\t var result = {};\n\t var keys = _.keys(obj);\n\t for (var i = 0, length = keys.length; i < length; i++) {\n\t result[obj[keys[i]]] = keys[i];\n\t }\n\t return result;\n\t };\n\t\n\t // Return a sorted list of the function names available on the object.\n\t // Aliased as `methods`\n\t _.functions = _.methods = function (obj) {\n\t var names = [];\n\t for (var key in obj) {\n\t if (_.isFunction(obj[key])) names.push(key);\n\t }\n\t return names.sort();\n\t };\n\t\n\t // Extend a given object with all the properties in passed-in object(s).\n\t _.extend = createAssigner(_.allKeys);\n\t\n\t // Assigns a given object with all the own properties in the passed-in object(s)\n\t // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n\t _.extendOwn = _.assign = createAssigner(_.keys);\n\t\n\t // Returns the first key on an object that passes a predicate test\n\t _.findKey = function (obj, predicate, context) {\n\t predicate = cb(predicate, context);\n\t var keys = _.keys(obj),\n\t key;\n\t for (var i = 0, length = keys.length; i < length; i++) {\n\t key = keys[i];\n\t if (predicate(obj[key], key, obj)) return key;\n\t }\n\t };\n\t\n\t // Return a copy of the object only containing the whitelisted properties.\n\t _.pick = function (object, oiteratee, context) {\n\t var result = {},\n\t obj = object,\n\t iteratee,\n\t keys;\n\t if (obj == null) return result;\n\t if (_.isFunction(oiteratee)) {\n\t keys = _.allKeys(obj);\n\t iteratee = optimizeCb(oiteratee, context);\n\t } else {\n\t keys = flatten(arguments, false, false, 1);\n\t iteratee = function iteratee(value, key, obj) {\n\t return key in obj;\n\t };\n\t obj = Object(obj);\n\t }\n\t for (var i = 0, length = keys.length; i < length; i++) {\n\t var key = keys[i];\n\t var value = obj[key];\n\t if (iteratee(value, key, obj)) result[key] = value;\n\t }\n\t return result;\n\t };\n\t\n\t // Return a copy of the object without the blacklisted properties.\n\t _.omit = function (obj, iteratee, context) {\n\t if (_.isFunction(iteratee)) {\n\t iteratee = _.negate(iteratee);\n\t } else {\n\t var keys = _.map(flatten(arguments, false, false, 1), String);\n\t iteratee = function iteratee(value, key) {\n\t return !_.contains(keys, key);\n\t };\n\t }\n\t return _.pick(obj, iteratee, context);\n\t };\n\t\n\t // Fill in a given object with default properties.\n\t _.defaults = createAssigner(_.allKeys, true);\n\t\n\t // Creates an object that inherits from the given prototype object.\n\t // If additional properties are provided then they will be added to the\n\t // created object.\n\t _.create = function (prototype, props) {\n\t var result = baseCreate(prototype);\n\t if (props) _.extendOwn(result, props);\n\t return result;\n\t };\n\t\n\t // Create a (shallow-cloned) duplicate of an object.\n\t _.clone = function (obj) {\n\t if (!_.isObject(obj)) return obj;\n\t return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n\t };\n\t\n\t // Invokes interceptor with the obj, and then returns obj.\n\t // The primary purpose of this method is to \"tap into\" a method chain, in\n\t // order to perform operations on intermediate results within the chain.\n\t _.tap = function (obj, interceptor) {\n\t interceptor(obj);\n\t return obj;\n\t };\n\t\n\t // Returns whether an object has a given set of `key:value` pairs.\n\t _.isMatch = function (object, attrs) {\n\t var keys = _.keys(attrs),\n\t length = keys.length;\n\t if (object == null) return !length;\n\t var obj = Object(object);\n\t for (var i = 0; i < length; i++) {\n\t var key = keys[i];\n\t if (attrs[key] !== obj[key] || !(key in obj)) return false;\n\t }\n\t return true;\n\t };\n\t\n\t // Internal recursive comparison function for `isEqual`.\n\t var eq = function eq(a, b, aStack, bStack) {\n\t // Identical objects are equal. `0 === -0`, but they aren't identical.\n\t // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n\t if (a === b) return a !== 0 || 1 / a === 1 / b;\n\t // A strict comparison is necessary because `null == undefined`.\n\t if (a == null || b == null) return a === b;\n\t // Unwrap any wrapped objects.\n\t if (a instanceof _) a = a._wrapped;\n\t if (b instanceof _) b = b._wrapped;\n\t // Compare `[[Class]]` names.\n\t var className = toString.call(a);\n\t if (className !== toString.call(b)) return false;\n\t switch (className) {\n\t // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n\t case '[object RegExp]':\n\t // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n\t case '[object String]':\n\t // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n\t // equivalent to `new String(\"5\")`.\n\t return '' + a === '' + b;\n\t case '[object Number]':\n\t // `NaN`s are equivalent, but non-reflexive.\n\t // Object(NaN) is equivalent to NaN\n\t if (+a !== +a) return +b !== +b;\n\t // An `egal` comparison is performed for other numeric values.\n\t return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n\t case '[object Date]':\n\t case '[object Boolean]':\n\t // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n\t // millisecond representations. Note that invalid dates with millisecond representations\n\t // of `NaN` are not equivalent.\n\t return +a === +b;\n\t }\n\t\n\t var areArrays = className === '[object Array]';\n\t if (!areArrays) {\n\t if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) != 'object' || (typeof b === 'undefined' ? 'undefined' : _typeof(b)) != 'object') return false;\n\t\n\t // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n\t // from different frames are.\n\t var aCtor = a.constructor,\n\t bCtor = b.constructor;\n\t if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor && _.isFunction(bCtor) && bCtor instanceof bCtor) && 'constructor' in a && 'constructor' in b) {\n\t return false;\n\t }\n\t }\n\t // Assume equality for cyclic structures. The algorithm for detecting cyclic\n\t // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\t\n\t // Initializing stack of traversed objects.\n\t // It's done here since we only need them for objects and arrays comparison.\n\t aStack = aStack || [];\n\t bStack = bStack || [];\n\t var length = aStack.length;\n\t while (length--) {\n\t // Linear search. Performance is inversely proportional to the number of\n\t // unique nested structures.\n\t if (aStack[length] === a) return bStack[length] === b;\n\t }\n\t\n\t // Add the first object to the stack of traversed objects.\n\t aStack.push(a);\n\t bStack.push(b);\n\t\n\t // Recursively compare objects and arrays.\n\t if (areArrays) {\n\t // Compare array lengths to determine if a deep comparison is necessary.\n\t length = a.length;\n\t if (length !== b.length) return false;\n\t // Deep compare the contents, ignoring non-numeric properties.\n\t while (length--) {\n\t if (!eq(a[length], b[length], aStack, bStack)) return false;\n\t }\n\t } else {\n\t // Deep compare objects.\n\t var keys = _.keys(a),\n\t key;\n\t length = keys.length;\n\t // Ensure that both objects contain the same number of properties before comparing deep equality.\n\t if (_.keys(b).length !== length) return false;\n\t while (length--) {\n\t // Deep compare each member\n\t key = keys[length];\n\t if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n\t }\n\t }\n\t // Remove the first object from the stack of traversed objects.\n\t aStack.pop();\n\t bStack.pop();\n\t return true;\n\t };\n\t\n\t // Perform a deep comparison to check if two objects are equal.\n\t _.isEqual = function (a, b) {\n\t return eq(a, b);\n\t };\n\t\n\t // Is a given array, string, or object empty?\n\t // An \"empty\" object has no enumerable own-properties.\n\t _.isEmpty = function (obj) {\n\t if (obj == null) return true;\n\t if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n\t return _.keys(obj).length === 0;\n\t };\n\t\n\t // Is a given value a DOM element?\n\t _.isElement = function (obj) {\n\t return !!(obj && obj.nodeType === 1);\n\t };\n\t\n\t // Is a given value an array?\n\t // Delegates to ECMA5's native Array.isArray\n\t _.isArray = nativeIsArray || function (obj) {\n\t return toString.call(obj) === '[object Array]';\n\t };\n\t\n\t // Is a given variable an object?\n\t _.isObject = function (obj) {\n\t var type = typeof obj === 'undefined' ? 'undefined' : _typeof(obj);\n\t return type === 'function' || type === 'object' && !!obj;\n\t };\n\t\n\t // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\n\t _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function (name) {\n\t _['is' + name] = function (obj) {\n\t return toString.call(obj) === '[object ' + name + ']';\n\t };\n\t });\n\t\n\t // Define a fallback version of the method in browsers (ahem, IE < 9), where\n\t // there isn't any inspectable \"Arguments\" type.\n\t if (!_.isArguments(arguments)) {\n\t _.isArguments = function (obj) {\n\t return _.has(obj, 'callee');\n\t };\n\t }\n\t\n\t // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n\t // IE 11 (#1621), and in Safari 8 (#1929).\n\t if (typeof /./ != 'function' && (typeof Int8Array === 'undefined' ? 'undefined' : _typeof(Int8Array)) != 'object') {\n\t _.isFunction = function (obj) {\n\t return typeof obj == 'function' || false;\n\t };\n\t }\n\t\n\t // Is a given object a finite number?\n\t _.isFinite = function (obj) {\n\t return isFinite(obj) && !isNaN(parseFloat(obj));\n\t };\n\t\n\t // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n\t _.isNaN = function (obj) {\n\t return _.isNumber(obj) && obj !== +obj;\n\t };\n\t\n\t // Is a given value a boolean?\n\t _.isBoolean = function (obj) {\n\t return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n\t };\n\t\n\t // Is a given value equal to null?\n\t _.isNull = function (obj) {\n\t return obj === null;\n\t };\n\t\n\t // Is a given variable undefined?\n\t _.isUndefined = function (obj) {\n\t return obj === void 0;\n\t };\n\t\n\t // Shortcut function for checking if an object has a given property directly\n\t // on itself (in other words, not on a prototype).\n\t _.has = function (obj, key) {\n\t return obj != null && hasOwnProperty.call(obj, key);\n\t };\n\t\n\t // Utility Functions\n\t // -----------------\n\t\n\t // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n\t // previous owner. Returns a reference to the Underscore object.\n\t _.noConflict = function () {\n\t root._ = previousUnderscore;\n\t return this;\n\t };\n\t\n\t // Keep the identity function around for default iteratees.\n\t _.identity = function (value) {\n\t return value;\n\t };\n\t\n\t // Predicate-generating functions. Often useful outside of Underscore.\n\t _.constant = function (value) {\n\t return function () {\n\t return value;\n\t };\n\t };\n\t\n\t _.noop = function () {};\n\t\n\t _.property = property;\n\t\n\t // Generates a function for a given object that returns a given property.\n\t _.propertyOf = function (obj) {\n\t return obj == null ? function () {} : function (key) {\n\t return obj[key];\n\t };\n\t };\n\t\n\t // Returns a predicate for checking whether an object has a given set of\n\t // `key:value` pairs.\n\t _.matcher = _.matches = function (attrs) {\n\t attrs = _.extendOwn({}, attrs);\n\t return function (obj) {\n\t return _.isMatch(obj, attrs);\n\t };\n\t };\n\t\n\t // Run a function **n** times.\n\t _.times = function (n, iteratee, context) {\n\t var accum = Array(Math.max(0, n));\n\t iteratee = optimizeCb(iteratee, context, 1);\n\t for (var i = 0; i < n; i++) {\n\t accum[i] = iteratee(i);\n\t }return accum;\n\t };\n\t\n\t // Return a random integer between min and max (inclusive).\n\t _.random = function (min, max) {\n\t if (max == null) {\n\t max = min;\n\t min = 0;\n\t }\n\t return min + Math.floor(Math.random() * (max - min + 1));\n\t };\n\t\n\t // A (possibly faster) way to get the current timestamp as an integer.\n\t _.now = Date.now || function () {\n\t return new Date().getTime();\n\t };\n\t\n\t // List of HTML entities for escaping.\n\t var escapeMap = {\n\t '&': '&',\n\t '<': '<',\n\t '>': '>',\n\t '\"': '"',\n\t \"'\": ''',\n\t '`': '`'\n\t };\n\t var unescapeMap = _.invert(escapeMap);\n\t\n\t // Functions for escaping and unescaping strings to/from HTML interpolation.\n\t var createEscaper = function createEscaper(map) {\n\t var escaper = function escaper(match) {\n\t return map[match];\n\t };\n\t // Regexes for identifying a key that needs to be escaped\n\t var source = '(?:' + _.keys(map).join('|') + ')';\n\t var testRegexp = RegExp(source);\n\t var replaceRegexp = RegExp(source, 'g');\n\t return function (string) {\n\t string = string == null ? '' : '' + string;\n\t return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n\t };\n\t };\n\t _.escape = createEscaper(escapeMap);\n\t _.unescape = createEscaper(unescapeMap);\n\t\n\t // If the value of the named `property` is a function then invoke it with the\n\t // `object` as context; otherwise, return it.\n\t _.result = function (object, property, fallback) {\n\t var value = object == null ? void 0 : object[property];\n\t if (value === void 0) {\n\t value = fallback;\n\t }\n\t return _.isFunction(value) ? value.call(object) : value;\n\t };\n\t\n\t // Generate a unique integer id (unique within the entire client session).\n\t // Useful for temporary DOM ids.\n\t var idCounter = 0;\n\t _.uniqueId = function (prefix) {\n\t var id = ++idCounter + '';\n\t return prefix ? prefix + id : id;\n\t };\n\t\n\t // By default, Underscore uses ERB-style template delimiters, change the\n\t // following template settings to use alternative delimiters.\n\t _.templateSettings = {\n\t evaluate: /<%([\\s\\S]+?)%>/g,\n\t interpolate: /<%=([\\s\\S]+?)%>/g,\n\t escape: /<%-([\\s\\S]+?)%>/g\n\t };\n\t\n\t // When customizing `templateSettings`, if you don't want to define an\n\t // interpolation, evaluation or escaping regex, we need one that is\n\t // guaranteed not to match.\n\t var noMatch = /(.)^/;\n\t\n\t // Certain characters need to be escaped so that they can be put into a\n\t // string literal.\n\t var escapes = {\n\t \"'\": \"'\",\n\t '\\\\': '\\\\',\n\t '\\r': 'r',\n\t '\\n': 'n',\n\t '\\u2028': 'u2028',\n\t '\\u2029': 'u2029'\n\t };\n\t\n\t var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\t\n\t var escapeChar = function escapeChar(match) {\n\t return '\\\\' + escapes[match];\n\t };\n\t\n\t // JavaScript micro-templating, similar to John Resig's implementation.\n\t // Underscore templating handles arbitrary delimiters, preserves whitespace,\n\t // and correctly escapes quotes within interpolated code.\n\t // NB: `oldSettings` only exists for backwards compatibility.\n\t _.template = function (text, settings, oldSettings) {\n\t if (!settings && oldSettings) settings = oldSettings;\n\t settings = _.defaults({}, settings, _.templateSettings);\n\t\n\t // Combine delimiters into one regular expression via alternation.\n\t var matcher = RegExp([(settings.escape || noMatch).source, (settings.interpolate || noMatch).source, (settings.evaluate || noMatch).source].join('|') + '|$', 'g');\n\t\n\t // Compile the template source, escaping string literals appropriately.\n\t var index = 0;\n\t var source = \"__p+='\";\n\t text.replace(matcher, function (match, escape, interpolate, evaluate, offset) {\n\t source += text.slice(index, offset).replace(escaper, escapeChar);\n\t index = offset + match.length;\n\t\n\t if (escape) {\n\t source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n\t } else if (interpolate) {\n\t source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n\t } else if (evaluate) {\n\t source += \"';\\n\" + evaluate + \"\\n__p+='\";\n\t }\n\t\n\t // Adobe VMs need the match returned to produce the correct offest.\n\t return match;\n\t });\n\t source += \"';\\n\";\n\t\n\t // If a variable is not specified, place data values in local scope.\n\t if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\t\n\t source = \"var __t,__p='',__j=Array.prototype.join,\" + \"print=function(){__p+=__j.call(arguments,'');};\\n\" + source + 'return __p;\\n';\n\t\n\t try {\n\t var render = new Function(settings.variable || 'obj', '_', source);\n\t } catch (e) {\n\t e.source = source;\n\t throw e;\n\t }\n\t\n\t var template = function template(data) {\n\t return render.call(this, data, _);\n\t };\n\t\n\t // Provide the compiled source as a convenience for precompilation.\n\t var argument = settings.variable || 'obj';\n\t template.source = 'function(' + argument + '){\\n' + source + '}';\n\t\n\t return template;\n\t };\n\t\n\t // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n\t _.chain = function (obj) {\n\t var instance = _(obj);\n\t instance._chain = true;\n\t return instance;\n\t };\n\t\n\t // OOP\n\t // ---------------\n\t // If Underscore is called as a function, it returns a wrapped object that\n\t // can be used OO-style. This wrapper holds altered versions of all the\n\t // underscore functions. Wrapped objects may be chained.\n\t\n\t // Helper function to continue chaining intermediate results.\n\t var result = function result(instance, obj) {\n\t return instance._chain ? _(obj).chain() : obj;\n\t };\n\t\n\t // Add your own custom functions to the Underscore object.\n\t _.mixin = function (obj) {\n\t _.each(_.functions(obj), function (name) {\n\t var func = _[name] = obj[name];\n\t _.prototype[name] = function () {\n\t var args = [this._wrapped];\n\t push.apply(args, arguments);\n\t return result(this, func.apply(_, args));\n\t };\n\t });\n\t };\n\t\n\t // Add all of the Underscore functions to the wrapper object.\n\t _.mixin(_);\n\t\n\t // Add all mutator Array functions to the wrapper.\n\t _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function (name) {\n\t var method = ArrayProto[name];\n\t _.prototype[name] = function () {\n\t var obj = this._wrapped;\n\t method.apply(obj, arguments);\n\t if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n\t return result(this, obj);\n\t };\n\t });\n\t\n\t // Add all accessor Array functions to the wrapper.\n\t _.each(['concat', 'join', 'slice'], function (name) {\n\t var method = ArrayProto[name];\n\t _.prototype[name] = function () {\n\t return result(this, method.apply(this._wrapped, arguments));\n\t };\n\t });\n\t\n\t // Extracts the result from a wrapped and chained object.\n\t _.prototype.value = function () {\n\t return this._wrapped;\n\t };\n\t\n\t // Provide unwrapping proxy for some methods used in engine operations\n\t // such as arithmetic and JSON stringification.\n\t _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\t\n\t _.prototype.toString = function () {\n\t return '' + this._wrapped;\n\t };\n\t\n\t // AMD registration happens at the end for compatibility with AMD loaders\n\t // that may not enforce next-turn semantics on modules. Even though general\n\t // practice for AMD registration is to be anonymous, underscore registers\n\t // as a named module because, like jQuery, it is a base library that is\n\t // popular enough to be bundled in a third party lib, but not be part of\n\t // an AMD load request. Those cases could generate an error when an\n\t // anonymous define() is called outside of a loader request.\n\t if (true) {\n\t !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {\n\t return _;\n\t }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t }\n\t}).call(undefined);\n\n/***/ }\n\n/******/ });\n\n\n/** WEBPACK FOOTER **\n ** frontend.js\n **/"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap caccfa6032bf26e21698\n **/","const $ = jQuery;\nimport { findIndex } from 'underscore';\n\n$('.alike-button').on('click', function (e) {\n e.preventDefault();\n const postId = $(this).data('post-id');\n const postTitle = $(this).data('post-title');\n const postThumb = $(this).data('post-thumb');\n const postLink = $(this).data('post-link');\n\n const allPosts = window.localStorage.getItem('alikeData') ? JSON.parse(window.localStorage.getItem('alikeData')) : [];\n\n const checkIndex = findIndex(allPosts, { postId });\n\n if (checkIndex === -1) {\n const newPost = {\n postId, postTitle, postThumb, postLink,\n };\n if (allPosts.length < ALIKE.max_compare) {\n allPosts.push(newPost);\n } else {\n alert(ALIKE.LANG.YOU_CAN_COMPARE_MAXIMUM_BETWEEN_S_ITEMS);\n }\n }\n\n window.localStorage.setItem('alikeData', JSON.stringify(allPosts));\n $('.alike-widget-btn-wrap').show();\n onStorageEvent();\n});\n\n$(window).on('load', function () {\n const items = (JSON.parse(localStorage.getItem('alikeData')) !== null) ? JSON.parse(localStorage.getItem('alikeData')) : [];\n if (items.length > 0) {\n $('.alike-widget-btn-wrap').show();\n } else {\n $('.alike-widget-btn-wrap').hide();\n }\n onStorageEvent();\n});\n\nfunction onStorageEvent() {\n if ($('.alike-widget').length > 0) {\n const items = (JSON.parse(localStorage.getItem('alikeData')) !== null) ? JSON.parse(localStorage.getItem('alikeData')) : [];\n if (items.length > 0) {\n $('.alike-widget-btn-wrap').show();\n } else {\n $('.alike-widget-btn-wrap').hide();\n }\n\n const resultTemplate = _.template($('.alike-list').html());\n const resultingHtml = resultTemplate({ items });\n const allPostIds = [];\n items.forEach(function (value) {\n allPostIds.push(value.postId);\n });\n const pageUrl = $('.alike-button-compare').data('page-url');\n $('.alike-button-compare').attr('href', pageUrl + '/?ids=' + allPostIds.join([',']));\n\n $('.alike-widget').html(resultingHtml).on('click', '.alike-widget-remove', function (e) {\n e.preventDefault();\n const postId = $(this).data('post-id');\n const allPosts = JSON.parse(window.localStorage.getItem('alikeData'));\n const checkIndex = findIndex(allPosts, { postId });\n\n if (checkIndex !== -1) {\n allPosts.splice(checkIndex, 1);\n window.localStorage.setItem('alikeData', JSON.stringify(allPosts));\n\n onStorageEvent();\n }\n }).next('.alike-widget-btn-wrap').on('click', '.alike-button-clear', function (e) {\n e.preventDefault();\n window.localStorage.setItem('alikeData', '[]');\n onStorageEvent();\n });\n }\n}\nwindow.addEventListener('storage', onStorageEvent, false);\n\n\n\n/** WEBPACK FOOTER **\n ** ./assets/src/frontend/frontend.js\n **/","// Underscore.js 1.8.3\n// http://underscorejs.org\n// (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n// Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n // Baseline setup\n // --------------\n\n // Establish the root object, `window` in the browser, or `exports` on the server.\n var root = this;\n\n // Save the previous value of the `_` variable.\n var previousUnderscore = root._;\n\n // Save bytes in the minified (but not gzipped) version:\n var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n // Create quick reference variables for speed access to core prototypes.\n var\n push = ArrayProto.push,\n slice = ArrayProto.slice,\n toString = ObjProto.toString,\n hasOwnProperty = ObjProto.hasOwnProperty;\n\n // All **ECMAScript 5** native function implementations that we hope to use\n // are declared here.\n var\n nativeIsArray = Array.isArray,\n nativeKeys = Object.keys,\n nativeBind = FuncProto.bind,\n nativeCreate = Object.create;\n\n // Naked function reference for surrogate-prototype-swapping.\n var Ctor = function(){};\n\n // Create a safe reference to the Underscore object for use below.\n var _ = function(obj) {\n if (obj instanceof _) return obj;\n if (!(this instanceof _)) return new _(obj);\n this._wrapped = obj;\n };\n\n // Export the Underscore object for **Node.js**, with\n // backwards-compatibility for the old `require()` API. If we're in\n // the browser, add `_` as a global object.\n if (typeof exports !== 'undefined') {\n if (typeof module !== 'undefined' && module.exports) {\n exports = module.exports = _;\n }\n exports._ = _;\n } else {\n root._ = _;\n }\n\n // Current version.\n _.VERSION = '1.8.3';\n\n // Internal function that returns an efficient (for current engines) version\n // of the passed-in callback, to be repeatedly applied in other Underscore\n // functions.\n var optimizeCb = function(func, context, argCount) {\n if (context === void 0) return func;\n switch (argCount == null ? 3 : argCount) {\n case 1: return function(value) {\n return func.call(context, value);\n };\n case 2: return function(value, other) {\n return func.call(context, value, other);\n };\n case 3: return function(value, index, collection) {\n return func.call(context, value, index, collection);\n };\n case 4: return function(accumulator, value, index, collection) {\n return func.call(context, accumulator, value, index, collection);\n };\n }\n return function() {\n return func.apply(context, arguments);\n };\n };\n\n // A mostly-internal function to generate callbacks that can be applied\n // to each element in a collection, returning the desired result — either\n // identity, an arbitrary callback, a property matcher, or a property accessor.\n var cb = function(value, context, argCount) {\n if (value == null) return _.identity;\n if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n if (_.isObject(value)) return _.matcher(value);\n return _.property(value);\n };\n _.iteratee = function(value, context) {\n return cb(value, context, Infinity);\n };\n\n // An internal function for creating assigner functions.\n var createAssigner = function(keysFunc, undefinedOnly) {\n return function(obj) {\n var length = arguments.length;\n if (length < 2 || obj == null) return obj;\n for (var index = 1; index < length; index++) {\n var source = arguments[index],\n keys = keysFunc(source),\n l = keys.length;\n for (var i = 0; i < l; i++) {\n var key = keys[i];\n if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\n }\n }\n return obj;\n };\n };\n\n // An internal function for creating a new object that inherits from another.\n var baseCreate = function(prototype) {\n if (!_.isObject(prototype)) return {};\n if (nativeCreate) return nativeCreate(prototype);\n Ctor.prototype = prototype;\n var result = new Ctor;\n Ctor.prototype = null;\n return result;\n };\n\n var property = function(key) {\n return function(obj) {\n return obj == null ? void 0 : obj[key];\n };\n };\n\n // Helper for collection methods to determine whether a collection\n // should be iterated as an array or as an object\n // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n var getLength = property('length');\n var isArrayLike = function(collection) {\n var length = getLength(collection);\n return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n };\n\n // Collection Functions\n // --------------------\n\n // The cornerstone, an `each` implementation, aka `forEach`.\n // Handles raw objects in addition to array-likes. Treats all\n // sparse array-likes as if they were dense.\n _.each = _.forEach = function(obj, iteratee, context) {\n iteratee = optimizeCb(iteratee, context);\n var i, length;\n if (isArrayLike(obj)) {\n for (i = 0, length = obj.length; i < length; i++) {\n iteratee(obj[i], i, obj);\n }\n } else {\n var keys = _.keys(obj);\n for (i = 0, length = keys.length; i < length; i++) {\n iteratee(obj[keys[i]], keys[i], obj);\n }\n }\n return obj;\n };\n\n // Return the results of applying the iteratee to each element.\n _.map = _.collect = function(obj, iteratee, context) {\n iteratee = cb(iteratee, context);\n var keys = !isArrayLike(obj) && _.keys(obj),\n length = (keys || obj).length,\n results = Array(length);\n for (var index = 0; index < length; index++) {\n var currentKey = keys ? keys[index] : index;\n results[index] = iteratee(obj[currentKey], currentKey, obj);\n }\n return results;\n };\n\n // Create a reducing function iterating left or right.\n function createReduce(dir) {\n // Optimized iterator function as using arguments.length\n // in the main function will deoptimize the, see #1991.\n function iterator(obj, iteratee, memo, keys, index, length) {\n for (; index >= 0 && index < length; index += dir) {\n var currentKey = keys ? keys[index] : index;\n memo = iteratee(memo, obj[currentKey], currentKey, obj);\n }\n return memo;\n }\n\n return function(obj, iteratee, memo, context) {\n iteratee = optimizeCb(iteratee, context, 4);\n var keys = !isArrayLike(obj) && _.keys(obj),\n length = (keys || obj).length,\n index = dir > 0 ? 0 : length - 1;\n // Determine the initial value if none is provided.\n if (arguments.length < 3) {\n memo = obj[keys ? keys[index] : index];\n index += dir;\n }\n return iterator(obj, iteratee, memo, keys, index, length);\n };\n }\n\n // **Reduce** builds up a single result from a list of values, aka `inject`,\n // or `foldl`.\n _.reduce = _.foldl = _.inject = createReduce(1);\n\n // The right-associative version of reduce, also known as `foldr`.\n _.reduceRight = _.foldr = createReduce(-1);\n\n // Return the first value which passes a truth test. Aliased as `detect`.\n _.find = _.detect = function(obj, predicate, context) {\n var key;\n if (isArrayLike(obj)) {\n key = _.findIndex(obj, predicate, context);\n } else {\n key = _.findKey(obj, predicate, context);\n }\n if (key !== void 0 && key !== -1) return obj[key];\n };\n\n // Return all the elements that pass a truth test.\n // Aliased as `select`.\n _.filter = _.select = function(obj, predicate, context) {\n var results = [];\n predicate = cb(predicate, context);\n _.each(obj, function(value, index, list) {\n if (predicate(value, index, list)) results.push(value);\n });\n return results;\n };\n\n // Return all the elements for which a truth test fails.\n _.reject = function(obj, predicate, context) {\n return _.filter(obj, _.negate(cb(predicate)), context);\n };\n\n // Determine whether all of the elements match a truth test.\n // Aliased as `all`.\n _.every = _.all = function(obj, predicate, context) {\n predicate = cb(predicate, context);\n var keys = !isArrayLike(obj) && _.keys(obj),\n length = (keys || obj).length;\n for (var index = 0; index < length; index++) {\n var currentKey = keys ? keys[index] : index;\n if (!predicate(obj[currentKey], currentKey, obj)) return false;\n }\n return true;\n };\n\n // Determine if at least one element in the object matches a truth test.\n // Aliased as `any`.\n _.some = _.any = function(obj, predicate, context) {\n predicate = cb(predicate, context);\n var keys = !isArrayLike(obj) && _.keys(obj),\n length = (keys || obj).length;\n for (var index = 0; index < length; index++) {\n var currentKey = keys ? keys[index] : index;\n if (predicate(obj[currentKey], currentKey, obj)) return true;\n }\n return false;\n };\n\n // Determine if the array or object contains a given item (using `===`).\n // Aliased as `includes` and `include`.\n _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n if (!isArrayLike(obj)) obj = _.values(obj);\n if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n return _.indexOf(obj, item, fromIndex) >= 0;\n };\n\n // Invoke a method (with arguments) on every item in a collection.\n _.invoke = function(obj, method) {\n var args = slice.call(arguments, 2);\n var isFunc = _.isFunction(method);\n return _.map(obj, function(value) {\n var func = isFunc ? method : value[method];\n return func == null ? func : func.apply(value, args);\n });\n };\n\n // Convenience version of a common use case of `map`: fetching a property.\n _.pluck = function(obj, key) {\n return _.map(obj, _.property(key));\n };\n\n // Convenience version of a common use case of `filter`: selecting only objects\n // containing specific `key:value` pairs.\n _.where = function(obj, attrs) {\n return _.filter(obj, _.matcher(attrs));\n };\n\n // Convenience version of a common use case of `find`: getting the first object\n // containing specific `key:value` pairs.\n _.findWhere = function(obj, attrs) {\n return _.find(obj, _.matcher(attrs));\n };\n\n // Return the maximum element (or element-based computation).\n _.max = function(obj, iteratee, context) {\n var result = -Infinity, lastComputed = -Infinity,\n value, computed;\n if (iteratee == null && obj != null) {\n obj = isArrayLike(obj) ? obj : _.values(obj);\n for (var i = 0, length = obj.length; i < length; i++) {\n value = obj[i];\n if (value > result) {\n result = value;\n }\n }\n } else {\n iteratee = cb(iteratee, context);\n _.each(obj, function(value, index, list) {\n computed = iteratee(value, index, list);\n if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n result = value;\n lastComputed = computed;\n }\n });\n }\n return result;\n };\n\n // Return the minimum element (or element-based computation).\n _.min = function(obj, iteratee, context) {\n var result = Infinity, lastComputed = Infinity,\n value, computed;\n if (iteratee == null && obj != null) {\n obj = isArrayLike(obj) ? obj : _.values(obj);\n for (var i = 0, length = obj.length; i < length; i++) {\n value = obj[i];\n if (value < result) {\n result = value;\n }\n }\n } else {\n iteratee = cb(iteratee, context);\n _.each(obj, function(value, index, list) {\n computed = iteratee(value, index, list);\n if (computed < lastComputed || computed === Infinity && result === Infinity) {\n result = value;\n lastComputed = computed;\n }\n });\n }\n return result;\n };\n\n // Shuffle a collection, using the modern version of the\n // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n _.shuffle = function(obj) {\n var set = isArrayLike(obj) ? obj : _.values(obj);\n var length = set.length;\n var shuffled = Array(length);\n for (var index = 0, rand; index < length; index++) {\n rand = _.random(0, index);\n if (rand !== index) shuffled[index] = shuffled[rand];\n shuffled[rand] = set[index];\n }\n return shuffled;\n };\n\n // Sample **n** random values from a collection.\n // If **n** is not specified, returns a single random element.\n // The internal `guard` argument allows it to work with `map`.\n _.sample = function(obj, n, guard) {\n if (n == null || guard) {\n if (!isArrayLike(obj)) obj = _.values(obj);\n return obj[_.random(obj.length - 1)];\n }\n return _.shuffle(obj).slice(0, Math.max(0, n));\n };\n\n // Sort the object's values by a criterion produced by an iteratee.\n _.sortBy = function(obj, iteratee, context) {\n iteratee = cb(iteratee, context);\n return _.pluck(_.map(obj, function(value, index, list) {\n return {\n value: value,\n index: index,\n criteria: iteratee(value, index, list)\n };\n }).sort(function(left, right) {\n var a = left.criteria;\n var b = right.criteria;\n if (a !== b) {\n if (a > b || a === void 0) return 1;\n if (a < b || b === void 0) return -1;\n }\n return left.index - right.index;\n }), 'value');\n };\n\n // An internal function used for aggregate \"group by\" operations.\n var group = function(behavior) {\n return function(obj, iteratee, context) {\n var result = {};\n iteratee = cb(iteratee, context);\n _.each(obj, function(value, index) {\n var key = iteratee(value, index, obj);\n behavior(result, value, key);\n });\n return result;\n };\n };\n\n // Groups the object's values by a criterion. Pass either a string attribute\n // to group by, or a function that returns the criterion.\n _.groupBy = group(function(result, value, key) {\n if (_.has(result, key)) result[key].push(value); else result[key] = [value];\n });\n\n // Indexes the object's values by a criterion, similar to `groupBy`, but for\n // when you know that your index values will be unique.\n _.indexBy = group(function(result, value, key) {\n result[key] = value;\n });\n\n // Counts instances of an object that group by a certain criterion. Pass\n // either a string attribute to count by, or a function that returns the\n // criterion.\n _.countBy = group(function(result, value, key) {\n if (_.has(result, key)) result[key]++; else result[key] = 1;\n });\n\n // Safely create a real, live array from anything iterable.\n _.toArray = function(obj) {\n if (!obj) return [];\n if (_.isArray(obj)) return slice.call(obj);\n if (isArrayLike(obj)) return _.map(obj, _.identity);\n return _.values(obj);\n };\n\n // Return the number of elements in an object.\n _.size = function(obj) {\n if (obj == null) return 0;\n return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n };\n\n // Split a collection into two arrays: one whose elements all satisfy the given\n // predicate, and one whose elements all do not satisfy the predicate.\n _.partition = function(obj, predicate, context) {\n predicate = cb(predicate, context);\n var pass = [], fail = [];\n _.each(obj, function(value, key, obj) {\n (predicate(value, key, obj) ? pass : fail).push(value);\n });\n return [pass, fail];\n };\n\n // Array Functions\n // ---------------\n\n // Get the first element of an array. Passing **n** will return the first N\n // values in the array. Aliased as `head` and `take`. The **guard** check\n // allows it to work with `_.map`.\n _.first = _.head = _.take = function(array, n, guard) {\n if (array == null) return void 0;\n if (n == null || guard) return array[0];\n return _.initial(array, array.length - n);\n };\n\n // Returns everything but the last entry of the array. Especially useful on\n // the arguments object. Passing **n** will return all the values in\n // the array, excluding the last N.\n _.initial = function(array, n, guard) {\n return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n };\n\n // Get the last element of an array. Passing **n** will return the last N\n // values in the array.\n _.last = function(array, n, guard) {\n if (array == null) return void 0;\n if (n == null || guard) return array[array.length - 1];\n return _.rest(array, Math.max(0, array.length - n));\n };\n\n // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n // Especially useful on the arguments object. Passing an **n** will return\n // the rest N values in the array.\n _.rest = _.tail = _.drop = function(array, n, guard) {\n return slice.call(array, n == null || guard ? 1 : n);\n };\n\n // Trim out all falsy values from an array.\n _.compact = function(array) {\n return _.filter(array, _.identity);\n };\n\n // Internal implementation of a recursive `flatten` function.\n var flatten = function(input, shallow, strict, startIndex) {\n var output = [], idx = 0;\n for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\n var value = input[i];\n if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n //flatten current level of array or arguments object\n if (!shallow) value = flatten(value, shallow, strict);\n var j = 0, len = value.length;\n output.length += len;\n while (j < len) {\n output[idx++] = value[j++];\n }\n } else if (!strict) {\n output[idx++] = value;\n }\n }\n return output;\n };\n\n // Flatten out an array, either recursively (by default), or just one level.\n _.flatten = function(array, shallow) {\n return flatten(array, shallow, false);\n };\n\n // Return a version of the array that does not contain the specified value(s).\n _.without = function(array) {\n return _.difference(array, slice.call(arguments, 1));\n };\n\n // Produce a duplicate-free version of the array. If the array has already\n // been sorted, you have the option of using a faster algorithm.\n // Aliased as `unique`.\n _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n if (!_.isBoolean(isSorted)) {\n context = iteratee;\n iteratee = isSorted;\n isSorted = false;\n }\n if (iteratee != null) iteratee = cb(iteratee, context);\n var result = [];\n var seen = [];\n for (var i = 0, length = getLength(array); i < length; i++) {\n var value = array[i],\n computed = iteratee ? iteratee(value, i, array) : value;\n if (isSorted) {\n if (!i || seen !== computed) result.push(value);\n seen = computed;\n } else if (iteratee) {\n if (!_.contains(seen, computed)) {\n seen.push(computed);\n result.push(value);\n }\n } else if (!_.contains(result, value)) {\n result.push(value);\n }\n }\n return result;\n };\n\n // Produce an array that contains the union: each distinct element from all of\n // the passed-in arrays.\n _.union = function() {\n return _.uniq(flatten(arguments, true, true));\n };\n\n // Produce an array that contains every item shared between all the\n // passed-in arrays.\n _.intersection = function(array) {\n var result = [];\n var argsLength = arguments.length;\n for (var i = 0, length = getLength(array); i < length; i++) {\n var item = array[i];\n if (_.contains(result, item)) continue;\n for (var j = 1; j < argsLength; j++) {\n if (!_.contains(arguments[j], item)) break;\n }\n if (j === argsLength) result.push(item);\n }\n return result;\n };\n\n // Take the difference between one array and a number of other arrays.\n // Only the elements present in just the first array will remain.\n _.difference = function(array) {\n var rest = flatten(arguments, true, true, 1);\n return _.filter(array, function(value){\n return !_.contains(rest, value);\n });\n };\n\n // Zip together multiple lists into a single array -- elements that share\n // an index go together.\n _.zip = function() {\n return _.unzip(arguments);\n };\n\n // Complement of _.zip. Unzip accepts an array of arrays and groups\n // each array's elements on shared indices\n _.unzip = function(array) {\n var length = array && _.max(array, getLength).length || 0;\n var result = Array(length);\n\n for (var index = 0; index < length; index++) {\n result[index] = _.pluck(array, index);\n }\n return result;\n };\n\n // Converts lists into objects. Pass either a single array of `[key, value]`\n // pairs, or two parallel arrays of the same length -- one of keys, and one of\n // the corresponding values.\n _.object = function(list, values) {\n var result = {};\n for (var i = 0, length = getLength(list); i < length; i++) {\n if (values) {\n result[list[i]] = values[i];\n } else {\n result[list[i][0]] = list[i][1];\n }\n }\n return result;\n };\n\n // Generator function to create the findIndex and findLastIndex functions\n function createPredicateIndexFinder(dir) {\n return function(array, predicate, context) {\n predicate = cb(predicate, context);\n var length = getLength(array);\n var index = dir > 0 ? 0 : length - 1;\n for (; index >= 0 && index < length; index += dir) {\n if (predicate(array[index], index, array)) return index;\n }\n return -1;\n };\n }\n\n // Returns the first index on an array-like that passes a predicate test\n _.findIndex = createPredicateIndexFinder(1);\n _.findLastIndex = createPredicateIndexFinder(-1);\n\n // Use a comparator function to figure out the smallest index at which\n // an object should be inserted so as to maintain order. Uses binary search.\n _.sortedIndex = function(array, obj, iteratee, context) {\n iteratee = cb(iteratee, context, 1);\n var value = iteratee(obj);\n var low = 0, high = getLength(array);\n while (low < high) {\n var mid = Math.floor((low + high) / 2);\n if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n }\n return low;\n };\n\n // Generator function to create the indexOf and lastIndexOf functions\n function createIndexFinder(dir, predicateFind, sortedIndex) {\n return function(array, item, idx) {\n var i = 0, length = getLength(array);\n if (typeof idx == 'number') {\n if (dir > 0) {\n i = idx >= 0 ? idx : Math.max(idx + length, i);\n } else {\n length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n }\n } else if (sortedIndex && idx && length) {\n idx = sortedIndex(array, item);\n return array[idx] === item ? idx : -1;\n }\n if (item !== item) {\n idx = predicateFind(slice.call(array, i, length), _.isNaN);\n return idx >= 0 ? idx + i : -1;\n }\n for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n if (array[idx] === item) return idx;\n }\n return -1;\n };\n }\n\n // Return the position of the first occurrence of an item in an array,\n // or -1 if the item is not included in the array.\n // If the array is large and already in sort order, pass `true`\n // for **isSorted** to use binary search.\n _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n // Generate an integer Array containing an arithmetic progression. A port of\n // the native Python `range()` function. See\n // [the Python documentation](http://docs.python.org/library/functions.html#range).\n _.range = function(start, stop, step) {\n if (stop == null) {\n stop = start || 0;\n start = 0;\n }\n step = step || 1;\n\n var length = Math.max(Math.ceil((stop - start) / step), 0);\n var range = Array(length);\n\n for (var idx = 0; idx < length; idx++, start += step) {\n range[idx] = start;\n }\n\n return range;\n };\n\n // Function (ahem) Functions\n // ------------------\n\n // Determines whether to execute a function as a constructor\n // or a normal function with the provided arguments\n var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n var self = baseCreate(sourceFunc.prototype);\n var result = sourceFunc.apply(self, args);\n if (_.isObject(result)) return result;\n return self;\n };\n\n // Create a function bound to a given object (assigning `this`, and arguments,\n // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n // available.\n _.bind = function(func, context) {\n if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n var args = slice.call(arguments, 2);\n var bound = function() {\n return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\n };\n return bound;\n };\n\n // Partially apply a function by creating a version that has had some of its\n // arguments pre-filled, without changing its dynamic `this` context. _ acts\n // as a placeholder, allowing any combination of arguments to be pre-filled.\n _.partial = function(func) {\n var boundArgs = slice.call(arguments, 1);\n var bound = function() {\n var position = 0, length = boundArgs.length;\n var args = Array(length);\n for (var i = 0; i < length; i++) {\n args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\n }\n while (position < arguments.length) args.push(arguments[position++]);\n return executeBound(func, bound, this, this, args);\n };\n return bound;\n };\n\n // Bind a number of an object's methods to that object. Remaining arguments\n // are the method names to be bound. Useful for ensuring that all callbacks\n // defined on an object belong to it.\n _.bindAll = function(obj) {\n var i, length = arguments.length, key;\n if (length <= 1) throw new Error('bindAll must be passed function names');\n for (i = 1; i < length; i++) {\n key = arguments[i];\n obj[key] = _.bind(obj[key], obj);\n }\n return obj;\n };\n\n // Memoize an expensive function by storing its results.\n _.memoize = function(func, hasher) {\n var memoize = function(key) {\n var cache = memoize.cache;\n var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n return cache[address];\n };\n memoize.cache = {};\n return memoize;\n };\n\n // Delays a function for the given number of milliseconds, and then calls\n // it with the arguments supplied.\n _.delay = function(func, wait) {\n var args = slice.call(arguments, 2);\n return setTimeout(function(){\n return func.apply(null, args);\n }, wait);\n };\n\n // Defers a function, scheduling it to run after the current call stack has\n // cleared.\n _.defer = _.partial(_.delay, _, 1);\n\n // Returns a function, that, when invoked, will only be triggered at most once\n // during a given window of time. Normally, the throttled function will run\n // as much as it can, without ever going more than once per `wait` duration;\n // but if you'd like to disable the execution on the leading edge, pass\n // `{leading: false}`. To disable execution on the trailing edge, ditto.\n _.throttle = function(func, wait, options) {\n var context, args, result;\n var timeout = null;\n var previous = 0;\n if (!options) options = {};\n var later = function() {\n previous = options.leading === false ? 0 : _.now();\n timeout = null;\n result = func.apply(context, args);\n if (!timeout) context = args = null;\n };\n return function() {\n var now = _.now();\n if (!previous && options.leading === false) previous = now;\n var remaining = wait - (now - previous);\n context = this;\n args = arguments;\n if (remaining <= 0 || remaining > wait) {\n if (timeout) {\n clearTimeout(timeout);\n timeout = null;\n }\n previous = now;\n result = func.apply(context, args);\n if (!timeout) context = args = null;\n } else if (!timeout && options.trailing !== false) {\n timeout = setTimeout(later, remaining);\n }\n return result;\n };\n };\n\n // Returns a function, that, as long as it continues to be invoked, will not\n // be triggered. The function will be called after it stops being called for\n // N milliseconds. If `immediate` is passed, trigger the function on the\n // leading edge, instead of the trailing.\n _.debounce = function(func, wait, immediate) {\n var timeout, args, context, timestamp, result;\n\n var later = function() {\n var last = _.now() - timestamp;\n\n if (last < wait && last >= 0) {\n timeout = setTimeout(later, wait - last);\n } else {\n timeout = null;\n if (!immediate) {\n result = func.apply(context, args);\n if (!timeout) context = args = null;\n }\n }\n };\n\n return function() {\n context = this;\n args = arguments;\n timestamp = _.now();\n var callNow = immediate && !timeout;\n if (!timeout) timeout = setTimeout(later, wait);\n if (callNow) {\n result = func.apply(context, args);\n context = args = null;\n }\n\n return result;\n };\n };\n\n // Returns the first function passed as an argument to the second,\n // allowing you to adjust arguments, run code before and after, and\n // conditionally execute the original function.\n _.wrap = function(func, wrapper) {\n return _.partial(wrapper, func);\n };\n\n // Returns a negated version of the passed-in predicate.\n _.negate = function(predicate) {\n return function() {\n return !predicate.apply(this, arguments);\n };\n };\n\n // Returns a function that is the composition of a list of functions, each\n // consuming the return value of the function that follows.\n _.compose = function() {\n var args = arguments;\n var start = args.length - 1;\n return function() {\n var i = start;\n var result = args[start].apply(this, arguments);\n while (i--) result = args[i].call(this, result);\n return result;\n };\n };\n\n // Returns a function that will only be executed on and after the Nth call.\n _.after = function(times, func) {\n return function() {\n if (--times < 1) {\n return func.apply(this, arguments);\n }\n };\n };\n\n // Returns a function that will only be executed up to (but not including) the Nth call.\n _.before = function(times, func) {\n var memo;\n return function() {\n if (--times > 0) {\n memo = func.apply(this, arguments);\n }\n if (times <= 1) func = null;\n return memo;\n };\n };\n\n // Returns a function that will be executed at most one time, no matter how\n // often you call it. Useful for lazy initialization.\n _.once = _.partial(_.before, 2);\n\n // Object Functions\n // ----------------\n\n // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n function collectNonEnumProps(obj, keys) {\n var nonEnumIdx = nonEnumerableProps.length;\n var constructor = obj.constructor;\n var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;\n\n // Constructor is a special case.\n var prop = 'constructor';\n if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n while (nonEnumIdx--) {\n prop = nonEnumerableProps[nonEnumIdx];\n if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n keys.push(prop);\n }\n }\n }\n\n // Retrieve the names of an object's own properties.\n // Delegates to **ECMAScript 5**'s native `Object.keys`\n _.keys = function(obj) {\n if (!_.isObject(obj)) return [];\n if (nativeKeys) return nativeKeys(obj);\n var keys = [];\n for (var key in obj) if (_.has(obj, key)) keys.push(key);\n // Ahem, IE < 9.\n if (hasEnumBug) collectNonEnumProps(obj, keys);\n return keys;\n };\n\n // Retrieve all the property names of an object.\n _.allKeys = function(obj) {\n if (!_.isObject(obj)) return [];\n var keys = [];\n for (var key in obj) keys.push(key);\n // Ahem, IE < 9.\n if (hasEnumBug) collectNonEnumProps(obj, keys);\n return keys;\n };\n\n // Retrieve the values of an object's properties.\n _.values = function(obj) {\n var keys = _.keys(obj);\n var length = keys.length;\n var values = Array(length);\n for (var i = 0; i < length; i++) {\n values[i] = obj[keys[i]];\n }\n return values;\n };\n\n // Returns the results of applying the iteratee to each element of the object\n // In contrast to _.map it returns an object\n _.mapObject = function(obj, iteratee, context) {\n iteratee = cb(iteratee, context);\n var keys = _.keys(obj),\n length = keys.length,\n results = {},\n currentKey;\n for (var index = 0; index < length; index++) {\n currentKey = keys[index];\n results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n }\n return results;\n };\n\n // Convert an object into a list of `[key, value]` pairs.\n _.pairs = function(obj) {\n var keys = _.keys(obj);\n var length = keys.length;\n var pairs = Array(length);\n for (var i = 0; i < length; i++) {\n pairs[i] = [keys[i], obj[keys[i]]];\n }\n return pairs;\n };\n\n // Invert the keys and values of an object. The values must be serializable.\n _.invert = function(obj) {\n var result = {};\n var keys = _.keys(obj);\n for (var i = 0, length = keys.length; i < length; i++) {\n result[obj[keys[i]]] = keys[i];\n }\n return result;\n };\n\n // Return a sorted list of the function names available on the object.\n // Aliased as `methods`\n _.functions = _.methods = function(obj) {\n var names = [];\n for (var key in obj) {\n if (_.isFunction(obj[key])) names.push(key);\n }\n return names.sort();\n };\n\n // Extend a given object with all the properties in passed-in object(s).\n _.extend = createAssigner(_.allKeys);\n\n // Assigns a given object with all the own properties in the passed-in object(s)\n // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n _.extendOwn = _.assign = createAssigner(_.keys);\n\n // Returns the first key on an object that passes a predicate test\n _.findKey = function(obj, predicate, context) {\n predicate = cb(predicate, context);\n var keys = _.keys(obj), key;\n for (var i = 0, length = keys.length; i < length; i++) {\n key = keys[i];\n if (predicate(obj[key], key, obj)) return key;\n }\n };\n\n // Return a copy of the object only containing the whitelisted properties.\n _.pick = function(object, oiteratee, context) {\n var result = {}, obj = object, iteratee, keys;\n if (obj == null) return result;\n if (_.isFunction(oiteratee)) {\n keys = _.allKeys(obj);\n iteratee = optimizeCb(oiteratee, context);\n } else {\n keys = flatten(arguments, false, false, 1);\n iteratee = function(value, key, obj) { return key in obj; };\n obj = Object(obj);\n }\n for (var i = 0, length = keys.length; i < length; i++) {\n var key = keys[i];\n var value = obj[key];\n if (iteratee(value, key, obj)) result[key] = value;\n }\n return result;\n };\n\n // Return a copy of the object without the blacklisted properties.\n _.omit = function(obj, iteratee, context) {\n if (_.isFunction(iteratee)) {\n iteratee = _.negate(iteratee);\n } else {\n var keys = _.map(flatten(arguments, false, false, 1), String);\n iteratee = function(value, key) {\n return !_.contains(keys, key);\n };\n }\n return _.pick(obj, iteratee, context);\n };\n\n // Fill in a given object with default properties.\n _.defaults = createAssigner(_.allKeys, true);\n\n // Creates an object that inherits from the given prototype object.\n // If additional properties are provided then they will be added to the\n // created object.\n _.create = function(prototype, props) {\n var result = baseCreate(prototype);\n if (props) _.extendOwn(result, props);\n return result;\n };\n\n // Create a (shallow-cloned) duplicate of an object.\n _.clone = function(obj) {\n if (!_.isObject(obj)) return obj;\n return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n };\n\n // Invokes interceptor with the obj, and then returns obj.\n // The primary purpose of this method is to \"tap into\" a method chain, in\n // order to perform operations on intermediate results within the chain.\n _.tap = function(obj, interceptor) {\n interceptor(obj);\n return obj;\n };\n\n // Returns whether an object has a given set of `key:value` pairs.\n _.isMatch = function(object, attrs) {\n var keys = _.keys(attrs), length = keys.length;\n if (object == null) return !length;\n var obj = Object(object);\n for (var i = 0; i < length; i++) {\n var key = keys[i];\n if (attrs[key] !== obj[key] || !(key in obj)) return false;\n }\n return true;\n };\n\n\n // Internal recursive comparison function for `isEqual`.\n var eq = function(a, b, aStack, bStack) {\n // Identical objects are equal. `0 === -0`, but they aren't identical.\n // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n if (a === b) return a !== 0 || 1 / a === 1 / b;\n // A strict comparison is necessary because `null == undefined`.\n if (a == null || b == null) return a === b;\n // Unwrap any wrapped objects.\n if (a instanceof _) a = a._wrapped;\n if (b instanceof _) b = b._wrapped;\n // Compare `[[Class]]` names.\n var className = toString.call(a);\n if (className !== toString.call(b)) return false;\n switch (className) {\n // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n case '[object RegExp]':\n // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n case '[object String]':\n // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n // equivalent to `new String(\"5\")`.\n return '' + a === '' + b;\n case '[object Number]':\n // `NaN`s are equivalent, but non-reflexive.\n // Object(NaN) is equivalent to NaN\n if (+a !== +a) return +b !== +b;\n // An `egal` comparison is performed for other numeric values.\n return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n case '[object Date]':\n case '[object Boolean]':\n // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n // millisecond representations. Note that invalid dates with millisecond representations\n // of `NaN` are not equivalent.\n return +a === +b;\n }\n\n var areArrays = className === '[object Array]';\n if (!areArrays) {\n if (typeof a != 'object' || typeof b != 'object') return false;\n\n // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n // from different frames are.\n var aCtor = a.constructor, bCtor = b.constructor;\n if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n _.isFunction(bCtor) && bCtor instanceof bCtor)\n && ('constructor' in a && 'constructor' in b)) {\n return false;\n }\n }\n // Assume equality for cyclic structures. The algorithm for detecting cyclic\n // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n // Initializing stack of traversed objects.\n // It's done here since we only need them for objects and arrays comparison.\n aStack = aStack || [];\n bStack = bStack || [];\n var length = aStack.length;\n while (length--) {\n // Linear search. Performance is inversely proportional to the number of\n // unique nested structures.\n if (aStack[length] === a) return bStack[length] === b;\n }\n\n // Add the first object to the stack of traversed objects.\n aStack.push(a);\n bStack.push(b);\n\n // Recursively compare objects and arrays.\n if (areArrays) {\n // Compare array lengths to determine if a deep comparison is necessary.\n length = a.length;\n if (length !== b.length) return false;\n // Deep compare the contents, ignoring non-numeric properties.\n while (length--) {\n if (!eq(a[length], b[length], aStack, bStack)) return false;\n }\n } else {\n // Deep compare objects.\n var keys = _.keys(a), key;\n length = keys.length;\n // Ensure that both objects contain the same number of properties before comparing deep equality.\n if (_.keys(b).length !== length) return false;\n while (length--) {\n // Deep compare each member\n key = keys[length];\n if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n }\n }\n // Remove the first object from the stack of traversed objects.\n aStack.pop();\n bStack.pop();\n return true;\n };\n\n // Perform a deep comparison to check if two objects are equal.\n _.isEqual = function(a, b) {\n return eq(a, b);\n };\n\n // Is a given array, string, or object empty?\n // An \"empty\" object has no enumerable own-properties.\n _.isEmpty = function(obj) {\n if (obj == null) return true;\n if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n return _.keys(obj).length === 0;\n };\n\n // Is a given value a DOM element?\n _.isElement = function(obj) {\n return !!(obj && obj.nodeType === 1);\n };\n\n // Is a given value an array?\n // Delegates to ECMA5's native Array.isArray\n _.isArray = nativeIsArray || function(obj) {\n return toString.call(obj) === '[object Array]';\n };\n\n // Is a given variable an object?\n _.isObject = function(obj) {\n var type = typeof obj;\n return type === 'function' || type === 'object' && !!obj;\n };\n\n // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\n _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {\n _['is' + name] = function(obj) {\n return toString.call(obj) === '[object ' + name + ']';\n };\n });\n\n // Define a fallback version of the method in browsers (ahem, IE < 9), where\n // there isn't any inspectable \"Arguments\" type.\n if (!_.isArguments(arguments)) {\n _.isArguments = function(obj) {\n return _.has(obj, 'callee');\n };\n }\n\n // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n // IE 11 (#1621), and in Safari 8 (#1929).\n if (typeof /./ != 'function' && typeof Int8Array != 'object') {\n _.isFunction = function(obj) {\n return typeof obj == 'function' || false;\n };\n }\n\n // Is a given object a finite number?\n _.isFinite = function(obj) {\n return isFinite(obj) && !isNaN(parseFloat(obj));\n };\n\n // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n _.isNaN = function(obj) {\n return _.isNumber(obj) && obj !== +obj;\n };\n\n // Is a given value a boolean?\n _.isBoolean = function(obj) {\n return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n };\n\n // Is a given value equal to null?\n _.isNull = function(obj) {\n return obj === null;\n };\n\n // Is a given variable undefined?\n _.isUndefined = function(obj) {\n return obj === void 0;\n };\n\n // Shortcut function for checking if an object has a given property directly\n // on itself (in other words, not on a prototype).\n _.has = function(obj, key) {\n return obj != null && hasOwnProperty.call(obj, key);\n };\n\n // Utility Functions\n // -----------------\n\n // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n // previous owner. Returns a reference to the Underscore object.\n _.noConflict = function() {\n root._ = previousUnderscore;\n return this;\n };\n\n // Keep the identity function around for default iteratees.\n _.identity = function(value) {\n return value;\n };\n\n // Predicate-generating functions. Often useful outside of Underscore.\n _.constant = function(value) {\n return function() {\n return value;\n };\n };\n\n _.noop = function(){};\n\n _.property = property;\n\n // Generates a function for a given object that returns a given property.\n _.propertyOf = function(obj) {\n return obj == null ? function(){} : function(key) {\n return obj[key];\n };\n };\n\n // Returns a predicate for checking whether an object has a given set of\n // `key:value` pairs.\n _.matcher = _.matches = function(attrs) {\n attrs = _.extendOwn({}, attrs);\n return function(obj) {\n return _.isMatch(obj, attrs);\n };\n };\n\n // Run a function **n** times.\n _.times = function(n, iteratee, context) {\n var accum = Array(Math.max(0, n));\n iteratee = optimizeCb(iteratee, context, 1);\n for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n return accum;\n };\n\n // Return a random integer between min and max (inclusive).\n _.random = function(min, max) {\n if (max == null) {\n max = min;\n min = 0;\n }\n return min + Math.floor(Math.random() * (max - min + 1));\n };\n\n // A (possibly faster) way to get the current timestamp as an integer.\n _.now = Date.now || function() {\n return new Date().getTime();\n };\n\n // List of HTML entities for escaping.\n var escapeMap = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": ''',\n '`': '`'\n };\n var unescapeMap = _.invert(escapeMap);\n\n // Functions for escaping and unescaping strings to/from HTML interpolation.\n var createEscaper = function(map) {\n var escaper = function(match) {\n return map[match];\n };\n // Regexes for identifying a key that needs to be escaped\n var source = '(?:' + _.keys(map).join('|') + ')';\n var testRegexp = RegExp(source);\n var replaceRegexp = RegExp(source, 'g');\n return function(string) {\n string = string == null ? '' : '' + string;\n return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n };\n };\n _.escape = createEscaper(escapeMap);\n _.unescape = createEscaper(unescapeMap);\n\n // If the value of the named `property` is a function then invoke it with the\n // `object` as context; otherwise, return it.\n _.result = function(object, property, fallback) {\n var value = object == null ? void 0 : object[property];\n if (value === void 0) {\n value = fallback;\n }\n return _.isFunction(value) ? value.call(object) : value;\n };\n\n // Generate a unique integer id (unique within the entire client session).\n // Useful for temporary DOM ids.\n var idCounter = 0;\n _.uniqueId = function(prefix) {\n var id = ++idCounter + '';\n return prefix ? prefix + id : id;\n };\n\n // By default, Underscore uses ERB-style template delimiters, change the\n // following template settings to use alternative delimiters.\n _.templateSettings = {\n evaluate : /<%([\\s\\S]+?)%>/g,\n interpolate : /<%=([\\s\\S]+?)%>/g,\n escape : /<%-([\\s\\S]+?)%>/g\n };\n\n // When customizing `templateSettings`, if you don't want to define an\n // interpolation, evaluation or escaping regex, we need one that is\n // guaranteed not to match.\n var noMatch = /(.)^/;\n\n // Certain characters need to be escaped so that they can be put into a\n // string literal.\n var escapes = {\n \"'\": \"'\",\n '\\\\': '\\\\',\n '\\r': 'r',\n '\\n': 'n',\n '\\u2028': 'u2028',\n '\\u2029': 'u2029'\n };\n\n var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n var escapeChar = function(match) {\n return '\\\\' + escapes[match];\n };\n\n // JavaScript micro-templating, similar to John Resig's implementation.\n // Underscore templating handles arbitrary delimiters, preserves whitespace,\n // and correctly escapes quotes within interpolated code.\n // NB: `oldSettings` only exists for backwards compatibility.\n _.template = function(text, settings, oldSettings) {\n if (!settings && oldSettings) settings = oldSettings;\n settings = _.defaults({}, settings, _.templateSettings);\n\n // Combine delimiters into one regular expression via alternation.\n var matcher = RegExp([\n (settings.escape || noMatch).source,\n (settings.interpolate || noMatch).source,\n (settings.evaluate || noMatch).source\n ].join('|') + '|$', 'g');\n\n // Compile the template source, escaping string literals appropriately.\n var index = 0;\n var source = \"__p+='\";\n text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n source += text.slice(index, offset).replace(escaper, escapeChar);\n index = offset + match.length;\n\n if (escape) {\n source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n } else if (interpolate) {\n source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n } else if (evaluate) {\n source += \"';\\n\" + evaluate + \"\\n__p+='\";\n }\n\n // Adobe VMs need the match returned to produce the correct offest.\n return match;\n });\n source += \"';\\n\";\n\n // If a variable is not specified, place data values in local scope.\n if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n source = \"var __t,__p='',__j=Array.prototype.join,\" +\n \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n source + 'return __p;\\n';\n\n try {\n var render = new Function(settings.variable || 'obj', '_', source);\n } catch (e) {\n e.source = source;\n throw e;\n }\n\n var template = function(data) {\n return render.call(this, data, _);\n };\n\n // Provide the compiled source as a convenience for precompilation.\n var argument = settings.variable || 'obj';\n template.source = 'function(' + argument + '){\\n' + source + '}';\n\n return template;\n };\n\n // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n _.chain = function(obj) {\n var instance = _(obj);\n instance._chain = true;\n return instance;\n };\n\n // OOP\n // ---------------\n // If Underscore is called as a function, it returns a wrapped object that\n // can be used OO-style. This wrapper holds altered versions of all the\n // underscore functions. Wrapped objects may be chained.\n\n // Helper function to continue chaining intermediate results.\n var result = function(instance, obj) {\n return instance._chain ? _(obj).chain() : obj;\n };\n\n // Add your own custom functions to the Underscore object.\n _.mixin = function(obj) {\n _.each(_.functions(obj), function(name) {\n var func = _[name] = obj[name];\n _.prototype[name] = function() {\n var args = [this._wrapped];\n push.apply(args, arguments);\n return result(this, func.apply(_, args));\n };\n });\n };\n\n // Add all of the Underscore functions to the wrapper object.\n _.mixin(_);\n\n // Add all mutator Array functions to the wrapper.\n _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n var method = ArrayProto[name];\n _.prototype[name] = function() {\n var obj = this._wrapped;\n method.apply(obj, arguments);\n if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n return result(this, obj);\n };\n });\n\n // Add all accessor Array functions to the wrapper.\n _.each(['concat', 'join', 'slice'], function(name) {\n var method = ArrayProto[name];\n _.prototype[name] = function() {\n return result(this, method.apply(this._wrapped, arguments));\n };\n });\n\n // Extracts the result from a wrapped and chained object.\n _.prototype.value = function() {\n return this._wrapped;\n };\n\n // Provide unwrapping proxy for some methods used in engine operations\n // such as arithmetic and JSON stringification.\n _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n _.prototype.toString = function() {\n return '' + this._wrapped;\n };\n\n // AMD registration happens at the end for compatibility with AMD loaders\n // that may not enforce next-turn semantics on modules. Even though general\n // practice for AMD registration is to be anonymous, underscore registers\n // as a named module because, like jQuery, it is a base library that is\n // popular enough to be bundled in a third party lib, but not be part of\n // an AMD load request. Those cases could generate an error when an\n // anonymous define() is called outside of a loader request.\n if (typeof define === 'function' && define.amd) {\n define('underscore', [], function() {\n return _;\n });\n }\n}.call(this));\n\n\n\n/** WEBPACK FOOTER **\n ** ./~/underscore/underscore.js\n **/"],"sourceRoot":""}