{"version":3,"sources":["webpack:///core-bef109a214aa0e57ba54.bundle.js","webpack:///webpack/bootstrap bef109a214aa0e57ba54?ca99","webpack:///./~/underscore/underscore.js?31a5","webpack:///external \"$\"?57aa","webpack:///./~/promise/lib/core.js?fed0","webpack:///./~/backbone/backbone.js?b8b2","webpack:///(webpack)/buildin/global.js?3698","webpack:///./~/promise/~/asap/browser-raw.js?0985","webpack:///./js/lib/helpers.js?5321","webpack:///./~/promise/index.js?2167","webpack:///./~/promise/lib/done.js?24cc","webpack:///./~/promise/lib/es6-extensions.js?5bdc","webpack:///./~/promise/lib/finally.js?1c58","webpack:///./~/promise/lib/index.js?d0e4","webpack:///./~/promise/lib/node-extensions.js?001f","webpack:///./~/promise/lib/synchronous.js?70fd","webpack:///./~/promise/~/asap/browser-asap.js?9b3f","webpack:///./js/lib/models/search.js","webpack:///./js/lib/views/search-input.js","webpack:///./js/lib/views/search-results.js","webpack:///./js/lib/storage.js","webpack:///./~/js-cookie/src/js.cookie.js","webpack:///./js/templates/search-results-grouped.html","webpack:///./js/templates/search-results-list.html","webpack:///./js/lib/views/overlay.js","webpack:///./js/lib/device.js","webpack:///./js/lib/models/expandable.js","webpack:///./js/components/global-nav.js","webpack:///./js/components/go-to-top.js","webpack:///./js/components/sidebar.js","webpack:///./js/components/social-share-expanding.js","webpack:///./js/lib/attribution.js","webpack:///./js/lib/forms.js","webpack:///./~/console-polyfill/index.js","webpack:///./js/core.js","webpack:///./js/lib/views/search-expander.js","webpack:///./js/templates/go-to-top.html","webpack:///./js/templates/hamburger.html","webpack:///external \"hbspt\""],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","value","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","createReduce","dir","iterator","obj","iteratee","memo","keys","index","length","currentKey","context","optimizeCb","isArrayLike","_","arguments","createPredicateIndexFinder","array","predicate","cb","getLength","createIndexFinder","predicateFind","sortedIndex","item","idx","Math","max","min","slice","isNaN","collectNonEnumProps","nonEnumIdx","nonEnumerableProps","constructor","proto","isFunction","ObjProto","prop","has","contains","push","root","this","previousUnderscore","ArrayProto","Array","FuncProto","Function","toString","nativeIsArray","isArray","nativeKeys","nativeBind","bind","nativeCreate","create","Ctor","_wrapped","VERSION","func","argCount","other","collection","accumulator","apply","identity","isObject","matcher","Infinity","createAssigner","keysFunc","undefinedOnly","source","key","baseCreate","result","MAX_ARRAY_INDEX","pow","each","forEach","map","collect","results","reduce","foldl","inject","reduceRight","foldr","find","detect","findIndex","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","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","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","Int8Array","isFinite","parseFloat","isNumber","isNull","isUndefined","noConflict","constant","noop","propertyOf","matches","accum","Date","getTime","escapeMap","&","<",">","\"","'","`","unescapeMap","createEscaper","escaper","match","join","testRegexp","RegExp","replaceRegexp","string","test","replace","escape","unescape","fallback","idCounter","uniqueId","prefix","id","templateSettings","evaluate","interpolate","noMatch","escapes","\\","\r","\n","
","
","escapeChar","template","text","settings","oldSettings","offset","variable","render","e","data","chain","instance","_chain","mixin","valueOf","toJSON","undefined","$","getThen","then","ex","LAST_ERROR","IS_ERROR","tryCallOne","fn","tryCallTwo","Promise","_40","_65","_55","_72","doResolve","safeThen","onFulfilled","onRejected","resolve","res","handle","Handler","deferred","_37","handleResolved","asap","promise","ret","newValue","finale","_87","done","reason","_61","global","factory","Backbone","previousBackbone","emulateHTTP","emulateJSON","addMethod","attribute","defaultVal","unshift","addUnderscoreMethods","Class","_isModel","modelMatcher","model","attributes","Events","eventSplitter","eventsApi","events","callback","opts","split","on","internalOn","listening","_events","onApi","ctx","_listeners","listenTo","_listenId","listeningTo","_listeningTo","thisId","objId","count","handlers","off","offApi","listeners","stopListening","ids","handler","_callback","onceMap","listenToOnce","offer","trigger","triggerApi","objEvents","allEvents","triggerEvents","ev","a1","a2","a3","unbind","Model","cid","cidPrefix","parse","changed","initialize","validationError","idAttribute","sync","attr","val","_validate","unset","silent","changes","changing","_changing","_previousAttributes","current","prev","_pending","clear","hasChanged","changedAttributes","diff","old","previousAttributes","fetch","success","resp","serverAttrs","wrapError","save","validate","isNew","patch","xhr","destroy","url","base","urlError","encodeURIComponent","isValid","error","Collection","models","comparator","_reset","reset","setOptions","add","remove","merge","addOptions","splice","insert","at","singular","removed","_removeModels","added","merged","toAdd","toMerge","toRemove","modelMap","sortable","sortAttr","existing","_prepareModel","_addReference","orderChanged","_removeReference","previousModels","shift","_byId","modelId","callbackOpts","_onModelEvent","event","prevId","View","viewOptions","_ensureElement","delegateEventSplitter","tagName","selector","$el","_removeElement","setElement","element","undelegateEvents","_setElement","delegateEvents","el","delegate","eventName","listener","undelegate","_createElement","document","createElement","_setAttributes","methodMap","params","dataType","contentType","JSON","stringify","_method","beforeSend","setRequestHeader","processData","textStatus","errorThrown","ajax","update","delete","read","Router","routes","_bindRoutes","optionalParam","namedParam","splatParam","escapeRegExp","route","isRegExp","_routeToRegExp","router","history","fragment","_extractParameters","execute","navigate","optional","exec","param","decodeURIComponent","History","checkUrl","window","location","routeStripper","rootStripper","pathStripper","started","interval","atRoot","pathname","getSearch","matchRoot","decodeFragment","decodeURI","href","getHash","getPath","path","charAt","getFragment","_usePushState","_wantsHashChange","hashChange","_hasHashChange","documentMode","_useHashChange","_wantsPushState","pushState","_hasPushState","rootPath","iframe","src","style","display","tabIndex","body","iWindow","insertBefore","firstChild","contentWindow","open","close","hash","addEventListener","attachEvent","_checkUrlInterval","setInterval","loadUrl","removeEventListener","detachEvent","removeChild","clearInterval","title","_updateHash","protoProps","staticProps","child","parent","__super__","g","eval","rawAsap","task","queue","requestFlush","flushing","flush","currentIndex","capacity","scan","newLength","makeRequestCallFromTimer","handleTimer","timeoutHandle","intervalHandle","scope","BrowserMutationObserver","MutationObserver","WebKitMutationObserver","toggle","observer","node","createTextNode","observe","characterData","getParameterByName","regex","getHashFromCurrentUrl","truncateWords","truncationChars","words","truncateCharacters","substring","toTitleCase","str","txt","toUpperCase","substr","toLowerCase","randomString","possible","scrollTopDistance","pageYOffset","documentElement","scrollTop","toggleScroll","flag","css","whenScrollReached","onScroll","err","valuePromise","TRUE","FALSE","NULL","UNDEFINED","ZERO","EMPTYSTRING","arr","race","f","denodeifyWithCount","argumentCount","callbackFn","denodeifyWithoutCount","fnLength","denodeify","nodeify","enableSynchronous","isPending","getState","isFulfilled","isRejected","getValue","getReason","disableSynchronous","throwFirstError","pendingErrors","rawTask","freeTasks","RawTask","requestErrorThrow","onerror","Search","q","result_types","fields","field_assert_names","field_assert_op","field_assert_value","search_fields","smart_match","limit","groupResultsByType","r","sortGroupedResults","groupedResults","resultPairs","sortOrder","rp","_this","addParamIfSet","isList","default","pendingRequests","SearchInput","keyup input","click .btn-close","min_chars","clearSearchInput","setContainerClass","setQ","evt","currentTarget","keyCode","cancelPendingRequests","pr","abort","clearSearchFull","addClass","removeClass","SearchResultsList","SearchResultsGrouped","_helpers","groupedSearchResultsTpl","listSearchResultsTpl","max_result_groups","max_results_per_group","gr","html","resultGroups","max_items","truncate","_classCallCheck","Constructor","_createClass","defineProperties","target","descriptor","writable","Cookies","Storage","k","getJSON","v","expires","StoredArray","ttl","backend","_state","load","otherArr","combined","top","__WEBPACK_AMD_DEFINE_FACTORY__","registeredInModuleLoader","OldCookies","api","init","converter","setMilliseconds","getMilliseconds","toUTCString","write","stringifiedAttributes","attributeName","cookie","cookies","rdecode","parts","json","withConverter","__t","__p","__j","print","rg","makeOverlay","overlay","Overlay","OverlayView","isOpen","click","closeOverlay","fadeIn","fadeOut","getDeviceClass","sizeMap","windowWidth","innerWidth","mapping","ExpandableModel","isExpanded","_interopRequireDefault","_search","_search2","_searchResults","_searchInput","_searchInput2","_searchExpander","_searchExpander2","_overlay","_overlay2","_device","hamburgerTpl","desktopSearchModel","searchExpander","mobileSearchModel","$nav","$navInner","$navHeader","$dropdownMenus","setMobileMenuMaxHeight","innerHeight","height","setDropdownMenusMaxHeight","DEVICE_CLASS","$hamburgerContainer","GoToTop","isShown","showAt","maybeShow","scroll","GoToTopView","click #go-top","scrollUp","animate","goToTopFactory","preventDefault","show","$button","hasClass","setLandingURL","storage","shouldSetAttributionParams","setLandingTimestamp","_storage","hbspt","renderForm","portalId","formId","onFormReady","onFormReadyWrapped","$form","forms","onFormSubmit","defaultValue","console","con","dummy","properties","_attribution","_forms","_forms2","_goToTop","_goToTop2","log","MM","portal","form","makeSearchExpander","_expandable2","SearchExpander","_expandable","click .expander","click .btn-close-expander","expanded_class","openExpander","closeExpander","focus"],"mappings":"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","file":"core-bef109a214aa0e57ba54.bundle.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/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\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.l = 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// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 81);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;//     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 (true) {\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 (true) {\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {\n      return _;\n    }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n  }\n}.call(this));\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports) {\n\nmodule.exports = $;\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar asap = __webpack_require__(5);\n\nfunction noop() {}\n\n// States:\n//\n// 0 - pending\n// 1 - fulfilled with _value\n// 2 - rejected with _value\n// 3 - adopted the state of another promise, _value\n//\n// once the state is no longer pending (0) it is immutable\n\n// All `_` prefixed properties will be reduced to `_{random number}`\n// at build time to obfuscate them and discourage their use.\n// We don't use symbols or Object.defineProperty to fully hide them\n// because the performance isn't good enough.\n\n\n// to avoid using try/catch inside critical functions, we\n// extract them to here.\nvar LAST_ERROR = null;\nvar IS_ERROR = {};\nfunction getThen(obj) {\n  try {\n    return obj.then;\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\n\nfunction tryCallOne(fn, a) {\n  try {\n    return fn(a);\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\nfunction tryCallTwo(fn, a, b) {\n  try {\n    fn(a, b);\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\n\nmodule.exports = Promise;\n\nfunction Promise(fn) {\n  if (typeof this !== 'object') {\n    throw new TypeError('Promises must be constructed via new');\n  }\n  if (typeof fn !== 'function') {\n    throw new TypeError('Promise constructor\\'s argument is not a function');\n  }\n  this._40 = 0;\n  this._65 = 0;\n  this._55 = null;\n  this._72 = null;\n  if (fn === noop) return;\n  doResolve(fn, this);\n}\nPromise._37 = null;\nPromise._87 = null;\nPromise._61 = noop;\n\nPromise.prototype.then = function(onFulfilled, onRejected) {\n  if (this.constructor !== Promise) {\n    return safeThen(this, onFulfilled, onRejected);\n  }\n  var res = new Promise(noop);\n  handle(this, new Handler(onFulfilled, onRejected, res));\n  return res;\n};\n\nfunction safeThen(self, onFulfilled, onRejected) {\n  return new self.constructor(function (resolve, reject) {\n    var res = new Promise(noop);\n    res.then(resolve, reject);\n    handle(self, new Handler(onFulfilled, onRejected, res));\n  });\n}\nfunction handle(self, deferred) {\n  while (self._65 === 3) {\n    self = self._55;\n  }\n  if (Promise._37) {\n    Promise._37(self);\n  }\n  if (self._65 === 0) {\n    if (self._40 === 0) {\n      self._40 = 1;\n      self._72 = deferred;\n      return;\n    }\n    if (self._40 === 1) {\n      self._40 = 2;\n      self._72 = [self._72, deferred];\n      return;\n    }\n    self._72.push(deferred);\n    return;\n  }\n  handleResolved(self, deferred);\n}\n\nfunction handleResolved(self, deferred) {\n  asap(function() {\n    var cb = self._65 === 1 ? deferred.onFulfilled : deferred.onRejected;\n    if (cb === null) {\n      if (self._65 === 1) {\n        resolve(deferred.promise, self._55);\n      } else {\n        reject(deferred.promise, self._55);\n      }\n      return;\n    }\n    var ret = tryCallOne(cb, self._55);\n    if (ret === IS_ERROR) {\n      reject(deferred.promise, LAST_ERROR);\n    } else {\n      resolve(deferred.promise, ret);\n    }\n  });\n}\nfunction resolve(self, newValue) {\n  // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n  if (newValue === self) {\n    return reject(\n      self,\n      new TypeError('A promise cannot be resolved with itself.')\n    );\n  }\n  if (\n    newValue &&\n    (typeof newValue === 'object' || typeof newValue === 'function')\n  ) {\n    var then = getThen(newValue);\n    if (then === IS_ERROR) {\n      return reject(self, LAST_ERROR);\n    }\n    if (\n      then === self.then &&\n      newValue instanceof Promise\n    ) {\n      self._65 = 3;\n      self._55 = newValue;\n      finale(self);\n      return;\n    } else if (typeof then === 'function') {\n      doResolve(then.bind(newValue), self);\n      return;\n    }\n  }\n  self._65 = 1;\n  self._55 = newValue;\n  finale(self);\n}\n\nfunction reject(self, newValue) {\n  self._65 = 2;\n  self._55 = newValue;\n  if (Promise._87) {\n    Promise._87(self, newValue);\n  }\n  finale(self);\n}\nfunction finale(self) {\n  if (self._40 === 1) {\n    handle(self, self._72);\n    self._72 = null;\n  }\n  if (self._40 === 2) {\n    for (var i = 0; i < self._72.length; i++) {\n      handle(self, self._72[i]);\n    }\n    self._72 = null;\n  }\n}\n\nfunction Handler(onFulfilled, onRejected, promise){\n  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n  this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n  this.promise = promise;\n}\n\n/**\n * Take a potentially misbehaving resolver function and make sure\n * onFulfilled and onRejected are only called once.\n *\n * Makes no guarantees about asynchrony.\n */\nfunction doResolve(fn, promise) {\n  var done = false;\n  var res = tryCallTwo(fn, function (value) {\n    if (done) return;\n    done = true;\n    resolve(promise, value);\n  }, function (reason) {\n    if (done) return;\n    done = true;\n    reject(promise, reason);\n  });\n  if (!done && res === IS_ERROR) {\n    done = true;\n    reject(promise, LAST_ERROR);\n  }\n}\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;//     Backbone.js 1.3.3\n\n//     (c) 2010-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Backbone may be freely distributed under the MIT license.\n//     For all details and documentation:\n//     http://backbonejs.org\n\n(function(factory) {\n\n  // Establish the root object, `window` (`self`) in the browser, or `global` on the server.\n  // We use `self` instead of `window` for `WebWorker` support.\n  var root = (typeof self == 'object' && self.self === self && self) ||\n            (typeof global == 'object' && global.global === global && global);\n\n  // Set up Backbone appropriately for the environment. Start with AMD.\n  if (true) {\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0), __webpack_require__(1), exports], __WEBPACK_AMD_DEFINE_RESULT__ = function(_, $, exports) {\n      // Export global even in AMD case in case this script is loaded with\n      // others that may still expect a global Backbone.\n      root.Backbone = factory(root, exports, _, $);\n    }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n  // Next for Node.js or CommonJS. jQuery may not be needed as a module.\n  } else if (typeof exports !== 'undefined') {\n    var _ = require('underscore'), $;\n    try { $ = require('jquery'); } catch (e) {}\n    factory(root, exports, _, $);\n\n  // Finally, as a browser global.\n  } else {\n    root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));\n  }\n\n})(function(root, Backbone, _, $) {\n\n  // Initial Setup\n  // -------------\n\n  // Save the previous value of the `Backbone` variable, so that it can be\n  // restored later on, if `noConflict` is used.\n  var previousBackbone = root.Backbone;\n\n  // Create a local reference to a common array method we'll want to use later.\n  var slice = Array.prototype.slice;\n\n  // Current version of the library. Keep in sync with `package.json`.\n  Backbone.VERSION = '1.3.3';\n\n  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns\n  // the `$` variable.\n  Backbone.$ = $;\n\n  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable\n  // to its previous owner. Returns a reference to this Backbone object.\n  Backbone.noConflict = function() {\n    root.Backbone = previousBackbone;\n    return this;\n  };\n\n  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option\n  // will fake `\"PATCH\"`, `\"PUT\"` and `\"DELETE\"` requests via the `_method` parameter and\n  // set a `X-Http-Method-Override` header.\n  Backbone.emulateHTTP = false;\n\n  // Turn on `emulateJSON` to support legacy servers that can't deal with direct\n  // `application/json` requests ... this will encode the body as\n  // `application/x-www-form-urlencoded` instead and will send the model in a\n  // form param named `model`.\n  Backbone.emulateJSON = false;\n\n  // Proxy Backbone class methods to Underscore functions, wrapping the model's\n  // `attributes` object or collection's `models` array behind the scenes.\n  //\n  // collection.filter(function(model) { return model.get('age') > 10 });\n  // collection.each(this.addView);\n  //\n  // `Function#apply` can be slow so we use the method's arg count, if we know it.\n  var addMethod = function(length, method, attribute) {\n    switch (length) {\n      case 1: return function() {\n        return _[method](this[attribute]);\n      };\n      case 2: return function(value) {\n        return _[method](this[attribute], value);\n      };\n      case 3: return function(iteratee, context) {\n        return _[method](this[attribute], cb(iteratee, this), context);\n      };\n      case 4: return function(iteratee, defaultVal, context) {\n        return _[method](this[attribute], cb(iteratee, this), defaultVal, context);\n      };\n      default: return function() {\n        var args = slice.call(arguments);\n        args.unshift(this[attribute]);\n        return _[method].apply(_, args);\n      };\n    }\n  };\n  var addUnderscoreMethods = function(Class, methods, attribute) {\n    _.each(methods, function(length, method) {\n      if (_[method]) Class.prototype[method] = addMethod(length, method, attribute);\n    });\n  };\n\n  // Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.\n  var cb = function(iteratee, instance) {\n    if (_.isFunction(iteratee)) return iteratee;\n    if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);\n    if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };\n    return iteratee;\n  };\n  var modelMatcher = function(attrs) {\n    var matcher = _.matches(attrs);\n    return function(model) {\n      return matcher(model.attributes);\n    };\n  };\n\n  // Backbone.Events\n  // ---------------\n\n  // A module that can be mixed in to *any object* in order to provide it with\n  // a custom event channel. You may bind a callback to an event with `on` or\n  // remove with `off`; `trigger`-ing an event fires all callbacks in\n  // succession.\n  //\n  //     var object = {};\n  //     _.extend(object, Backbone.Events);\n  //     object.on('expand', function(){ alert('expanded'); });\n  //     object.trigger('expand');\n  //\n  var Events = Backbone.Events = {};\n\n  // Regular expression used to split event strings.\n  var eventSplitter = /\\s+/;\n\n  // Iterates over the standard `event, callback` (as well as the fancy multiple\n  // space-separated events `\"change blur\", callback` and jQuery-style event\n  // maps `{event: callback}`).\n  var eventsApi = function(iteratee, events, name, callback, opts) {\n    var i = 0, names;\n    if (name && typeof name === 'object') {\n      // Handle event maps.\n      if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback;\n      for (names = _.keys(name); i < names.length ; i++) {\n        events = eventsApi(iteratee, events, names[i], name[names[i]], opts);\n      }\n    } else if (name && eventSplitter.test(name)) {\n      // Handle space-separated event names by delegating them individually.\n      for (names = name.split(eventSplitter); i < names.length; i++) {\n        events = iteratee(events, names[i], callback, opts);\n      }\n    } else {\n      // Finally, standard events.\n      events = iteratee(events, name, callback, opts);\n    }\n    return events;\n  };\n\n  // Bind an event to a `callback` function. Passing `\"all\"` will bind\n  // the callback to all events fired.\n  Events.on = function(name, callback, context) {\n    return internalOn(this, name, callback, context);\n  };\n\n  // Guard the `listening` argument from the public API.\n  var internalOn = function(obj, name, callback, context, listening) {\n    obj._events = eventsApi(onApi, obj._events || {}, name, callback, {\n      context: context,\n      ctx: obj,\n      listening: listening\n    });\n\n    if (listening) {\n      var listeners = obj._listeners || (obj._listeners = {});\n      listeners[listening.id] = listening;\n    }\n\n    return obj;\n  };\n\n  // Inversion-of-control versions of `on`. Tell *this* object to listen to\n  // an event in another object... keeping track of what it's listening to\n  // for easier unbinding later.\n  Events.listenTo = function(obj, name, callback) {\n    if (!obj) return this;\n    var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n    var listeningTo = this._listeningTo || (this._listeningTo = {});\n    var listening = listeningTo[id];\n\n    // This object is not listening to any other events on `obj` yet.\n    // Setup the necessary references to track the listening callbacks.\n    if (!listening) {\n      var thisId = this._listenId || (this._listenId = _.uniqueId('l'));\n      listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningTo: listeningTo, count: 0};\n    }\n\n    // Bind callbacks on obj, and keep track of them on listening.\n    internalOn(obj, name, callback, this, listening);\n    return this;\n  };\n\n  // The reducing API that adds a callback to the `events` object.\n  var onApi = function(events, name, callback, options) {\n    if (callback) {\n      var handlers = events[name] || (events[name] = []);\n      var context = options.context, ctx = options.ctx, listening = options.listening;\n      if (listening) listening.count++;\n\n      handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});\n    }\n    return events;\n  };\n\n  // Remove one or many callbacks. If `context` is null, removes all\n  // callbacks with that function. If `callback` is null, removes all\n  // callbacks for the event. If `name` is null, removes all bound\n  // callbacks for all events.\n  Events.off = function(name, callback, context) {\n    if (!this._events) return this;\n    this._events = eventsApi(offApi, this._events, name, callback, {\n      context: context,\n      listeners: this._listeners\n    });\n    return this;\n  };\n\n  // Tell this object to stop listening to either specific events ... or\n  // to every object it's currently listening to.\n  Events.stopListening = function(obj, name, callback) {\n    var listeningTo = this._listeningTo;\n    if (!listeningTo) return this;\n\n    var ids = obj ? [obj._listenId] : _.keys(listeningTo);\n\n    for (var i = 0; i < ids.length; i++) {\n      var listening = listeningTo[ids[i]];\n\n      // If listening doesn't exist, this object is not currently\n      // listening to obj. Break out early.\n      if (!listening) break;\n\n      listening.obj.off(name, callback, this);\n    }\n\n    return this;\n  };\n\n  // The reducing API that removes a callback from the `events` object.\n  var offApi = function(events, name, callback, options) {\n    if (!events) return;\n\n    var i = 0, listening;\n    var context = options.context, listeners = options.listeners;\n\n    // Delete all events listeners and \"drop\" events.\n    if (!name && !callback && !context) {\n      var ids = _.keys(listeners);\n      for (; i < ids.length; i++) {\n        listening = listeners[ids[i]];\n        delete listeners[listening.id];\n        delete listening.listeningTo[listening.objId];\n      }\n      return;\n    }\n\n    var names = name ? [name] : _.keys(events);\n    for (; i < names.length; i++) {\n      name = names[i];\n      var handlers = events[name];\n\n      // Bail out if there are no events stored.\n      if (!handlers) break;\n\n      // Replace events if there are any remaining.  Otherwise, clean up.\n      var remaining = [];\n      for (var j = 0; j < handlers.length; j++) {\n        var handler = handlers[j];\n        if (\n          callback && callback !== handler.callback &&\n            callback !== handler.callback._callback ||\n              context && context !== handler.context\n        ) {\n          remaining.push(handler);\n        } else {\n          listening = handler.listening;\n          if (listening && --listening.count === 0) {\n            delete listeners[listening.id];\n            delete listening.listeningTo[listening.objId];\n          }\n        }\n      }\n\n      // Update tail event if the list has any events.  Otherwise, clean up.\n      if (remaining.length) {\n        events[name] = remaining;\n      } else {\n        delete events[name];\n      }\n    }\n    return events;\n  };\n\n  // Bind an event to only be triggered a single time. After the first time\n  // the callback is invoked, its listener will be removed. If multiple events\n  // are passed in using the space-separated syntax, the handler will fire\n  // once for each event, not once for a combination of all events.\n  Events.once = function(name, callback, context) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this));\n    if (typeof name === 'string' && context == null) callback = void 0;\n    return this.on(events, callback, context);\n  };\n\n  // Inversion-of-control versions of `once`.\n  Events.listenToOnce = function(obj, name, callback) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListening, this, obj));\n    return this.listenTo(obj, events);\n  };\n\n  // Reduces the event callbacks into a map of `{event: onceWrapper}`.\n  // `offer` unbinds the `onceWrapper` after it has been called.\n  var onceMap = function(map, name, callback, offer) {\n    if (callback) {\n      var once = map[name] = _.once(function() {\n        offer(name, once);\n        callback.apply(this, arguments);\n      });\n      once._callback = callback;\n    }\n    return map;\n  };\n\n  // Trigger one or many events, firing all bound callbacks. Callbacks are\n  // passed the same arguments as `trigger` is, apart from the event name\n  // (unless you're listening on `\"all\"`, which will cause your callback to\n  // receive the true name of the event as the first argument).\n  Events.trigger = function(name) {\n    if (!this._events) return this;\n\n    var length = Math.max(0, arguments.length - 1);\n    var args = Array(length);\n    for (var i = 0; i < length; i++) args[i] = arguments[i + 1];\n\n    eventsApi(triggerApi, this._events, name, void 0, args);\n    return this;\n  };\n\n  // Handles triggering the appropriate event callbacks.\n  var triggerApi = function(objEvents, name, callback, args) {\n    if (objEvents) {\n      var events = objEvents[name];\n      var allEvents = objEvents.all;\n      if (events && allEvents) allEvents = allEvents.slice();\n      if (events) triggerEvents(events, args);\n      if (allEvents) triggerEvents(allEvents, [name].concat(args));\n    }\n    return objEvents;\n  };\n\n  // A difficult-to-believe, but optimized internal dispatch function for\n  // triggering events. Tries to keep the usual cases speedy (most internal\n  // Backbone events have 3 arguments).\n  var triggerEvents = function(events, args) {\n    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\n    switch (args.length) {\n      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\n      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\n      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\n      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\n      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;\n    }\n  };\n\n  // Aliases for backwards compatibility.\n  Events.bind   = Events.on;\n  Events.unbind = Events.off;\n\n  // Allow the `Backbone` object to serve as a global event bus, for folks who\n  // want global \"pubsub\" in a convenient place.\n  _.extend(Backbone, Events);\n\n  // Backbone.Model\n  // --------------\n\n  // Backbone **Models** are the basic data object in the framework --\n  // frequently representing a row in a table in a database on your server.\n  // A discrete chunk of data and a bunch of useful, related methods for\n  // performing computations and transformations on that data.\n\n  // Create a new model with the specified attributes. A client id (`cid`)\n  // is automatically generated and assigned for you.\n  var Model = Backbone.Model = function(attributes, options) {\n    var attrs = attributes || {};\n    options || (options = {});\n    this.cid = _.uniqueId(this.cidPrefix);\n    this.attributes = {};\n    if (options.collection) this.collection = options.collection;\n    if (options.parse) attrs = this.parse(attrs, options) || {};\n    var defaults = _.result(this, 'defaults');\n    attrs = _.defaults(_.extend({}, defaults, attrs), defaults);\n    this.set(attrs, options);\n    this.changed = {};\n    this.initialize.apply(this, arguments);\n  };\n\n  // Attach all inheritable methods to the Model prototype.\n  _.extend(Model.prototype, Events, {\n\n    // A hash of attributes whose current and previous value differ.\n    changed: null,\n\n    // The value returned during the last failed validation.\n    validationError: null,\n\n    // The default name for the JSON `id` attribute is `\"id\"`. MongoDB and\n    // CouchDB users may want to set this to `\"_id\"`.\n    idAttribute: 'id',\n\n    // The prefix is used to create the client id which is used to identify models locally.\n    // You may want to override this if you're experiencing name clashes with model ids.\n    cidPrefix: 'c',\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Return a copy of the model's `attributes` object.\n    toJSON: function(options) {\n      return _.clone(this.attributes);\n    },\n\n    // Proxy `Backbone.sync` by default -- but override this if you need\n    // custom syncing semantics for *this* particular model.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Get the value of an attribute.\n    get: function(attr) {\n      return this.attributes[attr];\n    },\n\n    // Get the HTML-escaped value of an attribute.\n    escape: function(attr) {\n      return _.escape(this.get(attr));\n    },\n\n    // Returns `true` if the attribute contains a value that is not null\n    // or undefined.\n    has: function(attr) {\n      return this.get(attr) != null;\n    },\n\n    // Special-cased proxy to underscore's `_.matches` method.\n    matches: function(attrs) {\n      return !!_.iteratee(attrs, this)(this.attributes);\n    },\n\n    // Set a hash of model attributes on the object, firing `\"change\"`. This is\n    // the core primitive operation of a model, updating the data and notifying\n    // anyone who needs to know about the change in state. The heart of the beast.\n    set: function(key, val, options) {\n      if (key == null) return this;\n\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options || (options = {});\n\n      // Run validation.\n      if (!this._validate(attrs, options)) return false;\n\n      // Extract attributes and options.\n      var unset      = options.unset;\n      var silent     = options.silent;\n      var changes    = [];\n      var changing   = this._changing;\n      this._changing = true;\n\n      if (!changing) {\n        this._previousAttributes = _.clone(this.attributes);\n        this.changed = {};\n      }\n\n      var current = this.attributes;\n      var changed = this.changed;\n      var prev    = this._previousAttributes;\n\n      // For each `set` attribute, update or delete the current value.\n      for (var attr in attrs) {\n        val = attrs[attr];\n        if (!_.isEqual(current[attr], val)) changes.push(attr);\n        if (!_.isEqual(prev[attr], val)) {\n          changed[attr] = val;\n        } else {\n          delete changed[attr];\n        }\n        unset ? delete current[attr] : current[attr] = val;\n      }\n\n      // Update the `id`.\n      if (this.idAttribute in attrs) this.id = this.get(this.idAttribute);\n\n      // Trigger all relevant attribute changes.\n      if (!silent) {\n        if (changes.length) this._pending = options;\n        for (var i = 0; i < changes.length; i++) {\n          this.trigger('change:' + changes[i], this, current[changes[i]], options);\n        }\n      }\n\n      // You might be wondering why there's a `while` loop here. Changes can\n      // be recursively nested within `\"change\"` events.\n      if (changing) return this;\n      if (!silent) {\n        while (this._pending) {\n          options = this._pending;\n          this._pending = false;\n          this.trigger('change', this, options);\n        }\n      }\n      this._pending = false;\n      this._changing = false;\n      return this;\n    },\n\n    // Remove an attribute from the model, firing `\"change\"`. `unset` is a noop\n    // if the attribute doesn't exist.\n    unset: function(attr, options) {\n      return this.set(attr, void 0, _.extend({}, options, {unset: true}));\n    },\n\n    // Clear all attributes on the model, firing `\"change\"`.\n    clear: function(options) {\n      var attrs = {};\n      for (var key in this.attributes) attrs[key] = void 0;\n      return this.set(attrs, _.extend({}, options, {unset: true}));\n    },\n\n    // Determine if the model has changed since the last `\"change\"` event.\n    // If you specify an attribute name, determine if that attribute has changed.\n    hasChanged: function(attr) {\n      if (attr == null) return !_.isEmpty(this.changed);\n      return _.has(this.changed, attr);\n    },\n\n    // Return an object containing all the attributes that have changed, or\n    // false if there are no changed attributes. Useful for determining what\n    // parts of a view need to be updated and/or what attributes need to be\n    // persisted to the server. Unset attributes will be set to undefined.\n    // You can also pass an attributes object to diff against the model,\n    // determining if there *would be* a change.\n    changedAttributes: function(diff) {\n      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;\n      var old = this._changing ? this._previousAttributes : this.attributes;\n      var changed = {};\n      for (var attr in diff) {\n        var val = diff[attr];\n        if (_.isEqual(old[attr], val)) continue;\n        changed[attr] = val;\n      }\n      return _.size(changed) ? changed : false;\n    },\n\n    // Get the previous value of an attribute, recorded at the time the last\n    // `\"change\"` event was fired.\n    previous: function(attr) {\n      if (attr == null || !this._previousAttributes) return null;\n      return this._previousAttributes[attr];\n    },\n\n    // Get all of the attributes of the model at the time of the previous\n    // `\"change\"` event.\n    previousAttributes: function() {\n      return _.clone(this._previousAttributes);\n    },\n\n    // Fetch the model from the server, merging the response with the model's\n    // local attributes. Any changed attributes will trigger a \"change\" event.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var model = this;\n      var success = options.success;\n      options.success = function(resp) {\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (!model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Set a hash of model attributes, and sync the model to the server.\n    // If the server returns an attributes hash that differs, the model's\n    // state will be `set` again.\n    save: function(key, val, options) {\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (key == null || typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options = _.extend({validate: true, parse: true}, options);\n      var wait = options.wait;\n\n      // If we're not waiting and attributes exist, save acts as\n      // `set(attr).save(null, opts)` with validation. Otherwise, check if\n      // the model will be valid when the attributes, if any, are set.\n      if (attrs && !wait) {\n        if (!this.set(attrs, options)) return false;\n      } else if (!this._validate(attrs, options)) {\n        return false;\n      }\n\n      // After a successful server-side save, the client is (optionally)\n      // updated with the server-side state.\n      var model = this;\n      var success = options.success;\n      var attributes = this.attributes;\n      options.success = function(resp) {\n        // Ensure attributes are restored during synchronous saves.\n        model.attributes = attributes;\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (wait) serverAttrs = _.extend({}, attrs, serverAttrs);\n        if (serverAttrs && !model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n\n      // Set temporary attributes if `{wait: true}` to properly find new ids.\n      if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);\n\n      var method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');\n      if (method === 'patch' && !options.attrs) options.attrs = attrs;\n      var xhr = this.sync(method, this, options);\n\n      // Restore attributes.\n      this.attributes = attributes;\n\n      return xhr;\n    },\n\n    // Destroy this model on the server if it was already persisted.\n    // Optimistically removes the model from its collection, if it has one.\n    // If `wait: true` is passed, waits for the server to respond before removal.\n    destroy: function(options) {\n      options = options ? _.clone(options) : {};\n      var model = this;\n      var success = options.success;\n      var wait = options.wait;\n\n      var destroy = function() {\n        model.stopListening();\n        model.trigger('destroy', model, model.collection, options);\n      };\n\n      options.success = function(resp) {\n        if (wait) destroy();\n        if (success) success.call(options.context, model, resp, options);\n        if (!model.isNew()) model.trigger('sync', model, resp, options);\n      };\n\n      var xhr = false;\n      if (this.isNew()) {\n        _.defer(options.success);\n      } else {\n        wrapError(this, options);\n        xhr = this.sync('delete', this, options);\n      }\n      if (!wait) destroy();\n      return xhr;\n    },\n\n    // Default URL for the model's representation on the server -- if you're\n    // using Backbone's restful methods, override this to change the endpoint\n    // that will be called.\n    url: function() {\n      var base =\n        _.result(this, 'urlRoot') ||\n        _.result(this.collection, 'url') ||\n        urlError();\n      if (this.isNew()) return base;\n      var id = this.get(this.idAttribute);\n      return base.replace(/[^\\/]$/, '$&/') + encodeURIComponent(id);\n    },\n\n    // **parse** converts a response into the hash of attributes to be `set` on\n    // the model. The default implementation is just to pass the response along.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new model with identical attributes to this one.\n    clone: function() {\n      return new this.constructor(this.attributes);\n    },\n\n    // A model is new if it has never been saved to the server, and lacks an id.\n    isNew: function() {\n      return !this.has(this.idAttribute);\n    },\n\n    // Check if the model is currently in a valid state.\n    isValid: function(options) {\n      return this._validate({}, _.extend({}, options, {validate: true}));\n    },\n\n    // Run validation against the next complete set of model attributes,\n    // returning `true` if all is well. Otherwise, fire an `\"invalid\"` event.\n    _validate: function(attrs, options) {\n      if (!options.validate || !this.validate) return true;\n      attrs = _.extend({}, this.attributes, attrs);\n      var error = this.validationError = this.validate(attrs, options) || null;\n      if (!error) return true;\n      this.trigger('invalid', this, error, _.extend(options, {validationError: error}));\n      return false;\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Model, mapped to the\n  // number of arguments they take.\n  var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,\n      omit: 0, chain: 1, isEmpty: 1};\n\n  // Mix in each Underscore method as a proxy to `Model#attributes`.\n  addUnderscoreMethods(Model, modelMethods, 'attributes');\n\n  // Backbone.Collection\n  // -------------------\n\n  // If models tend to represent a single row of data, a Backbone Collection is\n  // more analogous to a table full of data ... or a small slice or page of that\n  // table, or a collection of rows that belong together for a particular reason\n  // -- all of the messages in this particular folder, all of the documents\n  // belonging to this particular author, and so on. Collections maintain\n  // indexes of their models, both in order, and for lookup by `id`.\n\n  // Create a new **Collection**, perhaps to contain a specific type of `model`.\n  // If a `comparator` is specified, the Collection will maintain\n  // its models in sort order, as they're added and removed.\n  var Collection = Backbone.Collection = function(models, options) {\n    options || (options = {});\n    if (options.model) this.model = options.model;\n    if (options.comparator !== void 0) this.comparator = options.comparator;\n    this._reset();\n    this.initialize.apply(this, arguments);\n    if (models) this.reset(models, _.extend({silent: true}, options));\n  };\n\n  // Default options for `Collection#set`.\n  var setOptions = {add: true, remove: true, merge: true};\n  var addOptions = {add: true, remove: false};\n\n  // Splices `insert` into `array` at index `at`.\n  var splice = function(array, insert, at) {\n    at = Math.min(Math.max(at, 0), array.length);\n    var tail = Array(array.length - at);\n    var length = insert.length;\n    var i;\n    for (i = 0; i < tail.length; i++) tail[i] = array[i + at];\n    for (i = 0; i < length; i++) array[i + at] = insert[i];\n    for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];\n  };\n\n  // Define the Collection's inheritable methods.\n  _.extend(Collection.prototype, Events, {\n\n    // The default model for a collection is just a **Backbone.Model**.\n    // This should be overridden in most cases.\n    model: Model,\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // The JSON representation of a Collection is an array of the\n    // models' attributes.\n    toJSON: function(options) {\n      return this.map(function(model) { return model.toJSON(options); });\n    },\n\n    // Proxy `Backbone.sync` by default.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Add a model, or list of models to the set. `models` may be Backbone\n    // Models or raw JavaScript objects to be converted to Models, or any\n    // combination of the two.\n    add: function(models, options) {\n      return this.set(models, _.extend({merge: false}, options, addOptions));\n    },\n\n    // Remove a model, or a list of models from the set.\n    remove: function(models, options) {\n      options = _.extend({}, options);\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n      var removed = this._removeModels(models, options);\n      if (!options.silent && removed.length) {\n        options.changes = {added: [], merged: [], removed: removed};\n        this.trigger('update', this, options);\n      }\n      return singular ? removed[0] : removed;\n    },\n\n    // Update a collection by `set`-ing a new list of models, adding new ones,\n    // removing models that are no longer present, and merging models that\n    // already exist in the collection, as necessary. Similar to **Model#set**,\n    // the core operation for updating the data contained by the collection.\n    set: function(models, options) {\n      if (models == null) return;\n\n      options = _.extend({}, setOptions, options);\n      if (options.parse && !this._isModel(models)) {\n        models = this.parse(models, options) || [];\n      }\n\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n\n      var at = options.at;\n      if (at != null) at = +at;\n      if (at > this.length) at = this.length;\n      if (at < 0) at += this.length + 1;\n\n      var set = [];\n      var toAdd = [];\n      var toMerge = [];\n      var toRemove = [];\n      var modelMap = {};\n\n      var add = options.add;\n      var merge = options.merge;\n      var remove = options.remove;\n\n      var sort = false;\n      var sortable = this.comparator && at == null && options.sort !== false;\n      var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n\n      // Turn bare objects into model references, and prevent invalid models\n      // from being added.\n      var model, i;\n      for (i = 0; i < models.length; i++) {\n        model = models[i];\n\n        // If a duplicate is found, prevent it from being added and\n        // optionally merge it into the existing model.\n        var existing = this.get(model);\n        if (existing) {\n          if (merge && model !== existing) {\n            var attrs = this._isModel(model) ? model.attributes : model;\n            if (options.parse) attrs = existing.parse(attrs, options);\n            existing.set(attrs, options);\n            toMerge.push(existing);\n            if (sortable && !sort) sort = existing.hasChanged(sortAttr);\n          }\n          if (!modelMap[existing.cid]) {\n            modelMap[existing.cid] = true;\n            set.push(existing);\n          }\n          models[i] = existing;\n\n        // If this is a new, valid model, push it to the `toAdd` list.\n        } else if (add) {\n          model = models[i] = this._prepareModel(model, options);\n          if (model) {\n            toAdd.push(model);\n            this._addReference(model, options);\n            modelMap[model.cid] = true;\n            set.push(model);\n          }\n        }\n      }\n\n      // Remove stale models.\n      if (remove) {\n        for (i = 0; i < this.length; i++) {\n          model = this.models[i];\n          if (!modelMap[model.cid]) toRemove.push(model);\n        }\n        if (toRemove.length) this._removeModels(toRemove, options);\n      }\n\n      // See if sorting is needed, update `length` and splice in new models.\n      var orderChanged = false;\n      var replace = !sortable && add && remove;\n      if (set.length && replace) {\n        orderChanged = this.length !== set.length || _.some(this.models, function(m, index) {\n          return m !== set[index];\n        });\n        this.models.length = 0;\n        splice(this.models, set, 0);\n        this.length = this.models.length;\n      } else if (toAdd.length) {\n        if (sortable) sort = true;\n        splice(this.models, toAdd, at == null ? this.length : at);\n        this.length = this.models.length;\n      }\n\n      // Silently sort the collection if appropriate.\n      if (sort) this.sort({silent: true});\n\n      // Unless silenced, it's time to fire all appropriate add/sort/update events.\n      if (!options.silent) {\n        for (i = 0; i < toAdd.length; i++) {\n          if (at != null) options.index = at + i;\n          model = toAdd[i];\n          model.trigger('add', model, this, options);\n        }\n        if (sort || orderChanged) this.trigger('sort', this, options);\n        if (toAdd.length || toRemove.length || toMerge.length) {\n          options.changes = {\n            added: toAdd,\n            removed: toRemove,\n            merged: toMerge\n          };\n          this.trigger('update', this, options);\n        }\n      }\n\n      // Return the added (or merged) model (or models).\n      return singular ? models[0] : models;\n    },\n\n    // When you have more items than you want to add or remove individually,\n    // you can reset the entire set with a new list of models, without firing\n    // any granular `add` or `remove` events. Fires `reset` when finished.\n    // Useful for bulk operations and optimizations.\n    reset: function(models, options) {\n      options = options ? _.clone(options) : {};\n      for (var i = 0; i < this.models.length; i++) {\n        this._removeReference(this.models[i], options);\n      }\n      options.previousModels = this.models;\n      this._reset();\n      models = this.add(models, _.extend({silent: true}, options));\n      if (!options.silent) this.trigger('reset', this, options);\n      return models;\n    },\n\n    // Add a model to the end of the collection.\n    push: function(model, options) {\n      return this.add(model, _.extend({at: this.length}, options));\n    },\n\n    // Remove a model from the end of the collection.\n    pop: function(options) {\n      var model = this.at(this.length - 1);\n      return this.remove(model, options);\n    },\n\n    // Add a model to the beginning of the collection.\n    unshift: function(model, options) {\n      return this.add(model, _.extend({at: 0}, options));\n    },\n\n    // Remove a model from the beginning of the collection.\n    shift: function(options) {\n      var model = this.at(0);\n      return this.remove(model, options);\n    },\n\n    // Slice out a sub-array of models from the collection.\n    slice: function() {\n      return slice.apply(this.models, arguments);\n    },\n\n    // Get a model from the set by id, cid, model object with id or cid\n    // properties, or an attributes object that is transformed through modelId.\n    get: function(obj) {\n      if (obj == null) return void 0;\n      return this._byId[obj] ||\n        this._byId[this.modelId(obj.attributes || obj)] ||\n        obj.cid && this._byId[obj.cid];\n    },\n\n    // Returns `true` if the model is in the collection.\n    has: function(obj) {\n      return this.get(obj) != null;\n    },\n\n    // Get the model at the given index.\n    at: function(index) {\n      if (index < 0) index += this.length;\n      return this.models[index];\n    },\n\n    // Return models with matching attributes. Useful for simple cases of\n    // `filter`.\n    where: function(attrs, first) {\n      return this[first ? 'find' : 'filter'](attrs);\n    },\n\n    // Return the first model with matching attributes. Useful for simple cases\n    // of `find`.\n    findWhere: function(attrs) {\n      return this.where(attrs, true);\n    },\n\n    // Force the collection to re-sort itself. You don't need to call this under\n    // normal circumstances, as the set will maintain sort order as each item\n    // is added.\n    sort: function(options) {\n      var comparator = this.comparator;\n      if (!comparator) throw new Error('Cannot sort a set without a comparator');\n      options || (options = {});\n\n      var length = comparator.length;\n      if (_.isFunction(comparator)) comparator = _.bind(comparator, this);\n\n      // Run sort based on type of `comparator`.\n      if (length === 1 || _.isString(comparator)) {\n        this.models = this.sortBy(comparator);\n      } else {\n        this.models.sort(comparator);\n      }\n      if (!options.silent) this.trigger('sort', this, options);\n      return this;\n    },\n\n    // Pluck an attribute from each model in the collection.\n    pluck: function(attr) {\n      return this.map(attr + '');\n    },\n\n    // Fetch the default set of models for this collection, resetting the\n    // collection when they arrive. If `reset: true` is passed, the response\n    // data will be passed through the `reset` method instead of `set`.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var success = options.success;\n      var collection = this;\n      options.success = function(resp) {\n        var method = options.reset ? 'reset' : 'set';\n        collection[method](resp, options);\n        if (success) success.call(options.context, collection, resp, options);\n        collection.trigger('sync', collection, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Create a new instance of a model in this collection. Add the model to the\n    // collection immediately, unless `wait: true` is passed, in which case we\n    // wait for the server to agree.\n    create: function(model, options) {\n      options = options ? _.clone(options) : {};\n      var wait = options.wait;\n      model = this._prepareModel(model, options);\n      if (!model) return false;\n      if (!wait) this.add(model, options);\n      var collection = this;\n      var success = options.success;\n      options.success = function(m, resp, callbackOpts) {\n        if (wait) collection.add(m, callbackOpts);\n        if (success) success.call(callbackOpts.context, m, resp, callbackOpts);\n      };\n      model.save(null, options);\n      return model;\n    },\n\n    // **parse** converts a response into a list of models to be added to the\n    // collection. The default implementation is just to pass it through.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new collection with an identical list of models as this one.\n    clone: function() {\n      return new this.constructor(this.models, {\n        model: this.model,\n        comparator: this.comparator\n      });\n    },\n\n    // Define how to uniquely identify models in the collection.\n    modelId: function(attrs) {\n      return attrs[this.model.prototype.idAttribute || 'id'];\n    },\n\n    // Private method to reset all internal state. Called when the collection\n    // is first initialized or reset.\n    _reset: function() {\n      this.length = 0;\n      this.models = [];\n      this._byId  = {};\n    },\n\n    // Prepare a hash of attributes (or other model) to be added to this\n    // collection.\n    _prepareModel: function(attrs, options) {\n      if (this._isModel(attrs)) {\n        if (!attrs.collection) attrs.collection = this;\n        return attrs;\n      }\n      options = options ? _.clone(options) : {};\n      options.collection = this;\n      var model = new this.model(attrs, options);\n      if (!model.validationError) return model;\n      this.trigger('invalid', this, model.validationError, options);\n      return false;\n    },\n\n    // Internal method called by both remove and set.\n    _removeModels: function(models, options) {\n      var removed = [];\n      for (var i = 0; i < models.length; i++) {\n        var model = this.get(models[i]);\n        if (!model) continue;\n\n        var index = this.indexOf(model);\n        this.models.splice(index, 1);\n        this.length--;\n\n        // Remove references before triggering 'remove' event to prevent an\n        // infinite loop. #3693\n        delete this._byId[model.cid];\n        var id = this.modelId(model.attributes);\n        if (id != null) delete this._byId[id];\n\n        if (!options.silent) {\n          options.index = index;\n          model.trigger('remove', model, this, options);\n        }\n\n        removed.push(model);\n        this._removeReference(model, options);\n      }\n      return removed;\n    },\n\n    // Method for checking whether an object should be considered a model for\n    // the purposes of adding to the collection.\n    _isModel: function(model) {\n      return model instanceof Model;\n    },\n\n    // Internal method to create a model's ties to a collection.\n    _addReference: function(model, options) {\n      this._byId[model.cid] = model;\n      var id = this.modelId(model.attributes);\n      if (id != null) this._byId[id] = model;\n      model.on('all', this._onModelEvent, this);\n    },\n\n    // Internal method to sever a model's ties to a collection.\n    _removeReference: function(model, options) {\n      delete this._byId[model.cid];\n      var id = this.modelId(model.attributes);\n      if (id != null) delete this._byId[id];\n      if (this === model.collection) delete model.collection;\n      model.off('all', this._onModelEvent, this);\n    },\n\n    // Internal method called every time a model in the set fires an event.\n    // Sets need to update their indexes when models change ids. All other\n    // events simply proxy through. \"add\" and \"remove\" events that originate\n    // in other collections are ignored.\n    _onModelEvent: function(event, model, collection, options) {\n      if (model) {\n        if ((event === 'add' || event === 'remove') && collection !== this) return;\n        if (event === 'destroy') this.remove(model, options);\n        if (event === 'change') {\n          var prevId = this.modelId(model.previousAttributes());\n          var id = this.modelId(model.attributes);\n          if (prevId !== id) {\n            if (prevId != null) delete this._byId[prevId];\n            if (id != null) this._byId[id] = model;\n          }\n        }\n      }\n      this.trigger.apply(this, arguments);\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Collection.\n  // 90% of the core usefulness of Backbone Collections is actually implemented\n  // right here:\n  var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,\n      foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3,\n      select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,\n      contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,\n      head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,\n      without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,\n      isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,\n      sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};\n\n  // Mix in each Underscore method as a proxy to `Collection#models`.\n  addUnderscoreMethods(Collection, collectionMethods, 'models');\n\n  // Backbone.View\n  // -------------\n\n  // Backbone Views are almost more convention than they are actual code. A View\n  // is simply a JavaScript object that represents a logical chunk of UI in the\n  // DOM. This might be a single item, an entire list, a sidebar or panel, or\n  // even the surrounding frame which wraps your whole app. Defining a chunk of\n  // UI as a **View** allows you to define your DOM events declaratively, without\n  // having to worry about render order ... and makes it easy for the view to\n  // react to specific changes in the state of your models.\n\n  // Creating a Backbone.View creates its initial element outside of the DOM,\n  // if an existing element is not provided...\n  var View = Backbone.View = function(options) {\n    this.cid = _.uniqueId('view');\n    _.extend(this, _.pick(options, viewOptions));\n    this._ensureElement();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regex to split keys for `delegate`.\n  var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n  // List of view options to be set as properties.\n  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];\n\n  // Set up all inheritable **Backbone.View** properties and methods.\n  _.extend(View.prototype, Events, {\n\n    // The default `tagName` of a View's element is `\"div\"`.\n    tagName: 'div',\n\n    // jQuery delegate for element lookup, scoped to DOM elements within the\n    // current view. This should be preferred to global lookups where possible.\n    $: function(selector) {\n      return this.$el.find(selector);\n    },\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // **render** is the core function that your view should override, in order\n    // to populate its element (`this.el`), with the appropriate HTML. The\n    // convention is for **render** to always return `this`.\n    render: function() {\n      return this;\n    },\n\n    // Remove this view by taking the element out of the DOM, and removing any\n    // applicable Backbone.Events listeners.\n    remove: function() {\n      this._removeElement();\n      this.stopListening();\n      return this;\n    },\n\n    // Remove this view's element from the document and all event listeners\n    // attached to it. Exposed for subclasses using an alternative DOM\n    // manipulation API.\n    _removeElement: function() {\n      this.$el.remove();\n    },\n\n    // Change the view's element (`this.el` property) and re-delegate the\n    // view's events on the new element.\n    setElement: function(element) {\n      this.undelegateEvents();\n      this._setElement(element);\n      this.delegateEvents();\n      return this;\n    },\n\n    // Creates the `this.el` and `this.$el` references for this view using the\n    // given `el`. `el` can be a CSS selector or an HTML string, a jQuery\n    // context or an element. Subclasses can override this to utilize an\n    // alternative DOM manipulation API and are only required to set the\n    // `this.el` property.\n    _setElement: function(el) {\n      this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);\n      this.el = this.$el[0];\n    },\n\n    // Set callbacks, where `this.events` is a hash of\n    //\n    // *{\"event selector\": \"callback\"}*\n    //\n    //     {\n    //       'mousedown .title':  'edit',\n    //       'click .button':     'save',\n    //       'click .open':       function(e) { ... }\n    //     }\n    //\n    // pairs. Callbacks will be bound to the view, with `this` set properly.\n    // Uses event delegation for efficiency.\n    // Omitting the selector binds the event to `this.el`.\n    delegateEvents: function(events) {\n      events || (events = _.result(this, 'events'));\n      if (!events) return this;\n      this.undelegateEvents();\n      for (var key in events) {\n        var method = events[key];\n        if (!_.isFunction(method)) method = this[method];\n        if (!method) continue;\n        var match = key.match(delegateEventSplitter);\n        this.delegate(match[1], match[2], _.bind(method, this));\n      }\n      return this;\n    },\n\n    // Add a single event listener to the view's element (or a child element\n    // using `selector`). This only works for delegate-able events: not `focus`,\n    // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.\n    delegate: function(eventName, selector, listener) {\n      this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Clears all callbacks previously bound to the view by `delegateEvents`.\n    // You usually don't need to use this, but may wish to if you have multiple\n    // Backbone views attached to the same DOM element.\n    undelegateEvents: function() {\n      if (this.$el) this.$el.off('.delegateEvents' + this.cid);\n      return this;\n    },\n\n    // A finer-grained `undelegateEvents` for removing a single delegated event.\n    // `selector` and `listener` are both optional.\n    undelegate: function(eventName, selector, listener) {\n      this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Produces a DOM element to be assigned to your view. Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _createElement: function(tagName) {\n      return document.createElement(tagName);\n    },\n\n    // Ensure that the View has a DOM element to render into.\n    // If `this.el` is a string, pass it through `$()`, take the first\n    // matching element, and re-assign it to `el`. Otherwise, create\n    // an element from the `id`, `className` and `tagName` properties.\n    _ensureElement: function() {\n      if (!this.el) {\n        var attrs = _.extend({}, _.result(this, 'attributes'));\n        if (this.id) attrs.id = _.result(this, 'id');\n        if (this.className) attrs['class'] = _.result(this, 'className');\n        this.setElement(this._createElement(_.result(this, 'tagName')));\n        this._setAttributes(attrs);\n      } else {\n        this.setElement(_.result(this, 'el'));\n      }\n    },\n\n    // Set attributes from a hash on this view's element.  Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _setAttributes: function(attributes) {\n      this.$el.attr(attributes);\n    }\n\n  });\n\n  // Backbone.sync\n  // -------------\n\n  // Override this function to change the manner in which Backbone persists\n  // models to the server. You will be passed the type of request, and the\n  // model in question. By default, makes a RESTful Ajax request\n  // to the model's `url()`. Some possible customizations could be:\n  //\n  // * Use `setTimeout` to batch rapid-fire updates into a single request.\n  // * Send up the models as XML instead of JSON.\n  // * Persist models via WebSockets instead of Ajax.\n  //\n  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests\n  // as `POST`, with a `_method` parameter containing the true HTTP method,\n  // as well as all requests with the body as `application/x-www-form-urlencoded`\n  // instead of `application/json` with the model in a param named `model`.\n  // Useful when interfacing with server-side languages like **PHP** that make\n  // it difficult to read the body of `PUT` requests.\n  Backbone.sync = function(method, model, options) {\n    var type = methodMap[method];\n\n    // Default options, unless specified.\n    _.defaults(options || (options = {}), {\n      emulateHTTP: Backbone.emulateHTTP,\n      emulateJSON: Backbone.emulateJSON\n    });\n\n    // Default JSON-request options.\n    var params = {type: type, dataType: 'json'};\n\n    // Ensure that we have a URL.\n    if (!options.url) {\n      params.url = _.result(model, 'url') || urlError();\n    }\n\n    // Ensure that we have the appropriate request data.\n    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {\n      params.contentType = 'application/json';\n      params.data = JSON.stringify(options.attrs || model.toJSON(options));\n    }\n\n    // For older servers, emulate JSON by encoding the request into an HTML-form.\n    if (options.emulateJSON) {\n      params.contentType = 'application/x-www-form-urlencoded';\n      params.data = params.data ? {model: params.data} : {};\n    }\n\n    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`\n    // And an `X-HTTP-Method-Override` header.\n    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {\n      params.type = 'POST';\n      if (options.emulateJSON) params.data._method = type;\n      var beforeSend = options.beforeSend;\n      options.beforeSend = function(xhr) {\n        xhr.setRequestHeader('X-HTTP-Method-Override', type);\n        if (beforeSend) return beforeSend.apply(this, arguments);\n      };\n    }\n\n    // Don't process data on a non-GET request.\n    if (params.type !== 'GET' && !options.emulateJSON) {\n      params.processData = false;\n    }\n\n    // Pass along `textStatus` and `errorThrown` from jQuery.\n    var error = options.error;\n    options.error = function(xhr, textStatus, errorThrown) {\n      options.textStatus = textStatus;\n      options.errorThrown = errorThrown;\n      if (error) error.call(options.context, xhr, textStatus, errorThrown);\n    };\n\n    // Make the request, allowing the user to override any Ajax options.\n    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));\n    model.trigger('request', model, xhr, options);\n    return xhr;\n  };\n\n  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.\n  var methodMap = {\n    'create': 'POST',\n    'update': 'PUT',\n    'patch': 'PATCH',\n    'delete': 'DELETE',\n    'read': 'GET'\n  };\n\n  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.\n  // Override this if you'd like to use a different library.\n  Backbone.ajax = function() {\n    return Backbone.$.ajax.apply(Backbone.$, arguments);\n  };\n\n  // Backbone.Router\n  // ---------------\n\n  // Routers map faux-URLs to actions, and fire events when routes are\n  // matched. Creating a new one sets its `routes` hash, if not set statically.\n  var Router = Backbone.Router = function(options) {\n    options || (options = {});\n    if (options.routes) this.routes = options.routes;\n    this._bindRoutes();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regular expressions for matching named param parts and splatted\n  // parts of route strings.\n  var optionalParam = /\\((.*?)\\)/g;\n  var namedParam    = /(\\(\\?)?:\\w+/g;\n  var splatParam    = /\\*\\w+/g;\n  var escapeRegExp  = /[\\-{}\\[\\]+?.,\\\\\\^$|#\\s]/g;\n\n  // Set up all inheritable **Backbone.Router** properties and methods.\n  _.extend(Router.prototype, Events, {\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Manually bind a single named route to a callback. For example:\n    //\n    //     this.route('search/:query/p:num', 'search', function(query, num) {\n    //       ...\n    //     });\n    //\n    route: function(route, name, callback) {\n      if (!_.isRegExp(route)) route = this._routeToRegExp(route);\n      if (_.isFunction(name)) {\n        callback = name;\n        name = '';\n      }\n      if (!callback) callback = this[name];\n      var router = this;\n      Backbone.history.route(route, function(fragment) {\n        var args = router._extractParameters(route, fragment);\n        if (router.execute(callback, args, name) !== false) {\n          router.trigger.apply(router, ['route:' + name].concat(args));\n          router.trigger('route', name, args);\n          Backbone.history.trigger('route', router, name, args);\n        }\n      });\n      return this;\n    },\n\n    // Execute a route handler with the provided parameters.  This is an\n    // excellent place to do pre-route setup or post-route cleanup.\n    execute: function(callback, args, name) {\n      if (callback) callback.apply(this, args);\n    },\n\n    // Simple proxy to `Backbone.history` to save a fragment into the history.\n    navigate: function(fragment, options) {\n      Backbone.history.navigate(fragment, options);\n      return this;\n    },\n\n    // Bind all defined routes to `Backbone.history`. We have to reverse the\n    // order of the routes here to support behavior where the most general\n    // routes can be defined at the bottom of the route map.\n    _bindRoutes: function() {\n      if (!this.routes) return;\n      this.routes = _.result(this, 'routes');\n      var route, routes = _.keys(this.routes);\n      while ((route = routes.pop()) != null) {\n        this.route(route, this.routes[route]);\n      }\n    },\n\n    // Convert a route string into a regular expression, suitable for matching\n    // against the current location hash.\n    _routeToRegExp: function(route) {\n      route = route.replace(escapeRegExp, '\\\\$&')\n                   .replace(optionalParam, '(?:$1)?')\n                   .replace(namedParam, function(match, optional) {\n                     return optional ? match : '([^/?]+)';\n                   })\n                   .replace(splatParam, '([^?]*?)');\n      return new RegExp('^' + route + '(?:\\\\?([\\\\s\\\\S]*))?$');\n    },\n\n    // Given a route, and a URL fragment that it matches, return the array of\n    // extracted decoded parameters. Empty or unmatched parameters will be\n    // treated as `null` to normalize cross-browser behavior.\n    _extractParameters: function(route, fragment) {\n      var params = route.exec(fragment).slice(1);\n      return _.map(params, function(param, i) {\n        // Don't decode the search params.\n        if (i === params.length - 1) return param || null;\n        return param ? decodeURIComponent(param) : null;\n      });\n    }\n\n  });\n\n  // Backbone.History\n  // ----------------\n\n  // Handles cross-browser history management, based on either\n  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or\n  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)\n  // and URL fragments. If the browser supports neither (old IE, natch),\n  // falls back to polling.\n  var History = Backbone.History = function() {\n    this.handlers = [];\n    this.checkUrl = _.bind(this.checkUrl, this);\n\n    // Ensure that `History` can be used outside of the browser.\n    if (typeof window !== 'undefined') {\n      this.location = window.location;\n      this.history = window.history;\n    }\n  };\n\n  // Cached regex for stripping a leading hash/slash and trailing space.\n  var routeStripper = /^[#\\/]|\\s+$/g;\n\n  // Cached regex for stripping leading and trailing slashes.\n  var rootStripper = /^\\/+|\\/+$/g;\n\n  // Cached regex for stripping urls of hash.\n  var pathStripper = /#.*$/;\n\n  // Has the history handling already been started?\n  History.started = false;\n\n  // Set up all inheritable **Backbone.History** properties and methods.\n  _.extend(History.prototype, Events, {\n\n    // The default interval to poll for hash changes, if necessary, is\n    // twenty times a second.\n    interval: 50,\n\n    // Are we at the app root?\n    atRoot: function() {\n      var path = this.location.pathname.replace(/[^\\/]$/, '$&/');\n      return path === this.root && !this.getSearch();\n    },\n\n    // Does the pathname match the root?\n    matchRoot: function() {\n      var path = this.decodeFragment(this.location.pathname);\n      var rootPath = path.slice(0, this.root.length - 1) + '/';\n      return rootPath === this.root;\n    },\n\n    // Unicode characters in `location.pathname` are percent encoded so they're\n    // decoded for comparison. `%25` should not be decoded since it may be part\n    // of an encoded parameter.\n    decodeFragment: function(fragment) {\n      return decodeURI(fragment.replace(/%25/g, '%2525'));\n    },\n\n    // In IE6, the hash fragment and search params are incorrect if the\n    // fragment contains `?`.\n    getSearch: function() {\n      var match = this.location.href.replace(/#.*/, '').match(/\\?.+/);\n      return match ? match[0] : '';\n    },\n\n    // Gets the true hash value. Cannot use location.hash directly due to bug\n    // in Firefox where location.hash will always be decoded.\n    getHash: function(window) {\n      var match = (window || this).location.href.match(/#(.*)$/);\n      return match ? match[1] : '';\n    },\n\n    // Get the pathname and search params, without the root.\n    getPath: function() {\n      var path = this.decodeFragment(\n        this.location.pathname + this.getSearch()\n      ).slice(this.root.length - 1);\n      return path.charAt(0) === '/' ? path.slice(1) : path;\n    },\n\n    // Get the cross-browser normalized URL fragment from the path or hash.\n    getFragment: function(fragment) {\n      if (fragment == null) {\n        if (this._usePushState || !this._wantsHashChange) {\n          fragment = this.getPath();\n        } else {\n          fragment = this.getHash();\n        }\n      }\n      return fragment.replace(routeStripper, '');\n    },\n\n    // Start the hash change handling, returning `true` if the current URL matches\n    // an existing route, and `false` otherwise.\n    start: function(options) {\n      if (History.started) throw new Error('Backbone.history has already been started');\n      History.started = true;\n\n      // Figure out the initial configuration. Do we need an iframe?\n      // Is pushState desired ... is it available?\n      this.options          = _.extend({root: '/'}, this.options, options);\n      this.root             = this.options.root;\n      this._wantsHashChange = this.options.hashChange !== false;\n      this._hasHashChange   = 'onhashchange' in window && (document.documentMode === void 0 || document.documentMode > 7);\n      this._useHashChange   = this._wantsHashChange && this._hasHashChange;\n      this._wantsPushState  = !!this.options.pushState;\n      this._hasPushState    = !!(this.history && this.history.pushState);\n      this._usePushState    = this._wantsPushState && this._hasPushState;\n      this.fragment         = this.getFragment();\n\n      // Normalize root to always include a leading and trailing slash.\n      this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n      // Transition from hashChange to pushState or vice versa if both are\n      // requested.\n      if (this._wantsHashChange && this._wantsPushState) {\n\n        // If we've started off with a route from a `pushState`-enabled\n        // browser, but we're currently in a browser that doesn't support it...\n        if (!this._hasPushState && !this.atRoot()) {\n          var rootPath = this.root.slice(0, -1) || '/';\n          this.location.replace(rootPath + '#' + this.getPath());\n          // Return immediately as browser will do redirect to new url\n          return true;\n\n        // Or if we've started out with a hash-based route, but we're currently\n        // in a browser where it could be `pushState`-based instead...\n        } else if (this._hasPushState && this.atRoot()) {\n          this.navigate(this.getHash(), {replace: true});\n        }\n\n      }\n\n      // Proxy an iframe to handle location events if the browser doesn't\n      // support the `hashchange` event, HTML5 history, or the user wants\n      // `hashChange` but not `pushState`.\n      if (!this._hasHashChange && this._wantsHashChange && !this._usePushState) {\n        this.iframe = document.createElement('iframe');\n        this.iframe.src = 'javascript:0';\n        this.iframe.style.display = 'none';\n        this.iframe.tabIndex = -1;\n        var body = document.body;\n        // Using `appendChild` will throw on IE < 9 if the document is not ready.\n        var iWindow = body.insertBefore(this.iframe, body.firstChild).contentWindow;\n        iWindow.document.open();\n        iWindow.document.close();\n        iWindow.location.hash = '#' + this.fragment;\n      }\n\n      // Add a cross-platform `addEventListener` shim for older browsers.\n      var addEventListener = window.addEventListener || function(eventName, listener) {\n        return attachEvent('on' + eventName, listener);\n      };\n\n      // Depending on whether we're using pushState or hashes, and whether\n      // 'onhashchange' is supported, determine how we check the URL state.\n      if (this._usePushState) {\n        addEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        addEventListener('hashchange', this.checkUrl, false);\n      } else if (this._wantsHashChange) {\n        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);\n      }\n\n      if (!this.options.silent) return this.loadUrl();\n    },\n\n    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,\n    // but possibly useful for unit testing Routers.\n    stop: function() {\n      // Add a cross-platform `removeEventListener` shim for older browsers.\n      var removeEventListener = window.removeEventListener || function(eventName, listener) {\n        return detachEvent('on' + eventName, listener);\n      };\n\n      // Remove window listeners.\n      if (this._usePushState) {\n        removeEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        removeEventListener('hashchange', this.checkUrl, false);\n      }\n\n      // Clean up the iframe if necessary.\n      if (this.iframe) {\n        document.body.removeChild(this.iframe);\n        this.iframe = null;\n      }\n\n      // Some environments will throw when clearing an undefined interval.\n      if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);\n      History.started = false;\n    },\n\n    // Add a route to be tested when the fragment changes. Routes added later\n    // may override previous routes.\n    route: function(route, callback) {\n      this.handlers.unshift({route: route, callback: callback});\n    },\n\n    // Checks the current URL to see if it has changed, and if it has,\n    // calls `loadUrl`, normalizing across the hidden iframe.\n    checkUrl: function(e) {\n      var current = this.getFragment();\n\n      // If the user pressed the back button, the iframe's hash will have\n      // changed and we should use that for comparison.\n      if (current === this.fragment && this.iframe) {\n        current = this.getHash(this.iframe.contentWindow);\n      }\n\n      if (current === this.fragment) return false;\n      if (this.iframe) this.navigate(current);\n      this.loadUrl();\n    },\n\n    // Attempt to load the current URL fragment. If a route succeeds with a\n    // match, returns `true`. If no defined routes matches the fragment,\n    // returns `false`.\n    loadUrl: function(fragment) {\n      // If the root doesn't match, no routes can match either.\n      if (!this.matchRoot()) return false;\n      fragment = this.fragment = this.getFragment(fragment);\n      return _.some(this.handlers, function(handler) {\n        if (handler.route.test(fragment)) {\n          handler.callback(fragment);\n          return true;\n        }\n      });\n    },\n\n    // Save a fragment into the hash history, or replace the URL state if the\n    // 'replace' option is passed. You are responsible for properly URL-encoding\n    // the fragment in advance.\n    //\n    // The options object can contain `trigger: true` if you wish to have the\n    // route callback be fired (not usually desirable), or `replace: true`, if\n    // you wish to modify the current URL without adding an entry to the history.\n    navigate: function(fragment, options) {\n      if (!History.started) return false;\n      if (!options || options === true) options = {trigger: !!options};\n\n      // Normalize the fragment.\n      fragment = this.getFragment(fragment || '');\n\n      // Don't include a trailing slash on the root.\n      var rootPath = this.root;\n      if (fragment === '' || fragment.charAt(0) === '?') {\n        rootPath = rootPath.slice(0, -1) || '/';\n      }\n      var url = rootPath + fragment;\n\n      // Strip the hash and decode for matching.\n      fragment = this.decodeFragment(fragment.replace(pathStripper, ''));\n\n      if (this.fragment === fragment) return;\n      this.fragment = fragment;\n\n      // If pushState is available, we use it to set the fragment as a real URL.\n      if (this._usePushState) {\n        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);\n\n      // If hash changes haven't been explicitly disabled, update the hash\n      // fragment to store history.\n      } else if (this._wantsHashChange) {\n        this._updateHash(this.location, fragment, options.replace);\n        if (this.iframe && fragment !== this.getHash(this.iframe.contentWindow)) {\n          var iWindow = this.iframe.contentWindow;\n\n          // Opening and closing the iframe tricks IE7 and earlier to push a\n          // history entry on hash-tag change.  When replace is true, we don't\n          // want this.\n          if (!options.replace) {\n            iWindow.document.open();\n            iWindow.document.close();\n          }\n\n          this._updateHash(iWindow.location, fragment, options.replace);\n        }\n\n      // If you've told us that you explicitly don't want fallback hashchange-\n      // based history, then `navigate` becomes a page refresh.\n      } else {\n        return this.location.assign(url);\n      }\n      if (options.trigger) return this.loadUrl(fragment);\n    },\n\n    // Update the hash location, either replacing the current entry, or adding\n    // a new one to the browser history.\n    _updateHash: function(location, fragment, replace) {\n      if (replace) {\n        var href = location.href.replace(/(javascript:|#).*$/, '');\n        location.replace(href + '#' + fragment);\n      } else {\n        // Some browsers require that `hash` contains a leading #.\n        location.hash = '#' + fragment;\n      }\n    }\n\n  });\n\n  // Create the default Backbone.history.\n  Backbone.history = new History;\n\n  // Helpers\n  // -------\n\n  // Helper function to correctly set up the prototype chain for subclasses.\n  // Similar to `goog.inherits`, but uses a hash of prototype properties and\n  // class properties to be extended.\n  var extend = function(protoProps, staticProps) {\n    var parent = this;\n    var child;\n\n    // The constructor function for the new subclass is either defined by you\n    // (the \"constructor\" property in your `extend` definition), or defaulted\n    // by us to simply call the parent constructor.\n    if (protoProps && _.has(protoProps, 'constructor')) {\n      child = protoProps.constructor;\n    } else {\n      child = function(){ return parent.apply(this, arguments); };\n    }\n\n    // Add static properties to the constructor function, if supplied.\n    _.extend(child, parent, staticProps);\n\n    // Set the prototype chain to inherit from `parent`, without calling\n    // `parent`'s constructor function and add the prototype properties.\n    child.prototype = _.create(parent.prototype, protoProps);\n    child.prototype.constructor = child;\n\n    // Set a convenience property in case the parent's prototype is needed\n    // later.\n    child.__super__ = parent.prototype;\n\n    return child;\n  };\n\n  // Set up inheritance for the model, collection, router, view and history.\n  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;\n\n  // Throw an error when a URL is needed, and none is supplied.\n  var urlError = function() {\n    throw new Error('A \"url\" property or function must be specified');\n  };\n\n  // Wrap an optional error callback with a fallback error event.\n  var wrapError = function(model, options) {\n    var error = options.error;\n    options.error = function(resp) {\n      if (error) error.call(options.context, model, resp, options);\n      model.trigger('error', model, resp, options);\n    };\n  };\n\n  return Backbone;\n});\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\nvar g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n\n// Use the fastest means possible to execute a task in its own turn, with\n// priority over other events including IO, animation, reflow, and redraw\n// events in browsers.\n//\n// An exception thrown by a task will permanently interrupt the processing of\n// subsequent tasks. The higher level `asap` function ensures that if an\n// exception is thrown by a task, that the task queue will continue flushing as\n// soon as possible, but if you use `rawAsap` directly, you are responsible to\n// either ensure that no exceptions are thrown from your task, or to manually\n// call `rawAsap.requestFlush` if an exception is thrown.\nmodule.exports = rawAsap;\nfunction rawAsap(task) {\n    if (!queue.length) {\n        requestFlush();\n        flushing = true;\n    }\n    // Equivalent to push, but avoids a function call.\n    queue[queue.length] = task;\n}\n\nvar queue = [];\n// Once a flush has been requested, no further calls to `requestFlush` are\n// necessary until the next `flush` completes.\nvar flushing = false;\n// `requestFlush` is an implementation-specific method that attempts to kick\n// off a `flush` event as quickly as possible. `flush` will attempt to exhaust\n// the event queue before yielding to the browser's own event loop.\nvar requestFlush;\n// The position of the next task to execute in the task queue. This is\n// preserved between calls to `flush` so that it can be resumed if\n// a task throws an exception.\nvar index = 0;\n// If a task schedules additional tasks recursively, the task queue can grow\n// unbounded. To prevent memory exhaustion, the task queue will periodically\n// truncate already-completed tasks.\nvar capacity = 1024;\n\n// The flush function processes all tasks that have been scheduled with\n// `rawAsap` unless and until one of those tasks throws an exception.\n// If a task throws an exception, `flush` ensures that its state will remain\n// consistent and will resume where it left off when called again.\n// However, `flush` does not make any arrangements to be called again if an\n// exception is thrown.\nfunction flush() {\n    while (index < queue.length) {\n        var currentIndex = index;\n        // Advance the index before calling the task. This ensures that we will\n        // begin flushing on the next task the task throws an error.\n        index = index + 1;\n        queue[currentIndex].call();\n        // Prevent leaking memory for long chains of recursive calls to `asap`.\n        // If we call `asap` within tasks scheduled by `asap`, the queue will\n        // grow, but to avoid an O(n) walk for every task we execute, we don't\n        // shift tasks off the queue after they have been executed.\n        // Instead, we periodically shift 1024 tasks off the queue.\n        if (index > capacity) {\n            // Manually shift all values starting at the index back to the\n            // beginning of the queue.\n            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {\n                queue[scan] = queue[scan + index];\n            }\n            queue.length -= index;\n            index = 0;\n        }\n    }\n    queue.length = 0;\n    index = 0;\n    flushing = false;\n}\n\n// `requestFlush` is implemented using a strategy based on data collected from\n// every available SauceLabs Selenium web driver worker at time of writing.\n// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593\n\n// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that\n// have WebKitMutationObserver but not un-prefixed MutationObserver.\n// Must use `global` or `self` instead of `window` to work in both frames and web\n// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.\n\n/* globals self */\nvar scope = typeof global !== \"undefined\" ? global : self;\nvar BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;\n\n// MutationObservers are desirable because they have high priority and work\n// reliably everywhere they are implemented.\n// They are implemented in all modern browsers.\n//\n// - Android 4-4.3\n// - Chrome 26-34\n// - Firefox 14-29\n// - Internet Explorer 11\n// - iPad Safari 6-7.1\n// - iPhone Safari 7-7.1\n// - Safari 6-7\nif (typeof BrowserMutationObserver === \"function\") {\n    requestFlush = makeRequestCallFromMutationObserver(flush);\n\n// MessageChannels are desirable because they give direct access to the HTML\n// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera\n// 11-12, and in web workers in many engines.\n// Although message channels yield to any queued rendering and IO tasks, they\n// would be better than imposing the 4ms delay of timers.\n// However, they do not work reliably in Internet Explorer or Safari.\n\n// Internet Explorer 10 is the only browser that has setImmediate but does\n// not have MutationObservers.\n// Although setImmediate yields to the browser's renderer, it would be\n// preferrable to falling back to setTimeout since it does not have\n// the minimum 4ms penalty.\n// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and\n// Desktop to a lesser extent) that renders both setImmediate and\n// MessageChannel useless for the purposes of ASAP.\n// https://github.com/kriskowal/q/issues/396\n\n// Timers are implemented universally.\n// We fall back to timers in workers in most engines, and in foreground\n// contexts in the following browsers.\n// However, note that even this simple case requires nuances to operate in a\n// broad spectrum of browsers.\n//\n// - Firefox 3-13\n// - Internet Explorer 6-9\n// - iPad Safari 4.3\n// - Lynx 2.8.7\n} else {\n    requestFlush = makeRequestCallFromTimer(flush);\n}\n\n// `requestFlush` requests that the high priority event queue be flushed as\n// soon as possible.\n// This is useful to prevent an error thrown in a task from stalling the event\n// queue if the exception handled by Node.js’s\n// `process.on(\"uncaughtException\")` or by a domain.\nrawAsap.requestFlush = requestFlush;\n\n// To request a high priority event, we induce a mutation observer by toggling\n// the text of a text node between \"1\" and \"-1\".\nfunction makeRequestCallFromMutationObserver(callback) {\n    var toggle = 1;\n    var observer = new BrowserMutationObserver(callback);\n    var node = document.createTextNode(\"\");\n    observer.observe(node, {characterData: true});\n    return function requestCall() {\n        toggle = -toggle;\n        node.data = toggle;\n    };\n}\n\n// The message channel technique was discovered by Malte Ubl and was the\n// original foundation for this library.\n// http://www.nonblocking.io/2011/06/windownexttick.html\n\n// Safari 6.0.5 (at least) intermittently fails to create message ports on a\n// page's first load. Thankfully, this version of Safari supports\n// MutationObservers, so we don't need to fall back in that case.\n\n// function makeRequestCallFromMessageChannel(callback) {\n//     var channel = new MessageChannel();\n//     channel.port1.onmessage = callback;\n//     return function requestCall() {\n//         channel.port2.postMessage(0);\n//     };\n// }\n\n// For reasons explained above, we are also unable to use `setImmediate`\n// under any circumstances.\n// Even if we were, there is another bug in Internet Explorer 10.\n// It is not sufficient to assign `setImmediate` to `requestFlush` because\n// `setImmediate` must be called *by name* and therefore must be wrapped in a\n// closure.\n// Never forget.\n\n// function makeRequestCallFromSetImmediate(callback) {\n//     return function requestCall() {\n//         setImmediate(callback);\n//     };\n// }\n\n// Safari 6.0 has a problem where timers will get lost while the user is\n// scrolling. This problem does not impact ASAP because Safari 6.0 supports\n// mutation observers, so that implementation is used instead.\n// However, if we ever elect to use timers in Safari, the prevalent work-around\n// is to add a scroll event listener that calls for a flush.\n\n// `setTimeout` does not call the passed callback if the delay is less than\n// approximately 7 in web workers in Firefox 8 through 18, and sometimes not\n// even then.\n\nfunction makeRequestCallFromTimer(callback) {\n    return function requestCall() {\n        // We dispatch a timeout with a specified delay of 0 for engines that\n        // can reliably accommodate that request. This will usually be snapped\n        // to a 4 milisecond delay, but once we're flushing, there's no delay\n        // between events.\n        var timeoutHandle = setTimeout(handleTimer, 0);\n        // However, since this timer gets frequently dropped in Firefox\n        // workers, we enlist an interval handle that will try to fire\n        // an event 20 times per second until it succeeds.\n        var intervalHandle = setInterval(handleTimer, 50);\n\n        function handleTimer() {\n            // Whichever timer succeeds will cancel both timers and\n            // execute the callback.\n            clearTimeout(timeoutHandle);\n            clearInterval(intervalHandle);\n            callback();\n        }\n    };\n}\n\n// This is for `asap.js` only.\n// Its name will be periodically randomized to break any code that depends on\n// its existence.\nrawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;\n\n// ASAP was originally a nextTick shim included in Q. This was factored out\n// into this ASAP package. It was later adapted to RSVP which made further\n// amendments. These decisions, particularly to marginalize MessageChannel and\n// to capture the MutationObserver implementation in a closure, were integrated\n// back into ASAP proper.\n// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function($, _) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.getParameterByName = getParameterByName;\nexports.getHashFromCurrentUrl = getHashFromCurrentUrl;\nexports.truncateWords = truncateWords;\nexports.truncateCharacters = truncateCharacters;\nexports.toTitleCase = toTitleCase;\nexports.randomString = randomString;\nexports.scrollTopDistance = scrollTopDistance;\nexports.toggleScroll = toggleScroll;\nexports.whenScrollReached = whenScrollReached;\nvar Promise = __webpack_require__(7);\n\n// http://stackoverflow.com/questions/901115/how-can-i-get-query-string-values-in-javascript\nfunction getParameterByName(name, url) {\n    if (!url) url = window.location.href;\n    name = name.replace(/[\\[\\]]/g, '\\\\$&');\n    var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),\n        results = regex.exec(url);\n\n    if (!results) return null;\n    if (!results[2]) return '';\n\n    return decodeURIComponent(results[2].replace(/\\+/g, ' '));\n}\n\n/**\n * get the current value of the hash in the URL - if it exists\n * @return @{String}\n */\nfunction getHashFromCurrentUrl() {\n    return window.location.hash ? window.location.hash.replace('#', '') : null;\n}\n\n/**\n * truncate the given string after `n` words\n * @param s\n * @param n\n * @param truncationChars @{String} the value to append to the truncated value (if truncation occurs)\n */\nfunction truncateWords(s, n) {\n    var truncationChars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '...';\n\n    var words = s.split(' ');\n\n    if (words.length <= n) {\n        return s;\n    }\n\n    var truncated = words.slice(0, n).join(' ');\n    return truncated + truncationChars;\n}\n\n/**\n * truncate the given string after `n` characters\n * @param s\n * @param n\n * @param truncationChars\n */\nfunction truncateCharacters(s, n) {\n    var truncationChars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '...';\n\n    if (s.length <= n) {\n        return s;\n    }\n\n    return s.substring(0, n) + truncationChars;\n}\n\nfunction toTitleCase(str) {\n    return str.replace(/\\w\\S*/g, function (txt) {\n        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();\n    });\n}\n\n/**\n * generate a random string of size n (wripped from https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript)\n * @param n\n * @returns {string}\n */\nfunction randomString() {\n    var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;\n\n    var text = '';\n    var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n    for (var i = 0; i < n; i++) {\n        text += possible.charAt(Math.floor(Math.random() * possible.length));\n    }return text;\n}\n\n/**\n * browsers handle calculating the scroll distance from the top of the page differently. This method reconciles the different\n * ways browsers handle getting this value and returns the distance scrolled from the top:\n *\n * https://stackoverflow.com/questions/28633221/document-body-scrolltop-firefox-returns-0-only-js\n *\n * @returns {Number|number}\n */\nfunction scrollTopDistance() {\n    return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;\n}\n\n/**\n * toggle the ability to scroll in the page\n * @param flag {Boolean}\n */\nfunction toggleScroll(flag) {\n    $('html,body').css('overflow-y', flag ? 'auto' : 'hidden');\n}\n\n/**\n * listen for the window being scrolled to the given `limit` pixels down.\n * @param offset {Number} offset - in pixels - to reach\n * @return {Promise} resolving when the given offset is reached\n */\nfunction whenScrollReached() {\n    var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;\n\n    return new Promise(function (resolve, reject) {\n        var onScroll = _.throttle(function () {\n            if (scrollTopDistance() >= offset) {\n                window.removeEventListener('scroll', onScroll);\n                resolve();\n            }\n        }, 100);\n\n        window.addEventListener('scroll', onScroll);\n    });\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1), __webpack_require__(0)))\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(11)\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Promise = __webpack_require__(2);\n\nmodule.exports = Promise;\nPromise.prototype.done = function (onFulfilled, onRejected) {\n  var self = arguments.length ? this.then.apply(this, arguments) : this;\n  self.then(null, function (err) {\n    setTimeout(function () {\n      throw err;\n    }, 0);\n  });\n};\n\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n//This file contains the ES6 extensions to the core Promises/A+ API\n\nvar Promise = __webpack_require__(2);\n\nmodule.exports = Promise;\n\n/* Static Functions */\n\nvar TRUE = valuePromise(true);\nvar FALSE = valuePromise(false);\nvar NULL = valuePromise(null);\nvar UNDEFINED = valuePromise(undefined);\nvar ZERO = valuePromise(0);\nvar EMPTYSTRING = valuePromise('');\n\nfunction valuePromise(value) {\n  var p = new Promise(Promise._61);\n  p._65 = 1;\n  p._55 = value;\n  return p;\n}\nPromise.resolve = function (value) {\n  if (value instanceof Promise) return value;\n\n  if (value === null) return NULL;\n  if (value === undefined) return UNDEFINED;\n  if (value === true) return TRUE;\n  if (value === false) return FALSE;\n  if (value === 0) return ZERO;\n  if (value === '') return EMPTYSTRING;\n\n  if (typeof value === 'object' || typeof value === 'function') {\n    try {\n      var then = value.then;\n      if (typeof then === 'function') {\n        return new Promise(then.bind(value));\n      }\n    } catch (ex) {\n      return new Promise(function (resolve, reject) {\n        reject(ex);\n      });\n    }\n  }\n  return valuePromise(value);\n};\n\nPromise.all = function (arr) {\n  var args = Array.prototype.slice.call(arr);\n\n  return new Promise(function (resolve, reject) {\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n    function res(i, val) {\n      if (val && (typeof val === 'object' || typeof val === 'function')) {\n        if (val instanceof Promise && val.then === Promise.prototype.then) {\n          while (val._65 === 3) {\n            val = val._55;\n          }\n          if (val._65 === 1) return res(i, val._55);\n          if (val._65 === 2) reject(val._55);\n          val.then(function (val) {\n            res(i, val);\n          }, reject);\n          return;\n        } else {\n          var then = val.then;\n          if (typeof then === 'function') {\n            var p = new Promise(then.bind(val));\n            p.then(function (val) {\n              res(i, val);\n            }, reject);\n            return;\n          }\n        }\n      }\n      args[i] = val;\n      if (--remaining === 0) {\n        resolve(args);\n      }\n    }\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n};\n\nPromise.reject = function (value) {\n  return new Promise(function (resolve, reject) {\n    reject(value);\n  });\n};\n\nPromise.race = function (values) {\n  return new Promise(function (resolve, reject) {\n    values.forEach(function(value){\n      Promise.resolve(value).then(resolve, reject);\n    });\n  });\n};\n\n/* Prototype Methods */\n\nPromise.prototype['catch'] = function (onRejected) {\n  return this.then(null, onRejected);\n};\n\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Promise = __webpack_require__(2);\n\nmodule.exports = Promise;\nPromise.prototype['finally'] = function (f) {\n  return this.then(function (value) {\n    return Promise.resolve(f()).then(function () {\n      return value;\n    });\n  }, function (err) {\n    return Promise.resolve(f()).then(function () {\n      throw err;\n    });\n  });\n};\n\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(2);\n__webpack_require__(8);\n__webpack_require__(10);\n__webpack_require__(9);\n__webpack_require__(12);\n__webpack_require__(13);\n\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// This file contains then/promise specific extensions that are only useful\n// for node.js interop\n\nvar Promise = __webpack_require__(2);\nvar asap = __webpack_require__(14);\n\nmodule.exports = Promise;\n\n/* Static Functions */\n\nPromise.denodeify = function (fn, argumentCount) {\n  if (\n    typeof argumentCount === 'number' && argumentCount !== Infinity\n  ) {\n    return denodeifyWithCount(fn, argumentCount);\n  } else {\n    return denodeifyWithoutCount(fn);\n  }\n};\n\nvar callbackFn = (\n  'function (err, res) {' +\n  'if (err) { rj(err); } else { rs(res); }' +\n  '}'\n);\nfunction denodeifyWithCount(fn, argumentCount) {\n  var args = [];\n  for (var i = 0; i < argumentCount; i++) {\n    args.push('a' + i);\n  }\n  var body = [\n    'return function (' + args.join(',') + ') {',\n    'var self = this;',\n    'return new Promise(function (rs, rj) {',\n    'var res = fn.call(',\n    ['self'].concat(args).concat([callbackFn]).join(','),\n    ');',\n    'if (res &&',\n    '(typeof res === \"object\" || typeof res === \"function\") &&',\n    'typeof res.then === \"function\"',\n    ') {rs(res);}',\n    '});',\n    '};'\n  ].join('');\n  return Function(['Promise', 'fn'], body)(Promise, fn);\n}\nfunction denodeifyWithoutCount(fn) {\n  var fnLength = Math.max(fn.length - 1, 3);\n  var args = [];\n  for (var i = 0; i < fnLength; i++) {\n    args.push('a' + i);\n  }\n  var body = [\n    'return function (' + args.join(',') + ') {',\n    'var self = this;',\n    'var args;',\n    'var argLength = arguments.length;',\n    'if (arguments.length > ' + fnLength + ') {',\n    'args = new Array(arguments.length + 1);',\n    'for (var i = 0; i < arguments.length; i++) {',\n    'args[i] = arguments[i];',\n    '}',\n    '}',\n    'return new Promise(function (rs, rj) {',\n    'var cb = ' + callbackFn + ';',\n    'var res;',\n    'switch (argLength) {',\n    args.concat(['extra']).map(function (_, index) {\n      return (\n        'case ' + (index) + ':' +\n        'res = fn.call(' + ['self'].concat(args.slice(0, index)).concat('cb').join(',') + ');' +\n        'break;'\n      );\n    }).join(''),\n    'default:',\n    'args[argLength] = cb;',\n    'res = fn.apply(self, args);',\n    '}',\n    \n    'if (res &&',\n    '(typeof res === \"object\" || typeof res === \"function\") &&',\n    'typeof res.then === \"function\"',\n    ') {rs(res);}',\n    '});',\n    '};'\n  ].join('');\n\n  return Function(\n    ['Promise', 'fn'],\n    body\n  )(Promise, fn);\n}\n\nPromise.nodeify = function (fn) {\n  return function () {\n    var args = Array.prototype.slice.call(arguments);\n    var callback =\n      typeof args[args.length - 1] === 'function' ? args.pop() : null;\n    var ctx = this;\n    try {\n      return fn.apply(this, arguments).nodeify(callback, ctx);\n    } catch (ex) {\n      if (callback === null || typeof callback == 'undefined') {\n        return new Promise(function (resolve, reject) {\n          reject(ex);\n        });\n      } else {\n        asap(function () {\n          callback.call(ctx, ex);\n        })\n      }\n    }\n  }\n};\n\nPromise.prototype.nodeify = function (callback, ctx) {\n  if (typeof callback != 'function') return this;\n\n  this.then(function (value) {\n    asap(function () {\n      callback.call(ctx, null, value);\n    });\n  }, function (err) {\n    asap(function () {\n      callback.call(ctx, err);\n    });\n  });\n};\n\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Promise = __webpack_require__(2);\n\nmodule.exports = Promise;\nPromise.enableSynchronous = function () {\n  Promise.prototype.isPending = function() {\n    return this.getState() == 0;\n  };\n\n  Promise.prototype.isFulfilled = function() {\n    return this.getState() == 1;\n  };\n\n  Promise.prototype.isRejected = function() {\n    return this.getState() == 2;\n  };\n\n  Promise.prototype.getValue = function () {\n    if (this._65 === 3) {\n      return this._55.getValue();\n    }\n\n    if (!this.isFulfilled()) {\n      throw new Error('Cannot get a value of an unfulfilled promise.');\n    }\n\n    return this._55;\n  };\n\n  Promise.prototype.getReason = function () {\n    if (this._65 === 3) {\n      return this._55.getReason();\n    }\n\n    if (!this.isRejected()) {\n      throw new Error('Cannot get a rejection reason of a non-rejected promise.');\n    }\n\n    return this._55;\n  };\n\n  Promise.prototype.getState = function () {\n    if (this._65 === 3) {\n      return this._55.getState();\n    }\n    if (this._65 === -1 || this._65 === -2) {\n      return 0;\n    }\n\n    return this._65;\n  };\n};\n\nPromise.disableSynchronous = function() {\n  Promise.prototype.isPending = undefined;\n  Promise.prototype.isFulfilled = undefined;\n  Promise.prototype.isRejected = undefined;\n  Promise.prototype.getValue = undefined;\n  Promise.prototype.getReason = undefined;\n  Promise.prototype.getState = undefined;\n};\n\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// rawAsap provides everything we need except exception management.\nvar rawAsap = __webpack_require__(5);\n// RawTasks are recycled to reduce GC churn.\nvar freeTasks = [];\n// We queue errors to ensure they are thrown in right order (FIFO).\n// Array-as-queue is good enough here, since we are just dealing with exceptions.\nvar pendingErrors = [];\nvar requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);\n\nfunction throwFirstError() {\n    if (pendingErrors.length) {\n        throw pendingErrors.shift();\n    }\n}\n\n/**\n * Calls a task as soon as possible after returning, in its own event, with priority\n * over other events like animation, reflow, and repaint. An error thrown from an\n * event will not interrupt, nor even substantially slow down the processing of\n * other events, but will be rather postponed to a lower priority event.\n * @param {{call}} task A callable object, typically a function that takes no\n * arguments.\n */\nmodule.exports = asap;\nfunction asap(task) {\n    var rawTask;\n    if (freeTasks.length) {\n        rawTask = freeTasks.pop();\n    } else {\n        rawTask = new RawTask();\n    }\n    rawTask.task = task;\n    rawAsap(rawTask);\n}\n\n// We wrap tasks with recyclable task objects.  A task object implements\n// `call`, just like a function.\nfunction RawTask() {\n    this.task = null;\n}\n\n// The sole purpose of wrapping the task is to catch the exception and recycle\n// the task object after its single use.\nRawTask.prototype.call = function () {\n    try {\n        this.task.call();\n    } catch (error) {\n        if (asap.onerror) {\n            // This hook exists purely for testing purposes.\n            // Its name will be periodically randomized to break any code that\n            // depends on its existence.\n            asap.onerror(error);\n        } else {\n            // In a web browser, exceptions are not fatal. However, to avoid\n            // slowing down the queue of pending tasks, we rethrow the error in a\n            // lower priority turn.\n            pendingErrors.push(error);\n            requestErrorThrow();\n        }\n    } finally {\n        this.task = null;\n        freeTasks[freeTasks.length] = this;\n    }\n};\n\n\n/***/ }),\n/* 15 */,\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone, _, $) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nvar Search = Backbone.Model.extend({\n    defaults: {\n        q: null,\n        result_types: [], // limit results returned to only a given list of types\n        fields: ['title', 'permalink'], // limit what fields are retrieved from the API\n        field_assert_names: [], // specify assertions about objects to be returned, based on the contents of their fields\n        field_assert_op: null, // the assertion to make about `field_assert_names` (one of 'contains', 'excludes', or 'empty')\n        field_assert_value: null, // the value to check against the assertion parameterized by `field_assert_names` and `field_assert_op`\n        search_fields: [], // specify which fields should be searched for the query given by `q`\n        smart_match: false, // if true, then we want to apply a potentially more accurate (but more time intensive) search.\n        location: [], // a lat/lng pair (<latitude>,<longitude>) to geoweight results by\n        limit: 10, // max number of results to return\n        fallback: null, // a string describing the fallback action to take when a query yields no results (possible values are: 'all-results')\n        results: []\n    },\n\n    parse: function parse(attrs) {\n        attrs['results'] = attrs['data'];\n        return attrs;\n    },\n\n\n    /**\n     * generate an object which groups results by their type (i.e Attorneys, Practice Areas, etc.)\n     * @returns {{}}\n     */\n    groupResultsByType: function groupResultsByType() {\n        return _.groupBy(this.get('results'), function (r) {\n            return r.type;\n        });\n    },\n\n\n    /**\n     * sort our grouped results in descending order, by importance of result types\n     * @param groupedResults {Object}\n     * @return {Array} of {Array} of result type -> results\n     */\n    sortGroupedResults: function sortGroupedResults(groupedResults) {\n        var resultPairs = _.pairs(groupedResults);\n        var sortOrder = ['Practice Area', 'Class Action', 'Attorney', 'Location', 'Article', 'FAQ'];\n\n        return _.sortBy(resultPairs, function (rp) {\n            return sortOrder.indexOf(rp[0]);\n        });\n    },\n    reset: function reset() {\n        this.set({ q: null, results: [] });\n        this.trigger('reset');\n    },\n    url: function url() {\n        var _this = this;\n\n        var params = {\n            q: this.get('q')\n        };\n\n        var addParamIfSet = function addParamIfSet(name) {\n            var isList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n            var isSet = isList ? _this.get(name).length > 0 : _this.get(name);\n            if (isSet) {\n                params[name] = isList ? _this.get(name).join(',') : _this.get(name);\n            }\n        };\n\n        addParamIfSet('result_types', true);\n        addParamIfSet('fields', true);\n        addParamIfSet('search_fields', true);\n        addParamIfSet('field_assert_names', true);\n        addParamIfSet('field_assert_op');\n        addParamIfSet('field_assert_value');\n        addParamIfSet('smart_match');\n        addParamIfSet('location', true);\n        addParamIfSet('fallback');\n\n        return '//search.forthepeople.com?' + $.param(params);\n    }\n});\n\nexports.default = Search;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(1)))\n\n/***/ }),\n/* 17 */,\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone, _, $) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nvar pendingRequests = [];\n\nvar SearchInput = Backbone.View.extend({\n    events: {\n        'keyup input': 'setQ',\n        'click .btn-close': 'clearSearchFull'\n    },\n\n    initialize: function initialize(opts) {\n        this.options = {\n            min_chars: 3\n        };\n\n        _.extend(this.options, opts || {});\n\n        this.model.on('reset', this.clearSearchInput, this);\n        this.model.on('change:results', this.setContainerClass, this);\n    },\n    setQ: function setQ(evt) {\n        var ENTER = 13;\n        var q = $(evt.currentTarget).val();\n\n        // if the user hit the enter key, redirect to search results page\n        if (evt.keyCode === ENTER) {\n            var params = {\n                q: q\n            };\n\n            if (this.model.get('result_types').length) {\n                params['type'] = this.model.get('result_types').join(',');\n            }\n\n            window.location = '/search/?' + $.param(params);\n            return;\n        }\n\n        this.model.set({ q: q });\n\n        // cancel any pending requests\n        this.cancelPendingRequests();\n\n        if (q.length >= this.options.min_chars) {\n            pendingRequests.push(this.model.fetch());\n        } else {\n            this.model.set({ results: [] });\n        }\n    },\n    cancelPendingRequests: function cancelPendingRequests() {\n        pendingRequests.map(function (pr) {\n            return pr.abort();\n        });\n        pendingRequests = [];\n    },\n    clearSearchInput: function clearSearchInput() {\n        this.$el.find('input').val('');\n    },\n    clearSearchFull: function clearSearchFull() {\n        this.model.reset();\n    },\n    setContainerClass: function setContainerClass() {\n        this.model.get('results').length ? this.$el.addClass('has-results') : this.$el.removeClass('has-results');\n    }\n});\n\nexports.default = SearchInput;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(1)))\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone, _) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.SearchResultsList = exports.SearchResultsGrouped = undefined;\n\nvar _helpers = __webpack_require__(6);\n\nvar groupedSearchResultsTpl = __webpack_require__(23);\nvar listSearchResultsTpl = __webpack_require__(24);\nvar SearchResultsGrouped = exports.SearchResultsGrouped = Backbone.View.extend({\n    template: groupedSearchResultsTpl,\n\n    initialize: function initialize(opts) {\n        this.options = {\n            max_result_groups: 3,\n            max_results_per_group: 3\n        };\n\n        _.extend(this.options, opts || {});\n\n        this.model.on('change:results', this.render, this);\n    },\n    render: function render() {\n        var _this = this;\n\n        // group the results by result type, then show the top MAX_RESULT_GROUPS result types\n        var groupedResults = this.model.sortGroupedResults(this.model.groupResultsByType()).slice(0, this.options.max_result_groups);\n        groupedResults.forEach(function (gr) {\n            gr[1] = gr[1].slice(0, _this.options.max_results_per_group);\n        });\n\n        this.$el.html(this.template({\n            resultGroups: groupedResults\n        }));\n\n        groupedResults.length > 0 ? this.$el.addClass('open') : this.$el.removeClass('open');\n    }\n});\n\nvar SearchResultsList = exports.SearchResultsList = Backbone.View.extend({\n    template: listSearchResultsTpl,\n\n    initialize: function initialize(opts) {\n        this.options = {\n            max_items: 6\n        };\n\n        _.extend(this.options, opts || {});\n\n        this.model.on('change:results', this.render, this);\n    },\n    render: function render() {\n        var results = this.model.get('results').slice(0, this.options.max_items);\n\n        this.$el.html(this.template({\n            results: results,\n            truncate: _helpers.truncateWords\n        }));\n\n        results.length > 0 ? this.$el.addClass('open') : this.$el.removeClass('open');\n    }\n});\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0)))\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(_) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/** an abstraction around client-side storage, whether thats localStorage, Cookies, or Firebase, doesnt matter **/\nvar Cookies = __webpack_require__(22);\n\nvar Storage = function () {\n    function Storage() {\n        _classCallCheck(this, Storage);\n    }\n\n    _createClass(Storage, [{\n        key: 'get',\n        value: function get(k) {\n            var asJSON = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n            return asJSON ? Cookies.getJSON(k) : Cookies.get(k);\n        }\n    }, {\n        key: 'set',\n        value: function set(k, v) {\n            var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : { expires: 7 };\n\n            Cookies.set(k, v, options);\n        }\n    }]);\n\n    return Storage;\n}();\n\n// a storage-backed array. Meaning, the state of the array is backed by storage and persisted\n\n\nvar StoredArray = function () {\n    function StoredArray(props) {\n        _classCallCheck(this, StoredArray);\n\n        var options = {\n            key: null,\n            ttl: 2\n        };\n\n        _.extend(options, props);\n\n        this.key = options.key; // the unique identifier for this stored array (used for saving / loading from storage)\n        this.ttl = options.ttl; // the time to persist this array for (in days)\n        this.backend = new Storage();\n\n        this._state = this.load();\n    }\n\n    /** save the current state of the array **/\n\n\n    _createClass(StoredArray, [{\n        key: 'save',\n        value: function save() {\n            this.backend.set(this.key, JSON.stringify(this._state), { expires: this.ttl });\n        }\n    }, {\n        key: 'load',\n        value: function load() {\n            return this.backend.get(this.key, true) || [];\n        }\n    }, {\n        key: 'concat',\n        value: function concat(otherArr) {\n            var combined = this._state.concat(otherArr);\n            this.save();\n\n            return combined;\n        }\n    }, {\n        key: 'push',\n        value: function push(el) {\n            this._state.push(el);\n            this.save();\n        }\n    }, {\n        key: 'pop',\n        value: function pop() {\n            var top = this._state.pop();\n            this.save();\n\n            return top;\n        }\n    }]);\n\n    return StoredArray;\n}();\n\nexports.Storage = Storage;\nexports.StoredArray = StoredArray;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))\n\n/***/ }),\n/* 21 */,\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n * JavaScript Cookie v2.1.4\n * https://github.com/js-cookie/js-cookie\n *\n * Copyright 2006, 2015 Klaus Hartl & Fagner Brack\n * Released under the MIT license\n */\n;(function (factory) {\n\tvar registeredInModuleLoader = false;\n\tif (true) {\n\t\t!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :\n\t\t\t\t__WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (true) {\n\t\tmodule.exports = factory();\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (!registeredInModuleLoader) {\n\t\tvar OldCookies = window.Cookies;\n\t\tvar api = window.Cookies = factory();\n\t\tapi.noConflict = function () {\n\t\t\twindow.Cookies = OldCookies;\n\t\t\treturn api;\n\t\t};\n\t}\n}(function () {\n\tfunction extend () {\n\t\tvar i = 0;\n\t\tvar result = {};\n\t\tfor (; i < arguments.length; i++) {\n\t\t\tvar attributes = arguments[ i ];\n\t\t\tfor (var key in attributes) {\n\t\t\t\tresult[key] = attributes[key];\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\n\tfunction init (converter) {\n\t\tfunction api (key, value, attributes) {\n\t\t\tvar result;\n\t\t\tif (typeof document === 'undefined') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Write\n\n\t\t\tif (arguments.length > 1) {\n\t\t\t\tattributes = extend({\n\t\t\t\t\tpath: '/'\n\t\t\t\t}, api.defaults, attributes);\n\n\t\t\t\tif (typeof attributes.expires === 'number') {\n\t\t\t\t\tvar expires = new Date();\n\t\t\t\t\texpires.setMilliseconds(expires.getMilliseconds() + attributes.expires * 864e+5);\n\t\t\t\t\tattributes.expires = expires;\n\t\t\t\t}\n\n\t\t\t\t// We're using \"expires\" because \"max-age\" is not supported by IE\n\t\t\t\tattributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';\n\n\t\t\t\ttry {\n\t\t\t\t\tresult = JSON.stringify(value);\n\t\t\t\t\tif (/^[\\{\\[]/.test(result)) {\n\t\t\t\t\t\tvalue = result;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\n\t\t\t\tif (!converter.write) {\n\t\t\t\t\tvalue = encodeURIComponent(String(value))\n\t\t\t\t\t\t.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);\n\t\t\t\t} else {\n\t\t\t\t\tvalue = converter.write(value, key);\n\t\t\t\t}\n\n\t\t\t\tkey = encodeURIComponent(String(key));\n\t\t\t\tkey = key.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent);\n\t\t\t\tkey = key.replace(/[\\(\\)]/g, escape);\n\n\t\t\t\tvar stringifiedAttributes = '';\n\n\t\t\t\tfor (var attributeName in attributes) {\n\t\t\t\t\tif (!attributes[attributeName]) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '; ' + attributeName;\n\t\t\t\t\tif (attributes[attributeName] === true) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '=' + attributes[attributeName];\n\t\t\t\t}\n\t\t\t\treturn (document.cookie = key + '=' + value + stringifiedAttributes);\n\t\t\t}\n\n\t\t\t// Read\n\n\t\t\tif (!key) {\n\t\t\t\tresult = {};\n\t\t\t}\n\n\t\t\t// To prevent the for loop in the first place assign an empty array\n\t\t\t// in case there are no cookies at all. Also prevents odd result when\n\t\t\t// calling \"get()\"\n\t\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\t\t\tvar rdecode = /(%[0-9A-Z]{2})+/g;\n\t\t\tvar i = 0;\n\n\t\t\tfor (; i < cookies.length; i++) {\n\t\t\t\tvar parts = cookies[i].split('=');\n\t\t\t\tvar cookie = parts.slice(1).join('=');\n\n\t\t\t\tif (cookie.charAt(0) === '\"') {\n\t\t\t\t\tcookie = cookie.slice(1, -1);\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tvar name = parts[0].replace(rdecode, decodeURIComponent);\n\t\t\t\t\tcookie = converter.read ?\n\t\t\t\t\t\tconverter.read(cookie, name) : converter(cookie, name) ||\n\t\t\t\t\t\tcookie.replace(rdecode, decodeURIComponent);\n\n\t\t\t\t\tif (this.json) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tcookie = JSON.parse(cookie);\n\t\t\t\t\t\t} catch (e) {}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (key === name) {\n\t\t\t\t\t\tresult = cookie;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (!key) {\n\t\t\t\t\t\tresult[name] = cookie;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\t\t\t}\n\n\t\t\treturn result;\n\t\t}\n\n\t\tapi.set = api;\n\t\tapi.get = function (key) {\n\t\t\treturn api.call(api, key);\n\t\t};\n\t\tapi.getJSON = function () {\n\t\t\treturn api.apply({\n\t\t\t\tjson: true\n\t\t\t}, [].slice.call(arguments));\n\t\t};\n\t\tapi.defaults = {};\n\n\t\tapi.remove = function (key, attributes) {\n\t\t\tapi(key, '', extend(attributes, {\n\t\t\t\texpires: -1\n\t\t\t}));\n\t\t};\n\n\t\tapi.withConverter = init;\n\n\t\treturn api;\n\t}\n\n\treturn init(function () {});\n}));\n\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(_) {module.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/search-results-grouped.html -->\\n';\n _.each(resultGroups, function(rg) { \n__p+='\\n<div class=\"result-container\">\\n  <h3>'+\n((__t=( rg[0] ))==null?'':__t)+\n'</h3>\\n  <ul>\\n    ';\n _.each(rg[1], function(result) { \n__p+='\\n    <li>\\n      <a href=\"'+\n((__t=( result.permalink ))==null?'':__t)+\n'\">'+\n((__t=( result.title ))==null?'':__t)+\n'</a>\\n    </li>\\n    ';\n }) \n__p+='\\n  </ul>\\n</div>\\n';\n }) \n__p+='\\n';\n}\nreturn __p;\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(_) {module.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/search-results-list.html -->\\n';\n _.each(results, function(r) { \n__p+='\\n<li class=\"result-container\">\\n    <a href=\"'+\n((__t=( r.permalink ))==null?'':__t)+\n'\">\\n        <h3>'+\n((__t=( r.title ))==null?'':__t)+\n'</h3>\\n    </a>\\n</li>\\n';\n }) \n__p+='';\n}\nreturn __p;\n};\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))\n\n/***/ }),\n/* 25 */,\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.default = makeOverlay;\nvar Overlay = Backbone.Model.extend({\n    defaults: {\n        isOpen: false\n    }\n});\n\nvar OverlayView = Backbone.View.extend({\n    events: {\n        'click': 'closeOverlay'\n    },\n\n    initialize: function initialize() {\n        this.model.on('change:isOpen', this.render, this);\n    },\n    closeOverlay: function closeOverlay() {\n        this.model.set({ isOpen: false });\n    },\n    render: function render() {\n        this.model.get('isOpen') ? this.$el.fadeIn() : this.$el.fadeOut();\n    }\n});\n\nfunction makeOverlay() {\n    var overlay = new Overlay();\n\n    new OverlayView({\n        el: '.desktop-search-overlay',\n        model: overlay\n    });\n\n    return overlay;\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))\n\n/***/ }),\n/* 27 */,\n/* 28 */,\n/* 29 */,\n/* 30 */,\n/* 31 */,\n/* 32 */,\n/* 33 */,\n/* 34 */,\n/* 35 */,\n/* 36 */,\n/* 37 */,\n/* 38 */,\n/* 39 */,\n/* 40 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n/**\n * semi-naively categorize the form factor of the user's device as one of (phone, tablet, desktop)\n * @return @{String} the form factor class\n */\nvar getDeviceClass = function getDeviceClass() {\n    var sizeMap = [['phoneSm', 480], ['phoneLg', 768], ['tablet', 992], ['desktop', Infinity]];\n    var windowWidth = window.innerWidth;\n\n    return sizeMap.filter(function (mapping) {\n        if (windowWidth <= mapping[1]) {\n            return mapping[0];\n        }\n    })[0][0];\n};\n\nexports.getDeviceClass = getDeviceClass;\n\n/***/ }),\n/* 41 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nvar ExpandableModel = Backbone.Model.extend({\n    defaults: {\n        isExpanded: false\n    }\n});\n\nexports.default = ExpandableModel;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3)))\n\n/***/ }),\n/* 42 */,\n/* 43 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function($, _) {\n\nvar _search = __webpack_require__(16);\n\nvar _search2 = _interopRequireDefault(_search);\n\nvar _searchResults = __webpack_require__(19);\n\nvar _searchInput = __webpack_require__(18);\n\nvar _searchInput2 = _interopRequireDefault(_searchInput);\n\nvar _searchExpander = __webpack_require__(83);\n\nvar _searchExpander2 = _interopRequireDefault(_searchExpander);\n\nvar _overlay = __webpack_require__(26);\n\nvar _overlay2 = _interopRequireDefault(_overlay);\n\nvar _helpers = __webpack_require__(6);\n\nvar _device = __webpack_require__(40);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar hamburgerTpl = __webpack_require__(119);\n\n/**-- Desktop --**/\nvar desktopSearchModel = new _search2.default({\n    fields: ['title', 'permalink', 'type']\n});\n\nvar searchExpander = (0, _searchExpander2.default)('.nav-search.desktop');\n\nnew _searchInput2.default({\n    model: desktopSearchModel,\n    el: '.nav-search.desktop .input-container'\n});\n\nnew _searchResults.SearchResultsGrouped({\n    model: desktopSearchModel,\n    el: '.nav-search.desktop .results-container'\n});\n\nvar overlay = (0, _overlay2.default)();\n\n// when the overlay closes, reset the search model\noverlay.on('change:isOpen', function () {\n    return !overlay.get('isOpen') && searchExpander.set({ isExpanded: false });\n});\n\n// when a query is present or the expander is open, show the overlay\ndesktopSearchModel.on('change:q', function () {\n    return overlay.set({ isOpen: desktopSearchModel.get('q') || searchExpander.get('isExpanded') });\n});\n\n// when the search expander is 'X'd out of, reset the search results\nsearchExpander.on('change:isExpanded', function () {\n    return (0, _helpers.toggleScroll)(!searchExpander.get('isExpanded')) || !searchExpander.get('isExpanded') && desktopSearchModel.reset();\n});\n\n/**-- Mobile --**/\nvar mobileSearchModel = new _search2.default({\n    fields: ['title', 'permalink', 'type']\n});\n\nnew _searchInput2.default({\n    model: mobileSearchModel,\n    el: '.nav-search.mobile .input-container'\n});\n\nnew _searchResults.SearchResultsGrouped({\n    model: mobileSearchModel,\n    el: '.nav-search.mobile .results-container'\n});\n\nvar $nav = $('.navbar');\nvar $navInner = $nav.find('.navbar-collapse');\nvar $navHeader = $nav.find('.navbar-header');\nvar $dropdownMenus = $nav.find('.dropdown .dropdown-menu');\n\n/**-- Set The Max-Height Of The Expanded Menu For Mobile --**/\nvar setMobileMenuMaxHeight = function setMobileMenuMaxHeight() {\n    return $navInner.css('max-height', window.innerHeight - $navHeader.height());\n};\n\n/**-- Set The Max-Height Of The Dropdown Menu's for Desktop ONLY --**/\nvar setDropdownMenusMaxHeight = function setDropdownMenusMaxHeight() {\n    return $dropdownMenus.each(function () {\n        var DEVICE_CLASS = (0, _device.getDeviceClass)();\n        (DEVICE_CLASS === 'tablet' || DEVICE_CLASS === 'desktop') && $(this).css('max-height', window.innerHeight - $navInner.height());\n    });\n};\n\n$(window).on('resize', _.debounce(_.compose(setMobileMenuMaxHeight, setDropdownMenusMaxHeight), 300));\nsetMobileMenuMaxHeight();\nsetDropdownMenusMaxHeight();\n\n/**-- Set The Appearance of the Hamburger Depending on Open Vs. Close --**/\n(function bindHamburgerToggle($nav, $hamburgerContainer) {\n    $nav.on('shown.bs.collapse', function () {\n        return (0, _helpers.toggleScroll)(false) || $hamburgerContainer.html(hamburgerTpl({ isExpanded: true }));\n    });\n    $nav.on('hidden.bs.collapse', function () {\n        return (0, _helpers.toggleScroll)(true) || $hamburgerContainer.html(hamburgerTpl({ isExpanded: false }));\n    });\n})($nav, $nav.find('.navbar-header button'));\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1), __webpack_require__(0)))\n\n/***/ }),\n/* 44 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone, $, _) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nvar template = __webpack_require__(118);\n\nvar GoToTop = Backbone.Model.extend({\n    defaults: {\n        isShown: false,\n        showAt: 50\n    },\n\n    maybeShow: function maybeShow() {\n        var scrollTop = $(window).scrollTop();\n        this.set({ isShown: scrollTop >= this.get('showAt') });\n    },\n    initialize: function initialize() {\n        $(window).scroll(_.throttle(this.maybeShow.bind(this), 100));\n    }\n});\n\nvar GoToTopView = Backbone.View.extend({\n    template: template,\n    events: {\n        'click #go-top': 'scrollUp'\n    },\n\n    initialize: function initialize() {\n        this.$el.html(this.template());\n        this.model.on('change:isShown', this.render, this);\n    },\n    scrollUp: function scrollUp(evt) {\n        $('html, body').animate({\n            scrollTop: $($(evt.currentTarget).attr('href')).offset().top\n        });\n    },\n    render: function render() {\n        this.model.get('isShown') ? this.$el.addClass('show') : this.$el.removeClass('show');\n    }\n});\n\nvar goToTopFactory = function goToTopFactory(el, opts) {\n    var model = new GoToTop(opts || {});\n\n    return new GoToTopView({\n        el: el,\n        model: model\n    });\n};\n\nexports.default = goToTopFactory;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(1), __webpack_require__(0)))\n\n/***/ }),\n/* 45 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function($) {\n\n$('#more-related-articles').on('click', function (event) {\n    event.preventDefault();\n    event.currentTarget.remove();\n    $('.related-articles ul li').show().css('text-align', 'left');\n});\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))\n\n/***/ }),\n/* 46 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function($) {\n\n$('.social-share-expanding .more').on('click', function (event) {\n    var $button = $(event.currentTarget);\n    if ($button.hasClass('plus')) {\n        $button.removeClass('plus');\n        $button.find('img.plus').addClass('hidden');\n        $button.find('img.minus').removeClass('hidden');\n    } else {\n        $button.addClass('plus');\n        $button.find('img.plus').removeClass('hidden');\n        $button.find('img.minus').addClass('hidden');\n    }\n});\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))\n\n/***/ }),\n/* 47 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function($) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.setLandingURL = setLandingURL;\nexports.setLandingTimestamp = setLandingTimestamp;\n\nvar _storage = __webpack_require__(20);\n\nvar storage = new _storage.Storage();\nvar shouldSetAttributionParams = function shouldSetAttributionParams() {\n    return !/thank-you/.test(document.location.href);\n};\n\n/**\n * set the sessions landing page URL\n */\nfunction setLandingURL() {\n    if (storage.get('MMLandingURL') && shouldSetAttributionParams()) {\n        return;\n    }\n\n    storage.set('MMLandingURL', document.location.href, { expires: 30 });\n}\n\n/**\n * set the sessions landing timestamp\n */\nfunction setLandingTimestamp() {\n    document.addEventListener('DOMContentLoaded', function (event) {\n        if (storage.get('MMLandingTimestamp') && shouldSetAttributionParams()) {\n            return;\n        }\n\n        storage.set('MMLandingTimestamp', $('meta[name=request-timestamp]').attr('content'), { expires: 30 });\n    });\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))\n\n/***/ }),\n/* 48 */,\n/* 49 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function($) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _storage = __webpack_require__(20);\n\nvar hbspt = __webpack_require__(122);\n\n\nvar storage = new _storage.Storage();\n\nvar renderForm = function renderForm(portalId, formId, target) {\n    var onFormReady = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {\n        return null;\n    };\n\n    var onFormReadyWrapped = function onFormReadyWrapped($form) {\n        $form.find('input[name=\"tracked_landing_page\"]').val(storage.get('MMLandingURL'));\n        $form.find('input[name=\"tracked_landing_timestamp\"]').val(storage.get('MMLandingTimestamp'));\n\n        onFormReady($form);\n    };\n\n    hbspt.forms.create({\n        portalId: portalId,\n        formId: formId,\n        target: target,\n        onFormReady: onFormReadyWrapped,\n        onFormSubmit: function onFormSubmit($form) {\n            storage.remove('MMLandingURL');\n            storage.remove('MMLandingTimestamp');\n\n            $form.find('input, textarea').each(function () {\n                var el = $(undefined).get(0);\n\n                $(undefined).val($(undefined).val().replace(/\\n|\\r/g, ' '));\n                el.defaultValue = el.defaultValue.replace(/\\n|\\r/g, ' ');\n            });\n        }\n    });\n};\n\nexports.default = renderForm;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))\n\n/***/ }),\n/* 50 */,\n/* 51 */,\n/* 52 */,\n/* 53 */,\n/* 54 */,\n/* 55 */,\n/* 56 */,\n/* 57 */,\n/* 58 */\n/***/ (function(module, exports) {\n\n// Console-polyfill. MIT license.\n// https://github.com/paulmillr/console-polyfill\n// Make it safe to do console.log() always.\n(function(global) {\n  'use strict';\n  if (!global.console) {\n    global.console = {};\n  }\n  var con = global.console;\n  var prop, method;\n  var dummy = function() {};\n  var properties = ['memory'];\n  var methods = ('assert,clear,count,debug,dir,dirxml,error,exception,group,' +\n     'groupCollapsed,groupEnd,info,log,markTimeline,profile,profiles,profileEnd,' +\n     'show,table,time,timeEnd,timeline,timelineEnd,timeStamp,trace,warn').split(',');\n  while (prop = properties.pop()) if (!con[prop]) con[prop] = {};\n  while (method = methods.pop()) if (!con[method]) con[method] = dummy;\n  // Using `this` for web workers & supports Browserify / Webpack.\n})(typeof window === 'undefined' ? this : window);\n\n\n/***/ }),\n/* 59 */,\n/* 60 */,\n/* 61 */,\n/* 62 */,\n/* 63 */,\n/* 64 */,\n/* 65 */,\n/* 66 */,\n/* 67 */,\n/* 68 */,\n/* 69 */,\n/* 70 */,\n/* 71 */,\n/* 72 */,\n/* 73 */,\n/* 74 */,\n/* 75 */,\n/* 76 */,\n/* 77 */,\n/* 78 */,\n/* 79 */,\n/* 80 */,\n/* 81 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _attribution = __webpack_require__(47);\n\nvar _forms = __webpack_require__(49);\n\nvar _forms2 = _interopRequireDefault(_forms);\n\nvar _goToTop = __webpack_require__(44);\n\nvar _goToTop2 = _interopRequireDefault(_goToTop);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// polyfills\n__webpack_require__(58);\n\n// attribution\n\n\n(0, _attribution.setLandingURL)();\n(0, _attribution.setLandingTimestamp)();\n\n// forms\n\nconsole.log('**' + window.MM.forms.length + ' forms**');\nwindow.MM.forms.forEach(function (f) {\n  return (0, _forms2.default)(f.portal, f.form, f.target, f.onFormReady || function () {\n    return null;\n  });\n});\n\n// common components\n__webpack_require__(43);\n__webpack_require__(45);\n__webpack_require__(46);\n\n(0, _goToTop2.default)('.go-to-top-container');\n\n/***/ }),\n/* 82 */,\n/* 83 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone, _, $) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.default = makeSearchExpander;\n\nvar _expandable = __webpack_require__(41);\n\nvar _expandable2 = _interopRequireDefault(_expandable);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar SearchExpander = Backbone.View.extend({\n    events: {\n        'click .expander': 'openExpander',\n        'click .btn-close-expander': 'closeExpander'\n    },\n\n    initialize: function initialize(opts) {\n        this.options = {\n            expanded_class: 'focused'\n        };\n\n        _.extend(this.options, opts || {});\n\n        this.model.on('change:isExpanded', this.render, this);\n    },\n    openExpander: function openExpander() {\n        this.model.set({ isExpanded: true });\n    },\n    closeExpander: function closeExpander() {\n        this.model.set({ isExpanded: false });\n    },\n    render: function render() {\n        this.model.get('isExpanded') ? this.$el.addClass(this.options.expanded_class) && this.$el.find('input').focus() : this.$el.removeClass(this.options.expanded_class);\n    }\n}); /** a search expander (the most ubiquitous example being a magnifying glass which expands into an input field is responsible\n     * for doing a couple of things:\n     *\n     * 1) On click of the expander element, apply the expanded class to the container element\n     * 2) On click of the 'X' button added to the expanded container, close the container (by removing the expanded class)\n     **/\nfunction makeSearchExpander(el, opts) {\n    var model = new _expandable2.default();\n    new SearchExpander($.extend({\n        el: el,\n        model: model\n    }, opts || {}));\n\n    return model;\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(1)))\n\n/***/ }),\n/* 84 */,\n/* 85 */,\n/* 86 */,\n/* 87 */,\n/* 88 */,\n/* 89 */,\n/* 90 */,\n/* 91 */,\n/* 92 */,\n/* 93 */,\n/* 94 */,\n/* 95 */,\n/* 96 */,\n/* 97 */,\n/* 98 */,\n/* 99 */,\n/* 100 */,\n/* 101 */,\n/* 102 */,\n/* 103 */,\n/* 104 */,\n/* 105 */,\n/* 106 */,\n/* 107 */,\n/* 108 */,\n/* 109 */,\n/* 110 */,\n/* 111 */,\n/* 112 */,\n/* 113 */,\n/* 114 */,\n/* 115 */,\n/* 116 */,\n/* 117 */,\n/* 118 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/go-to-top.html -->\\n<!-- go-to-top.html -->\\n<a id=\"go-top\" class=\"go-top\" href=\"#masthead\"><i class=\"fa fa-chevron-up\" aria-hidden=\"true\"></i></a>\\n';\n}\nreturn __p;\n};\n\n\n/***/ }),\n/* 119 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/hamburger.html -->\\n';\n if (!isExpanded) { \n__p+='\\n<span class=\"icon-bar\"></span>\\n<span class=\"icon-bar\"></span>\\n<span class=\"icon-bar\"></span>\\n';\n } else { \n__p+='\\n<span class=\"close\">&times;</span>\\n';\n } \n__p+='';\n}\nreturn __p;\n};\n\n\n/***/ }),\n/* 120 */,\n/* 121 */,\n/* 122 */\n/***/ (function(module, exports) {\n\nmodule.exports = hbspt;\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// core-bef109a214aa0e57ba54.bundle.js"," \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 \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\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.l = 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// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 81);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap bef109a214aa0e57ba54","//     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//////////////////\n// WEBPACK FOOTER\n// ./~/underscore/underscore.js\n// module id = 0\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21","module.exports = $;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"$\"\n// module id = 1\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21","'use strict';\n\nvar asap = require('asap/raw');\n\nfunction noop() {}\n\n// States:\n//\n// 0 - pending\n// 1 - fulfilled with _value\n// 2 - rejected with _value\n// 3 - adopted the state of another promise, _value\n//\n// once the state is no longer pending (0) it is immutable\n\n// All `_` prefixed properties will be reduced to `_{random number}`\n// at build time to obfuscate them and discourage their use.\n// We don't use symbols or Object.defineProperty to fully hide them\n// because the performance isn't good enough.\n\n\n// to avoid using try/catch inside critical functions, we\n// extract them to here.\nvar LAST_ERROR = null;\nvar IS_ERROR = {};\nfunction getThen(obj) {\n  try {\n    return obj.then;\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\n\nfunction tryCallOne(fn, a) {\n  try {\n    return fn(a);\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\nfunction tryCallTwo(fn, a, b) {\n  try {\n    fn(a, b);\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\n\nmodule.exports = Promise;\n\nfunction Promise(fn) {\n  if (typeof this !== 'object') {\n    throw new TypeError('Promises must be constructed via new');\n  }\n  if (typeof fn !== 'function') {\n    throw new TypeError('Promise constructor\\'s argument is not a function');\n  }\n  this._40 = 0;\n  this._65 = 0;\n  this._55 = null;\n  this._72 = null;\n  if (fn === noop) return;\n  doResolve(fn, this);\n}\nPromise._37 = null;\nPromise._87 = null;\nPromise._61 = noop;\n\nPromise.prototype.then = function(onFulfilled, onRejected) {\n  if (this.constructor !== Promise) {\n    return safeThen(this, onFulfilled, onRejected);\n  }\n  var res = new Promise(noop);\n  handle(this, new Handler(onFulfilled, onRejected, res));\n  return res;\n};\n\nfunction safeThen(self, onFulfilled, onRejected) {\n  return new self.constructor(function (resolve, reject) {\n    var res = new Promise(noop);\n    res.then(resolve, reject);\n    handle(self, new Handler(onFulfilled, onRejected, res));\n  });\n}\nfunction handle(self, deferred) {\n  while (self._65 === 3) {\n    self = self._55;\n  }\n  if (Promise._37) {\n    Promise._37(self);\n  }\n  if (self._65 === 0) {\n    if (self._40 === 0) {\n      self._40 = 1;\n      self._72 = deferred;\n      return;\n    }\n    if (self._40 === 1) {\n      self._40 = 2;\n      self._72 = [self._72, deferred];\n      return;\n    }\n    self._72.push(deferred);\n    return;\n  }\n  handleResolved(self, deferred);\n}\n\nfunction handleResolved(self, deferred) {\n  asap(function() {\n    var cb = self._65 === 1 ? deferred.onFulfilled : deferred.onRejected;\n    if (cb === null) {\n      if (self._65 === 1) {\n        resolve(deferred.promise, self._55);\n      } else {\n        reject(deferred.promise, self._55);\n      }\n      return;\n    }\n    var ret = tryCallOne(cb, self._55);\n    if (ret === IS_ERROR) {\n      reject(deferred.promise, LAST_ERROR);\n    } else {\n      resolve(deferred.promise, ret);\n    }\n  });\n}\nfunction resolve(self, newValue) {\n  // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n  if (newValue === self) {\n    return reject(\n      self,\n      new TypeError('A promise cannot be resolved with itself.')\n    );\n  }\n  if (\n    newValue &&\n    (typeof newValue === 'object' || typeof newValue === 'function')\n  ) {\n    var then = getThen(newValue);\n    if (then === IS_ERROR) {\n      return reject(self, LAST_ERROR);\n    }\n    if (\n      then === self.then &&\n      newValue instanceof Promise\n    ) {\n      self._65 = 3;\n      self._55 = newValue;\n      finale(self);\n      return;\n    } else if (typeof then === 'function') {\n      doResolve(then.bind(newValue), self);\n      return;\n    }\n  }\n  self._65 = 1;\n  self._55 = newValue;\n  finale(self);\n}\n\nfunction reject(self, newValue) {\n  self._65 = 2;\n  self._55 = newValue;\n  if (Promise._87) {\n    Promise._87(self, newValue);\n  }\n  finale(self);\n}\nfunction finale(self) {\n  if (self._40 === 1) {\n    handle(self, self._72);\n    self._72 = null;\n  }\n  if (self._40 === 2) {\n    for (var i = 0; i < self._72.length; i++) {\n      handle(self, self._72[i]);\n    }\n    self._72 = null;\n  }\n}\n\nfunction Handler(onFulfilled, onRejected, promise){\n  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n  this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n  this.promise = promise;\n}\n\n/**\n * Take a potentially misbehaving resolver function and make sure\n * onFulfilled and onRejected are only called once.\n *\n * Makes no guarantees about asynchrony.\n */\nfunction doResolve(fn, promise) {\n  var done = false;\n  var res = tryCallTwo(fn, function (value) {\n    if (done) return;\n    done = true;\n    resolve(promise, value);\n  }, function (reason) {\n    if (done) return;\n    done = true;\n    reject(promise, reason);\n  });\n  if (!done && res === IS_ERROR) {\n    done = true;\n    reject(promise, LAST_ERROR);\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/core.js\n// module id = 2\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","//     Backbone.js 1.3.3\n\n//     (c) 2010-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Backbone may be freely distributed under the MIT license.\n//     For all details and documentation:\n//     http://backbonejs.org\n\n(function(factory) {\n\n  // Establish the root object, `window` (`self`) in the browser, or `global` on the server.\n  // We use `self` instead of `window` for `WebWorker` support.\n  var root = (typeof self == 'object' && self.self === self && self) ||\n            (typeof global == 'object' && global.global === global && global);\n\n  // Set up Backbone appropriately for the environment. Start with AMD.\n  if (typeof define === 'function' && define.amd) {\n    define(['underscore', 'jquery', 'exports'], function(_, $, exports) {\n      // Export global even in AMD case in case this script is loaded with\n      // others that may still expect a global Backbone.\n      root.Backbone = factory(root, exports, _, $);\n    });\n\n  // Next for Node.js or CommonJS. jQuery may not be needed as a module.\n  } else if (typeof exports !== 'undefined') {\n    var _ = require('underscore'), $;\n    try { $ = require('jquery'); } catch (e) {}\n    factory(root, exports, _, $);\n\n  // Finally, as a browser global.\n  } else {\n    root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));\n  }\n\n})(function(root, Backbone, _, $) {\n\n  // Initial Setup\n  // -------------\n\n  // Save the previous value of the `Backbone` variable, so that it can be\n  // restored later on, if `noConflict` is used.\n  var previousBackbone = root.Backbone;\n\n  // Create a local reference to a common array method we'll want to use later.\n  var slice = Array.prototype.slice;\n\n  // Current version of the library. Keep in sync with `package.json`.\n  Backbone.VERSION = '1.3.3';\n\n  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns\n  // the `$` variable.\n  Backbone.$ = $;\n\n  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable\n  // to its previous owner. Returns a reference to this Backbone object.\n  Backbone.noConflict = function() {\n    root.Backbone = previousBackbone;\n    return this;\n  };\n\n  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option\n  // will fake `\"PATCH\"`, `\"PUT\"` and `\"DELETE\"` requests via the `_method` parameter and\n  // set a `X-Http-Method-Override` header.\n  Backbone.emulateHTTP = false;\n\n  // Turn on `emulateJSON` to support legacy servers that can't deal with direct\n  // `application/json` requests ... this will encode the body as\n  // `application/x-www-form-urlencoded` instead and will send the model in a\n  // form param named `model`.\n  Backbone.emulateJSON = false;\n\n  // Proxy Backbone class methods to Underscore functions, wrapping the model's\n  // `attributes` object or collection's `models` array behind the scenes.\n  //\n  // collection.filter(function(model) { return model.get('age') > 10 });\n  // collection.each(this.addView);\n  //\n  // `Function#apply` can be slow so we use the method's arg count, if we know it.\n  var addMethod = function(length, method, attribute) {\n    switch (length) {\n      case 1: return function() {\n        return _[method](this[attribute]);\n      };\n      case 2: return function(value) {\n        return _[method](this[attribute], value);\n      };\n      case 3: return function(iteratee, context) {\n        return _[method](this[attribute], cb(iteratee, this), context);\n      };\n      case 4: return function(iteratee, defaultVal, context) {\n        return _[method](this[attribute], cb(iteratee, this), defaultVal, context);\n      };\n      default: return function() {\n        var args = slice.call(arguments);\n        args.unshift(this[attribute]);\n        return _[method].apply(_, args);\n      };\n    }\n  };\n  var addUnderscoreMethods = function(Class, methods, attribute) {\n    _.each(methods, function(length, method) {\n      if (_[method]) Class.prototype[method] = addMethod(length, method, attribute);\n    });\n  };\n\n  // Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.\n  var cb = function(iteratee, instance) {\n    if (_.isFunction(iteratee)) return iteratee;\n    if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);\n    if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };\n    return iteratee;\n  };\n  var modelMatcher = function(attrs) {\n    var matcher = _.matches(attrs);\n    return function(model) {\n      return matcher(model.attributes);\n    };\n  };\n\n  // Backbone.Events\n  // ---------------\n\n  // A module that can be mixed in to *any object* in order to provide it with\n  // a custom event channel. You may bind a callback to an event with `on` or\n  // remove with `off`; `trigger`-ing an event fires all callbacks in\n  // succession.\n  //\n  //     var object = {};\n  //     _.extend(object, Backbone.Events);\n  //     object.on('expand', function(){ alert('expanded'); });\n  //     object.trigger('expand');\n  //\n  var Events = Backbone.Events = {};\n\n  // Regular expression used to split event strings.\n  var eventSplitter = /\\s+/;\n\n  // Iterates over the standard `event, callback` (as well as the fancy multiple\n  // space-separated events `\"change blur\", callback` and jQuery-style event\n  // maps `{event: callback}`).\n  var eventsApi = function(iteratee, events, name, callback, opts) {\n    var i = 0, names;\n    if (name && typeof name === 'object') {\n      // Handle event maps.\n      if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback;\n      for (names = _.keys(name); i < names.length ; i++) {\n        events = eventsApi(iteratee, events, names[i], name[names[i]], opts);\n      }\n    } else if (name && eventSplitter.test(name)) {\n      // Handle space-separated event names by delegating them individually.\n      for (names = name.split(eventSplitter); i < names.length; i++) {\n        events = iteratee(events, names[i], callback, opts);\n      }\n    } else {\n      // Finally, standard events.\n      events = iteratee(events, name, callback, opts);\n    }\n    return events;\n  };\n\n  // Bind an event to a `callback` function. Passing `\"all\"` will bind\n  // the callback to all events fired.\n  Events.on = function(name, callback, context) {\n    return internalOn(this, name, callback, context);\n  };\n\n  // Guard the `listening` argument from the public API.\n  var internalOn = function(obj, name, callback, context, listening) {\n    obj._events = eventsApi(onApi, obj._events || {}, name, callback, {\n      context: context,\n      ctx: obj,\n      listening: listening\n    });\n\n    if (listening) {\n      var listeners = obj._listeners || (obj._listeners = {});\n      listeners[listening.id] = listening;\n    }\n\n    return obj;\n  };\n\n  // Inversion-of-control versions of `on`. Tell *this* object to listen to\n  // an event in another object... keeping track of what it's listening to\n  // for easier unbinding later.\n  Events.listenTo = function(obj, name, callback) {\n    if (!obj) return this;\n    var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n    var listeningTo = this._listeningTo || (this._listeningTo = {});\n    var listening = listeningTo[id];\n\n    // This object is not listening to any other events on `obj` yet.\n    // Setup the necessary references to track the listening callbacks.\n    if (!listening) {\n      var thisId = this._listenId || (this._listenId = _.uniqueId('l'));\n      listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningTo: listeningTo, count: 0};\n    }\n\n    // Bind callbacks on obj, and keep track of them on listening.\n    internalOn(obj, name, callback, this, listening);\n    return this;\n  };\n\n  // The reducing API that adds a callback to the `events` object.\n  var onApi = function(events, name, callback, options) {\n    if (callback) {\n      var handlers = events[name] || (events[name] = []);\n      var context = options.context, ctx = options.ctx, listening = options.listening;\n      if (listening) listening.count++;\n\n      handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});\n    }\n    return events;\n  };\n\n  // Remove one or many callbacks. If `context` is null, removes all\n  // callbacks with that function. If `callback` is null, removes all\n  // callbacks for the event. If `name` is null, removes all bound\n  // callbacks for all events.\n  Events.off = function(name, callback, context) {\n    if (!this._events) return this;\n    this._events = eventsApi(offApi, this._events, name, callback, {\n      context: context,\n      listeners: this._listeners\n    });\n    return this;\n  };\n\n  // Tell this object to stop listening to either specific events ... or\n  // to every object it's currently listening to.\n  Events.stopListening = function(obj, name, callback) {\n    var listeningTo = this._listeningTo;\n    if (!listeningTo) return this;\n\n    var ids = obj ? [obj._listenId] : _.keys(listeningTo);\n\n    for (var i = 0; i < ids.length; i++) {\n      var listening = listeningTo[ids[i]];\n\n      // If listening doesn't exist, this object is not currently\n      // listening to obj. Break out early.\n      if (!listening) break;\n\n      listening.obj.off(name, callback, this);\n    }\n\n    return this;\n  };\n\n  // The reducing API that removes a callback from the `events` object.\n  var offApi = function(events, name, callback, options) {\n    if (!events) return;\n\n    var i = 0, listening;\n    var context = options.context, listeners = options.listeners;\n\n    // Delete all events listeners and \"drop\" events.\n    if (!name && !callback && !context) {\n      var ids = _.keys(listeners);\n      for (; i < ids.length; i++) {\n        listening = listeners[ids[i]];\n        delete listeners[listening.id];\n        delete listening.listeningTo[listening.objId];\n      }\n      return;\n    }\n\n    var names = name ? [name] : _.keys(events);\n    for (; i < names.length; i++) {\n      name = names[i];\n      var handlers = events[name];\n\n      // Bail out if there are no events stored.\n      if (!handlers) break;\n\n      // Replace events if there are any remaining.  Otherwise, clean up.\n      var remaining = [];\n      for (var j = 0; j < handlers.length; j++) {\n        var handler = handlers[j];\n        if (\n          callback && callback !== handler.callback &&\n            callback !== handler.callback._callback ||\n              context && context !== handler.context\n        ) {\n          remaining.push(handler);\n        } else {\n          listening = handler.listening;\n          if (listening && --listening.count === 0) {\n            delete listeners[listening.id];\n            delete listening.listeningTo[listening.objId];\n          }\n        }\n      }\n\n      // Update tail event if the list has any events.  Otherwise, clean up.\n      if (remaining.length) {\n        events[name] = remaining;\n      } else {\n        delete events[name];\n      }\n    }\n    return events;\n  };\n\n  // Bind an event to only be triggered a single time. After the first time\n  // the callback is invoked, its listener will be removed. If multiple events\n  // are passed in using the space-separated syntax, the handler will fire\n  // once for each event, not once for a combination of all events.\n  Events.once = function(name, callback, context) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this));\n    if (typeof name === 'string' && context == null) callback = void 0;\n    return this.on(events, callback, context);\n  };\n\n  // Inversion-of-control versions of `once`.\n  Events.listenToOnce = function(obj, name, callback) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListening, this, obj));\n    return this.listenTo(obj, events);\n  };\n\n  // Reduces the event callbacks into a map of `{event: onceWrapper}`.\n  // `offer` unbinds the `onceWrapper` after it has been called.\n  var onceMap = function(map, name, callback, offer) {\n    if (callback) {\n      var once = map[name] = _.once(function() {\n        offer(name, once);\n        callback.apply(this, arguments);\n      });\n      once._callback = callback;\n    }\n    return map;\n  };\n\n  // Trigger one or many events, firing all bound callbacks. Callbacks are\n  // passed the same arguments as `trigger` is, apart from the event name\n  // (unless you're listening on `\"all\"`, which will cause your callback to\n  // receive the true name of the event as the first argument).\n  Events.trigger = function(name) {\n    if (!this._events) return this;\n\n    var length = Math.max(0, arguments.length - 1);\n    var args = Array(length);\n    for (var i = 0; i < length; i++) args[i] = arguments[i + 1];\n\n    eventsApi(triggerApi, this._events, name, void 0, args);\n    return this;\n  };\n\n  // Handles triggering the appropriate event callbacks.\n  var triggerApi = function(objEvents, name, callback, args) {\n    if (objEvents) {\n      var events = objEvents[name];\n      var allEvents = objEvents.all;\n      if (events && allEvents) allEvents = allEvents.slice();\n      if (events) triggerEvents(events, args);\n      if (allEvents) triggerEvents(allEvents, [name].concat(args));\n    }\n    return objEvents;\n  };\n\n  // A difficult-to-believe, but optimized internal dispatch function for\n  // triggering events. Tries to keep the usual cases speedy (most internal\n  // Backbone events have 3 arguments).\n  var triggerEvents = function(events, args) {\n    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\n    switch (args.length) {\n      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\n      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\n      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\n      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\n      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;\n    }\n  };\n\n  // Aliases for backwards compatibility.\n  Events.bind   = Events.on;\n  Events.unbind = Events.off;\n\n  // Allow the `Backbone` object to serve as a global event bus, for folks who\n  // want global \"pubsub\" in a convenient place.\n  _.extend(Backbone, Events);\n\n  // Backbone.Model\n  // --------------\n\n  // Backbone **Models** are the basic data object in the framework --\n  // frequently representing a row in a table in a database on your server.\n  // A discrete chunk of data and a bunch of useful, related methods for\n  // performing computations and transformations on that data.\n\n  // Create a new model with the specified attributes. A client id (`cid`)\n  // is automatically generated and assigned for you.\n  var Model = Backbone.Model = function(attributes, options) {\n    var attrs = attributes || {};\n    options || (options = {});\n    this.cid = _.uniqueId(this.cidPrefix);\n    this.attributes = {};\n    if (options.collection) this.collection = options.collection;\n    if (options.parse) attrs = this.parse(attrs, options) || {};\n    var defaults = _.result(this, 'defaults');\n    attrs = _.defaults(_.extend({}, defaults, attrs), defaults);\n    this.set(attrs, options);\n    this.changed = {};\n    this.initialize.apply(this, arguments);\n  };\n\n  // Attach all inheritable methods to the Model prototype.\n  _.extend(Model.prototype, Events, {\n\n    // A hash of attributes whose current and previous value differ.\n    changed: null,\n\n    // The value returned during the last failed validation.\n    validationError: null,\n\n    // The default name for the JSON `id` attribute is `\"id\"`. MongoDB and\n    // CouchDB users may want to set this to `\"_id\"`.\n    idAttribute: 'id',\n\n    // The prefix is used to create the client id which is used to identify models locally.\n    // You may want to override this if you're experiencing name clashes with model ids.\n    cidPrefix: 'c',\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Return a copy of the model's `attributes` object.\n    toJSON: function(options) {\n      return _.clone(this.attributes);\n    },\n\n    // Proxy `Backbone.sync` by default -- but override this if you need\n    // custom syncing semantics for *this* particular model.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Get the value of an attribute.\n    get: function(attr) {\n      return this.attributes[attr];\n    },\n\n    // Get the HTML-escaped value of an attribute.\n    escape: function(attr) {\n      return _.escape(this.get(attr));\n    },\n\n    // Returns `true` if the attribute contains a value that is not null\n    // or undefined.\n    has: function(attr) {\n      return this.get(attr) != null;\n    },\n\n    // Special-cased proxy to underscore's `_.matches` method.\n    matches: function(attrs) {\n      return !!_.iteratee(attrs, this)(this.attributes);\n    },\n\n    // Set a hash of model attributes on the object, firing `\"change\"`. This is\n    // the core primitive operation of a model, updating the data and notifying\n    // anyone who needs to know about the change in state. The heart of the beast.\n    set: function(key, val, options) {\n      if (key == null) return this;\n\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options || (options = {});\n\n      // Run validation.\n      if (!this._validate(attrs, options)) return false;\n\n      // Extract attributes and options.\n      var unset      = options.unset;\n      var silent     = options.silent;\n      var changes    = [];\n      var changing   = this._changing;\n      this._changing = true;\n\n      if (!changing) {\n        this._previousAttributes = _.clone(this.attributes);\n        this.changed = {};\n      }\n\n      var current = this.attributes;\n      var changed = this.changed;\n      var prev    = this._previousAttributes;\n\n      // For each `set` attribute, update or delete the current value.\n      for (var attr in attrs) {\n        val = attrs[attr];\n        if (!_.isEqual(current[attr], val)) changes.push(attr);\n        if (!_.isEqual(prev[attr], val)) {\n          changed[attr] = val;\n        } else {\n          delete changed[attr];\n        }\n        unset ? delete current[attr] : current[attr] = val;\n      }\n\n      // Update the `id`.\n      if (this.idAttribute in attrs) this.id = this.get(this.idAttribute);\n\n      // Trigger all relevant attribute changes.\n      if (!silent) {\n        if (changes.length) this._pending = options;\n        for (var i = 0; i < changes.length; i++) {\n          this.trigger('change:' + changes[i], this, current[changes[i]], options);\n        }\n      }\n\n      // You might be wondering why there's a `while` loop here. Changes can\n      // be recursively nested within `\"change\"` events.\n      if (changing) return this;\n      if (!silent) {\n        while (this._pending) {\n          options = this._pending;\n          this._pending = false;\n          this.trigger('change', this, options);\n        }\n      }\n      this._pending = false;\n      this._changing = false;\n      return this;\n    },\n\n    // Remove an attribute from the model, firing `\"change\"`. `unset` is a noop\n    // if the attribute doesn't exist.\n    unset: function(attr, options) {\n      return this.set(attr, void 0, _.extend({}, options, {unset: true}));\n    },\n\n    // Clear all attributes on the model, firing `\"change\"`.\n    clear: function(options) {\n      var attrs = {};\n      for (var key in this.attributes) attrs[key] = void 0;\n      return this.set(attrs, _.extend({}, options, {unset: true}));\n    },\n\n    // Determine if the model has changed since the last `\"change\"` event.\n    // If you specify an attribute name, determine if that attribute has changed.\n    hasChanged: function(attr) {\n      if (attr == null) return !_.isEmpty(this.changed);\n      return _.has(this.changed, attr);\n    },\n\n    // Return an object containing all the attributes that have changed, or\n    // false if there are no changed attributes. Useful for determining what\n    // parts of a view need to be updated and/or what attributes need to be\n    // persisted to the server. Unset attributes will be set to undefined.\n    // You can also pass an attributes object to diff against the model,\n    // determining if there *would be* a change.\n    changedAttributes: function(diff) {\n      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;\n      var old = this._changing ? this._previousAttributes : this.attributes;\n      var changed = {};\n      for (var attr in diff) {\n        var val = diff[attr];\n        if (_.isEqual(old[attr], val)) continue;\n        changed[attr] = val;\n      }\n      return _.size(changed) ? changed : false;\n    },\n\n    // Get the previous value of an attribute, recorded at the time the last\n    // `\"change\"` event was fired.\n    previous: function(attr) {\n      if (attr == null || !this._previousAttributes) return null;\n      return this._previousAttributes[attr];\n    },\n\n    // Get all of the attributes of the model at the time of the previous\n    // `\"change\"` event.\n    previousAttributes: function() {\n      return _.clone(this._previousAttributes);\n    },\n\n    // Fetch the model from the server, merging the response with the model's\n    // local attributes. Any changed attributes will trigger a \"change\" event.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var model = this;\n      var success = options.success;\n      options.success = function(resp) {\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (!model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Set a hash of model attributes, and sync the model to the server.\n    // If the server returns an attributes hash that differs, the model's\n    // state will be `set` again.\n    save: function(key, val, options) {\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (key == null || typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options = _.extend({validate: true, parse: true}, options);\n      var wait = options.wait;\n\n      // If we're not waiting and attributes exist, save acts as\n      // `set(attr).save(null, opts)` with validation. Otherwise, check if\n      // the model will be valid when the attributes, if any, are set.\n      if (attrs && !wait) {\n        if (!this.set(attrs, options)) return false;\n      } else if (!this._validate(attrs, options)) {\n        return false;\n      }\n\n      // After a successful server-side save, the client is (optionally)\n      // updated with the server-side state.\n      var model = this;\n      var success = options.success;\n      var attributes = this.attributes;\n      options.success = function(resp) {\n        // Ensure attributes are restored during synchronous saves.\n        model.attributes = attributes;\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (wait) serverAttrs = _.extend({}, attrs, serverAttrs);\n        if (serverAttrs && !model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n\n      // Set temporary attributes if `{wait: true}` to properly find new ids.\n      if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);\n\n      var method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');\n      if (method === 'patch' && !options.attrs) options.attrs = attrs;\n      var xhr = this.sync(method, this, options);\n\n      // Restore attributes.\n      this.attributes = attributes;\n\n      return xhr;\n    },\n\n    // Destroy this model on the server if it was already persisted.\n    // Optimistically removes the model from its collection, if it has one.\n    // If `wait: true` is passed, waits for the server to respond before removal.\n    destroy: function(options) {\n      options = options ? _.clone(options) : {};\n      var model = this;\n      var success = options.success;\n      var wait = options.wait;\n\n      var destroy = function() {\n        model.stopListening();\n        model.trigger('destroy', model, model.collection, options);\n      };\n\n      options.success = function(resp) {\n        if (wait) destroy();\n        if (success) success.call(options.context, model, resp, options);\n        if (!model.isNew()) model.trigger('sync', model, resp, options);\n      };\n\n      var xhr = false;\n      if (this.isNew()) {\n        _.defer(options.success);\n      } else {\n        wrapError(this, options);\n        xhr = this.sync('delete', this, options);\n      }\n      if (!wait) destroy();\n      return xhr;\n    },\n\n    // Default URL for the model's representation on the server -- if you're\n    // using Backbone's restful methods, override this to change the endpoint\n    // that will be called.\n    url: function() {\n      var base =\n        _.result(this, 'urlRoot') ||\n        _.result(this.collection, 'url') ||\n        urlError();\n      if (this.isNew()) return base;\n      var id = this.get(this.idAttribute);\n      return base.replace(/[^\\/]$/, '$&/') + encodeURIComponent(id);\n    },\n\n    // **parse** converts a response into the hash of attributes to be `set` on\n    // the model. The default implementation is just to pass the response along.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new model with identical attributes to this one.\n    clone: function() {\n      return new this.constructor(this.attributes);\n    },\n\n    // A model is new if it has never been saved to the server, and lacks an id.\n    isNew: function() {\n      return !this.has(this.idAttribute);\n    },\n\n    // Check if the model is currently in a valid state.\n    isValid: function(options) {\n      return this._validate({}, _.extend({}, options, {validate: true}));\n    },\n\n    // Run validation against the next complete set of model attributes,\n    // returning `true` if all is well. Otherwise, fire an `\"invalid\"` event.\n    _validate: function(attrs, options) {\n      if (!options.validate || !this.validate) return true;\n      attrs = _.extend({}, this.attributes, attrs);\n      var error = this.validationError = this.validate(attrs, options) || null;\n      if (!error) return true;\n      this.trigger('invalid', this, error, _.extend(options, {validationError: error}));\n      return false;\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Model, mapped to the\n  // number of arguments they take.\n  var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,\n      omit: 0, chain: 1, isEmpty: 1};\n\n  // Mix in each Underscore method as a proxy to `Model#attributes`.\n  addUnderscoreMethods(Model, modelMethods, 'attributes');\n\n  // Backbone.Collection\n  // -------------------\n\n  // If models tend to represent a single row of data, a Backbone Collection is\n  // more analogous to a table full of data ... or a small slice or page of that\n  // table, or a collection of rows that belong together for a particular reason\n  // -- all of the messages in this particular folder, all of the documents\n  // belonging to this particular author, and so on. Collections maintain\n  // indexes of their models, both in order, and for lookup by `id`.\n\n  // Create a new **Collection**, perhaps to contain a specific type of `model`.\n  // If a `comparator` is specified, the Collection will maintain\n  // its models in sort order, as they're added and removed.\n  var Collection = Backbone.Collection = function(models, options) {\n    options || (options = {});\n    if (options.model) this.model = options.model;\n    if (options.comparator !== void 0) this.comparator = options.comparator;\n    this._reset();\n    this.initialize.apply(this, arguments);\n    if (models) this.reset(models, _.extend({silent: true}, options));\n  };\n\n  // Default options for `Collection#set`.\n  var setOptions = {add: true, remove: true, merge: true};\n  var addOptions = {add: true, remove: false};\n\n  // Splices `insert` into `array` at index `at`.\n  var splice = function(array, insert, at) {\n    at = Math.min(Math.max(at, 0), array.length);\n    var tail = Array(array.length - at);\n    var length = insert.length;\n    var i;\n    for (i = 0; i < tail.length; i++) tail[i] = array[i + at];\n    for (i = 0; i < length; i++) array[i + at] = insert[i];\n    for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];\n  };\n\n  // Define the Collection's inheritable methods.\n  _.extend(Collection.prototype, Events, {\n\n    // The default model for a collection is just a **Backbone.Model**.\n    // This should be overridden in most cases.\n    model: Model,\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // The JSON representation of a Collection is an array of the\n    // models' attributes.\n    toJSON: function(options) {\n      return this.map(function(model) { return model.toJSON(options); });\n    },\n\n    // Proxy `Backbone.sync` by default.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Add a model, or list of models to the set. `models` may be Backbone\n    // Models or raw JavaScript objects to be converted to Models, or any\n    // combination of the two.\n    add: function(models, options) {\n      return this.set(models, _.extend({merge: false}, options, addOptions));\n    },\n\n    // Remove a model, or a list of models from the set.\n    remove: function(models, options) {\n      options = _.extend({}, options);\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n      var removed = this._removeModels(models, options);\n      if (!options.silent && removed.length) {\n        options.changes = {added: [], merged: [], removed: removed};\n        this.trigger('update', this, options);\n      }\n      return singular ? removed[0] : removed;\n    },\n\n    // Update a collection by `set`-ing a new list of models, adding new ones,\n    // removing models that are no longer present, and merging models that\n    // already exist in the collection, as necessary. Similar to **Model#set**,\n    // the core operation for updating the data contained by the collection.\n    set: function(models, options) {\n      if (models == null) return;\n\n      options = _.extend({}, setOptions, options);\n      if (options.parse && !this._isModel(models)) {\n        models = this.parse(models, options) || [];\n      }\n\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n\n      var at = options.at;\n      if (at != null) at = +at;\n      if (at > this.length) at = this.length;\n      if (at < 0) at += this.length + 1;\n\n      var set = [];\n      var toAdd = [];\n      var toMerge = [];\n      var toRemove = [];\n      var modelMap = {};\n\n      var add = options.add;\n      var merge = options.merge;\n      var remove = options.remove;\n\n      var sort = false;\n      var sortable = this.comparator && at == null && options.sort !== false;\n      var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n\n      // Turn bare objects into model references, and prevent invalid models\n      // from being added.\n      var model, i;\n      for (i = 0; i < models.length; i++) {\n        model = models[i];\n\n        // If a duplicate is found, prevent it from being added and\n        // optionally merge it into the existing model.\n        var existing = this.get(model);\n        if (existing) {\n          if (merge && model !== existing) {\n            var attrs = this._isModel(model) ? model.attributes : model;\n            if (options.parse) attrs = existing.parse(attrs, options);\n            existing.set(attrs, options);\n            toMerge.push(existing);\n            if (sortable && !sort) sort = existing.hasChanged(sortAttr);\n          }\n          if (!modelMap[existing.cid]) {\n            modelMap[existing.cid] = true;\n            set.push(existing);\n          }\n          models[i] = existing;\n\n        // If this is a new, valid model, push it to the `toAdd` list.\n        } else if (add) {\n          model = models[i] = this._prepareModel(model, options);\n          if (model) {\n            toAdd.push(model);\n            this._addReference(model, options);\n            modelMap[model.cid] = true;\n            set.push(model);\n          }\n        }\n      }\n\n      // Remove stale models.\n      if (remove) {\n        for (i = 0; i < this.length; i++) {\n          model = this.models[i];\n          if (!modelMap[model.cid]) toRemove.push(model);\n        }\n        if (toRemove.length) this._removeModels(toRemove, options);\n      }\n\n      // See if sorting is needed, update `length` and splice in new models.\n      var orderChanged = false;\n      var replace = !sortable && add && remove;\n      if (set.length && replace) {\n        orderChanged = this.length !== set.length || _.some(this.models, function(m, index) {\n          return m !== set[index];\n        });\n        this.models.length = 0;\n        splice(this.models, set, 0);\n        this.length = this.models.length;\n      } else if (toAdd.length) {\n        if (sortable) sort = true;\n        splice(this.models, toAdd, at == null ? this.length : at);\n        this.length = this.models.length;\n      }\n\n      // Silently sort the collection if appropriate.\n      if (sort) this.sort({silent: true});\n\n      // Unless silenced, it's time to fire all appropriate add/sort/update events.\n      if (!options.silent) {\n        for (i = 0; i < toAdd.length; i++) {\n          if (at != null) options.index = at + i;\n          model = toAdd[i];\n          model.trigger('add', model, this, options);\n        }\n        if (sort || orderChanged) this.trigger('sort', this, options);\n        if (toAdd.length || toRemove.length || toMerge.length) {\n          options.changes = {\n            added: toAdd,\n            removed: toRemove,\n            merged: toMerge\n          };\n          this.trigger('update', this, options);\n        }\n      }\n\n      // Return the added (or merged) model (or models).\n      return singular ? models[0] : models;\n    },\n\n    // When you have more items than you want to add or remove individually,\n    // you can reset the entire set with a new list of models, without firing\n    // any granular `add` or `remove` events. Fires `reset` when finished.\n    // Useful for bulk operations and optimizations.\n    reset: function(models, options) {\n      options = options ? _.clone(options) : {};\n      for (var i = 0; i < this.models.length; i++) {\n        this._removeReference(this.models[i], options);\n      }\n      options.previousModels = this.models;\n      this._reset();\n      models = this.add(models, _.extend({silent: true}, options));\n      if (!options.silent) this.trigger('reset', this, options);\n      return models;\n    },\n\n    // Add a model to the end of the collection.\n    push: function(model, options) {\n      return this.add(model, _.extend({at: this.length}, options));\n    },\n\n    // Remove a model from the end of the collection.\n    pop: function(options) {\n      var model = this.at(this.length - 1);\n      return this.remove(model, options);\n    },\n\n    // Add a model to the beginning of the collection.\n    unshift: function(model, options) {\n      return this.add(model, _.extend({at: 0}, options));\n    },\n\n    // Remove a model from the beginning of the collection.\n    shift: function(options) {\n      var model = this.at(0);\n      return this.remove(model, options);\n    },\n\n    // Slice out a sub-array of models from the collection.\n    slice: function() {\n      return slice.apply(this.models, arguments);\n    },\n\n    // Get a model from the set by id, cid, model object with id or cid\n    // properties, or an attributes object that is transformed through modelId.\n    get: function(obj) {\n      if (obj == null) return void 0;\n      return this._byId[obj] ||\n        this._byId[this.modelId(obj.attributes || obj)] ||\n        obj.cid && this._byId[obj.cid];\n    },\n\n    // Returns `true` if the model is in the collection.\n    has: function(obj) {\n      return this.get(obj) != null;\n    },\n\n    // Get the model at the given index.\n    at: function(index) {\n      if (index < 0) index += this.length;\n      return this.models[index];\n    },\n\n    // Return models with matching attributes. Useful for simple cases of\n    // `filter`.\n    where: function(attrs, first) {\n      return this[first ? 'find' : 'filter'](attrs);\n    },\n\n    // Return the first model with matching attributes. Useful for simple cases\n    // of `find`.\n    findWhere: function(attrs) {\n      return this.where(attrs, true);\n    },\n\n    // Force the collection to re-sort itself. You don't need to call this under\n    // normal circumstances, as the set will maintain sort order as each item\n    // is added.\n    sort: function(options) {\n      var comparator = this.comparator;\n      if (!comparator) throw new Error('Cannot sort a set without a comparator');\n      options || (options = {});\n\n      var length = comparator.length;\n      if (_.isFunction(comparator)) comparator = _.bind(comparator, this);\n\n      // Run sort based on type of `comparator`.\n      if (length === 1 || _.isString(comparator)) {\n        this.models = this.sortBy(comparator);\n      } else {\n        this.models.sort(comparator);\n      }\n      if (!options.silent) this.trigger('sort', this, options);\n      return this;\n    },\n\n    // Pluck an attribute from each model in the collection.\n    pluck: function(attr) {\n      return this.map(attr + '');\n    },\n\n    // Fetch the default set of models for this collection, resetting the\n    // collection when they arrive. If `reset: true` is passed, the response\n    // data will be passed through the `reset` method instead of `set`.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var success = options.success;\n      var collection = this;\n      options.success = function(resp) {\n        var method = options.reset ? 'reset' : 'set';\n        collection[method](resp, options);\n        if (success) success.call(options.context, collection, resp, options);\n        collection.trigger('sync', collection, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Create a new instance of a model in this collection. Add the model to the\n    // collection immediately, unless `wait: true` is passed, in which case we\n    // wait for the server to agree.\n    create: function(model, options) {\n      options = options ? _.clone(options) : {};\n      var wait = options.wait;\n      model = this._prepareModel(model, options);\n      if (!model) return false;\n      if (!wait) this.add(model, options);\n      var collection = this;\n      var success = options.success;\n      options.success = function(m, resp, callbackOpts) {\n        if (wait) collection.add(m, callbackOpts);\n        if (success) success.call(callbackOpts.context, m, resp, callbackOpts);\n      };\n      model.save(null, options);\n      return model;\n    },\n\n    // **parse** converts a response into a list of models to be added to the\n    // collection. The default implementation is just to pass it through.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new collection with an identical list of models as this one.\n    clone: function() {\n      return new this.constructor(this.models, {\n        model: this.model,\n        comparator: this.comparator\n      });\n    },\n\n    // Define how to uniquely identify models in the collection.\n    modelId: function(attrs) {\n      return attrs[this.model.prototype.idAttribute || 'id'];\n    },\n\n    // Private method to reset all internal state. Called when the collection\n    // is first initialized or reset.\n    _reset: function() {\n      this.length = 0;\n      this.models = [];\n      this._byId  = {};\n    },\n\n    // Prepare a hash of attributes (or other model) to be added to this\n    // collection.\n    _prepareModel: function(attrs, options) {\n      if (this._isModel(attrs)) {\n        if (!attrs.collection) attrs.collection = this;\n        return attrs;\n      }\n      options = options ? _.clone(options) : {};\n      options.collection = this;\n      var model = new this.model(attrs, options);\n      if (!model.validationError) return model;\n      this.trigger('invalid', this, model.validationError, options);\n      return false;\n    },\n\n    // Internal method called by both remove and set.\n    _removeModels: function(models, options) {\n      var removed = [];\n      for (var i = 0; i < models.length; i++) {\n        var model = this.get(models[i]);\n        if (!model) continue;\n\n        var index = this.indexOf(model);\n        this.models.splice(index, 1);\n        this.length--;\n\n        // Remove references before triggering 'remove' event to prevent an\n        // infinite loop. #3693\n        delete this._byId[model.cid];\n        var id = this.modelId(model.attributes);\n        if (id != null) delete this._byId[id];\n\n        if (!options.silent) {\n          options.index = index;\n          model.trigger('remove', model, this, options);\n        }\n\n        removed.push(model);\n        this._removeReference(model, options);\n      }\n      return removed;\n    },\n\n    // Method for checking whether an object should be considered a model for\n    // the purposes of adding to the collection.\n    _isModel: function(model) {\n      return model instanceof Model;\n    },\n\n    // Internal method to create a model's ties to a collection.\n    _addReference: function(model, options) {\n      this._byId[model.cid] = model;\n      var id = this.modelId(model.attributes);\n      if (id != null) this._byId[id] = model;\n      model.on('all', this._onModelEvent, this);\n    },\n\n    // Internal method to sever a model's ties to a collection.\n    _removeReference: function(model, options) {\n      delete this._byId[model.cid];\n      var id = this.modelId(model.attributes);\n      if (id != null) delete this._byId[id];\n      if (this === model.collection) delete model.collection;\n      model.off('all', this._onModelEvent, this);\n    },\n\n    // Internal method called every time a model in the set fires an event.\n    // Sets need to update their indexes when models change ids. All other\n    // events simply proxy through. \"add\" and \"remove\" events that originate\n    // in other collections are ignored.\n    _onModelEvent: function(event, model, collection, options) {\n      if (model) {\n        if ((event === 'add' || event === 'remove') && collection !== this) return;\n        if (event === 'destroy') this.remove(model, options);\n        if (event === 'change') {\n          var prevId = this.modelId(model.previousAttributes());\n          var id = this.modelId(model.attributes);\n          if (prevId !== id) {\n            if (prevId != null) delete this._byId[prevId];\n            if (id != null) this._byId[id] = model;\n          }\n        }\n      }\n      this.trigger.apply(this, arguments);\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Collection.\n  // 90% of the core usefulness of Backbone Collections is actually implemented\n  // right here:\n  var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,\n      foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3,\n      select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,\n      contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,\n      head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,\n      without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,\n      isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,\n      sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};\n\n  // Mix in each Underscore method as a proxy to `Collection#models`.\n  addUnderscoreMethods(Collection, collectionMethods, 'models');\n\n  // Backbone.View\n  // -------------\n\n  // Backbone Views are almost more convention than they are actual code. A View\n  // is simply a JavaScript object that represents a logical chunk of UI in the\n  // DOM. This might be a single item, an entire list, a sidebar or panel, or\n  // even the surrounding frame which wraps your whole app. Defining a chunk of\n  // UI as a **View** allows you to define your DOM events declaratively, without\n  // having to worry about render order ... and makes it easy for the view to\n  // react to specific changes in the state of your models.\n\n  // Creating a Backbone.View creates its initial element outside of the DOM,\n  // if an existing element is not provided...\n  var View = Backbone.View = function(options) {\n    this.cid = _.uniqueId('view');\n    _.extend(this, _.pick(options, viewOptions));\n    this._ensureElement();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regex to split keys for `delegate`.\n  var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n  // List of view options to be set as properties.\n  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];\n\n  // Set up all inheritable **Backbone.View** properties and methods.\n  _.extend(View.prototype, Events, {\n\n    // The default `tagName` of a View's element is `\"div\"`.\n    tagName: 'div',\n\n    // jQuery delegate for element lookup, scoped to DOM elements within the\n    // current view. This should be preferred to global lookups where possible.\n    $: function(selector) {\n      return this.$el.find(selector);\n    },\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // **render** is the core function that your view should override, in order\n    // to populate its element (`this.el`), with the appropriate HTML. The\n    // convention is for **render** to always return `this`.\n    render: function() {\n      return this;\n    },\n\n    // Remove this view by taking the element out of the DOM, and removing any\n    // applicable Backbone.Events listeners.\n    remove: function() {\n      this._removeElement();\n      this.stopListening();\n      return this;\n    },\n\n    // Remove this view's element from the document and all event listeners\n    // attached to it. Exposed for subclasses using an alternative DOM\n    // manipulation API.\n    _removeElement: function() {\n      this.$el.remove();\n    },\n\n    // Change the view's element (`this.el` property) and re-delegate the\n    // view's events on the new element.\n    setElement: function(element) {\n      this.undelegateEvents();\n      this._setElement(element);\n      this.delegateEvents();\n      return this;\n    },\n\n    // Creates the `this.el` and `this.$el` references for this view using the\n    // given `el`. `el` can be a CSS selector or an HTML string, a jQuery\n    // context or an element. Subclasses can override this to utilize an\n    // alternative DOM manipulation API and are only required to set the\n    // `this.el` property.\n    _setElement: function(el) {\n      this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);\n      this.el = this.$el[0];\n    },\n\n    // Set callbacks, where `this.events` is a hash of\n    //\n    // *{\"event selector\": \"callback\"}*\n    //\n    //     {\n    //       'mousedown .title':  'edit',\n    //       'click .button':     'save',\n    //       'click .open':       function(e) { ... }\n    //     }\n    //\n    // pairs. Callbacks will be bound to the view, with `this` set properly.\n    // Uses event delegation for efficiency.\n    // Omitting the selector binds the event to `this.el`.\n    delegateEvents: function(events) {\n      events || (events = _.result(this, 'events'));\n      if (!events) return this;\n      this.undelegateEvents();\n      for (var key in events) {\n        var method = events[key];\n        if (!_.isFunction(method)) method = this[method];\n        if (!method) continue;\n        var match = key.match(delegateEventSplitter);\n        this.delegate(match[1], match[2], _.bind(method, this));\n      }\n      return this;\n    },\n\n    // Add a single event listener to the view's element (or a child element\n    // using `selector`). This only works for delegate-able events: not `focus`,\n    // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.\n    delegate: function(eventName, selector, listener) {\n      this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Clears all callbacks previously bound to the view by `delegateEvents`.\n    // You usually don't need to use this, but may wish to if you have multiple\n    // Backbone views attached to the same DOM element.\n    undelegateEvents: function() {\n      if (this.$el) this.$el.off('.delegateEvents' + this.cid);\n      return this;\n    },\n\n    // A finer-grained `undelegateEvents` for removing a single delegated event.\n    // `selector` and `listener` are both optional.\n    undelegate: function(eventName, selector, listener) {\n      this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Produces a DOM element to be assigned to your view. Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _createElement: function(tagName) {\n      return document.createElement(tagName);\n    },\n\n    // Ensure that the View has a DOM element to render into.\n    // If `this.el` is a string, pass it through `$()`, take the first\n    // matching element, and re-assign it to `el`. Otherwise, create\n    // an element from the `id`, `className` and `tagName` properties.\n    _ensureElement: function() {\n      if (!this.el) {\n        var attrs = _.extend({}, _.result(this, 'attributes'));\n        if (this.id) attrs.id = _.result(this, 'id');\n        if (this.className) attrs['class'] = _.result(this, 'className');\n        this.setElement(this._createElement(_.result(this, 'tagName')));\n        this._setAttributes(attrs);\n      } else {\n        this.setElement(_.result(this, 'el'));\n      }\n    },\n\n    // Set attributes from a hash on this view's element.  Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _setAttributes: function(attributes) {\n      this.$el.attr(attributes);\n    }\n\n  });\n\n  // Backbone.sync\n  // -------------\n\n  // Override this function to change the manner in which Backbone persists\n  // models to the server. You will be passed the type of request, and the\n  // model in question. By default, makes a RESTful Ajax request\n  // to the model's `url()`. Some possible customizations could be:\n  //\n  // * Use `setTimeout` to batch rapid-fire updates into a single request.\n  // * Send up the models as XML instead of JSON.\n  // * Persist models via WebSockets instead of Ajax.\n  //\n  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests\n  // as `POST`, with a `_method` parameter containing the true HTTP method,\n  // as well as all requests with the body as `application/x-www-form-urlencoded`\n  // instead of `application/json` with the model in a param named `model`.\n  // Useful when interfacing with server-side languages like **PHP** that make\n  // it difficult to read the body of `PUT` requests.\n  Backbone.sync = function(method, model, options) {\n    var type = methodMap[method];\n\n    // Default options, unless specified.\n    _.defaults(options || (options = {}), {\n      emulateHTTP: Backbone.emulateHTTP,\n      emulateJSON: Backbone.emulateJSON\n    });\n\n    // Default JSON-request options.\n    var params = {type: type, dataType: 'json'};\n\n    // Ensure that we have a URL.\n    if (!options.url) {\n      params.url = _.result(model, 'url') || urlError();\n    }\n\n    // Ensure that we have the appropriate request data.\n    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {\n      params.contentType = 'application/json';\n      params.data = JSON.stringify(options.attrs || model.toJSON(options));\n    }\n\n    // For older servers, emulate JSON by encoding the request into an HTML-form.\n    if (options.emulateJSON) {\n      params.contentType = 'application/x-www-form-urlencoded';\n      params.data = params.data ? {model: params.data} : {};\n    }\n\n    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`\n    // And an `X-HTTP-Method-Override` header.\n    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {\n      params.type = 'POST';\n      if (options.emulateJSON) params.data._method = type;\n      var beforeSend = options.beforeSend;\n      options.beforeSend = function(xhr) {\n        xhr.setRequestHeader('X-HTTP-Method-Override', type);\n        if (beforeSend) return beforeSend.apply(this, arguments);\n      };\n    }\n\n    // Don't process data on a non-GET request.\n    if (params.type !== 'GET' && !options.emulateJSON) {\n      params.processData = false;\n    }\n\n    // Pass along `textStatus` and `errorThrown` from jQuery.\n    var error = options.error;\n    options.error = function(xhr, textStatus, errorThrown) {\n      options.textStatus = textStatus;\n      options.errorThrown = errorThrown;\n      if (error) error.call(options.context, xhr, textStatus, errorThrown);\n    };\n\n    // Make the request, allowing the user to override any Ajax options.\n    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));\n    model.trigger('request', model, xhr, options);\n    return xhr;\n  };\n\n  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.\n  var methodMap = {\n    'create': 'POST',\n    'update': 'PUT',\n    'patch': 'PATCH',\n    'delete': 'DELETE',\n    'read': 'GET'\n  };\n\n  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.\n  // Override this if you'd like to use a different library.\n  Backbone.ajax = function() {\n    return Backbone.$.ajax.apply(Backbone.$, arguments);\n  };\n\n  // Backbone.Router\n  // ---------------\n\n  // Routers map faux-URLs to actions, and fire events when routes are\n  // matched. Creating a new one sets its `routes` hash, if not set statically.\n  var Router = Backbone.Router = function(options) {\n    options || (options = {});\n    if (options.routes) this.routes = options.routes;\n    this._bindRoutes();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regular expressions for matching named param parts and splatted\n  // parts of route strings.\n  var optionalParam = /\\((.*?)\\)/g;\n  var namedParam    = /(\\(\\?)?:\\w+/g;\n  var splatParam    = /\\*\\w+/g;\n  var escapeRegExp  = /[\\-{}\\[\\]+?.,\\\\\\^$|#\\s]/g;\n\n  // Set up all inheritable **Backbone.Router** properties and methods.\n  _.extend(Router.prototype, Events, {\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Manually bind a single named route to a callback. For example:\n    //\n    //     this.route('search/:query/p:num', 'search', function(query, num) {\n    //       ...\n    //     });\n    //\n    route: function(route, name, callback) {\n      if (!_.isRegExp(route)) route = this._routeToRegExp(route);\n      if (_.isFunction(name)) {\n        callback = name;\n        name = '';\n      }\n      if (!callback) callback = this[name];\n      var router = this;\n      Backbone.history.route(route, function(fragment) {\n        var args = router._extractParameters(route, fragment);\n        if (router.execute(callback, args, name) !== false) {\n          router.trigger.apply(router, ['route:' + name].concat(args));\n          router.trigger('route', name, args);\n          Backbone.history.trigger('route', router, name, args);\n        }\n      });\n      return this;\n    },\n\n    // Execute a route handler with the provided parameters.  This is an\n    // excellent place to do pre-route setup or post-route cleanup.\n    execute: function(callback, args, name) {\n      if (callback) callback.apply(this, args);\n    },\n\n    // Simple proxy to `Backbone.history` to save a fragment into the history.\n    navigate: function(fragment, options) {\n      Backbone.history.navigate(fragment, options);\n      return this;\n    },\n\n    // Bind all defined routes to `Backbone.history`. We have to reverse the\n    // order of the routes here to support behavior where the most general\n    // routes can be defined at the bottom of the route map.\n    _bindRoutes: function() {\n      if (!this.routes) return;\n      this.routes = _.result(this, 'routes');\n      var route, routes = _.keys(this.routes);\n      while ((route = routes.pop()) != null) {\n        this.route(route, this.routes[route]);\n      }\n    },\n\n    // Convert a route string into a regular expression, suitable for matching\n    // against the current location hash.\n    _routeToRegExp: function(route) {\n      route = route.replace(escapeRegExp, '\\\\$&')\n                   .replace(optionalParam, '(?:$1)?')\n                   .replace(namedParam, function(match, optional) {\n                     return optional ? match : '([^/?]+)';\n                   })\n                   .replace(splatParam, '([^?]*?)');\n      return new RegExp('^' + route + '(?:\\\\?([\\\\s\\\\S]*))?$');\n    },\n\n    // Given a route, and a URL fragment that it matches, return the array of\n    // extracted decoded parameters. Empty or unmatched parameters will be\n    // treated as `null` to normalize cross-browser behavior.\n    _extractParameters: function(route, fragment) {\n      var params = route.exec(fragment).slice(1);\n      return _.map(params, function(param, i) {\n        // Don't decode the search params.\n        if (i === params.length - 1) return param || null;\n        return param ? decodeURIComponent(param) : null;\n      });\n    }\n\n  });\n\n  // Backbone.History\n  // ----------------\n\n  // Handles cross-browser history management, based on either\n  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or\n  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)\n  // and URL fragments. If the browser supports neither (old IE, natch),\n  // falls back to polling.\n  var History = Backbone.History = function() {\n    this.handlers = [];\n    this.checkUrl = _.bind(this.checkUrl, this);\n\n    // Ensure that `History` can be used outside of the browser.\n    if (typeof window !== 'undefined') {\n      this.location = window.location;\n      this.history = window.history;\n    }\n  };\n\n  // Cached regex for stripping a leading hash/slash and trailing space.\n  var routeStripper = /^[#\\/]|\\s+$/g;\n\n  // Cached regex for stripping leading and trailing slashes.\n  var rootStripper = /^\\/+|\\/+$/g;\n\n  // Cached regex for stripping urls of hash.\n  var pathStripper = /#.*$/;\n\n  // Has the history handling already been started?\n  History.started = false;\n\n  // Set up all inheritable **Backbone.History** properties and methods.\n  _.extend(History.prototype, Events, {\n\n    // The default interval to poll for hash changes, if necessary, is\n    // twenty times a second.\n    interval: 50,\n\n    // Are we at the app root?\n    atRoot: function() {\n      var path = this.location.pathname.replace(/[^\\/]$/, '$&/');\n      return path === this.root && !this.getSearch();\n    },\n\n    // Does the pathname match the root?\n    matchRoot: function() {\n      var path = this.decodeFragment(this.location.pathname);\n      var rootPath = path.slice(0, this.root.length - 1) + '/';\n      return rootPath === this.root;\n    },\n\n    // Unicode characters in `location.pathname` are percent encoded so they're\n    // decoded for comparison. `%25` should not be decoded since it may be part\n    // of an encoded parameter.\n    decodeFragment: function(fragment) {\n      return decodeURI(fragment.replace(/%25/g, '%2525'));\n    },\n\n    // In IE6, the hash fragment and search params are incorrect if the\n    // fragment contains `?`.\n    getSearch: function() {\n      var match = this.location.href.replace(/#.*/, '').match(/\\?.+/);\n      return match ? match[0] : '';\n    },\n\n    // Gets the true hash value. Cannot use location.hash directly due to bug\n    // in Firefox where location.hash will always be decoded.\n    getHash: function(window) {\n      var match = (window || this).location.href.match(/#(.*)$/);\n      return match ? match[1] : '';\n    },\n\n    // Get the pathname and search params, without the root.\n    getPath: function() {\n      var path = this.decodeFragment(\n        this.location.pathname + this.getSearch()\n      ).slice(this.root.length - 1);\n      return path.charAt(0) === '/' ? path.slice(1) : path;\n    },\n\n    // Get the cross-browser normalized URL fragment from the path or hash.\n    getFragment: function(fragment) {\n      if (fragment == null) {\n        if (this._usePushState || !this._wantsHashChange) {\n          fragment = this.getPath();\n        } else {\n          fragment = this.getHash();\n        }\n      }\n      return fragment.replace(routeStripper, '');\n    },\n\n    // Start the hash change handling, returning `true` if the current URL matches\n    // an existing route, and `false` otherwise.\n    start: function(options) {\n      if (History.started) throw new Error('Backbone.history has already been started');\n      History.started = true;\n\n      // Figure out the initial configuration. Do we need an iframe?\n      // Is pushState desired ... is it available?\n      this.options          = _.extend({root: '/'}, this.options, options);\n      this.root             = this.options.root;\n      this._wantsHashChange = this.options.hashChange !== false;\n      this._hasHashChange   = 'onhashchange' in window && (document.documentMode === void 0 || document.documentMode > 7);\n      this._useHashChange   = this._wantsHashChange && this._hasHashChange;\n      this._wantsPushState  = !!this.options.pushState;\n      this._hasPushState    = !!(this.history && this.history.pushState);\n      this._usePushState    = this._wantsPushState && this._hasPushState;\n      this.fragment         = this.getFragment();\n\n      // Normalize root to always include a leading and trailing slash.\n      this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n      // Transition from hashChange to pushState or vice versa if both are\n      // requested.\n      if (this._wantsHashChange && this._wantsPushState) {\n\n        // If we've started off with a route from a `pushState`-enabled\n        // browser, but we're currently in a browser that doesn't support it...\n        if (!this._hasPushState && !this.atRoot()) {\n          var rootPath = this.root.slice(0, -1) || '/';\n          this.location.replace(rootPath + '#' + this.getPath());\n          // Return immediately as browser will do redirect to new url\n          return true;\n\n        // Or if we've started out with a hash-based route, but we're currently\n        // in a browser where it could be `pushState`-based instead...\n        } else if (this._hasPushState && this.atRoot()) {\n          this.navigate(this.getHash(), {replace: true});\n        }\n\n      }\n\n      // Proxy an iframe to handle location events if the browser doesn't\n      // support the `hashchange` event, HTML5 history, or the user wants\n      // `hashChange` but not `pushState`.\n      if (!this._hasHashChange && this._wantsHashChange && !this._usePushState) {\n        this.iframe = document.createElement('iframe');\n        this.iframe.src = 'javascript:0';\n        this.iframe.style.display = 'none';\n        this.iframe.tabIndex = -1;\n        var body = document.body;\n        // Using `appendChild` will throw on IE < 9 if the document is not ready.\n        var iWindow = body.insertBefore(this.iframe, body.firstChild).contentWindow;\n        iWindow.document.open();\n        iWindow.document.close();\n        iWindow.location.hash = '#' + this.fragment;\n      }\n\n      // Add a cross-platform `addEventListener` shim for older browsers.\n      var addEventListener = window.addEventListener || function(eventName, listener) {\n        return attachEvent('on' + eventName, listener);\n      };\n\n      // Depending on whether we're using pushState or hashes, and whether\n      // 'onhashchange' is supported, determine how we check the URL state.\n      if (this._usePushState) {\n        addEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        addEventListener('hashchange', this.checkUrl, false);\n      } else if (this._wantsHashChange) {\n        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);\n      }\n\n      if (!this.options.silent) return this.loadUrl();\n    },\n\n    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,\n    // but possibly useful for unit testing Routers.\n    stop: function() {\n      // Add a cross-platform `removeEventListener` shim for older browsers.\n      var removeEventListener = window.removeEventListener || function(eventName, listener) {\n        return detachEvent('on' + eventName, listener);\n      };\n\n      // Remove window listeners.\n      if (this._usePushState) {\n        removeEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        removeEventListener('hashchange', this.checkUrl, false);\n      }\n\n      // Clean up the iframe if necessary.\n      if (this.iframe) {\n        document.body.removeChild(this.iframe);\n        this.iframe = null;\n      }\n\n      // Some environments will throw when clearing an undefined interval.\n      if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);\n      History.started = false;\n    },\n\n    // Add a route to be tested when the fragment changes. Routes added later\n    // may override previous routes.\n    route: function(route, callback) {\n      this.handlers.unshift({route: route, callback: callback});\n    },\n\n    // Checks the current URL to see if it has changed, and if it has,\n    // calls `loadUrl`, normalizing across the hidden iframe.\n    checkUrl: function(e) {\n      var current = this.getFragment();\n\n      // If the user pressed the back button, the iframe's hash will have\n      // changed and we should use that for comparison.\n      if (current === this.fragment && this.iframe) {\n        current = this.getHash(this.iframe.contentWindow);\n      }\n\n      if (current === this.fragment) return false;\n      if (this.iframe) this.navigate(current);\n      this.loadUrl();\n    },\n\n    // Attempt to load the current URL fragment. If a route succeeds with a\n    // match, returns `true`. If no defined routes matches the fragment,\n    // returns `false`.\n    loadUrl: function(fragment) {\n      // If the root doesn't match, no routes can match either.\n      if (!this.matchRoot()) return false;\n      fragment = this.fragment = this.getFragment(fragment);\n      return _.some(this.handlers, function(handler) {\n        if (handler.route.test(fragment)) {\n          handler.callback(fragment);\n          return true;\n        }\n      });\n    },\n\n    // Save a fragment into the hash history, or replace the URL state if the\n    // 'replace' option is passed. You are responsible for properly URL-encoding\n    // the fragment in advance.\n    //\n    // The options object can contain `trigger: true` if you wish to have the\n    // route callback be fired (not usually desirable), or `replace: true`, if\n    // you wish to modify the current URL without adding an entry to the history.\n    navigate: function(fragment, options) {\n      if (!History.started) return false;\n      if (!options || options === true) options = {trigger: !!options};\n\n      // Normalize the fragment.\n      fragment = this.getFragment(fragment || '');\n\n      // Don't include a trailing slash on the root.\n      var rootPath = this.root;\n      if (fragment === '' || fragment.charAt(0) === '?') {\n        rootPath = rootPath.slice(0, -1) || '/';\n      }\n      var url = rootPath + fragment;\n\n      // Strip the hash and decode for matching.\n      fragment = this.decodeFragment(fragment.replace(pathStripper, ''));\n\n      if (this.fragment === fragment) return;\n      this.fragment = fragment;\n\n      // If pushState is available, we use it to set the fragment as a real URL.\n      if (this._usePushState) {\n        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);\n\n      // If hash changes haven't been explicitly disabled, update the hash\n      // fragment to store history.\n      } else if (this._wantsHashChange) {\n        this._updateHash(this.location, fragment, options.replace);\n        if (this.iframe && fragment !== this.getHash(this.iframe.contentWindow)) {\n          var iWindow = this.iframe.contentWindow;\n\n          // Opening and closing the iframe tricks IE7 and earlier to push a\n          // history entry on hash-tag change.  When replace is true, we don't\n          // want this.\n          if (!options.replace) {\n            iWindow.document.open();\n            iWindow.document.close();\n          }\n\n          this._updateHash(iWindow.location, fragment, options.replace);\n        }\n\n      // If you've told us that you explicitly don't want fallback hashchange-\n      // based history, then `navigate` becomes a page refresh.\n      } else {\n        return this.location.assign(url);\n      }\n      if (options.trigger) return this.loadUrl(fragment);\n    },\n\n    // Update the hash location, either replacing the current entry, or adding\n    // a new one to the browser history.\n    _updateHash: function(location, fragment, replace) {\n      if (replace) {\n        var href = location.href.replace(/(javascript:|#).*$/, '');\n        location.replace(href + '#' + fragment);\n      } else {\n        // Some browsers require that `hash` contains a leading #.\n        location.hash = '#' + fragment;\n      }\n    }\n\n  });\n\n  // Create the default Backbone.history.\n  Backbone.history = new History;\n\n  // Helpers\n  // -------\n\n  // Helper function to correctly set up the prototype chain for subclasses.\n  // Similar to `goog.inherits`, but uses a hash of prototype properties and\n  // class properties to be extended.\n  var extend = function(protoProps, staticProps) {\n    var parent = this;\n    var child;\n\n    // The constructor function for the new subclass is either defined by you\n    // (the \"constructor\" property in your `extend` definition), or defaulted\n    // by us to simply call the parent constructor.\n    if (protoProps && _.has(protoProps, 'constructor')) {\n      child = protoProps.constructor;\n    } else {\n      child = function(){ return parent.apply(this, arguments); };\n    }\n\n    // Add static properties to the constructor function, if supplied.\n    _.extend(child, parent, staticProps);\n\n    // Set the prototype chain to inherit from `parent`, without calling\n    // `parent`'s constructor function and add the prototype properties.\n    child.prototype = _.create(parent.prototype, protoProps);\n    child.prototype.constructor = child;\n\n    // Set a convenience property in case the parent's prototype is needed\n    // later.\n    child.__super__ = parent.prototype;\n\n    return child;\n  };\n\n  // Set up inheritance for the model, collection, router, view and history.\n  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;\n\n  // Throw an error when a URL is needed, and none is supplied.\n  var urlError = function() {\n    throw new Error('A \"url\" property or function must be specified');\n  };\n\n  // Wrap an optional error callback with a fallback error event.\n  var wrapError = function(model, options) {\n    var error = options.error;\n    options.error = function(resp) {\n      if (error) error.call(options.context, model, resp, options);\n      model.trigger('error', model, resp, options);\n    };\n  };\n\n  return Backbone;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/backbone/backbone.js\n// module id = 3\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 20","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 4\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20","\"use strict\";\n\n// Use the fastest means possible to execute a task in its own turn, with\n// priority over other events including IO, animation, reflow, and redraw\n// events in browsers.\n//\n// An exception thrown by a task will permanently interrupt the processing of\n// subsequent tasks. The higher level `asap` function ensures that if an\n// exception is thrown by a task, that the task queue will continue flushing as\n// soon as possible, but if you use `rawAsap` directly, you are responsible to\n// either ensure that no exceptions are thrown from your task, or to manually\n// call `rawAsap.requestFlush` if an exception is thrown.\nmodule.exports = rawAsap;\nfunction rawAsap(task) {\n    if (!queue.length) {\n        requestFlush();\n        flushing = true;\n    }\n    // Equivalent to push, but avoids a function call.\n    queue[queue.length] = task;\n}\n\nvar queue = [];\n// Once a flush has been requested, no further calls to `requestFlush` are\n// necessary until the next `flush` completes.\nvar flushing = false;\n// `requestFlush` is an implementation-specific method that attempts to kick\n// off a `flush` event as quickly as possible. `flush` will attempt to exhaust\n// the event queue before yielding to the browser's own event loop.\nvar requestFlush;\n// The position of the next task to execute in the task queue. This is\n// preserved between calls to `flush` so that it can be resumed if\n// a task throws an exception.\nvar index = 0;\n// If a task schedules additional tasks recursively, the task queue can grow\n// unbounded. To prevent memory exhaustion, the task queue will periodically\n// truncate already-completed tasks.\nvar capacity = 1024;\n\n// The flush function processes all tasks that have been scheduled with\n// `rawAsap` unless and until one of those tasks throws an exception.\n// If a task throws an exception, `flush` ensures that its state will remain\n// consistent and will resume where it left off when called again.\n// However, `flush` does not make any arrangements to be called again if an\n// exception is thrown.\nfunction flush() {\n    while (index < queue.length) {\n        var currentIndex = index;\n        // Advance the index before calling the task. This ensures that we will\n        // begin flushing on the next task the task throws an error.\n        index = index + 1;\n        queue[currentIndex].call();\n        // Prevent leaking memory for long chains of recursive calls to `asap`.\n        // If we call `asap` within tasks scheduled by `asap`, the queue will\n        // grow, but to avoid an O(n) walk for every task we execute, we don't\n        // shift tasks off the queue after they have been executed.\n        // Instead, we periodically shift 1024 tasks off the queue.\n        if (index > capacity) {\n            // Manually shift all values starting at the index back to the\n            // beginning of the queue.\n            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {\n                queue[scan] = queue[scan + index];\n            }\n            queue.length -= index;\n            index = 0;\n        }\n    }\n    queue.length = 0;\n    index = 0;\n    flushing = false;\n}\n\n// `requestFlush` is implemented using a strategy based on data collected from\n// every available SauceLabs Selenium web driver worker at time of writing.\n// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593\n\n// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that\n// have WebKitMutationObserver but not un-prefixed MutationObserver.\n// Must use `global` or `self` instead of `window` to work in both frames and web\n// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.\n\n/* globals self */\nvar scope = typeof global !== \"undefined\" ? global : self;\nvar BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;\n\n// MutationObservers are desirable because they have high priority and work\n// reliably everywhere they are implemented.\n// They are implemented in all modern browsers.\n//\n// - Android 4-4.3\n// - Chrome 26-34\n// - Firefox 14-29\n// - Internet Explorer 11\n// - iPad Safari 6-7.1\n// - iPhone Safari 7-7.1\n// - Safari 6-7\nif (typeof BrowserMutationObserver === \"function\") {\n    requestFlush = makeRequestCallFromMutationObserver(flush);\n\n// MessageChannels are desirable because they give direct access to the HTML\n// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera\n// 11-12, and in web workers in many engines.\n// Although message channels yield to any queued rendering and IO tasks, they\n// would be better than imposing the 4ms delay of timers.\n// However, they do not work reliably in Internet Explorer or Safari.\n\n// Internet Explorer 10 is the only browser that has setImmediate but does\n// not have MutationObservers.\n// Although setImmediate yields to the browser's renderer, it would be\n// preferrable to falling back to setTimeout since it does not have\n// the minimum 4ms penalty.\n// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and\n// Desktop to a lesser extent) that renders both setImmediate and\n// MessageChannel useless for the purposes of ASAP.\n// https://github.com/kriskowal/q/issues/396\n\n// Timers are implemented universally.\n// We fall back to timers in workers in most engines, and in foreground\n// contexts in the following browsers.\n// However, note that even this simple case requires nuances to operate in a\n// broad spectrum of browsers.\n//\n// - Firefox 3-13\n// - Internet Explorer 6-9\n// - iPad Safari 4.3\n// - Lynx 2.8.7\n} else {\n    requestFlush = makeRequestCallFromTimer(flush);\n}\n\n// `requestFlush` requests that the high priority event queue be flushed as\n// soon as possible.\n// This is useful to prevent an error thrown in a task from stalling the event\n// queue if the exception handled by Node.js’s\n// `process.on(\"uncaughtException\")` or by a domain.\nrawAsap.requestFlush = requestFlush;\n\n// To request a high priority event, we induce a mutation observer by toggling\n// the text of a text node between \"1\" and \"-1\".\nfunction makeRequestCallFromMutationObserver(callback) {\n    var toggle = 1;\n    var observer = new BrowserMutationObserver(callback);\n    var node = document.createTextNode(\"\");\n    observer.observe(node, {characterData: true});\n    return function requestCall() {\n        toggle = -toggle;\n        node.data = toggle;\n    };\n}\n\n// The message channel technique was discovered by Malte Ubl and was the\n// original foundation for this library.\n// http://www.nonblocking.io/2011/06/windownexttick.html\n\n// Safari 6.0.5 (at least) intermittently fails to create message ports on a\n// page's first load. Thankfully, this version of Safari supports\n// MutationObservers, so we don't need to fall back in that case.\n\n// function makeRequestCallFromMessageChannel(callback) {\n//     var channel = new MessageChannel();\n//     channel.port1.onmessage = callback;\n//     return function requestCall() {\n//         channel.port2.postMessage(0);\n//     };\n// }\n\n// For reasons explained above, we are also unable to use `setImmediate`\n// under any circumstances.\n// Even if we were, there is another bug in Internet Explorer 10.\n// It is not sufficient to assign `setImmediate` to `requestFlush` because\n// `setImmediate` must be called *by name* and therefore must be wrapped in a\n// closure.\n// Never forget.\n\n// function makeRequestCallFromSetImmediate(callback) {\n//     return function requestCall() {\n//         setImmediate(callback);\n//     };\n// }\n\n// Safari 6.0 has a problem where timers will get lost while the user is\n// scrolling. This problem does not impact ASAP because Safari 6.0 supports\n// mutation observers, so that implementation is used instead.\n// However, if we ever elect to use timers in Safari, the prevalent work-around\n// is to add a scroll event listener that calls for a flush.\n\n// `setTimeout` does not call the passed callback if the delay is less than\n// approximately 7 in web workers in Firefox 8 through 18, and sometimes not\n// even then.\n\nfunction makeRequestCallFromTimer(callback) {\n    return function requestCall() {\n        // We dispatch a timeout with a specified delay of 0 for engines that\n        // can reliably accommodate that request. This will usually be snapped\n        // to a 4 milisecond delay, but once we're flushing, there's no delay\n        // between events.\n        var timeoutHandle = setTimeout(handleTimer, 0);\n        // However, since this timer gets frequently dropped in Firefox\n        // workers, we enlist an interval handle that will try to fire\n        // an event 20 times per second until it succeeds.\n        var intervalHandle = setInterval(handleTimer, 50);\n\n        function handleTimer() {\n            // Whichever timer succeeds will cancel both timers and\n            // execute the callback.\n            clearTimeout(timeoutHandle);\n            clearInterval(intervalHandle);\n            callback();\n        }\n    };\n}\n\n// This is for `asap.js` only.\n// Its name will be periodically randomized to break any code that depends on\n// its existence.\nrawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;\n\n// ASAP was originally a nextTick shim included in Q. This was factored out\n// into this ASAP package. It was later adapted to RSVP which made further\n// amendments. These decisions, particularly to marginalize MessageChannel and\n// to capture the MutationObserver implementation in a closure, were integrated\n// back into ASAP proper.\n// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/~/asap/browser-raw.js\n// module id = 5\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","const Promise = require('promise');\n\n\n// http://stackoverflow.com/questions/901115/how-can-i-get-query-string-values-in-javascript\nexport function getParameterByName(name, url) {\n    if (!url) url = window.location.href;\n    name = name.replace(/[\\[\\]]/g, '\\\\$&');\n    let regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),\n        results = regex.exec(url);\n\n    if (!results) return null;\n    if (!results[2]) return '';\n\n    return decodeURIComponent(results[2].replace(/\\+/g, ' '));\n}\n\n\n/**\n * get the current value of the hash in the URL - if it exists\n * @return @{String}\n */\nexport function getHashFromCurrentUrl() {\n    return window.location.hash ? window.location.hash.replace('#', '') : null;\n}\n\n\n/**\n * truncate the given string after `n` words\n * @param s\n * @param n\n * @param truncationChars @{String} the value to append to the truncated value (if truncation occurs)\n */\nexport function truncateWords(s, n, truncationChars='...') {\n    let words = s.split(' ');\n\n    if (words.length <= n) {\n        return s;\n    }\n\n    let truncated = words.slice(0, n).join(' ');\n    return truncated + truncationChars;\n}\n\n\n/**\n * truncate the given string after `n` characters\n * @param s\n * @param n\n * @param truncationChars\n */\nexport function truncateCharacters(s, n, truncationChars='...') {\n    if (s.length <= n) {\n        return s;\n    }\n\n    return s.substring(0, n) + truncationChars;\n}\n\n\nexport function toTitleCase(str) {\n    return str.replace(/\\w\\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});\n}\n\n\n/**\n * generate a random string of size n (wripped from https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript)\n * @param n\n * @returns {string}\n */\nexport function randomString(n=10) {\n    let text = '';\n    const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n    for (let i = 0; i < n; i++)\n        text += possible.charAt(Math.floor(Math.random() * possible.length));\n\n    return text;\n}\n\n\n\n/**\n * browsers handle calculating the scroll distance from the top of the page differently. This method reconciles the different\n * ways browsers handle getting this value and returns the distance scrolled from the top:\n *\n * https://stackoverflow.com/questions/28633221/document-body-scrolltop-firefox-returns-0-only-js\n *\n * @returns {Number|number}\n */\nexport function scrollTopDistance() {\n    return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;\n}\n\n\n/**\n * toggle the ability to scroll in the page\n * @param flag {Boolean}\n */\nexport function toggleScroll(flag) {\n    $('html,body').css('overflow-y', flag ? 'auto' : 'hidden');\n}\n\n\n/**\n * listen for the window being scrolled to the given `limit` pixels down.\n * @param offset {Number} offset - in pixels - to reach\n * @return {Promise} resolving when the given offset is reached\n */\nexport function whenScrollReached(offset=100) {\n    return new Promise((resolve, reject) => {\n        let onScroll = _.throttle(() => {\n            if (scrollTopDistance() >= offset) {\n                window.removeEventListener('scroll', onScroll);\n                resolve();\n            }\n        }, 100);\n\n        window.addEventListener('scroll', onScroll);\n    });\n}\n\n\n\n// WEBPACK FOOTER //\n// ./js/lib/helpers.js","'use strict';\n\nmodule.exports = require('./lib')\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/index.js\n// module id = 7\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\nvar Promise = require('./core.js');\n\nmodule.exports = Promise;\nPromise.prototype.done = function (onFulfilled, onRejected) {\n  var self = arguments.length ? this.then.apply(this, arguments) : this;\n  self.then(null, function (err) {\n    setTimeout(function () {\n      throw err;\n    }, 0);\n  });\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/done.js\n// module id = 8\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\n//This file contains the ES6 extensions to the core Promises/A+ API\n\nvar Promise = require('./core.js');\n\nmodule.exports = Promise;\n\n/* Static Functions */\n\nvar TRUE = valuePromise(true);\nvar FALSE = valuePromise(false);\nvar NULL = valuePromise(null);\nvar UNDEFINED = valuePromise(undefined);\nvar ZERO = valuePromise(0);\nvar EMPTYSTRING = valuePromise('');\n\nfunction valuePromise(value) {\n  var p = new Promise(Promise._61);\n  p._65 = 1;\n  p._55 = value;\n  return p;\n}\nPromise.resolve = function (value) {\n  if (value instanceof Promise) return value;\n\n  if (value === null) return NULL;\n  if (value === undefined) return UNDEFINED;\n  if (value === true) return TRUE;\n  if (value === false) return FALSE;\n  if (value === 0) return ZERO;\n  if (value === '') return EMPTYSTRING;\n\n  if (typeof value === 'object' || typeof value === 'function') {\n    try {\n      var then = value.then;\n      if (typeof then === 'function') {\n        return new Promise(then.bind(value));\n      }\n    } catch (ex) {\n      return new Promise(function (resolve, reject) {\n        reject(ex);\n      });\n    }\n  }\n  return valuePromise(value);\n};\n\nPromise.all = function (arr) {\n  var args = Array.prototype.slice.call(arr);\n\n  return new Promise(function (resolve, reject) {\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n    function res(i, val) {\n      if (val && (typeof val === 'object' || typeof val === 'function')) {\n        if (val instanceof Promise && val.then === Promise.prototype.then) {\n          while (val._65 === 3) {\n            val = val._55;\n          }\n          if (val._65 === 1) return res(i, val._55);\n          if (val._65 === 2) reject(val._55);\n          val.then(function (val) {\n            res(i, val);\n          }, reject);\n          return;\n        } else {\n          var then = val.then;\n          if (typeof then === 'function') {\n            var p = new Promise(then.bind(val));\n            p.then(function (val) {\n              res(i, val);\n            }, reject);\n            return;\n          }\n        }\n      }\n      args[i] = val;\n      if (--remaining === 0) {\n        resolve(args);\n      }\n    }\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n};\n\nPromise.reject = function (value) {\n  return new Promise(function (resolve, reject) {\n    reject(value);\n  });\n};\n\nPromise.race = function (values) {\n  return new Promise(function (resolve, reject) {\n    values.forEach(function(value){\n      Promise.resolve(value).then(resolve, reject);\n    });\n  });\n};\n\n/* Prototype Methods */\n\nPromise.prototype['catch'] = function (onRejected) {\n  return this.then(null, onRejected);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/es6-extensions.js\n// module id = 9\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\nvar Promise = require('./core.js');\n\nmodule.exports = Promise;\nPromise.prototype['finally'] = function (f) {\n  return this.then(function (value) {\n    return Promise.resolve(f()).then(function () {\n      return value;\n    });\n  }, function (err) {\n    return Promise.resolve(f()).then(function () {\n      throw err;\n    });\n  });\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/finally.js\n// module id = 10\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\nmodule.exports = require('./core.js');\nrequire('./done.js');\nrequire('./finally.js');\nrequire('./es6-extensions.js');\nrequire('./node-extensions.js');\nrequire('./synchronous.js');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/index.js\n// module id = 11\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\n// This file contains then/promise specific extensions that are only useful\n// for node.js interop\n\nvar Promise = require('./core.js');\nvar asap = require('asap');\n\nmodule.exports = Promise;\n\n/* Static Functions */\n\nPromise.denodeify = function (fn, argumentCount) {\n  if (\n    typeof argumentCount === 'number' && argumentCount !== Infinity\n  ) {\n    return denodeifyWithCount(fn, argumentCount);\n  } else {\n    return denodeifyWithoutCount(fn);\n  }\n};\n\nvar callbackFn = (\n  'function (err, res) {' +\n  'if (err) { rj(err); } else { rs(res); }' +\n  '}'\n);\nfunction denodeifyWithCount(fn, argumentCount) {\n  var args = [];\n  for (var i = 0; i < argumentCount; i++) {\n    args.push('a' + i);\n  }\n  var body = [\n    'return function (' + args.join(',') + ') {',\n    'var self = this;',\n    'return new Promise(function (rs, rj) {',\n    'var res = fn.call(',\n    ['self'].concat(args).concat([callbackFn]).join(','),\n    ');',\n    'if (res &&',\n    '(typeof res === \"object\" || typeof res === \"function\") &&',\n    'typeof res.then === \"function\"',\n    ') {rs(res);}',\n    '});',\n    '};'\n  ].join('');\n  return Function(['Promise', 'fn'], body)(Promise, fn);\n}\nfunction denodeifyWithoutCount(fn) {\n  var fnLength = Math.max(fn.length - 1, 3);\n  var args = [];\n  for (var i = 0; i < fnLength; i++) {\n    args.push('a' + i);\n  }\n  var body = [\n    'return function (' + args.join(',') + ') {',\n    'var self = this;',\n    'var args;',\n    'var argLength = arguments.length;',\n    'if (arguments.length > ' + fnLength + ') {',\n    'args = new Array(arguments.length + 1);',\n    'for (var i = 0; i < arguments.length; i++) {',\n    'args[i] = arguments[i];',\n    '}',\n    '}',\n    'return new Promise(function (rs, rj) {',\n    'var cb = ' + callbackFn + ';',\n    'var res;',\n    'switch (argLength) {',\n    args.concat(['extra']).map(function (_, index) {\n      return (\n        'case ' + (index) + ':' +\n        'res = fn.call(' + ['self'].concat(args.slice(0, index)).concat('cb').join(',') + ');' +\n        'break;'\n      );\n    }).join(''),\n    'default:',\n    'args[argLength] = cb;',\n    'res = fn.apply(self, args);',\n    '}',\n    \n    'if (res &&',\n    '(typeof res === \"object\" || typeof res === \"function\") &&',\n    'typeof res.then === \"function\"',\n    ') {rs(res);}',\n    '});',\n    '};'\n  ].join('');\n\n  return Function(\n    ['Promise', 'fn'],\n    body\n  )(Promise, fn);\n}\n\nPromise.nodeify = function (fn) {\n  return function () {\n    var args = Array.prototype.slice.call(arguments);\n    var callback =\n      typeof args[args.length - 1] === 'function' ? args.pop() : null;\n    var ctx = this;\n    try {\n      return fn.apply(this, arguments).nodeify(callback, ctx);\n    } catch (ex) {\n      if (callback === null || typeof callback == 'undefined') {\n        return new Promise(function (resolve, reject) {\n          reject(ex);\n        });\n      } else {\n        asap(function () {\n          callback.call(ctx, ex);\n        })\n      }\n    }\n  }\n};\n\nPromise.prototype.nodeify = function (callback, ctx) {\n  if (typeof callback != 'function') return this;\n\n  this.then(function (value) {\n    asap(function () {\n      callback.call(ctx, null, value);\n    });\n  }, function (err) {\n    asap(function () {\n      callback.call(ctx, err);\n    });\n  });\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/node-extensions.js\n// module id = 12\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\nvar Promise = require('./core.js');\n\nmodule.exports = Promise;\nPromise.enableSynchronous = function () {\n  Promise.prototype.isPending = function() {\n    return this.getState() == 0;\n  };\n\n  Promise.prototype.isFulfilled = function() {\n    return this.getState() == 1;\n  };\n\n  Promise.prototype.isRejected = function() {\n    return this.getState() == 2;\n  };\n\n  Promise.prototype.getValue = function () {\n    if (this._65 === 3) {\n      return this._55.getValue();\n    }\n\n    if (!this.isFulfilled()) {\n      throw new Error('Cannot get a value of an unfulfilled promise.');\n    }\n\n    return this._55;\n  };\n\n  Promise.prototype.getReason = function () {\n    if (this._65 === 3) {\n      return this._55.getReason();\n    }\n\n    if (!this.isRejected()) {\n      throw new Error('Cannot get a rejection reason of a non-rejected promise.');\n    }\n\n    return this._55;\n  };\n\n  Promise.prototype.getState = function () {\n    if (this._65 === 3) {\n      return this._55.getState();\n    }\n    if (this._65 === -1 || this._65 === -2) {\n      return 0;\n    }\n\n    return this._65;\n  };\n};\n\nPromise.disableSynchronous = function() {\n  Promise.prototype.isPending = undefined;\n  Promise.prototype.isFulfilled = undefined;\n  Promise.prototype.isRejected = undefined;\n  Promise.prototype.getValue = undefined;\n  Promise.prototype.getReason = undefined;\n  Promise.prototype.getState = undefined;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/synchronous.js\n// module id = 13\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","\"use strict\";\n\n// rawAsap provides everything we need except exception management.\nvar rawAsap = require(\"./raw\");\n// RawTasks are recycled to reduce GC churn.\nvar freeTasks = [];\n// We queue errors to ensure they are thrown in right order (FIFO).\n// Array-as-queue is good enough here, since we are just dealing with exceptions.\nvar pendingErrors = [];\nvar requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);\n\nfunction throwFirstError() {\n    if (pendingErrors.length) {\n        throw pendingErrors.shift();\n    }\n}\n\n/**\n * Calls a task as soon as possible after returning, in its own event, with priority\n * over other events like animation, reflow, and repaint. An error thrown from an\n * event will not interrupt, nor even substantially slow down the processing of\n * other events, but will be rather postponed to a lower priority event.\n * @param {{call}} task A callable object, typically a function that takes no\n * arguments.\n */\nmodule.exports = asap;\nfunction asap(task) {\n    var rawTask;\n    if (freeTasks.length) {\n        rawTask = freeTasks.pop();\n    } else {\n        rawTask = new RawTask();\n    }\n    rawTask.task = task;\n    rawAsap(rawTask);\n}\n\n// We wrap tasks with recyclable task objects.  A task object implements\n// `call`, just like a function.\nfunction RawTask() {\n    this.task = null;\n}\n\n// The sole purpose of wrapping the task is to catch the exception and recycle\n// the task object after its single use.\nRawTask.prototype.call = function () {\n    try {\n        this.task.call();\n    } catch (error) {\n        if (asap.onerror) {\n            // This hook exists purely for testing purposes.\n            // Its name will be periodically randomized to break any code that\n            // depends on its existence.\n            asap.onerror(error);\n        } else {\n            // In a web browser, exceptions are not fatal. However, to avoid\n            // slowing down the queue of pending tasks, we rethrow the error in a\n            // lower priority turn.\n            pendingErrors.push(error);\n            requestErrorThrow();\n        }\n    } finally {\n        this.task = null;\n        freeTasks[freeTasks.length] = this;\n    }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/~/asap/browser-asap.js\n// module id = 14\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","const Search = Backbone.Model.extend({\n    defaults: {\n        q: null,\n        result_types: [], // limit results returned to only a given list of types\n        fields: ['title', 'permalink'], // limit what fields are retrieved from the API\n        field_assert_names: [], // specify assertions about objects to be returned, based on the contents of their fields\n        field_assert_op: null, // the assertion to make about `field_assert_names` (one of 'contains', 'excludes', or 'empty')\n        field_assert_value: null, // the value to check against the assertion parameterized by `field_assert_names` and `field_assert_op`\n        search_fields: [], // specify which fields should be searched for the query given by `q`\n        smart_match: false, // if true, then we want to apply a potentially more accurate (but more time intensive) search.\n        location: [], // a lat/lng pair (<latitude>,<longitude>) to geoweight results by\n        limit: 10, // max number of results to return\n        fallback: null, // a string describing the fallback action to take when a query yields no results (possible values are: 'all-results')\n        results: []\n    },\n\n    parse(attrs) {\n        attrs['results'] = attrs['data'];\n        return attrs;\n    },\n\n    /**\n     * generate an object which groups results by their type (i.e Attorneys, Practice Areas, etc.)\n     * @returns {{}}\n     */\n    groupResultsByType() {\n        return _.groupBy(this.get('results'), r => r.type);\n    },\n\n    /**\n     * sort our grouped results in descending order, by importance of result types\n     * @param groupedResults {Object}\n     * @return {Array} of {Array} of result type -> results\n     */\n    sortGroupedResults(groupedResults) {\n        const resultPairs = _.pairs(groupedResults);\n        const sortOrder = ['Practice Area', 'Class Action', 'Attorney', 'Location', 'Article', 'FAQ'];\n\n        return _.sortBy(resultPairs, rp => sortOrder.indexOf(rp[0]));\n    },\n\n    reset() {\n        this.set({ q: null, results: [] });\n        this.trigger('reset');\n    },\n\n    url() {\n        let params = {\n            q: this.get('q')\n        };\n\n        let addParamIfSet = (name, isList=false) => {\n            let isSet = isList ? this.get(name).length > 0 : this.get(name);\n            if (isSet) {\n                params[name] = isList ? this.get(name).join(',') : this.get(name);\n            }\n        };\n\n        addParamIfSet('result_types', true);\n        addParamIfSet('fields', true);\n        addParamIfSet('search_fields', true);\n        addParamIfSet('field_assert_names', true);\n        addParamIfSet('field_assert_op');\n        addParamIfSet('field_assert_value');\n        addParamIfSet('smart_match');\n        addParamIfSet('location', true);\n        addParamIfSet('fallback');\n\n        return '//search.forthepeople.com?' + $.param(params);\n    },\n});\n\n\nexport default Search;\n\n\n// WEBPACK FOOTER //\n// ./js/lib/models/search.js","let pendingRequests = [];\n\nconst SearchInput = Backbone.View.extend({\n    events: {\n        'keyup input': 'setQ',\n        'click .btn-close': 'clearSearchFull'\n    },\n\n    initialize(opts) {\n        this.options = {\n            min_chars: 3\n        };\n\n        _.extend(this.options, opts || {});\n\n        this.model.on('reset', this.clearSearchInput, this);\n        this.model.on('change:results', this.setContainerClass, this);\n    },\n\n    setQ(evt) {\n        const ENTER = 13;\n        const q = $(evt.currentTarget).val();\n\n        // if the user hit the enter key, redirect to search results page\n        if (evt.keyCode === ENTER) {\n            let params = {\n                q: q\n            };\n\n            if (this.model.get('result_types').length) {\n                params['type'] = this.model.get('result_types').join(',');\n            }\n\n            window.location = '/search/?' + $.param(params);\n            return;\n        }\n\n        this.model.set({q: q});\n\n        // cancel any pending requests\n        this.cancelPendingRequests();\n\n        if (q.length >= this.options.min_chars) {\n            pendingRequests.push(this.model.fetch());\n        } else {\n            this.model.set({results: []});\n        }\n    },\n\n    cancelPendingRequests() {\n        pendingRequests.map(pr => pr.abort());\n        pendingRequests = [];\n    },\n\n    clearSearchInput() {\n        this.$el.find('input').val('');\n    },\n\n    clearSearchFull() {\n        this.model.reset();\n    },\n\n    setContainerClass() {\n        this.model.get('results').length ? this.$el.addClass('has-results') : this.$el.removeClass('has-results');\n    }\n});\n\n\nexport default SearchInput;\n\n\n// WEBPACK FOOTER //\n// ./js/lib/views/search-input.js","const groupedSearchResultsTpl = require('js/templates/search-results-grouped.html');\nconst listSearchResultsTpl = require('js/templates/search-results-list.html');\nimport { truncateWords } from 'js/lib/helpers';\n\n\nexport const SearchResultsGrouped = Backbone.View.extend({\n    template: groupedSearchResultsTpl,\n\n    initialize(opts) {\n        this.options = {\n            max_result_groups: 3,\n            max_results_per_group: 3\n        };\n\n        _.extend(this.options, opts || {});\n\n        this.model.on('change:results', this.render, this);\n    },\n\n    render() {\n        // group the results by result type, then show the top MAX_RESULT_GROUPS result types\n        let groupedResults = this.model.sortGroupedResults(this.model.groupResultsByType()).slice(0, this.options.max_result_groups);\n        groupedResults.forEach(gr => {\n            gr[1] = gr[1].slice(0, this.options.max_results_per_group);\n        });\n\n        this.$el.html(this.template({\n            resultGroups: groupedResults\n        }));\n\n        groupedResults.length > 0 ? this.$el.addClass('open') : this.$el.removeClass('open');\n    }\n});\n\n\nexport const SearchResultsList = Backbone.View.extend({\n    template: listSearchResultsTpl,\n\n    initialize(opts) {\n        this.options = {\n            max_items: 6\n        };\n\n        _.extend(this.options, opts || {});\n\n        this.model.on('change:results', this.render, this);\n    },\n\n    render() {\n        let results = this.model.get('results').slice(0, this.options.max_items);\n\n        this.$el.html(this.template({\n            results: results,\n            truncate: truncateWords\n        }));\n\n        results.length > 0 ? this.$el.addClass('open') : this.$el.removeClass('open');\n    }\n});\n\n\n// WEBPACK FOOTER //\n// ./js/lib/views/search-results.js","/** an abstraction around client-side storage, whether thats localStorage, Cookies, or Firebase, doesnt matter **/\nlet Cookies = require('js-cookie');\n\n\nclass Storage {\n    get(k, asJSON=false) {\n        return asJSON ? Cookies.getJSON(k) : Cookies.get(k);\n    }\n\n    set(k, v, options={ expires: 7 }) {\n        Cookies.set(k, v, options);\n    }\n}\n\n// a storage-backed array. Meaning, the state of the array is backed by storage and persisted\nclass StoredArray {\n    constructor(props) {\n        let options = {\n            key: null,\n            ttl: 2\n        };\n\n        _.extend(options, props);\n\n        this.key = options.key; // the unique identifier for this stored array (used for saving / loading from storage)\n        this.ttl = options.ttl; // the time to persist this array for (in days)\n        this.backend = new Storage();\n\n        this._state = this.load();\n    }\n\n    /** save the current state of the array **/\n    save() {\n        this.backend.set(this.key, JSON.stringify(this._state), { expires: this.ttl });\n    }\n\n    load() {\n        return this.backend.get(this.key, true) || [];\n    }\n\n    concat(otherArr) {\n        let combined = this._state.concat(otherArr);\n        this.save();\n\n        return combined;\n    }\n\n    push(el) {\n        this._state.push(el);\n        this.save();\n    }\n\n    pop() {\n        let top = this._state.pop();\n        this.save();\n\n        return top;\n    }\n}\n\n\nexport { Storage, StoredArray };\n\n\n// WEBPACK FOOTER //\n// ./js/lib/storage.js","/*!\n * JavaScript Cookie v2.1.4\n * https://github.com/js-cookie/js-cookie\n *\n * Copyright 2006, 2015 Klaus Hartl & Fagner Brack\n * Released under the MIT license\n */\n;(function (factory) {\n\tvar registeredInModuleLoader = false;\n\tif (typeof define === 'function' && define.amd) {\n\t\tdefine(factory);\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (typeof exports === 'object') {\n\t\tmodule.exports = factory();\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (!registeredInModuleLoader) {\n\t\tvar OldCookies = window.Cookies;\n\t\tvar api = window.Cookies = factory();\n\t\tapi.noConflict = function () {\n\t\t\twindow.Cookies = OldCookies;\n\t\t\treturn api;\n\t\t};\n\t}\n}(function () {\n\tfunction extend () {\n\t\tvar i = 0;\n\t\tvar result = {};\n\t\tfor (; i < arguments.length; i++) {\n\t\t\tvar attributes = arguments[ i ];\n\t\t\tfor (var key in attributes) {\n\t\t\t\tresult[key] = attributes[key];\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\n\tfunction init (converter) {\n\t\tfunction api (key, value, attributes) {\n\t\t\tvar result;\n\t\t\tif (typeof document === 'undefined') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Write\n\n\t\t\tif (arguments.length > 1) {\n\t\t\t\tattributes = extend({\n\t\t\t\t\tpath: '/'\n\t\t\t\t}, api.defaults, attributes);\n\n\t\t\t\tif (typeof attributes.expires === 'number') {\n\t\t\t\t\tvar expires = new Date();\n\t\t\t\t\texpires.setMilliseconds(expires.getMilliseconds() + attributes.expires * 864e+5);\n\t\t\t\t\tattributes.expires = expires;\n\t\t\t\t}\n\n\t\t\t\t// We're using \"expires\" because \"max-age\" is not supported by IE\n\t\t\t\tattributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';\n\n\t\t\t\ttry {\n\t\t\t\t\tresult = JSON.stringify(value);\n\t\t\t\t\tif (/^[\\{\\[]/.test(result)) {\n\t\t\t\t\t\tvalue = result;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\n\t\t\t\tif (!converter.write) {\n\t\t\t\t\tvalue = encodeURIComponent(String(value))\n\t\t\t\t\t\t.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);\n\t\t\t\t} else {\n\t\t\t\t\tvalue = converter.write(value, key);\n\t\t\t\t}\n\n\t\t\t\tkey = encodeURIComponent(String(key));\n\t\t\t\tkey = key.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent);\n\t\t\t\tkey = key.replace(/[\\(\\)]/g, escape);\n\n\t\t\t\tvar stringifiedAttributes = '';\n\n\t\t\t\tfor (var attributeName in attributes) {\n\t\t\t\t\tif (!attributes[attributeName]) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '; ' + attributeName;\n\t\t\t\t\tif (attributes[attributeName] === true) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '=' + attributes[attributeName];\n\t\t\t\t}\n\t\t\t\treturn (document.cookie = key + '=' + value + stringifiedAttributes);\n\t\t\t}\n\n\t\t\t// Read\n\n\t\t\tif (!key) {\n\t\t\t\tresult = {};\n\t\t\t}\n\n\t\t\t// To prevent the for loop in the first place assign an empty array\n\t\t\t// in case there are no cookies at all. Also prevents odd result when\n\t\t\t// calling \"get()\"\n\t\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\t\t\tvar rdecode = /(%[0-9A-Z]{2})+/g;\n\t\t\tvar i = 0;\n\n\t\t\tfor (; i < cookies.length; i++) {\n\t\t\t\tvar parts = cookies[i].split('=');\n\t\t\t\tvar cookie = parts.slice(1).join('=');\n\n\t\t\t\tif (cookie.charAt(0) === '\"') {\n\t\t\t\t\tcookie = cookie.slice(1, -1);\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tvar name = parts[0].replace(rdecode, decodeURIComponent);\n\t\t\t\t\tcookie = converter.read ?\n\t\t\t\t\t\tconverter.read(cookie, name) : converter(cookie, name) ||\n\t\t\t\t\t\tcookie.replace(rdecode, decodeURIComponent);\n\n\t\t\t\t\tif (this.json) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tcookie = JSON.parse(cookie);\n\t\t\t\t\t\t} catch (e) {}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (key === name) {\n\t\t\t\t\t\tresult = cookie;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (!key) {\n\t\t\t\t\t\tresult[name] = cookie;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\t\t\t}\n\n\t\t\treturn result;\n\t\t}\n\n\t\tapi.set = api;\n\t\tapi.get = function (key) {\n\t\t\treturn api.call(api, key);\n\t\t};\n\t\tapi.getJSON = function () {\n\t\t\treturn api.apply({\n\t\t\t\tjson: true\n\t\t\t}, [].slice.call(arguments));\n\t\t};\n\t\tapi.defaults = {};\n\n\t\tapi.remove = function (key, attributes) {\n\t\t\tapi(key, '', extend(attributes, {\n\t\t\t\texpires: -1\n\t\t\t}));\n\t\t};\n\n\t\tapi.withConverter = init;\n\n\t\treturn api;\n\t}\n\n\treturn init(function () {});\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/js-cookie/src/js.cookie.js\n// module id = 22\n// module chunks = 0 1 2 4 8 18 19","module.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/search-results-grouped.html -->\\n';\n _.each(resultGroups, function(rg) { \n__p+='\\n<div class=\"result-container\">\\n  <h3>'+\n((__t=( rg[0] ))==null?'':__t)+\n'</h3>\\n  <ul>\\n    ';\n _.each(rg[1], function(result) { \n__p+='\\n    <li>\\n      <a href=\"'+\n((__t=( result.permalink ))==null?'':__t)+\n'\">'+\n((__t=( result.title ))==null?'':__t)+\n'</a>\\n    </li>\\n    ';\n }) \n__p+='\\n  </ul>\\n</div>\\n';\n }) \n__p+='\\n';\n}\nreturn __p;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./js/templates/search-results-grouped.html\n// module id = 23\n// module chunks = 0 6 9 10 11 12 13","module.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/search-results-list.html -->\\n';\n _.each(results, function(r) { \n__p+='\\n<li class=\"result-container\">\\n    <a href=\"'+\n((__t=( r.permalink ))==null?'':__t)+\n'\">\\n        <h3>'+\n((__t=( r.title ))==null?'':__t)+\n'</h3>\\n    </a>\\n</li>\\n';\n }) \n__p+='';\n}\nreturn __p;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./js/templates/search-results-list.html\n// module id = 24\n// module chunks = 0 6 9 10 11 12 13","const Overlay = Backbone.Model.extend({\n    defaults: {\n        isOpen: false\n    }\n});\n\nconst OverlayView = Backbone.View.extend({\n    events: {\n        'click': 'closeOverlay'\n    },\n\n    initialize() {\n        this.model.on('change:isOpen', this.render, this);\n    },\n\n    closeOverlay() {\n        this.model.set({ isOpen: false });\n    },\n\n    render() {\n        this.model.get('isOpen') ? this.$el.fadeIn() : this.$el.fadeOut();\n    }\n});\n\nexport default function makeOverlay() {\n    let overlay = new Overlay();\n\n    new OverlayView({\n        el: '.desktop-search-overlay',\n        model: overlay\n    });\n\n    return overlay;\n}\n\n\n// WEBPACK FOOTER //\n// ./js/lib/views/overlay.js","/**\n * semi-naively categorize the form factor of the user's device as one of (phone, tablet, desktop)\n * @return @{String} the form factor class\n */\nconst getDeviceClass = () => {\n    const sizeMap = [\n        ['phoneSm', 480],\n        ['phoneLg', 768],\n        ['tablet', 992],\n        ['desktop', Infinity]\n    ];\n    const windowWidth = window.innerWidth;\n\n    return sizeMap.filter(mapping => {\n        if (windowWidth <= mapping[1]) {\n            return mapping[0];\n        }\n    })[0][0];\n};\n\n\nexport { getDeviceClass };\n\n\n// WEBPACK FOOTER //\n// ./js/lib/device.js","const ExpandableModel = Backbone.Model.extend({\n    defaults: {\n        isExpanded: false\n    }\n});\n\nexport default ExpandableModel;\n\n\n// WEBPACK FOOTER //\n// ./js/lib/models/expandable.js","let hamburgerTpl = require('js/templates/hamburger.html');\n\nimport Search from 'js/lib/models/search';\nimport { SearchResultsGrouped } from 'js/lib/views/search-results';\nimport SearchInput from 'js/lib/views/search-input';\nimport makeSearchExpander from 'js/lib/views/search-expander';\nimport makeOverlay from 'js/lib/views/overlay';\nimport { toggleScroll } from 'js/lib/helpers';\nimport { getDeviceClass } from 'js/lib/device';\n\n\n/**-- Desktop --**/\nlet desktopSearchModel = new Search({\n    fields: ['title', 'permalink', 'type']\n});\n\nlet searchExpander = makeSearchExpander('.nav-search.desktop');\n\nnew SearchInput({\n    model: desktopSearchModel,\n    el: '.nav-search.desktop .input-container'\n});\n\nnew SearchResultsGrouped({\n    model: desktopSearchModel,\n    el: '.nav-search.desktop .results-container'\n});\n\nlet overlay = makeOverlay();\n\n// when the overlay closes, reset the search model\noverlay.on('change:isOpen', () => !overlay.get('isOpen') && searchExpander.set({ isExpanded: false }));\n\n// when a query is present or the expander is open, show the overlay\ndesktopSearchModel.on('change:q', () => overlay.set({ isOpen: desktopSearchModel.get('q') || searchExpander.get('isExpanded') }));\n\n// when the search expander is 'X'd out of, reset the search results\nsearchExpander.on('change:isExpanded', () => toggleScroll(!searchExpander.get('isExpanded')) || !searchExpander.get('isExpanded') && desktopSearchModel.reset());\n\n/**-- Mobile --**/\nlet mobileSearchModel = new Search({\n    fields: ['title', 'permalink', 'type']\n});\n\nnew SearchInput({\n    model: mobileSearchModel,\n    el: '.nav-search.mobile .input-container'\n});\n\nnew SearchResultsGrouped({\n    model: mobileSearchModel,\n    el: '.nav-search.mobile .results-container'\n});\n\nlet $nav = $('.navbar');\nlet $navInner = $nav.find('.navbar-collapse');\nlet $navHeader = $nav.find('.navbar-header');\nlet $dropdownMenus = $nav.find('.dropdown .dropdown-menu');\n\n/**-- Set The Max-Height Of The Expanded Menu For Mobile --**/\nlet setMobileMenuMaxHeight = () => $navInner.css('max-height', window.innerHeight - $navHeader.height());\n\n/**-- Set The Max-Height Of The Dropdown Menu's for Desktop ONLY --**/\nlet setDropdownMenusMaxHeight = () => $dropdownMenus.each(function() {\n    const DEVICE_CLASS = getDeviceClass();\n    (DEVICE_CLASS === 'tablet' || DEVICE_CLASS === 'desktop') && $(this).css('max-height', window.innerHeight - $navInner.height());\n});\n\n$(window).on('resize', _.debounce(_.compose(setMobileMenuMaxHeight, setDropdownMenusMaxHeight), 300));\nsetMobileMenuMaxHeight();\nsetDropdownMenusMaxHeight();\n\n/**-- Set The Appearance of the Hamburger Depending on Open Vs. Close --**/\n(function bindHamburgerToggle($nav, $hamburgerContainer) {\n    $nav.on('shown.bs.collapse', () => toggleScroll(false) || $hamburgerContainer.html(hamburgerTpl({ isExpanded: true })));\n    $nav.on('hidden.bs.collapse', () => toggleScroll(true) || $hamburgerContainer.html(hamburgerTpl({ isExpanded: false })));\n})($nav, $nav.find('.navbar-header button'));\n\n\n// WEBPACK FOOTER //\n// ./js/components/global-nav.js","let template = require('js/templates/go-to-top.html');\n\n\nconst GoToTop = Backbone.Model.extend({\n    defaults: {\n        isShown: false,\n        showAt: 50\n    },\n\n    maybeShow() {\n        let scrollTop = $(window).scrollTop();\n        this.set({ isShown: scrollTop >= this.get('showAt') });\n    },\n\n    initialize() {\n        $(window).scroll(_.throttle(this.maybeShow.bind(this), 100));\n    }\n});\n\nconst GoToTopView = Backbone.View.extend({\n    template: template,\n    events: {\n        'click #go-top': 'scrollUp'\n    },\n\n    initialize() {\n        this.$el.html(this.template());\n        this.model.on('change:isShown', this.render, this);\n    },\n\n    scrollUp(evt) {\n        $('html, body').animate({\n            scrollTop: $($(evt.currentTarget).attr('href')).offset().top\n        });\n    },\n\n    render() {\n        this.model.get('isShown') ? this.$el.addClass('show') : this.$el.removeClass('show');\n    }\n});\n\n\nconst goToTopFactory = function(el, opts) {\n    let model = new GoToTop(opts || {});\n\n    return new GoToTopView({\n        el: el,\n        model: model\n    });\n};\n\nexport default goToTopFactory;\n\n\n// WEBPACK FOOTER //\n// ./js/components/go-to-top.js","$('#more-related-articles').on('click', function( event ) {\n    event.preventDefault();\n    event.currentTarget.remove();\n    $('.related-articles ul li').show().css('text-align', 'left');\n});\n\n\n// WEBPACK FOOTER //\n// ./js/components/sidebar.js","$('.social-share-expanding .more').on('click', function( event ) {\n    var $button = $(event.currentTarget);\n    if ($button.hasClass('plus')) {\n        $button.removeClass('plus');\n        $button.find('img.plus').addClass('hidden');\n        $button.find('img.minus').removeClass('hidden');\n    } else {\n        $button.addClass('plus');\n        $button.find('img.plus').removeClass('hidden');\n        $button.find('img.minus').addClass('hidden');\n    }\n});\n\n\n// WEBPACK FOOTER //\n// ./js/components/social-share-expanding.js","import { Storage } from 'js/lib/storage';\n\nlet storage = new Storage();\nlet shouldSetAttributionParams = () => !/thank-you/.test( document.location.href );\n\n/**\n * set the sessions landing page URL\n */\nexport function setLandingURL() {\n    if (storage.get('MMLandingURL') && shouldSetAttributionParams()) {\n        return;\n    }\n\n    storage.set('MMLandingURL', document.location.href, { expires: 30 });\n}\n\n\n/**\n * set the sessions landing timestamp\n */\nexport function setLandingTimestamp() {\n    document.addEventListener('DOMContentLoaded', function(event) {\n        if (storage.get('MMLandingTimestamp') && shouldSetAttributionParams()) {\n            return;\n        }\n\n        storage.set('MMLandingTimestamp', $('meta[name=request-timestamp]').attr('content'), { expires: 30 });\n    });\n}\n\n\n// WEBPACK FOOTER //\n// ./js/lib/attribution.js","let hbspt = require('hubspot');\nimport { Storage } from 'js/lib/storage';\n\n\nlet storage = new Storage();\n\nlet renderForm = (portalId, formId, target, onFormReady=() => null) => {\n    let onFormReadyWrapped = $form => {\n        $form.find('input[name=\"tracked_landing_page\"]').val(storage.get('MMLandingURL'));\n        $form.find('input[name=\"tracked_landing_timestamp\"]').val(storage.get('MMLandingTimestamp'));\n\n        onFormReady($form);\n    };\n\n    hbspt.forms.create({\n        portalId: portalId,\n        formId: formId,\n        target: target,\n        onFormReady: onFormReadyWrapped,\n        onFormSubmit: $form => {\n            storage.remove('MMLandingURL');\n            storage.remove('MMLandingTimestamp');\n\n            $form.find('input, textarea').each(() => {\n                let el = $(this).get(0);\n\n                $(this).val($(this).val().replace(/\\n|\\r/g, ' '));\n                el.defaultValue = el.defaultValue.replace(/\\n|\\r/g, ' ');\n            });\n        }\n    });\n};\n\n\nexport default renderForm;\n\n\n// WEBPACK FOOTER //\n// ./js/lib/forms.js","// Console-polyfill. MIT license.\n// https://github.com/paulmillr/console-polyfill\n// Make it safe to do console.log() always.\n(function(global) {\n  'use strict';\n  if (!global.console) {\n    global.console = {};\n  }\n  var con = global.console;\n  var prop, method;\n  var dummy = function() {};\n  var properties = ['memory'];\n  var methods = ('assert,clear,count,debug,dir,dirxml,error,exception,group,' +\n     'groupCollapsed,groupEnd,info,log,markTimeline,profile,profiles,profileEnd,' +\n     'show,table,time,timeEnd,timeline,timelineEnd,timeStamp,trace,warn').split(',');\n  while (prop = properties.pop()) if (!con[prop]) con[prop] = {};\n  while (method = methods.pop()) if (!con[method]) con[method] = dummy;\n  // Using `this` for web workers & supports Browserify / Webpack.\n})(typeof window === 'undefined' ? this : window);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/console-polyfill/index.js\n// module id = 58\n// module chunks = 0","// polyfills\nrequire('console-polyfill');\n\n\n// attribution\nimport { setLandingURL, setLandingTimestamp } from 'js/lib/attribution';\n\nsetLandingURL();\nsetLandingTimestamp();\n\n\n// forms\nimport renderForm from 'js/lib/forms';\nconsole.log(`**${window.MM.forms.length} forms**`);\nwindow.MM.forms.forEach(f => renderForm(f.portal, f.form, f.target, f.onFormReady || (() => null)));\n\n\n// common components\nrequire('js/components/global-nav');\nrequire('js/components/sidebar');\nrequire('js/components/social-share-expanding');\n\nimport GoToTopButton from 'js/components/go-to-top';\n\nGoToTopButton('.go-to-top-container');\n\n\n// WEBPACK FOOTER //\n// ./js/core.js","/** a search expander (the most ubiquitous example being a magnifying glass which expands into an input field is responsible\n * for doing a couple of things:\n *\n * 1) On click of the expander element, apply the expanded class to the container element\n * 2) On click of the 'X' button added to the expanded container, close the container (by removing the expanded class)\n **/\nimport ExpandableModel from 'js/lib/models/expandable';\n\nconst SearchExpander = Backbone.View.extend({\n    events: {\n        'click .expander': 'openExpander',\n        'click .btn-close-expander': 'closeExpander',\n    },\n\n    initialize(opts) {\n        this.options = {\n            expanded_class: 'focused'\n        };\n\n        _.extend(this.options, opts || {});\n\n        this.model.on('change:isExpanded', this.render, this);\n    },\n\n    openExpander() {\n        this.model.set({ isExpanded: true });\n    },\n\n    closeExpander() {\n        this.model.set({ isExpanded: false });\n    },\n\n    render() {\n        this.model.get('isExpanded') ? this.$el.addClass(this.options.expanded_class) && this.$el.find('input').focus() : this.$el.removeClass(this.options.expanded_class);\n    }\n});\n\n\nexport default function makeSearchExpander(el, opts) {\n    let model = new ExpandableModel();\n    new SearchExpander($.extend({\n        el: el,\n        model: model\n    }, opts || {}));\n\n    return model;\n}\n\n\n// WEBPACK FOOTER //\n// ./js/lib/views/search-expander.js","module.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/go-to-top.html -->\\n<!-- go-to-top.html -->\\n<a id=\"go-top\" class=\"go-top\" href=\"#masthead\"><i class=\"fa fa-chevron-up\" aria-hidden=\"true\"></i></a>\\n';\n}\nreturn __p;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./js/templates/go-to-top.html\n// module id = 118\n// module chunks = 0","module.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/hamburger.html -->\\n';\n if (!isExpanded) { \n__p+='\\n<span class=\"icon-bar\"></span>\\n<span class=\"icon-bar\"></span>\\n<span class=\"icon-bar\"></span>\\n';\n } else { \n__p+='\\n<span class=\"close\">&times;</span>\\n';\n } \n__p+='';\n}\nreturn __p;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./js/templates/hamburger.html\n// module id = 119\n// module chunks = 0","module.exports = hbspt;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"hbspt\"\n// module id = 122\n// module chunks = 0"],"sourceRoot":""}