{"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":"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","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    '&': '&amp;',\n\t    '<': '&lt;',\n\t    '>': '&gt;',\n\t    '\"': '&quot;',\n\t    \"'\": '&#x27;',\n\t    '`': '&#x60;'\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    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\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":""}