\";return a(j);\n }, createView: function createView() {\n var a = this.createDropdown(),\n b = this.createLi();return a.find(\"ul\")[0].innerHTML = b, a;\n }, reloadLi: function reloadLi() {\n var a = this.createLi();this.$menuInner[0].innerHTML = a;\n }, createLi: function createLi() {\n var c = this,\n d = [],\n e = 0,\n f = document.createElement(\"option\"),\n g = -1,\n h = function h(a, b, c, d) {\n return \"\" + a + \"\";\n },\n j = function j(d, e, f, g) {\n return '' + d + '';\n };if (this.options.title && !this.multiple && (g--, !this.$element.find(\".bs-title-option\").length)) {\n var k = this.$element[0];f.className = \"bs-title-option\", f.innerHTML = this.options.title, f.value = \"\", k.insertBefore(f, k.firstChild);var l = a(k.options[k.selectedIndex]);void 0 === l.attr(\"selected\") && void 0 === this.$element.data(\"selected\") && (f.selected = !0);\n }var m = this.$element.find(\"option\");return m.each(function (b) {\n var f = a(this);if (g++, !f.hasClass(\"bs-title-option\")) {\n var k,\n l = this.className || \"\",\n n = i(this.style.cssText),\n o = f.data(\"content\") ? f.data(\"content\") : f.html(),\n p = f.data(\"tokens\") ? f.data(\"tokens\") : null,\n q = \"undefined\" != typeof f.data(\"subtext\") ? '' + f.data(\"subtext\") + \"\" : \"\",\n r = \"undefined\" != typeof f.data(\"icon\") ? ' ' : \"\",\n s = f.parent(),\n t = \"OPTGROUP\" === s[0].tagName,\n u = t && s[0].disabled,\n v = this.disabled || u;if (\"\" !== r && v && (r = \"\" + r + \"\"), c.options.hideDisabled && (v && !t || u)) return k = f.data(\"prevHiddenIndex\"), f.next().data(\"prevHiddenIndex\", void 0 !== k ? k : b), void g--;if (f.data(\"content\") || (o = r + '' + o + q + \"\"), t && f.data(\"divider\") !== !0) {\n if (c.options.hideDisabled && v) {\n if (void 0 === s.data(\"allOptionsDisabled\")) {\n var w = s.children();s.data(\"allOptionsDisabled\", w.filter(\":disabled\").length === w.length);\n }if (s.data(\"allOptionsDisabled\")) return void g--;\n }var x = \" \" + s[0].className || \"\";if (0 === f.index()) {\n e += 1;var y = s[0].label,\n z = \"undefined\" != typeof s.data(\"subtext\") ? '' + s.data(\"subtext\") + \"\" : \"\",\n A = s.data(\"icon\") ? ' ' : \"\";y = A + '' + i(y) + z + \"\", 0 !== b && d.length > 0 && (g++, d.push(h(\"\", null, \"divider\", e + \"div\"))), g++, d.push(h(y, null, \"dropdown-header\" + x, e));\n }if (c.options.hideDisabled && v) return void g--;d.push(h(j(o, \"opt \" + l + x, n, p), b, \"\", e));\n } else if (f.data(\"divider\") === !0) d.push(h(\"\", b, \"divider\"));else if (f.data(\"hidden\") === !0) k = f.data(\"prevHiddenIndex\"), f.next().data(\"prevHiddenIndex\", void 0 !== k ? k : b), d.push(h(j(o, l, n, p), b, \"hidden is-hidden\"));else {\n var B = this.previousElementSibling && \"OPTGROUP\" === this.previousElementSibling.tagName;if (!B && c.options.hideDisabled && (k = f.data(\"prevHiddenIndex\"), void 0 !== k)) {\n var C = m.eq(k)[0].previousElementSibling;C && \"OPTGROUP\" === C.tagName && !C.disabled && (B = !0);\n }B && (g++, d.push(h(\"\", null, \"divider\", e + \"div\"))), d.push(h(j(o, l, n, p), b));\n }c.liObj[b] = g;\n }\n }), this.multiple || 0 !== this.$element.find(\"option:selected\").length || this.options.title || this.$element.find(\"option\").eq(0).prop(\"selected\", !0).attr(\"selected\", \"selected\"), d.join(\"\");\n }, findLis: function findLis() {\n return null == this.$lis && (this.$lis = this.$menu.find(\"li\")), this.$lis;\n }, render: function render(b) {\n var c,\n d = this,\n e = this.$element.find(\"option\");b !== !1 && e.each(function (a) {\n var b = d.findLis().eq(d.liObj[a]);d.setDisabled(a, this.disabled || \"OPTGROUP\" === this.parentNode.tagName && this.parentNode.disabled, b), d.setSelected(a, this.selected, b);\n }), this.togglePlaceholder(), this.tabIndex();var f = e.map(function () {\n if (this.selected) {\n if (d.options.hideDisabled && (this.disabled || \"OPTGROUP\" === this.parentNode.tagName && this.parentNode.disabled)) return;var b,\n c = a(this),\n e = c.data(\"icon\") && d.options.showIcon ? ' ' : \"\";return b = d.options.showSubtext && c.data(\"subtext\") && !d.multiple ? ' ' + c.data(\"subtext\") + \"\" : \"\", \"undefined\" != typeof c.attr(\"title\") ? c.attr(\"title\") : c.data(\"content\") && d.options.showContent ? c.data(\"content\").toString() : e + c.html() + b;\n }\n }).toArray(),\n g = this.multiple ? f.join(this.options.multipleSeparator) : f[0];if (this.multiple && this.options.selectedTextFormat.indexOf(\"count\") > -1) {\n var h = this.options.selectedTextFormat.split(\">\");if (h.length > 1 && f.length > h[1] || 1 == h.length && f.length >= 2) {\n c = this.options.hideDisabled ? \", [disabled]\" : \"\";var i = e.not('[data-divider=\"true\"], [data-hidden=\"true\"]' + c).length,\n k = \"function\" == typeof this.options.countSelectedText ? this.options.countSelectedText(f.length, i) : this.options.countSelectedText;g = k.replace(\"{0}\", f.length.toString()).replace(\"{1}\", i.toString());\n }\n }void 0 == this.options.title && (this.options.title = this.$element.attr(\"title\")), \"static\" == this.options.selectedTextFormat && (g = this.options.title), g || (g = \"undefined\" != typeof this.options.title ? this.options.title : this.options.noneSelectedText), this.$button.attr(\"title\", j(a.trim(g.replace(/<[^>]*>?/g, \"\")))), this.$button.children(\".filter-option\").html(g), this.$element.trigger(\"rendered.bs.select\");\n }, setStyle: function setStyle(a, b) {\n this.$element.attr(\"class\") && this.$newElement.addClass(this.$element.attr(\"class\").replace(/selectpicker|mobile-device|bs-select-hidden|validate\\[.*\\]/gi, \"\"));var c = a ? a : this.options.style;\"add\" == b ? this.$button.addClass(c) : \"remove\" == b ? this.$button.removeClass(c) : (this.$button.removeClass(this.options.style), this.$button.addClass(c));\n }, liHeight: function liHeight(b) {\n if (b || this.options.size !== !1 && !this.sizeInfo) {\n var c = document.createElement(\"div\"),\n d = document.createElement(\"div\"),\n e = document.createElement(\"ul\"),\n f = document.createElement(\"li\"),\n g = document.createElement(\"li\"),\n h = document.createElement(\"a\"),\n i = document.createElement(\"span\"),\n j = this.options.header && this.$menu.find(\".popover-title\").length > 0 ? this.$menu.find(\".popover-title\")[0].cloneNode(!0) : null,\n k = this.options.liveSearch ? document.createElement(\"div\") : null,\n l = this.options.actionsBox && this.multiple && this.$menu.find(\".bs-actionsbox\").length > 0 ? this.$menu.find(\".bs-actionsbox\")[0].cloneNode(!0) : null,\n m = this.options.doneButton && this.multiple && this.$menu.find(\".bs-donebutton\").length > 0 ? this.$menu.find(\".bs-donebutton\")[0].cloneNode(!0) : null;if (i.className = \"text\", c.className = this.$menu[0].parentNode.className + \" open\", d.className = \"dropdown-menu open\", e.className = \"dropdown-menu inner\", f.className = \"divider\", i.appendChild(document.createTextNode(\"Inner text\")), h.appendChild(i), g.appendChild(h), e.appendChild(g), e.appendChild(f), j && d.appendChild(j), k) {\n var n = document.createElement(\"input\");k.className = \"bs-searchbox\", n.className = \"form-control\", k.appendChild(n), d.appendChild(k);\n }l && d.appendChild(l), d.appendChild(e), m && d.appendChild(m), c.appendChild(d), document.body.appendChild(c);var o = h.offsetHeight,\n p = j ? j.offsetHeight : 0,\n q = k ? k.offsetHeight : 0,\n r = l ? l.offsetHeight : 0,\n s = m ? m.offsetHeight : 0,\n t = a(f).outerHeight(!0),\n u = \"function\" == typeof getComputedStyle && getComputedStyle(d),\n v = u ? null : a(d),\n w = { vert: parseInt(u ? u.paddingTop : v.css(\"paddingTop\")) + parseInt(u ? u.paddingBottom : v.css(\"paddingBottom\")) + parseInt(u ? u.borderTopWidth : v.css(\"borderTopWidth\")) + parseInt(u ? u.borderBottomWidth : v.css(\"borderBottomWidth\")), horiz: parseInt(u ? u.paddingLeft : v.css(\"paddingLeft\")) + parseInt(u ? u.paddingRight : v.css(\"paddingRight\")) + parseInt(u ? u.borderLeftWidth : v.css(\"borderLeftWidth\")) + parseInt(u ? u.borderRightWidth : v.css(\"borderRightWidth\")) },\n x = { vert: w.vert + parseInt(u ? u.marginTop : v.css(\"marginTop\")) + parseInt(u ? u.marginBottom : v.css(\"marginBottom\")) + 2, horiz: w.horiz + parseInt(u ? u.marginLeft : v.css(\"marginLeft\")) + parseInt(u ? u.marginRight : v.css(\"marginRight\")) + 2 };document.body.removeChild(c), this.sizeInfo = { liHeight: o, headerHeight: p, searchHeight: q, actionsHeight: r, doneButtonHeight: s, dividerHeight: t, menuPadding: w, menuExtras: x };\n }\n }, setSize: function setSize() {\n if (this.findLis(), this.liHeight(), this.options.header && this.$menu.css(\"padding-top\", 0), this.options.size !== !1) {\n var b,\n c,\n d,\n e,\n f,\n g,\n h,\n i,\n j = this,\n k = this.$menu,\n l = this.$menuInner,\n m = a(window),\n n = this.$newElement[0].offsetHeight,\n o = this.$newElement[0].offsetWidth,\n p = this.sizeInfo.liHeight,\n q = this.sizeInfo.headerHeight,\n r = this.sizeInfo.searchHeight,\n s = this.sizeInfo.actionsHeight,\n t = this.sizeInfo.doneButtonHeight,\n u = this.sizeInfo.dividerHeight,\n v = this.sizeInfo.menuPadding,\n w = this.sizeInfo.menuExtras,\n x = this.options.hideDisabled ? \".disabled\" : \"\",\n y = function y() {\n var b,\n c = j.$newElement.offset(),\n d = a(j.options.container);j.options.container && !d.is(\"body\") ? (b = d.offset(), b.top += parseInt(d.css(\"borderTopWidth\")), b.left += parseInt(d.css(\"borderLeftWidth\"))) : b = { top: 0, left: 0 };var e = j.options.windowPadding;f = c.top - b.top - m.scrollTop(), g = m.height() - f - n - b.top - e[2], h = c.left - b.left - m.scrollLeft(), i = m.width() - h - o - b.left - e[1], f -= e[0], h -= e[3];\n };if (y(), \"auto\" === this.options.size) {\n var z = function z() {\n var m,\n n = function n(b, c) {\n return function (d) {\n return c ? d.classList ? d.classList.contains(b) : a(d).hasClass(b) : !(d.classList ? d.classList.contains(b) : a(d).hasClass(b));\n };\n },\n u = j.$menuInner[0].getElementsByTagName(\"li\"),\n x = Array.prototype.filter ? Array.prototype.filter.call(u, n(\"hidden\", !1)) : j.$lis.not(\".hidden\"),\n z = Array.prototype.filter ? Array.prototype.filter.call(x, n(\"dropdown-header\", !0)) : x.filter(\".dropdown-header\");y(), b = g - w.vert, c = i - w.horiz, j.options.container ? (k.data(\"height\") || k.data(\"height\", k.height()), d = k.data(\"height\"), k.data(\"width\") || k.data(\"width\", k.width()), e = k.data(\"width\")) : (d = k.height(), e = k.width()), j.options.dropupAuto && j.$newElement.toggleClass(\"dropup\", f > g && b - w.vert < d), j.$newElement.hasClass(\"dropup\") && (b = f - w.vert), \"auto\" === j.options.dropdownAlignRight && k.toggleClass(\"dropdown-menu-right\", h > i && c - w.horiz < e - o), m = x.length + z.length > 3 ? 3 * p + w.vert - 2 : 0, k.css({ \"max-height\": b + \"px\", overflow: \"hidden\", \"min-height\": m + q + r + s + t + \"px\" }), l.css({ \"max-height\": b - q - r - s - t - v.vert + \"px\", \"overflow-y\": \"auto\", \"min-height\": Math.max(m - v.vert, 0) + \"px\" });\n };z(), this.$searchbox.off(\"input.getSize propertychange.getSize\").on(\"input.getSize propertychange.getSize\", z), m.off(\"resize.getSize scroll.getSize\").on(\"resize.getSize scroll.getSize\", z);\n } else if (this.options.size && \"auto\" != this.options.size && this.$lis.not(x).length > this.options.size) {\n var A = this.$lis.not(\".divider\").not(x).children().slice(0, this.options.size).last().parent().index(),\n B = this.$lis.slice(0, A + 1).filter(\".divider\").length;b = p * this.options.size + B * u + v.vert, j.options.container ? (k.data(\"height\") || k.data(\"height\", k.height()), d = k.data(\"height\")) : d = k.height(), j.options.dropupAuto && this.$newElement.toggleClass(\"dropup\", f > g && b - w.vert < d), k.css({ \"max-height\": b + q + r + s + t + \"px\", overflow: \"hidden\", \"min-height\": \"\" }), l.css({ \"max-height\": b - v.vert + \"px\", \"overflow-y\": \"auto\", \"min-height\": \"\" });\n }\n }\n }, setWidth: function setWidth() {\n if (\"auto\" === this.options.width) {\n this.$menu.css(\"min-width\", \"0\");var a = this.$menu.parent().clone().appendTo(\"body\"),\n b = this.options.container ? this.$newElement.clone().appendTo(\"body\") : a,\n c = a.children(\".dropdown-menu\").outerWidth(),\n d = b.css(\"width\", \"auto\").children(\"button\").outerWidth();a.remove(), b.remove(), this.$newElement.css(\"width\", Math.max(c, d) + \"px\");\n } else \"fit\" === this.options.width ? (this.$menu.css(\"min-width\", \"\"), this.$newElement.css(\"width\", \"\").addClass(\"fit-width\")) : this.options.width ? (this.$menu.css(\"min-width\", \"\"), this.$newElement.css(\"width\", this.options.width)) : (this.$menu.css(\"min-width\", \"\"), this.$newElement.css(\"width\", \"\"));this.$newElement.hasClass(\"fit-width\") && \"fit\" !== this.options.width && this.$newElement.removeClass(\"fit-width\");\n }, selectPosition: function selectPosition() {\n this.$bsContainer = a('');var b,\n c,\n d,\n e = this,\n f = a(this.options.container),\n g = function g(a) {\n e.$bsContainer.addClass(a.attr(\"class\").replace(/form-control|fit-width/gi, \"\")).toggleClass(\"dropup\", a.hasClass(\"dropup\")), b = a.offset(), f.is(\"body\") ? c = { top: 0, left: 0 } : (c = f.offset(), c.top += parseInt(f.css(\"borderTopWidth\")) - f.scrollTop(), c.left += parseInt(f.css(\"borderLeftWidth\")) - f.scrollLeft()), d = a.hasClass(\"dropup\") ? 0 : a[0].offsetHeight, e.$bsContainer.css({ top: b.top - c.top + d, left: b.left - c.left, width: a[0].offsetWidth });\n };this.$button.on(\"click\", function () {\n var b = a(this);e.isDisabled() || (g(e.$newElement), e.$bsContainer.appendTo(e.options.container).toggleClass(\"open\", !b.hasClass(\"open\")).append(e.$menu));\n }), a(window).on(\"resize scroll\", function () {\n g(e.$newElement);\n }), this.$element.on(\"hide.bs.select\", function () {\n e.$menu.data(\"height\", e.$menu.height()), e.$bsContainer.detach();\n });\n }, setSelected: function setSelected(a, b, c) {\n c || (this.togglePlaceholder(), c = this.findLis().eq(this.liObj[a])), c.toggleClass(\"selected\", b).find(\"a\").attr(\"aria-selected\", b);\n }, setDisabled: function setDisabled(a, b, c) {\n c || (c = this.findLis().eq(this.liObj[a])), b ? c.addClass(\"disabled\").children(\"a\").attr(\"href\", \"#\").attr(\"tabindex\", -1).attr(\"aria-disabled\", !0) : c.removeClass(\"disabled\").children(\"a\").removeAttr(\"href\").attr(\"tabindex\", 0).attr(\"aria-disabled\", !1);\n }, isDisabled: function isDisabled() {\n return this.$element[0].disabled;\n }, checkDisabled: function checkDisabled() {\n var a = this;this.isDisabled() ? (this.$newElement.addClass(\"disabled\"), this.$button.addClass(\"disabled\").attr(\"tabindex\", -1).attr(\"aria-disabled\", !0)) : (this.$button.hasClass(\"disabled\") && (this.$newElement.removeClass(\"disabled\"), this.$button.removeClass(\"disabled\").attr(\"aria-disabled\", !1)), this.$button.attr(\"tabindex\") != -1 || this.$element.data(\"tabindex\") || this.$button.removeAttr(\"tabindex\")), this.$button.click(function () {\n return !a.isDisabled();\n });\n }, togglePlaceholder: function togglePlaceholder() {\n var a = this.$element.val();this.$button.toggleClass(\"bs-placeholder\", null === a || \"\" === a || a.constructor === Array && 0 === a.length);\n }, tabIndex: function tabIndex() {\n this.$element.data(\"tabindex\") !== this.$element.attr(\"tabindex\") && this.$element.attr(\"tabindex\") !== -98 && \"-98\" !== this.$element.attr(\"tabindex\") && (this.$element.data(\"tabindex\", this.$element.attr(\"tabindex\")), this.$button.attr(\"tabindex\", this.$element.data(\"tabindex\"))), this.$element.attr(\"tabindex\", -98);\n }, clickListener: function clickListener() {\n var b = this,\n c = a(document);c.data(\"spaceSelect\", !1), this.$button.on(\"keyup\", function (a) {\n /(32)/.test(a.keyCode.toString(10)) && c.data(\"spaceSelect\") && (a.preventDefault(), c.data(\"spaceSelect\", !1));\n }), this.$button.on(\"click\", function () {\n b.setSize();\n }), this.$element.on(\"shown.bs.select\", function () {\n if (b.options.liveSearch || b.multiple) {\n if (!b.multiple) {\n var a = b.liObj[b.$element[0].selectedIndex];if (\"number\" != typeof a || b.options.size === !1) return;var c = b.$lis.eq(a)[0].offsetTop - b.$menuInner[0].offsetTop;c = c - b.$menuInner[0].offsetHeight / 2 + b.sizeInfo.liHeight / 2, b.$menuInner[0].scrollTop = c;\n }\n } else b.$menuInner.find(\".selected a\").focus();\n }), this.$menuInner.on(\"click\", \"li a\", function (c) {\n var d = a(this),\n f = d.parent().data(\"originalIndex\"),\n g = b.$element.val(),\n h = b.$element.prop(\"selectedIndex\"),\n i = !0;if (b.multiple && 1 !== b.options.maxOptions && c.stopPropagation(), c.preventDefault(), !b.isDisabled() && !d.parent().hasClass(\"disabled\")) {\n var j = b.$element.find(\"option\"),\n k = j.eq(f),\n l = k.prop(\"selected\"),\n m = k.parent(\"optgroup\"),\n n = b.options.maxOptions,\n o = m.data(\"maxOptions\") || !1;if (b.multiple) {\n if (k.prop(\"selected\", !l), b.setSelected(f, !l), d.blur(), n !== !1 || o !== !1) {\n var p = n < j.filter(\":selected\").length,\n q = o < m.find(\"option:selected\").length;if (n && p || o && q) if (n && 1 == n) j.prop(\"selected\", !1), k.prop(\"selected\", !0), b.$menuInner.find(\".selected\").removeClass(\"selected\"), b.setSelected(f, !0);else if (o && 1 == o) {\n m.find(\"option:selected\").prop(\"selected\", !1), k.prop(\"selected\", !0);var r = d.parent().data(\"optgroup\");b.$menuInner.find('[data-optgroup=\"' + r + '\"]').removeClass(\"selected\"), b.setSelected(f, !0);\n } else {\n var s = \"string\" == typeof b.options.maxOptionsText ? [b.options.maxOptionsText, b.options.maxOptionsText] : b.options.maxOptionsText,\n t = \"function\" == typeof s ? s(n, o) : s,\n u = t[0].replace(\"{n}\", n),\n v = t[1].replace(\"{n}\", o),\n w = a('');t[2] && (u = u.replace(\"{var}\", t[2][n > 1 ? 0 : 1]), v = v.replace(\"{var}\", t[2][o > 1 ? 0 : 1])), k.prop(\"selected\", !1), b.$menu.append(w), n && p && (w.append(a(\"
\" + u + \"
\")), i = !1, b.$element.trigger(\"maxReached.bs.select\")), o && q && (w.append(a(\"
\" + v + \"
\")), i = !1, b.$element.trigger(\"maxReachedGrp.bs.select\")), setTimeout(function () {\n b.setSelected(f, !1);\n }, 10), w.delay(750).fadeOut(300, function () {\n a(this).remove();\n });\n }\n }\n } else j.prop(\"selected\", !1), k.prop(\"selected\", !0), b.$menuInner.find(\".selected\").removeClass(\"selected\").find(\"a\").attr(\"aria-selected\", !1), b.setSelected(f, !0);!b.multiple || b.multiple && 1 === b.options.maxOptions ? b.$button.focus() : b.options.liveSearch && b.$searchbox.focus(), i && (g != b.$element.val() && b.multiple || h != b.$element.prop(\"selectedIndex\") && !b.multiple) && (e = [f, k.prop(\"selected\"), l], b.$element.triggerNative(\"change\"));\n }\n }), this.$menu.on(\"click\", \"li.disabled a, .popover-title, .popover-title :not(.close)\", function (c) {\n c.currentTarget == this && (c.preventDefault(), c.stopPropagation(), b.options.liveSearch && !a(c.target).hasClass(\"close\") ? b.$searchbox.focus() : b.$button.focus());\n }), this.$menuInner.on(\"click\", \".divider, .dropdown-header\", function (a) {\n a.preventDefault(), a.stopPropagation(), b.options.liveSearch ? b.$searchbox.focus() : b.$button.focus();\n }), this.$menu.on(\"click\", \".popover-title .close\", function () {\n b.$button.click();\n }), this.$searchbox.on(\"click\", function (a) {\n a.stopPropagation();\n }), this.$menu.on(\"click\", \".actions-btn\", function (c) {\n b.options.liveSearch ? b.$searchbox.focus() : b.$button.focus(), c.preventDefault(), c.stopPropagation(), a(this).hasClass(\"bs-select-all\") ? b.selectAll() : b.deselectAll();\n }), this.$element.change(function () {\n b.render(!1), b.$element.trigger(\"changed.bs.select\", e), e = null;\n });\n }, liveSearchListener: function liveSearchListener() {\n var c = this,\n d = a('');this.$button.on(\"click.dropdown.data-api\", function () {\n c.$menuInner.find(\".active\").removeClass(\"active\"), c.$searchbox.val() && (c.$searchbox.val(\"\"), c.$lis.not(\".is-hidden\").removeClass(\"hidden\"), d.parent().length && d.remove()), c.multiple || c.$menuInner.find(\".selected\").addClass(\"active\"), setTimeout(function () {\n c.$searchbox.focus();\n }, 10);\n }), this.$searchbox.on(\"click.dropdown.data-api focus.dropdown.data-api touchend.dropdown.data-api\", function (a) {\n a.stopPropagation();\n }), this.$searchbox.on(\"input propertychange\", function () {\n if (c.$lis.not(\".is-hidden\").removeClass(\"hidden\"), c.$lis.filter(\".active\").removeClass(\"active\"), d.remove(), c.$searchbox.val()) {\n var e,\n f = c.$lis.not(\".is-hidden, .divider, .dropdown-header\");if (e = c.options.liveSearchNormalize ? f.not(\":a\" + c._searchStyle() + '(\"' + b(c.$searchbox.val()) + '\")') : f.not(\":\" + c._searchStyle() + '(\"' + c.$searchbox.val() + '\")'), e.length === f.length) d.html(c.options.noneResultsText.replace(\"{0}\", '\"' + i(c.$searchbox.val()) + '\"')), c.$menuInner.append(d), c.$lis.addClass(\"hidden\");else {\n e.addClass(\"hidden\");var g,\n h = c.$lis.not(\".hidden\");h.each(function (b) {\n var c = a(this);c.hasClass(\"divider\") ? void 0 === g ? c.addClass(\"hidden\") : (g && g.addClass(\"hidden\"), g = c) : c.hasClass(\"dropdown-header\") && h.eq(b + 1).data(\"optgroup\") !== c.data(\"optgroup\") ? c.addClass(\"hidden\") : g = null;\n }), g && g.addClass(\"hidden\"), f.not(\".hidden\").first().addClass(\"active\"), c.$menuInner.scrollTop(0);\n }\n }\n });\n }, _searchStyle: function _searchStyle() {\n var a = { begins: \"ibegins\", startsWith: \"ibegins\" };return a[this.options.liveSearchStyle] || \"icontains\";\n }, val: function val(a) {\n return \"undefined\" != typeof a ? (this.$element.val(a), this.render(), this.$element) : this.$element.val();\n }, changeAll: function changeAll(b) {\n if (this.multiple) {\n \"undefined\" == typeof b && (b = !0), this.findLis();var c = this.$element.find(\"option\"),\n d = this.$lis.not(\".divider, .dropdown-header, .disabled, .hidden\"),\n e = d.length,\n f = [];if (b) {\n if (d.filter(\".selected\").length === d.length) return;\n } else if (0 === d.filter(\".selected\").length) return;d.toggleClass(\"selected\", b);for (var g = 0; g < e; g++) {\n var h = d[g].getAttribute(\"data-original-index\");f[f.length] = c.eq(h)[0];\n }a(f).prop(\"selected\", b), this.render(!1), this.togglePlaceholder(), this.$element.triggerNative(\"change\");\n }\n }, selectAll: function selectAll() {\n return this.changeAll(!0);\n }, deselectAll: function deselectAll() {\n return this.changeAll(!1);\n }, toggle: function toggle(a) {\n a = a || window.event, a && a.stopPropagation(), this.$button.trigger(\"click\");\n }, keydown: function keydown(b) {\n var c,\n d,\n e,\n f,\n g = a(this),\n h = g.is(\"input\") ? g.parent().parent() : g.parent(),\n i = h.data(\"this\"),\n j = \":not(.disabled, .hidden, .dropdown-header, .divider)\",\n k = { 32: \" \", 48: \"0\", 49: \"1\", 50: \"2\", 51: \"3\", 52: \"4\", 53: \"5\", 54: \"6\", 55: \"7\", 56: \"8\", 57: \"9\", 59: \";\", 65: \"a\", 66: \"b\", 67: \"c\", 68: \"d\", 69: \"e\", 70: \"f\", 71: \"g\", 72: \"h\", 73: \"i\", 74: \"j\", 75: \"k\", 76: \"l\", 77: \"m\", 78: \"n\", 79: \"o\", 80: \"p\", 81: \"q\", 82: \"r\", 83: \"s\", 84: \"t\", 85: \"u\", 86: \"v\", 87: \"w\", 88: \"x\", 89: \"y\", 90: \"z\", 96: \"0\", 97: \"1\", 98: \"2\", 99: \"3\", 100: \"4\", 101: \"5\", 102: \"6\", 103: \"7\", 104: \"8\", 105: \"9\" };if (f = i.$newElement.hasClass(\"open\"), !f && (b.keyCode >= 48 && b.keyCode <= 57 || b.keyCode >= 96 && b.keyCode <= 105 || b.keyCode >= 65 && b.keyCode <= 90)) return i.options.container ? i.$button.trigger(\"click\") : (i.setSize(), i.$menu.parent().addClass(\"open\"), f = !0), void i.$searchbox.focus();if (i.options.liveSearch && /(^9$|27)/.test(b.keyCode.toString(10)) && f && (b.preventDefault(), b.stopPropagation(), i.$menuInner.click(), i.$button.focus()), /(38|40)/.test(b.keyCode.toString(10))) {\n if (c = i.$lis.filter(j), !c.length) return;d = i.options.liveSearch ? c.index(c.filter(\".active\")) : c.index(c.find(\"a\").filter(\":focus\").parent()), e = i.$menuInner.data(\"prevIndex\"), 38 == b.keyCode ? (!i.options.liveSearch && d != e || d == -1 || d--, d < 0 && (d += c.length)) : 40 == b.keyCode && ((i.options.liveSearch || d == e) && d++, d %= c.length), i.$menuInner.data(\"prevIndex\", d), i.options.liveSearch ? (b.preventDefault(), g.hasClass(\"dropdown-toggle\") || (c.removeClass(\"active\").eq(d).addClass(\"active\").children(\"a\").focus(), g.focus())) : c.eq(d).children(\"a\").focus();\n } else if (!g.is(\"input\")) {\n var l,\n m,\n n = [];c = i.$lis.filter(j), c.each(function (c) {\n a.trim(a(this).children(\"a\").text().toLowerCase()).substring(0, 1) == k[b.keyCode] && n.push(c);\n }), l = a(document).data(\"keycount\"), l++, a(document).data(\"keycount\", l), m = a.trim(a(\":focus\").text().toLowerCase()).substring(0, 1), m != k[b.keyCode] ? (l = 1, a(document).data(\"keycount\", l)) : l >= n.length && (a(document).data(\"keycount\", 0), l > n.length && (l = 1)), c.eq(n[l - 1]).children(\"a\").focus();\n }if ((/(13|32)/.test(b.keyCode.toString(10)) || /(^9$)/.test(b.keyCode.toString(10)) && i.options.selectOnTab) && f) {\n if (/(32)/.test(b.keyCode.toString(10)) || b.preventDefault(), i.options.liveSearch) /(32)/.test(b.keyCode.toString(10)) || (i.$menuInner.find(\".active a\").click(), g.focus());else {\n var o = a(\":focus\");o.click(), o.focus(), b.preventDefault(), a(document).data(\"spaceSelect\", !0);\n }a(document).data(\"keycount\", 0);\n }(/(^9$|27)/.test(b.keyCode.toString(10)) && f && (i.multiple || i.options.liveSearch) || /(27)/.test(b.keyCode.toString(10)) && !f) && (i.$menu.parent().removeClass(\"open\"), i.options.container && i.$newElement.removeClass(\"open\"), i.$button.focus());\n }, mobile: function mobile() {\n this.$element.addClass(\"mobile-device\");\n }, refresh: function refresh() {\n this.$lis = null, this.liObj = {}, this.reloadLi(), this.render(), this.checkDisabled(), this.liHeight(!0), this.setStyle(), this.setWidth(), this.$lis && this.$searchbox.trigger(\"propertychange\"), this.$element.trigger(\"refreshed.bs.select\");\n }, hide: function hide() {\n this.$newElement.hide();\n }, show: function show() {\n this.$newElement.show();\n }, remove: function remove() {\n this.$newElement.remove(), this.$element.remove();\n }, destroy: function destroy() {\n this.$newElement.before(this.$element).remove(), this.$bsContainer ? this.$bsContainer.remove() : this.$menu.remove(), this.$element.off(\".bs.select\").removeData(\"selectpicker\").removeClass(\"bs-select-hidden selectpicker\");\n } };var l = a.fn.selectpicker;a.fn.selectpicker = c, a.fn.selectpicker.Constructor = k, a.fn.selectpicker.noConflict = function () {\n return a.fn.selectpicker = l, this;\n }, a(document).data(\"keycount\", 0).on(\"keydown.bs.select\", '.bootstrap-select [data-toggle=dropdown], .bootstrap-select [role=\"listbox\"], .bs-searchbox input', k.prototype.keydown).on(\"focusin.modal\", '.bootstrap-select [data-toggle=dropdown], .bootstrap-select [role=\"listbox\"], .bs-searchbox input', function (a) {\n a.stopPropagation();\n }), a(window).on(\"load.bs.select.data-api\", function () {\n a(\".selectpicker\").each(function () {\n var b = a(this);c.call(b, b.data());\n });\n });\n }(a);\n});\n//# sourceMappingURL=bootstrap-select.js.map\n\n/***/ }),\n/* 147 */,\n/* 148 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n/***/ }),\n/* 149 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// Underscore.js 1.7.0\n// http://underscorejs.org\n// (c) 2009-2014 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 concat = ArrayProto.concat,\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\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.7.0';\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 createCallback = 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 _.iteratee = function(value, context, argCount) {\n if (value == null) return _.identity;\n if (_.isFunction(value)) return createCallback(value, context, argCount);\n if (_.isObject(value)) return _.matches(value);\n return _.property(value);\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 if (obj == null) return obj;\n iteratee = createCallback(iteratee, context);\n var i, length = obj.length;\n if (length === +length) {\n for (i = 0; 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 if (obj == null) return [];\n iteratee = _.iteratee(iteratee, context);\n var keys = obj.length !== +obj.length && _.keys(obj),\n length = (keys || obj).length,\n results = Array(length),\n currentKey;\n for (var index = 0; index < length; index++) {\n currentKey = keys ? keys[index] : index;\n results[index] = iteratee(obj[currentKey], currentKey, obj);\n }\n return results;\n };\n\n var reduceError = 'Reduce of empty array with no initial value';\n\n // **Reduce** builds up a single result from a list of values, aka `inject`,\n // or `foldl`.\n _.reduce = _.foldl = _.inject = function(obj, iteratee, memo, context) {\n if (obj == null) obj = [];\n iteratee = createCallback(iteratee, context, 4);\n var keys = obj.length !== +obj.length && _.keys(obj),\n length = (keys || obj).length,\n index = 0, currentKey;\n if (arguments.length < 3) {\n if (!length) throw new TypeError(reduceError);\n memo = obj[keys ? keys[index++] : index++];\n }\n for (; index < length; index++) {\n currentKey = keys ? keys[index] : index;\n memo = iteratee(memo, obj[currentKey], currentKey, obj);\n }\n return memo;\n };\n\n // The right-associative version of reduce, also known as `foldr`.\n _.reduceRight = _.foldr = function(obj, iteratee, memo, context) {\n if (obj == null) obj = [];\n iteratee = createCallback(iteratee, context, 4);\n var keys = obj.length !== + obj.length && _.keys(obj),\n index = (keys || obj).length,\n currentKey;\n if (arguments.length < 3) {\n if (!index) throw new TypeError(reduceError);\n memo = obj[keys ? keys[--index] : --index];\n }\n while (index--) {\n currentKey = keys ? keys[index] : index;\n memo = iteratee(memo, obj[currentKey], currentKey, obj);\n }\n return memo;\n };\n\n // Return the first value which passes a truth test. Aliased as `detect`.\n _.find = _.detect = function(obj, predicate, context) {\n var result;\n predicate = _.iteratee(predicate, context);\n _.some(obj, function(value, index, list) {\n if (predicate(value, index, list)) {\n result = value;\n return true;\n }\n });\n return result;\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 if (obj == null) return results;\n predicate = _.iteratee(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(_.iteratee(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 if (obj == null) return true;\n predicate = _.iteratee(predicate, context);\n var keys = obj.length !== +obj.length && _.keys(obj),\n length = (keys || obj).length,\n index, currentKey;\n for (index = 0; index < length; index++) {\n 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 if (obj == null) return false;\n predicate = _.iteratee(predicate, context);\n var keys = obj.length !== +obj.length && _.keys(obj),\n length = (keys || obj).length,\n index, currentKey;\n for (index = 0; index < length; index++) {\n 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 value (using `===`).\n // Aliased as `include`.\n _.contains = _.include = function(obj, target) {\n if (obj == null) return false;\n if (obj.length !== +obj.length) obj = _.values(obj);\n return _.indexOf(obj, target) >= 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 return (isFunc ? method : value[method]).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, _.matches(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, _.matches(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 = obj.length === +obj.length ? 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 = _.iteratee(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 = obj.length === +obj.length ? 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 = _.iteratee(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 = obj && obj.length === +obj.length ? 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 (obj.length !== +obj.length) 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 = _.iteratee(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 = _.iteratee(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 // 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 = _.iteratee(iteratee, context, 1);\n var value = iteratee(obj);\n var low = 0, high = array.length;\n while (low < high) {\n var mid = low + high >>> 1;\n if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n }\n return low;\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 (obj.length === +obj.length) 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 obj.length === +obj.length ? 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 = _.iteratee(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 if (n < 0) return [];\n return slice.call(array, 0, 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. The **guard** check allows it to work with\n // `_.map`.\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. The **guard** check allows it to work with `_.map`.\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 slice.call(array, Math.max(array.length - n, 0));\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. The **guard**\n // check allows it to work with `_.map`.\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, output) {\n if (shallow && _.every(input, _.isArray)) {\n return concat.apply(output, input);\n }\n for (var i = 0, length = input.length; i < length; i++) {\n var value = input[i];\n if (!_.isArray(value) && !_.isArguments(value)) {\n if (!strict) output.push(value);\n } else if (shallow) {\n push.apply(output, value);\n } else {\n flatten(value, shallow, strict, output);\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 (array == null) return [];\n if (!_.isBoolean(isSorted)) {\n context = iteratee;\n iteratee = isSorted;\n isSorted = false;\n }\n if (iteratee != null) iteratee = _.iteratee(iteratee, context);\n var result = [];\n var seen = [];\n for (var i = 0, length = array.length; i < length; i++) {\n var value = array[i];\n if (isSorted) {\n if (!i || seen !== value) result.push(value);\n seen = value;\n } else if (iteratee) {\n var computed = iteratee(value, i, array);\n if (_.indexOf(seen, computed) < 0) {\n seen.push(computed);\n result.push(value);\n }\n } else if (_.indexOf(result, value) < 0) {\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 if (array == null) return [];\n var result = [];\n var argsLength = arguments.length;\n for (var i = 0, length = array.length; 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(slice.call(arguments, 1), true, true, []);\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(array) {\n if (array == null) return [];\n var length = _.max(arguments, 'length').length;\n var results = Array(length);\n for (var i = 0; i < length; i++) {\n results[i] = _.pluck(arguments, i);\n }\n return results;\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 if (list == null) return {};\n var result = {};\n for (var i = 0, length = list.length; 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 // 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 = function(array, item, isSorted) {\n if (array == null) return -1;\n var i = 0, length = array.length;\n if (isSorted) {\n if (typeof isSorted == 'number') {\n i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;\n } else {\n i = _.sortedIndex(array, item);\n return array[i] === item ? i : -1;\n }\n }\n for (; i < length; i++) if (array[i] === item) return i;\n return -1;\n };\n\n _.lastIndexOf = function(array, item, from) {\n if (array == null) return -1;\n var idx = array.length;\n if (typeof from == 'number') {\n idx = from < 0 ? idx + from + 1 : Math.min(idx, from + 1);\n }\n while (--idx >= 0) if (array[idx] === item) return idx;\n return -1;\n };\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 (arguments.length <= 1) {\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 // Reusable constructor function for prototype setting.\n var Ctor = function(){};\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 var args, bound;\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 args = slice.call(arguments, 2);\n bound = function() {\n if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));\n Ctor.prototype = func.prototype;\n var self = new Ctor;\n Ctor.prototype = null;\n var result = func.apply(self, args.concat(slice.call(arguments)));\n if (_.isObject(result)) return result;\n return self;\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 return function() {\n var position = 0;\n var args = boundArgs.slice();\n for (var i = 0, length = args.length; i < length; i++) {\n if (args[i] === _) args[i] = arguments[position++];\n }\n while (position < arguments.length) args.push(arguments[position++]);\n return func.apply(this, args);\n };\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 = function(func) {\n return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));\n };\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 clearTimeout(timeout);\n timeout = null;\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 after being called N times.\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 before being called N times.\n _.before = function(times, func) {\n var memo;\n return function() {\n if (--times > 0) {\n memo = func.apply(this, arguments);\n } else {\n func = null;\n }\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 // Retrieve the names of an object's 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 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 // 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 = function(obj) {\n if (!_.isObject(obj)) return obj;\n var source, prop;\n for (var i = 1, length = arguments.length; i < length; i++) {\n source = arguments[i];\n for (prop in source) {\n if (hasOwnProperty.call(source, prop)) {\n obj[prop] = source[prop];\n }\n }\n }\n return obj;\n };\n\n // Return a copy of the object only containing the whitelisted properties.\n _.pick = function(obj, iteratee, context) {\n var result = {}, key;\n if (obj == null) return result;\n if (_.isFunction(iteratee)) {\n iteratee = createCallback(iteratee, context);\n for (key in obj) {\n var value = obj[key];\n if (iteratee(value, key, obj)) result[key] = value;\n }\n } else {\n var keys = concat.apply([], slice.call(arguments, 1));\n obj = new Object(obj);\n for (var i = 0, length = keys.length; i < length; i++) {\n key = keys[i];\n if (key in obj) result[key] = obj[key];\n }\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(concat.apply([], slice.call(arguments, 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 = function(obj) {\n if (!_.isObject(obj)) return obj;\n for (var i = 1, length = arguments.length; i < length; i++) {\n var source = arguments[i];\n for (var prop in source) {\n if (obj[prop] === void 0) obj[prop] = source[prop];\n }\n }\n return obj;\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 // 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 if (typeof a != 'object' || typeof b != 'object') return false;\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 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 // Objects with different constructors are not equivalent, but `Object`s\n // from different frames are.\n var aCtor = a.constructor, bCtor = b.constructor;\n if (\n aCtor !== bCtor &&\n // Handle Object.create(x) cases\n 'constructor' in a && 'constructor' in b &&\n !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n _.isFunction(bCtor) && bCtor instanceof bCtor)\n ) {\n return false;\n }\n // Add the first object to the stack of traversed objects.\n aStack.push(a);\n bStack.push(b);\n var size, result;\n // Recursively compare objects and arrays.\n if (className === '[object Array]') {\n // Compare array lengths to determine if a deep comparison is necessary.\n size = a.length;\n result = size === b.length;\n if (result) {\n // Deep compare the contents, ignoring non-numeric properties.\n while (size--) {\n if (!(result = eq(a[size], b[size], aStack, bStack))) break;\n }\n }\n } else {\n // Deep compare objects.\n var keys = _.keys(a), key;\n size = keys.length;\n // Ensure that both objects contain the same number of properties before comparing deep equality.\n result = _.keys(b).length === size;\n if (result) {\n while (size--) {\n // Deep compare each member\n key = keys[size];\n if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;\n }\n }\n }\n // Remove the first object from the stack of traversed objects.\n aStack.pop();\n bStack.pop();\n return result;\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 (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)) return obj.length === 0;\n for (var key in obj) if (_.has(obj, key)) return false;\n return true;\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.\n _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], 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), 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 an IE 11 bug.\n if (true) {\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 = function(key) {\n return function(obj) {\n return obj[key];\n };\n };\n\n // Returns a predicate for checking whether an object has a given set of `key:value` pairs.\n _.matches = function(attrs) {\n var pairs = _.pairs(attrs), length = pairs.length;\n return function(obj) {\n if (obj == null) return !length;\n obj = new Object(obj);\n for (var i = 0; i < length; i++) {\n var pair = pairs[i], key = pair[0];\n if (pair[1] !== obj[key] || !(key in obj)) return false;\n }\n return true;\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 = createCallback(iteratee, context, 1);\n for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n return accum;\n };\n\n // Return a random integer between min and max (inclusive).\n _.random = function(min, max) {\n if (max == null) {\n max = min;\n min = 0;\n }\n return min + Math.floor(Math.random() * (max - min + 1));\n };\n\n // A (possibly faster) way to get the current timestamp as an integer.\n _.now = Date.now || function() {\n return new Date().getTime();\n };\n\n // List of HTML entities for escaping.\n var escapeMap = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": ''',\n '`': '`'\n };\n var unescapeMap = _.invert(escapeMap);\n\n // Functions for escaping and unescaping strings to/from HTML interpolation.\n var createEscaper = function(map) {\n var escaper = function(match) {\n return map[match];\n };\n // Regexes for identifying a key that needs to be escaped\n var source = '(?:' + _.keys(map).join('|') + ')';\n var testRegexp = RegExp(source);\n var replaceRegexp = RegExp(source, 'g');\n return function(string) {\n string = string == null ? '' : '' + string;\n return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n };\n };\n _.escape = createEscaper(escapeMap);\n _.unescape = createEscaper(unescapeMap);\n\n // If the value of the named `property` is a function then invoke it with the\n // `object` as context; otherwise, return it.\n _.result = function(object, property) {\n if (object == null) return void 0;\n var value = object[property];\n return _.isFunction(value) ? object[property]() : 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(obj) {\n return this._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.call(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.call(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.call(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 // 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/* 150 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(process) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (root, factory) {\n if (\"function\" === 'function' && __webpack_require__(11) && __webpack_require__(11).dust === true) {\n !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __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__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n } else if (true) {\n module.exports = factory();\n } else {\n root.dust = factory();\n }\n}(this, function() {\n var dust = {\n \"version\": \"2.7.5\"\n },\n NONE = 'NONE', ERROR = 'ERROR', WARN = 'WARN', INFO = 'INFO', DEBUG = 'DEBUG',\n EMPTY_FUNC = function() {};\n\n dust.config = {\n whitespace: false,\n amd: false,\n cjs: false,\n cache: true\n };\n\n // Directive aliases to minify code\n dust._aliases = {\n \"write\": \"w\",\n \"end\": \"e\",\n \"map\": \"m\",\n \"render\": \"r\",\n \"reference\": \"f\",\n \"section\": \"s\",\n \"exists\": \"x\",\n \"notexists\": \"nx\",\n \"block\": \"b\",\n \"partial\": \"p\",\n \"helper\": \"h\"\n };\n\n (function initLogging() {\n /*global process, console*/\n var loggingLevels = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, NONE: 4 },\n consoleLog,\n log;\n\n if (typeof console !== 'undefined' && console.log) {\n consoleLog = console.log;\n if(typeof consoleLog === 'function') {\n log = function() {\n consoleLog.apply(console, arguments);\n };\n } else {\n log = function() {\n consoleLog(Array.prototype.slice.apply(arguments).join(' '));\n };\n }\n } else {\n log = EMPTY_FUNC;\n }\n\n /**\n * Filters messages based on `dust.debugLevel`.\n * This default implementation will print to the console if it exists.\n * @param {String|Error} message the message to print/throw\n * @param {String} type the severity of the message(ERROR, WARN, INFO, or DEBUG)\n * @public\n */\n dust.log = function(message, type) {\n type = type || INFO;\n if (loggingLevels[type] >= loggingLevels[dust.debugLevel]) {\n log('[DUST:' + type + ']', message);\n }\n };\n\n dust.debugLevel = NONE;\n if(typeof process !== 'undefined' && process.env && /\\bdust\\b/.test(process.env.DEBUG)) {\n dust.debugLevel = DEBUG;\n }\n\n }());\n\n dust.helpers = {};\n\n dust.cache = {};\n\n dust.register = function(name, tmpl) {\n if (!name) {\n return;\n }\n tmpl.templateName = name;\n if (dust.config.cache !== false) {\n dust.cache[name] = tmpl;\n }\n };\n\n dust.render = function(nameOrTemplate, context, callback) {\n var chunk = new Stub(callback).head;\n try {\n load(nameOrTemplate, chunk, context).end();\n } catch (err) {\n chunk.setError(err);\n }\n };\n\n dust.stream = function(nameOrTemplate, context) {\n var stream = new Stream(),\n chunk = stream.head;\n dust.nextTick(function() {\n try {\n load(nameOrTemplate, chunk, context).end();\n } catch (err) {\n chunk.setError(err);\n }\n });\n return stream;\n };\n\n /**\n * Extracts a template function (body_0) from whatever is passed.\n * @param nameOrTemplate {*} Could be:\n * - the name of a template to load from cache\n * - a CommonJS-compiled template (a function with a `template` property)\n * - a template function\n * @param loadFromCache {Boolean} if false, don't look in the cache\n * @return {Function} a template function, if found\n */\n function getTemplate(nameOrTemplate, loadFromCache/*=true*/) {\n if(!nameOrTemplate) {\n return;\n }\n if(typeof nameOrTemplate === 'function' && nameOrTemplate.template) {\n // Sugar away CommonJS module templates\n return nameOrTemplate.template;\n }\n if(dust.isTemplateFn(nameOrTemplate)) {\n // Template functions passed directly\n return nameOrTemplate;\n }\n if(loadFromCache !== false) {\n // Try loading a template with this name from cache\n return dust.cache[nameOrTemplate];\n }\n }\n\n function load(nameOrTemplate, chunk, context) {\n if(!nameOrTemplate) {\n return chunk.setError(new Error('No template or template name provided to render'));\n }\n\n var template = getTemplate(nameOrTemplate, dust.config.cache);\n\n if (template) {\n return template(chunk, Context.wrap(context, template.templateName));\n } else {\n if (dust.onLoad) {\n return chunk.map(function(chunk) {\n // Alias just so it's easier to read that this would always be a name\n var name = nameOrTemplate;\n // Three possible scenarios for a successful callback:\n // - `require(nameOrTemplate)(dust); cb()`\n // - `src = readFile('src.dust'); cb(null, src)`\n // - `compiledTemplate = require(nameOrTemplate)(dust); cb(null, compiledTemplate)`\n function done(err, srcOrTemplate) {\n var template;\n if (err) {\n return chunk.setError(err);\n }\n // Prefer a template that is passed via callback over the cached version.\n template = getTemplate(srcOrTemplate, false) || getTemplate(name, dust.config.cache);\n if (!template) {\n // It's a template string, compile it and register under `name`\n if(dust.compile) {\n template = dust.loadSource(dust.compile(srcOrTemplate, name));\n } else {\n return chunk.setError(new Error('Dust compiler not available'));\n }\n }\n template(chunk, Context.wrap(context, template.templateName)).end();\n }\n\n if(dust.onLoad.length === 3) {\n dust.onLoad(name, context.options, done);\n } else {\n dust.onLoad(name, done);\n }\n });\n }\n return chunk.setError(new Error('Template Not Found: ' + nameOrTemplate));\n }\n }\n\n dust.loadSource = function(source) {\n /*jshint evil:true*/\n return eval(source);\n };\n\n if (Array.isArray) {\n dust.isArray = Array.isArray;\n } else {\n dust.isArray = function(arr) {\n return Object.prototype.toString.call(arr) === '[object Array]';\n };\n }\n\n dust.nextTick = (function() {\n return function(callback) {\n setTimeout(callback, 0);\n };\n })();\n\n /**\n * Dust has its own rules for what is \"empty\"-- which is not the same as falsy.\n * Empty arrays, null, and undefined are empty\n */\n dust.isEmpty = function(value) {\n if (value === 0) {\n return false;\n }\n if (dust.isArray(value) && !value.length) {\n return true;\n }\n return !value;\n };\n\n dust.isEmptyObject = function(obj) {\n var key;\n if (obj === null) {\n return false;\n }\n if (obj === undefined) {\n return false;\n }\n if (obj.length > 0) {\n return false;\n }\n for (key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n return false;\n }\n }\n return true;\n };\n\n dust.isTemplateFn = function(elem) {\n return typeof elem === 'function' &&\n elem.__dustBody;\n };\n\n /**\n * Decide somewhat-naively if something is a Thenable.\n * @param elem {*} object to inspect\n * @return {Boolean} is `elem` a Thenable?\n */\n dust.isThenable = function(elem) {\n return elem &&\n typeof elem === 'object' &&\n typeof elem.then === 'function';\n };\n\n /**\n * Decide very naively if something is a Stream.\n * @param elem {*} object to inspect\n * @return {Boolean} is `elem` a Stream?\n */\n dust.isStreamable = function(elem) {\n return elem &&\n typeof elem.on === 'function' &&\n typeof elem.pipe === 'function';\n };\n\n // apply the filter chain and return the output string\n dust.filter = function(string, auto, filters, context) {\n var i, len, name, filter;\n if (filters) {\n for (i = 0, len = filters.length; i < len; i++) {\n name = filters[i];\n if (!name.length) {\n continue;\n }\n filter = dust.filters[name];\n if (name === 's') {\n auto = null;\n } else if (typeof filter === 'function') {\n string = filter(string, context);\n } else {\n dust.log('Invalid filter `' + name + '`', WARN);\n }\n }\n }\n // by default always apply the h filter, unless asked to unescape with |s\n if (auto) {\n string = dust.filters[auto](string, context);\n }\n return string;\n };\n\n dust.filters = {\n h: function(value) { return dust.escapeHtml(value); },\n j: function(value) { return dust.escapeJs(value); },\n u: encodeURI,\n uc: encodeURIComponent,\n js: function(value) { return dust.escapeJSON(value); },\n jp: function(value) {\n if (!JSON) {dust.log('JSON is undefined; could not parse `' + value + '`', WARN);\n return value;\n } else {\n return JSON.parse(value);\n }\n }\n };\n\n function Context(stack, global, options, blocks, templateName) {\n if(stack !== undefined && !(stack instanceof Stack)) {\n stack = new Stack(stack);\n }\n this.stack = stack;\n this.global = global;\n this.options = options;\n this.blocks = blocks;\n this.templateName = templateName;\n this._isContext = true;\n }\n\n dust.makeBase = dust.context = function(global, options) {\n return new Context(undefined, global, options);\n };\n\n dust.isContext = function(obj) {\n return typeof obj === \"object\" && obj._isContext === true;\n };\n\n /**\n * Factory function that creates a closure scope around a Thenable-callback.\n * Returns a function that can be passed to a Thenable that will resume a\n * Context lookup once the Thenable resolves with new data, adding that new\n * data to the lookup stack.\n */\n function getWithResolvedData(ctx, cur, down) {\n return function(data) {\n return ctx.push(data)._get(cur, down);\n };\n }\n\n Context.wrap = function(context, name) {\n if (dust.isContext(context)) {\n return context;\n }\n return new Context(context, {}, {}, null, name);\n };\n\n /**\n * Public API for getting a value from the context.\n * @method get\n * @param {string|array} path The path to the value. Supported formats are:\n * 'key'\n * 'path.to.key'\n * '.path.to.key'\n * ['path', 'to', 'key']\n * ['key']\n * @param {boolean} [cur=false] Boolean which determines if the search should be limited to the\n * current context (true), or if get should search in parent contexts as well (false).\n * @public\n * @returns {string|object}\n */\n Context.prototype.get = function(path, cur) {\n if (typeof path === 'string') {\n if (path[0] === '.') {\n cur = true;\n path = path.substr(1);\n }\n path = path.split('.');\n }\n return this._get(cur, path);\n };\n\n /**\n * Get a value from the context\n * @method _get\n * @param {boolean} cur Get only from the current context\n * @param {array} down An array of each step in the path\n * @private\n * @return {string | object}\n */\n Context.prototype._get = function(cur, down) {\n var ctx = this.stack || {},\n i = 1,\n value, first, len, ctxThis, fn;\n\n first = down[0];\n len = down.length;\n\n if (cur && len === 0) {\n ctxThis = ctx;\n ctx = ctx.head;\n } else {\n if (!cur) {\n // Search up the stack for the first value\n while (ctx) {\n if (ctx.isObject) {\n ctxThis = ctx.head;\n value = ctx.head[first];\n if (value !== undefined) {\n break;\n }\n }\n ctx = ctx.tail;\n }\n\n // Try looking in the global context if we haven't found anything yet\n if (value !== undefined) {\n ctx = value;\n } else {\n ctx = this.global && this.global[first];\n }\n } else if (ctx) {\n // if scope is limited by a leading dot, don't search up the tree\n if(ctx.head) {\n ctx = ctx.head[first];\n } else {\n // context's head is empty, value we are searching for is not defined\n ctx = undefined;\n }\n }\n\n while (ctx && i < len) {\n if (dust.isThenable(ctx)) {\n // Bail early by returning a Thenable for the remainder of the search tree\n return ctx.then(getWithResolvedData(this, cur, down.slice(i)));\n }\n ctxThis = ctx;\n ctx = ctx[down[i]];\n i++;\n }\n }\n\n if (typeof ctx === 'function') {\n fn = function() {\n try {\n return ctx.apply(ctxThis, arguments);\n } catch (err) {\n dust.log(err, ERROR);\n throw err;\n }\n };\n fn.__dustBody = !!ctx.__dustBody;\n return fn;\n } else {\n if (ctx === undefined) {\n dust.log('Cannot find reference `{' + down.join('.') + '}` in template `' + this.getTemplateName() + '`', INFO);\n }\n return ctx;\n }\n };\n\n Context.prototype.getPath = function(cur, down) {\n return this._get(cur, down);\n };\n\n Context.prototype.push = function(head, idx, len) {\n if(head === undefined) {\n dust.log(\"Not pushing an undefined variable onto the context\", INFO);\n return this;\n }\n return this.rebase(new Stack(head, this.stack, idx, len));\n };\n\n Context.prototype.pop = function() {\n var head = this.current();\n this.stack = this.stack && this.stack.tail;\n return head;\n };\n\n Context.prototype.rebase = function(head) {\n return new Context(head, this.global, this.options, this.blocks, this.getTemplateName());\n };\n\n Context.prototype.clone = function() {\n var context = this.rebase();\n context.stack = this.stack;\n return context;\n };\n\n Context.prototype.current = function() {\n return this.stack && this.stack.head;\n };\n\n Context.prototype.getBlock = function(key) {\n var blocks, len, fn;\n\n if (typeof key === 'function') {\n key = key(new Chunk(), this).data.join('');\n }\n\n blocks = this.blocks;\n\n if (!blocks) {\n dust.log('No blocks for context `' + key + '` in template `' + this.getTemplateName() + '`', DEBUG);\n return false;\n }\n\n len = blocks.length;\n while (len--) {\n fn = blocks[len][key];\n if (fn) {\n return fn;\n }\n }\n\n dust.log('Malformed template `' + this.getTemplateName() + '` was missing one or more blocks.');\n return false;\n };\n\n Context.prototype.shiftBlocks = function(locals) {\n var blocks = this.blocks,\n newBlocks;\n\n if (locals) {\n if (!blocks) {\n newBlocks = [locals];\n } else {\n newBlocks = blocks.concat([locals]);\n }\n return new Context(this.stack, this.global, this.options, newBlocks, this.getTemplateName());\n }\n return this;\n };\n\n Context.prototype.resolve = function(body) {\n var chunk;\n\n if(typeof body !== 'function') {\n return body;\n }\n chunk = new Chunk().render(body, this);\n if(chunk instanceof Chunk) {\n return chunk.data.join(''); // ie7 perf\n }\n return chunk;\n };\n\n Context.prototype.getTemplateName = function() {\n return this.templateName;\n };\n\n function Stack(head, tail, idx, len) {\n this.tail = tail;\n this.isObject = head && typeof head === 'object';\n this.head = head;\n this.index = idx;\n this.of = len;\n }\n\n function Stub(callback) {\n this.head = new Chunk(this);\n this.callback = callback;\n this.out = '';\n }\n\n Stub.prototype.flush = function() {\n var chunk = this.head;\n\n while (chunk) {\n if (chunk.flushable) {\n this.out += chunk.data.join(''); //ie7 perf\n } else if (chunk.error) {\n this.callback(chunk.error);\n dust.log('Rendering failed with error `' + chunk.error + '`', ERROR);\n this.flush = EMPTY_FUNC;\n return;\n } else {\n return;\n }\n chunk = chunk.next;\n this.head = chunk;\n }\n this.callback(null, this.out);\n };\n\n /**\n * Creates an interface sort of like a Streams2 ReadableStream.\n */\n function Stream() {\n this.head = new Chunk(this);\n }\n\n Stream.prototype.flush = function() {\n var chunk = this.head;\n\n while(chunk) {\n if (chunk.flushable) {\n this.emit('data', chunk.data.join('')); //ie7 perf\n } else if (chunk.error) {\n this.emit('error', chunk.error);\n this.emit('end');\n dust.log('Streaming failed with error `' + chunk.error + '`', ERROR);\n this.flush = EMPTY_FUNC;\n return;\n } else {\n return;\n }\n chunk = chunk.next;\n this.head = chunk;\n }\n this.emit('end');\n };\n\n /**\n * Executes listeners for `type` by passing data. Note that this is different from a\n * Node stream, which can pass an arbitrary number of arguments\n * @return `true` if event had listeners, `false` otherwise\n */\n Stream.prototype.emit = function(type, data) {\n var events = this.events || {},\n handlers = events[type] || [],\n i, l;\n\n if (!handlers.length) {\n dust.log('Stream broadcasting, but no listeners for `' + type + '`', DEBUG);\n return false;\n }\n\n handlers = handlers.slice(0);\n for (i = 0, l = handlers.length; i < l; i++) {\n handlers[i](data);\n }\n return true;\n };\n\n Stream.prototype.on = function(type, callback) {\n var events = this.events = this.events || {},\n handlers = events[type] = events[type] || [];\n\n if(typeof callback !== 'function') {\n dust.log('No callback function provided for `' + type + '` event listener', WARN);\n } else {\n handlers.push(callback);\n }\n return this;\n };\n\n /**\n * Pipes to a WritableStream. Note that backpressure isn't implemented,\n * so we just write as fast as we can.\n * @param stream {WritableStream}\n * @return self\n */\n Stream.prototype.pipe = function(stream) {\n if(typeof stream.write !== 'function' ||\n typeof stream.end !== 'function') {\n dust.log('Incompatible stream passed to `pipe`', WARN);\n return this;\n }\n\n var destEnded = false;\n\n if(typeof stream.emit === 'function') {\n stream.emit('pipe', this);\n }\n\n if(typeof stream.on === 'function') {\n stream.on('error', function() {\n destEnded = true;\n });\n }\n\n return this\n .on('data', function(data) {\n if(destEnded) {\n return;\n }\n try {\n stream.write(data, 'utf8');\n } catch (err) {\n dust.log(err, ERROR);\n }\n })\n .on('end', function() {\n if(destEnded) {\n return;\n }\n try {\n stream.end();\n destEnded = true;\n } catch (err) {\n dust.log(err, ERROR);\n }\n });\n };\n\n function Chunk(root, next, taps) {\n this.root = root;\n this.next = next;\n this.data = []; //ie7 perf\n this.flushable = false;\n this.taps = taps;\n }\n\n Chunk.prototype.write = function(data) {\n var taps = this.taps;\n\n if (taps) {\n data = taps.go(data);\n }\n this.data.push(data);\n return this;\n };\n\n Chunk.prototype.end = function(data) {\n if (data) {\n this.write(data);\n }\n this.flushable = true;\n this.root.flush();\n return this;\n };\n\n Chunk.prototype.map = function(callback) {\n var cursor = new Chunk(this.root, this.next, this.taps),\n branch = new Chunk(this.root, cursor, this.taps);\n\n this.next = branch;\n this.flushable = true;\n try {\n callback(branch);\n } catch(err) {\n dust.log(err, ERROR);\n branch.setError(err);\n }\n return cursor;\n };\n\n Chunk.prototype.tap = function(tap) {\n var taps = this.taps;\n\n if (taps) {\n this.taps = taps.push(tap);\n } else {\n this.taps = new Tap(tap);\n }\n return this;\n };\n\n Chunk.prototype.untap = function() {\n this.taps = this.taps.tail;\n return this;\n };\n\n Chunk.prototype.render = function(body, context) {\n return body(this, context);\n };\n\n Chunk.prototype.reference = function(elem, context, auto, filters) {\n if (typeof elem === 'function') {\n elem = elem.apply(context.current(), [this, context, null, {auto: auto, filters: filters}]);\n if (elem instanceof Chunk) {\n return elem;\n } else {\n return this.reference(elem, context, auto, filters);\n }\n }\n if (dust.isThenable(elem)) {\n return this.await(elem, context, null, auto, filters);\n } else if (dust.isStreamable(elem)) {\n return this.stream(elem, context, null, auto, filters);\n } else if (!dust.isEmpty(elem)) {\n return this.write(dust.filter(elem, auto, filters, context));\n } else {\n return this;\n }\n };\n\n Chunk.prototype.section = function(elem, context, bodies, params) {\n var body = bodies.block,\n skip = bodies['else'],\n chunk = this,\n i, len, head;\n\n if (typeof elem === 'function' && !dust.isTemplateFn(elem)) {\n try {\n elem = elem.apply(context.current(), [this, context, bodies, params]);\n } catch(err) {\n dust.log(err, ERROR);\n return this.setError(err);\n }\n // Functions that return chunks are assumed to have handled the chunk manually.\n // Make that chunk the current one and go to the next method in the chain.\n if (elem instanceof Chunk) {\n return elem;\n }\n }\n\n if (dust.isEmptyObject(bodies)) {\n // No bodies to render, and we've already invoked any function that was available in\n // hopes of returning a Chunk.\n return chunk;\n }\n\n if (!dust.isEmptyObject(params)) {\n context = context.push(params);\n }\n\n /*\n Dust's default behavior is to enumerate over the array elem, passing each object in the array to the block.\n When elem resolves to a value or object instead of an array, Dust sets the current context to the value\n and renders the block one time.\n */\n if (dust.isArray(elem)) {\n if (body) {\n len = elem.length;\n if (len > 0) {\n head = context.stack && context.stack.head || {};\n head.$len = len;\n for (i = 0; i < len; i++) {\n head.$idx = i;\n chunk = body(chunk, context.push(elem[i], i, len));\n }\n head.$idx = undefined;\n head.$len = undefined;\n return chunk;\n } else if (skip) {\n return skip(this, context);\n }\n }\n } else if (dust.isThenable(elem)) {\n return this.await(elem, context, bodies);\n } else if (dust.isStreamable(elem)) {\n return this.stream(elem, context, bodies);\n } else if (elem === true) {\n // true is truthy but does not change context\n if (body) {\n return body(this, context);\n }\n } else if (elem || elem === 0) {\n // everything that evaluates to true are truthy ( e.g. Non-empty strings and Empty objects are truthy. )\n // zero is truthy\n // for anonymous functions that did not returns a chunk, truthiness is evaluated based on the return value\n if (body) {\n return body(this, context.push(elem));\n }\n // nonexistent, scalar false value, scalar empty string, null,\n // undefined are all falsy\n } else if (skip) {\n return skip(this, context);\n }\n dust.log('Section without corresponding key in template `' + context.getTemplateName() + '`', DEBUG);\n return this;\n };\n\n Chunk.prototype.exists = function(elem, context, bodies) {\n var body = bodies.block,\n skip = bodies['else'];\n\n if (!dust.isEmpty(elem)) {\n if (body) {\n return body(this, context);\n }\n dust.log('No block for exists check in template `' + context.getTemplateName() + '`', DEBUG);\n } else if (skip) {\n return skip(this, context);\n }\n return this;\n };\n\n Chunk.prototype.notexists = function(elem, context, bodies) {\n var body = bodies.block,\n skip = bodies['else'];\n\n if (dust.isEmpty(elem)) {\n if (body) {\n return body(this, context);\n }\n dust.log('No block for not-exists check in template `' + context.getTemplateName() + '`', DEBUG);\n } else if (skip) {\n return skip(this, context);\n }\n return this;\n };\n\n Chunk.prototype.block = function(elem, context, bodies) {\n var body = elem || bodies.block;\n\n if (body) {\n return body(this, context);\n }\n return this;\n };\n\n Chunk.prototype.partial = function(elem, context, partialContext, params) {\n var head;\n\n if(params === undefined) {\n // Compatibility for < 2.7.0 where `partialContext` did not exist\n params = partialContext;\n partialContext = context;\n }\n\n if (!dust.isEmptyObject(params)) {\n partialContext = partialContext.clone();\n head = partialContext.pop();\n partialContext = partialContext.push(params)\n .push(head);\n }\n\n if (dust.isTemplateFn(elem)) {\n // The eventual result of evaluating `elem` is a partial name\n // Load the partial after getting its name and end the async chunk\n return this.capture(elem, context, function(name, chunk) {\n partialContext.templateName = name;\n load(name, chunk, partialContext).end();\n });\n } else {\n partialContext.templateName = elem;\n return load(elem, this, partialContext);\n }\n };\n\n Chunk.prototype.helper = function(name, context, bodies, params, auto) {\n var chunk = this,\n filters = params.filters,\n ret;\n\n // Pre-2.7.1 compat: if auto is undefined, it's an old template. Automatically escape\n if (auto === undefined) {\n auto = 'h';\n }\n\n // handle invalid helpers, similar to invalid filters\n if(dust.helpers[name]) {\n try {\n ret = dust.helpers[name](chunk, context, bodies, params);\n if (ret instanceof Chunk) {\n return ret;\n }\n if(typeof filters === 'string') {\n filters = filters.split('|');\n }\n if (!dust.isEmptyObject(bodies)) {\n return chunk.section(ret, context, bodies, params);\n }\n // Helpers act slightly differently from functions in context in that they will act as\n // a reference if they are self-closing (due to grammar limitations)\n // In the Chunk.await function we check to make sure bodies is null before acting as a reference\n return chunk.reference(ret, context, auto, filters);\n } catch(err) {\n dust.log('Error in helper `' + name + '`: ' + err.message, ERROR);\n return chunk.setError(err);\n }\n } else {\n dust.log('Helper `' + name + '` does not exist', WARN);\n return chunk;\n }\n };\n\n /**\n * Reserve a chunk to be evaluated once a thenable is resolved or rejected\n * @param thenable {Thenable} the target thenable to await\n * @param context {Context} context to use to render the deferred chunk\n * @param bodies {Object} must contain a \"body\", may contain an \"error\"\n * @param auto {String} automatically apply this filter if the Thenable is a reference\n * @param filters {Array} apply these filters if the Thenable is a reference\n * @return {Chunk}\n */\n Chunk.prototype.await = function(thenable, context, bodies, auto, filters) {\n return this.map(function(chunk) {\n thenable.then(function(data) {\n if (bodies) {\n chunk = chunk.section(data, context, bodies);\n } else {\n // Actually a reference. Self-closing sections don't render\n chunk = chunk.reference(data, context, auto, filters);\n }\n chunk.end();\n }, function(err) {\n var errorBody = bodies && bodies.error;\n if(errorBody) {\n chunk.render(errorBody, context.push(err)).end();\n } else {\n dust.log('Unhandled promise rejection in `' + context.getTemplateName() + '`', INFO);\n chunk.end();\n }\n });\n });\n };\n\n /**\n * Reserve a chunk to be evaluated with the contents of a streamable.\n * Currently an error event will bomb out the stream. Once an error\n * is received, we push it to an {:error} block if one exists, and log otherwise,\n * then stop listening to the stream.\n * @param streamable {Streamable} the target streamable that will emit events\n * @param context {Context} context to use to render each thunk\n * @param bodies {Object} must contain a \"body\", may contain an \"error\"\n * @return {Chunk}\n */\n Chunk.prototype.stream = function(stream, context, bodies, auto, filters) {\n var body = bodies && bodies.block,\n errorBody = bodies && bodies.error;\n return this.map(function(chunk) {\n var ended = false;\n stream\n .on('data', function data(thunk) {\n if(ended) {\n return;\n }\n if(body) {\n // Fork a new chunk out of the blockstream so that we can flush it independently\n chunk = chunk.map(function(chunk) {\n chunk.render(body, context.push(thunk)).end();\n });\n } else if(!bodies) {\n // When actually a reference, don't fork, just write into the master async chunk\n chunk = chunk.reference(thunk, context, auto, filters);\n }\n })\n .on('error', function error(err) {\n if(ended) {\n return;\n }\n if(errorBody) {\n chunk.render(errorBody, context.push(err));\n } else {\n dust.log('Unhandled stream error in `' + context.getTemplateName() + '`', INFO);\n }\n if(!ended) {\n ended = true;\n chunk.end();\n }\n })\n .on('end', function end() {\n if(!ended) {\n ended = true;\n chunk.end();\n }\n });\n });\n };\n\n Chunk.prototype.capture = function(body, context, callback) {\n return this.map(function(chunk) {\n var stub = new Stub(function(err, out) {\n if (err) {\n chunk.setError(err);\n } else {\n callback(out, chunk);\n }\n });\n body(stub.head, context).end();\n });\n };\n\n Chunk.prototype.setError = function(err) {\n this.error = err;\n this.root.flush();\n return this;\n };\n\n // Chunk aliases\n for(var f in Chunk.prototype) {\n if(dust._aliases[f]) {\n Chunk.prototype[dust._aliases[f]] = Chunk.prototype[f];\n }\n }\n\n function Tap(head, tail) {\n this.head = head;\n this.tail = tail;\n }\n\n Tap.prototype.push = function(tap) {\n return new Tap(tap, this);\n };\n\n Tap.prototype.go = function(value) {\n var tap = this;\n\n while(tap) {\n value = tap.head(value);\n tap = tap.tail;\n }\n return value;\n };\n\n var HCHARS = /[&<>\"']/,\n AMP = /&/g,\n LT = //g,\n QUOT = /\\\"/g,\n SQUOT = /\\'/g;\n\n dust.escapeHtml = function(s) {\n if (typeof s === \"string\" || (s && typeof s.toString === \"function\")) {\n if (typeof s !== \"string\") {\n s = s.toString();\n }\n if (!HCHARS.test(s)) {\n return s;\n }\n return s.replace(AMP,'&').replace(LT,'<').replace(GT,'>').replace(QUOT,'"').replace(SQUOT, ''');\n }\n return s;\n };\n\n var BS = /\\\\/g,\n FS = /\\//g,\n CR = /\\r/g,\n LS = /\\u2028/g,\n PS = /\\u2029/g,\n NL = /\\n/g,\n LF = /\\f/g,\n SQ = /'/g,\n DQ = /\"/g,\n TB = /\\t/g;\n\n dust.escapeJs = function(s) {\n if (typeof s === 'string') {\n return s\n .replace(BS, '\\\\\\\\')\n .replace(FS, '\\\\/')\n .replace(DQ, '\\\\\"')\n .replace(SQ, '\\\\\\'')\n .replace(CR, '\\\\r')\n .replace(LS, '\\\\u2028')\n .replace(PS, '\\\\u2029')\n .replace(NL, '\\\\n')\n .replace(LF, '\\\\f')\n .replace(TB, '\\\\t');\n }\n return s;\n };\n\n dust.escapeJSON = function(o) {\n if (!JSON) {\n dust.log('JSON is undefined; could not escape `' + o + '`', WARN);\n return o;\n } else {\n return JSON.stringify(o)\n .replace(LS, '\\\\u2028')\n .replace(PS, '\\\\u2029')\n .replace(LT, '\\\\u003c');\n }\n };\n\n return dust;\n\n}));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(100)))\n\n/***/ }),\n/* 151 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*** IMPORTS FROM imports-loader ***/\nvar underscore = __webpack_require__(70);\nvar jquery = __webpack_require__(25);\n\n// Backbone.js 1.1.2\n\n// (c) 2010-2014 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(root, factory) {\n\n // Set up Backbone appropriately for the environment. Start with AMD.\n if (true) {\n !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(70), __webpack_require__(25), 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 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}(this, 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 local references to array methods we'll want to use later.\n var array = [];\n var push = array.push;\n var slice = array.slice;\n var splice = array.splice;\n\n // Current version of the library. Keep in sync with `package.json`.\n Backbone.VERSION = '1.1.2';\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 ... 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 // Backbone.Events\n // ---------------\n\n // A module that can be mixed in to *any object* in order to provide it with\n // custom events. You may bind with `on` or remove with `off` callback\n // functions to an event; `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 // Bind an event to a `callback` function. Passing `\"all\"` will bind\n // the callback to all events fired.\n on: function(name, callback, context) {\n if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;\n this._events || (this._events = {});\n var events = this._events[name] || (this._events[name] = []);\n events.push({callback: callback, context: context, ctx: context || this});\n return this;\n },\n\n // Bind an event to only be triggered a single time. After the first time\n // the callback is invoked, it will be removed.\n once: function(name, callback, context) {\n if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;\n var self = this;\n var once = _.once(function() {\n self.off(name, once);\n callback.apply(this, arguments);\n });\n once._callback = callback;\n return this.on(name, once, context);\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 off: function(name, callback, context) {\n var retain, ev, events, names, i, l, j, k;\n if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;\n if (!name && !callback && !context) {\n this._events = void 0;\n return this;\n }\n names = name ? [name] : _.keys(this._events);\n for (i = 0, l = names.length; i < l; i++) {\n name = names[i];\n if (events = this._events[name]) {\n this._events[name] = retain = [];\n if (callback || context) {\n for (j = 0, k = events.length; j < k; j++) {\n ev = events[j];\n if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||\n (context && context !== ev.context)) {\n retain.push(ev);\n }\n }\n }\n if (!retain.length) delete this._events[name];\n }\n }\n\n return this;\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 trigger: function(name) {\n if (!this._events) return this;\n var args = slice.call(arguments, 1);\n if (!eventsApi(this, 'trigger', name, args)) return this;\n var events = this._events[name];\n var allEvents = this._events.all;\n if (events) triggerEvents(events, args);\n if (allEvents) triggerEvents(allEvents, arguments);\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 stopListening: function(obj, name, callback) {\n var listeningTo = this._listeningTo;\n if (!listeningTo) return this;\n var remove = !name && !callback;\n if (!callback && typeof name === 'object') callback = this;\n if (obj) (listeningTo = {})[obj._listenId] = obj;\n for (var id in listeningTo) {\n obj = listeningTo[id];\n obj.off(name, callback, this);\n if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];\n }\n return this;\n }\n\n };\n\n // Regular expression used to split event strings.\n var eventSplitter = /\\s+/;\n\n // Implement fancy features of the Events API such as multiple event\n // names `\"change blur\"` and jQuery-style event maps `{change: action}`\n // in terms of the existing API.\n var eventsApi = function(obj, action, name, rest) {\n if (!name) return true;\n\n // Handle event maps.\n if (typeof name === 'object') {\n for (var key in name) {\n obj[action].apply(obj, [key, name[key]].concat(rest));\n }\n return false;\n }\n\n // Handle space separated event names.\n if (eventSplitter.test(name)) {\n var names = name.split(eventSplitter);\n for (var i = 0, l = names.length; i < l; i++) {\n obj[action].apply(obj, [names[i]].concat(rest));\n }\n return false;\n }\n\n return true;\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 var listenMethods = {listenTo: 'on', listenToOnce: 'once'};\n\n // Inversion-of-control versions of `on` and `once`. Tell *this* object to\n // listen to an event in another object ... keeping track of what it's\n // listening to.\n _.each(listenMethods, function(implementation, method) {\n Events[method] = function(obj, name, callback) {\n var listeningTo = this._listeningTo || (this._listeningTo = {});\n var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n listeningTo[id] = obj;\n if (!callback && typeof name === 'object') callback = this;\n obj[implementation](name, callback, this);\n return this;\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('c');\n this.attributes = {};\n if (options.collection) this.collection = options.collection;\n if (options.parse) attrs = this.parse(attrs, options) || {};\n attrs = _.defaults({}, attrs, _.result(this, '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 // 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 // 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 var attr, attrs, unset, changes, silent, changing, prev, current;\n if (key == null) return this;\n\n // Handle both `\"key\", value` and `{key: value}` -style arguments.\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 unset = options.unset;\n silent = options.silent;\n changes = [];\n changing = this._changing;\n this._changing = true;\n\n if (!changing) {\n this._previousAttributes = _.clone(this.attributes);\n this.changed = {};\n }\n current = this.attributes, prev = this._previousAttributes;\n\n // Check for changes of `id`.\n if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];\n\n // For each `set` attribute, update or delete the current value.\n for (attr in attrs) {\n val = attrs[attr];\n if (!_.isEqual(current[attr], val)) changes.push(attr);\n if (!_.isEqual(prev[attr], val)) {\n this.changed[attr] = val;\n } else {\n delete this.changed[attr];\n }\n unset ? delete current[attr] : current[attr] = val;\n }\n\n // Trigger all relevant attribute changes.\n if (!silent) {\n if (changes.length) this._pending = options;\n for (var i = 0, l = changes.length; i < l; 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 val, changed = false;\n var old = this._changing ? this._previousAttributes : this.attributes;\n for (var attr in diff) {\n if (_.isEqual(old[attr], (val = diff[attr]))) continue;\n (changed || (changed = {}))[attr] = val;\n }\n return changed;\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. If the server's representation of the\n // model differs from its current attributes, they will be overridden,\n // triggering a `\"change\"` event.\n fetch: function(options) {\n options = options ? _.clone(options) : {};\n if (options.parse === void 0) options.parse = true;\n var model = this;\n var success = options.success;\n options.success = function(resp) {\n if (!model.set(model.parse(resp, options), options)) return false;\n if (success) success(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 var attrs, method, xhr, attributes = this.attributes;\n\n // Handle both `\"key\", value` and `{key: value}` -style arguments.\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}, options);\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 && !options.wait) {\n if (!this.set(attrs, options)) return false;\n } else {\n if (!this._validate(attrs, options)) return false;\n }\n\n // Set temporary attributes if `{wait: true}`.\n if (attrs && options.wait) {\n this.attributes = _.extend({}, attributes, attrs);\n }\n\n // After a successful server-side save, the client is (optionally)\n // updated with the server-side state.\n if (options.parse === void 0) options.parse = true;\n var model = this;\n var success = options.success;\n options.success = function(resp) {\n // Ensure attributes are restored during synchronous saves.\n model.attributes = attributes;\n var serverAttrs = model.parse(resp, options);\n if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);\n if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {\n return false;\n }\n if (success) success(model, resp, options);\n model.trigger('sync', model, resp, options);\n };\n wrapError(this, options);\n\n method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');\n if (method === 'patch') options.attrs = attrs;\n xhr = this.sync(method, this, options);\n\n // Restore attributes.\n if (attrs && options.wait) 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\n var destroy = function() {\n model.trigger('destroy', model, model.collection, options);\n };\n\n options.success = function(resp) {\n if (options.wait || model.isNew()) destroy();\n if (success) success(model, resp, options);\n if (!model.isNew()) model.trigger('sync', model, resp, options);\n };\n\n if (this.isNew()) {\n options.success();\n return false;\n }\n wrapError(this, options);\n\n var xhr = this.sync('delete', this, options);\n if (!options.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 return base.replace(/([^\\/])$/, '$1/') + encodeURIComponent(this.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.\n var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];\n\n // Mix in each Underscore method as a proxy to `Model#attributes`.\n _.each(modelMethods, function(method) {\n Model.prototype[method] = function() {\n var args = slice.call(arguments);\n args.unshift(this.attributes);\n return _[method].apply(_, args);\n };\n });\n\n // Backbone.Collection\n // -------------------\n\n // If models tend to represent a single row of data, a Backbone Collection is\n // more analagous 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 // 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.\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 var singular = !_.isArray(models);\n models = singular ? [models] : _.clone(models);\n options || (options = {});\n var i, l, index, model;\n for (i = 0, l = models.length; i < l; i++) {\n model = models[i] = this.get(models[i]);\n if (!model) continue;\n delete this._byId[model.id];\n delete this._byId[model.cid];\n index = this.indexOf(model);\n this.models.splice(index, 1);\n this.length--;\n if (!options.silent) {\n options.index = index;\n model.trigger('remove', model, this, options);\n }\n this._removeReference(model, options);\n }\n return singular ? models[0] : models;\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 options = _.defaults({}, options, setOptions);\n if (options.parse) models = this.parse(models, options);\n var singular = !_.isArray(models);\n models = singular ? (models ? [models] : []) : _.clone(models);\n var i, l, id, model, attrs, existing, sort;\n var at = options.at;\n var targetModel = this.model;\n var sortable = this.comparator && (at == null) && options.sort !== false;\n var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n var toAdd = [], toRemove = [], modelMap = {};\n var add = options.add, merge = options.merge, remove = options.remove;\n var order = !sortable && add && remove ? [] : false;\n\n // Turn bare objects into model references, and prevent invalid models\n // from being added.\n for (i = 0, l = models.length; i < l; i++) {\n attrs = models[i] || {};\n if (attrs instanceof Model) {\n id = model = attrs;\n } else {\n id = attrs[targetModel.prototype.idAttribute || 'id'];\n }\n\n // If a duplicate is found, prevent it from being added and\n // optionally merge it into the existing model.\n if (existing = this.get(id)) {\n if (remove) modelMap[existing.cid] = true;\n if (merge) {\n attrs = attrs === model ? model.attributes : attrs;\n if (options.parse) attrs = existing.parse(attrs, options);\n existing.set(attrs, options);\n if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;\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(attrs, options);\n if (!model) continue;\n toAdd.push(model);\n this._addReference(model, options);\n }\n\n // Do not add multiple models with the same `id`.\n model = existing || model;\n if (order && (model.isNew() || !modelMap[model.id])) order.push(model);\n modelMap[model.id] = true;\n }\n\n // Remove nonexistent models if appropriate.\n if (remove) {\n for (i = 0, l = this.length; i < l; ++i) {\n if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);\n }\n if (toRemove.length) this.remove(toRemove, options);\n }\n\n // See if sorting is needed, update `length` and splice in new models.\n if (toAdd.length || (order && order.length)) {\n if (sortable) sort = true;\n this.length += toAdd.length;\n if (at != null) {\n for (i = 0, l = toAdd.length; i < l; i++) {\n this.models.splice(at + i, 0, toAdd[i]);\n }\n } else {\n if (order) this.models.length = 0;\n var orderedModels = order || toAdd;\n for (i = 0, l = orderedModels.length; i < l; i++) {\n this.models.push(orderedModels[i]);\n }\n }\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 events.\n if (!options.silent) {\n for (i = 0, l = toAdd.length; i < l; i++) {\n (model = toAdd[i]).trigger('add', model, this, options);\n }\n if (sort || (order && order.length)) this.trigger('sort', this, options);\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 = {});\n for (var i = 0, l = this.models.length; i < l; 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 this.remove(model, options);\n return model;\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 this.remove(model, options);\n return model;\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.\n get: function(obj) {\n if (obj == null) return void 0;\n return this._byId[obj] || this._byId[obj.id] || this._byId[obj.cid];\n },\n\n // Get the model at the given index.\n at: function(index) {\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 if (_.isEmpty(attrs)) return first ? void 0 : [];\n return this[first ? 'find' : 'filter'](function(model) {\n for (var key in attrs) {\n if (attrs[key] !== model.get(key)) return false;\n }\n return true;\n });\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 if (!this.comparator) throw new Error('Cannot sort a set without a comparator');\n options || (options = {});\n\n // Run sort based on type of `comparator`.\n if (_.isString(this.comparator) || this.comparator.length === 1) {\n this.models = this.sortBy(this.comparator, this);\n } else {\n this.models.sort(_.bind(this.comparator, this));\n }\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 _.invoke(this.models, 'get', 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 = options ? _.clone(options) : {};\n if (options.parse === void 0) options.parse = true;\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(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 if (!(model = this._prepareModel(model, options))) return false;\n if (!options.wait) this.add(model, options);\n var collection = this;\n var success = options.success;\n options.success = function(model, resp) {\n if (options.wait) collection.add(model, options);\n if (success) success(model, resp, options);\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 },\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 (attrs instanceof Model) return attrs;\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 to create a model's ties to a collection.\n _addReference: function(model, options) {\n this._byId[model.cid] = model;\n if (model.id != null) this._byId[model.id] = model;\n if (!model.collection) model.collection = this;\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 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 ((event === 'add' || event === 'remove') && collection !== this) return;\n if (event === 'destroy') this.remove(model, options);\n if (model && event === 'change:' + model.idAttribute) {\n delete this._byId[model.previous(model.idAttribute)];\n if (model.id != null) this._byId[model.id] = model;\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 methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',\n 'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',\n 'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',\n 'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',\n 'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',\n 'lastIndexOf', 'isEmpty', 'chain', 'sample'];\n\n // Mix in each Underscore method as a proxy to `Collection#models`.\n _.each(methods, function(method) {\n Collection.prototype[method] = function() {\n var args = slice.call(arguments);\n args.unshift(this.models);\n return _[method].apply(_, args);\n };\n });\n\n // Underscore methods that take a property name as an argument.\n var attributeMethods = ['groupBy', 'countBy', 'sortBy', 'indexBy'];\n\n // Use attributes instead of properties.\n _.each(attributeMethods, function(method) {\n Collection.prototype[method] = function(value, context) {\n var iterator = _.isFunction(value) ? value : function(model) {\n return model.get(value);\n };\n return _[method](this.models, iterator, context);\n };\n });\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 options || (options = {});\n _.extend(this, _.pick(options, viewOptions));\n this._ensureElement();\n this.initialize.apply(this, arguments);\n this.delegateEvents();\n };\n\n // Cached regex to split keys for `delegate`.\n var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n // List of view options to be merged 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.$el.remove();\n this.stopListening();\n return this;\n },\n\n // Change the view's element (`this.el` property), including event\n // re-delegation.\n setElement: function(element, delegate) {\n if (this.$el) this.undelegateEvents();\n this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);\n this.el = this.$el[0];\n if (delegate !== false) this.delegateEvents();\n return this;\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 // This only works for delegate-able events: not `focus`, `blur`, and\n // not `change`, `submit`, and `reset` in Internet Explorer.\n delegateEvents: function(events) {\n if (!(events || (events = _.result(this, 'events')))) return this;\n this.undelegateEvents();\n for (var key in events) {\n var method = events[key];\n if (!_.isFunction(method)) method = this[events[key]];\n if (!method) continue;\n\n var match = key.match(delegateEventSplitter);\n var eventName = match[1], selector = match[2];\n method = _.bind(method, this);\n eventName += '.delegateEvents' + this.cid;\n if (selector === '') {\n this.$el.on(eventName, method);\n } else {\n this.$el.on(eventName, selector, method);\n }\n }\n return this;\n },\n\n // Clears all callbacks previously bound to the view with `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 this.$el.off('.delegateEvents' + this.cid);\n return this;\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 var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);\n this.setElement($el, false);\n } else {\n this.setElement(_.result(this, 'el'), false);\n }\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 // If we're sending a `PATCH` request, and we're in an old Internet Explorer\n // that still has ActiveX enabled by default, override jQuery to use that\n // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.\n if (params.type === 'PATCH' && noXhrPatch) {\n params.xhr = function() {\n return new ActiveXObject(\"Microsoft.XMLHTTP\");\n };\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 var noXhrPatch =\n typeof window !== 'undefined' && !!window.ActiveXObject &&\n !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent);\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 router.execute(callback, args);\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 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) {\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 _.bindAll(this, 'checkUrl');\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 detecting MSIE.\n var isExplorer = /msie [\\w.]+/;\n\n // Cached regex for removing a trailing slash.\n var trailingSlash = /\\/$/;\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 return this.location.pathname.replace(/[^\\/]$/, '$&/') === this.root;\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 cross-browser normalized URL fragment, either from the URL,\n // the hash, or the override.\n getFragment: function(fragment, forcePushState) {\n if (fragment == null) {\n if (this._hasPushState || !this._wantsHashChange || forcePushState) {\n fragment = decodeURI(this.location.pathname + this.location.search);\n var root = this.root.replace(trailingSlash, '');\n if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);\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._wantsPushState = !!this.options.pushState;\n this._hasPushState = !!(this.options.pushState && this.history && this.history.pushState);\n var fragment = this.getFragment();\n var docMode = document.documentMode;\n var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));\n\n // Normalize root to always include a leading and trailing slash.\n this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n if (oldIE && this._wantsHashChange) {\n var frame = Backbone.$('