\").append( jQuery.parseHTML( responseText ) ).find( selector ) :\r\n\r\n\t\t\t\t// Otherwise use the full result\r\n\t\t\t\tresponseText );\r\n\r\n\t\t}).complete( callback && function( jqXHR, status ) {\r\n\t\t\tself.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );\r\n\t\t});\r\n\t}\r\n\r\n\treturn this;\r\n};\r\n\r\n\r\n\r\n\r\njQuery.expr.filters.animated = function( elem ) {\r\n\treturn jQuery.grep(jQuery.timers, function( fn ) {\r\n\t\treturn elem === fn.elem;\r\n\t}).length;\r\n};\r\n\r\n\r\n\r\n\r\n\r\nvar docElem = window.document.documentElement;\r\n\r\n/**\r\n * Gets a window from an element\r\n */\r\nfunction getWindow( elem ) {\r\n\treturn jQuery.isWindow( elem ) ?\r\n\t\telem :\r\n\t\telem.nodeType === 9 ?\r\n\t\t\telem.defaultView || elem.parentWindow :\r\n\t\t\tfalse;\r\n}\r\n\r\njQuery.offset = {\r\n\tsetOffset: function( elem, options, i ) {\r\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\r\n\t\t\tposition = jQuery.css( elem, \"position\" ),\r\n\t\t\tcurElem = jQuery( elem ),\r\n\t\t\tprops = {};\r\n\r\n\t\t// set position first, in-case top/left are set even on static elem\r\n\t\tif ( position === \"static\" ) {\r\n\t\t\telem.style.position = \"relative\";\r\n\t\t}\r\n\r\n\t\tcurOffset = curElem.offset();\r\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\r\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\r\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\r\n\t\t\tjQuery.inArray(\"auto\", [ curCSSTop, curCSSLeft ] ) > -1;\r\n\r\n\t\t// need to be able to calculate position if either top or left is auto and position is either absolute or fixed\r\n\t\tif ( calculatePosition ) {\r\n\t\t\tcurPosition = curElem.position();\r\n\t\t\tcurTop = curPosition.top;\r\n\t\t\tcurLeft = curPosition.left;\r\n\t\t} else {\r\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\r\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\r\n\t\t}\r\n\r\n\t\tif ( jQuery.isFunction( options ) ) {\r\n\t\t\toptions = options.call( elem, i, curOffset );\r\n\t\t}\r\n\r\n\t\tif ( options.top != null ) {\r\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\r\n\t\t}\r\n\t\tif ( options.left != null ) {\r\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\r\n\t\t}\r\n\r\n\t\tif ( \"using\" in options ) {\r\n\t\t\toptions.using.call( elem, props );\r\n\t\t} else {\r\n\t\t\tcurElem.css( props );\r\n\t\t}\r\n\t}\r\n};\r\n\r\njQuery.fn.extend({\r\n\toffset: function( options ) {\r\n\t\tif ( arguments.length ) {\r\n\t\t\treturn options === undefined ?\r\n\t\t\t\tthis :\r\n\t\t\t\tthis.each(function( i ) {\r\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\r\n\t\t\t\t});\r\n\t\t}\r\n\r\n\t\tvar docElem, win,\r\n\t\t\tbox = { top: 0, left: 0 },\r\n\t\t\telem = this[ 0 ],\r\n\t\t\tdoc = elem && elem.ownerDocument;\r\n\r\n\t\tif ( !doc ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tdocElem = doc.documentElement;\r\n\r\n\t\t// Make sure it's not a disconnected DOM node\r\n\t\tif ( !jQuery.contains( docElem, elem ) ) {\r\n\t\t\treturn box;\r\n\t\t}\r\n\r\n\t\t// If we don't have gBCR, just use 0,0 rather than error\r\n\t\t// BlackBerry 5, iOS 3 (original iPhone)\r\n\t\tif ( typeof elem.getBoundingClientRect !== strundefined ) {\r\n\t\t\tbox = elem.getBoundingClientRect();\r\n\t\t}\r\n\t\twin = getWindow( doc );\r\n\t\treturn {\r\n\t\t\ttop: box.top + ( win.pageYOffset || docElem.scrollTop ) - ( docElem.clientTop || 0 ),\r\n\t\t\tleft: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )\r\n\t\t};\r\n\t},\r\n\r\n\tposition: function() {\r\n\t\tif ( !this[ 0 ] ) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tvar offsetParent, offset,\r\n\t\t\tparentOffset = { top: 0, left: 0 },\r\n\t\t\telem = this[ 0 ];\r\n\r\n\t\t// fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is its only offset parent\r\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\r\n\t\t\t// we assume that getBoundingClientRect is available when computed position is fixed\r\n\t\t\toffset = elem.getBoundingClientRect();\r\n\t\t} else {\r\n\t\t\t// Get *real* offsetParent\r\n\t\t\toffsetParent = this.offsetParent();\r\n\r\n\t\t\t// Get correct offsets\r\n\t\t\toffset = this.offset();\r\n\t\t\tif ( !jQuery.nodeName( offsetParent[ 0 ], \"html\" ) ) {\r\n\t\t\t\tparentOffset = offsetParent.offset();\r\n\t\t\t}\r\n\r\n\t\t\t// Add offsetParent borders\r\n\t\t\tparentOffset.top += jQuery.css( offsetParent[ 0 ], \"borderTopWidth\", true );\r\n\t\t\tparentOffset.left += jQuery.css( offsetParent[ 0 ], \"borderLeftWidth\", true );\r\n\t\t}\r\n\r\n\t\t// Subtract parent offsets and element margins\r\n\t\t// note: when an element has margin: auto the offsetLeft and marginLeft\r\n\t\t// are the same in Safari causing offset.left to incorrectly be 0\r\n\t\treturn {\r\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\r\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true)\r\n\t\t};\r\n\t},\r\n\r\n\toffsetParent: function() {\r\n\t\treturn this.map(function() {\r\n\t\t\tvar offsetParent = this.offsetParent || docElem;\r\n\r\n\t\t\twhile ( offsetParent && ( !jQuery.nodeName( offsetParent, \"html\" ) && jQuery.css( offsetParent, \"position\" ) === \"static\" ) ) {\r\n\t\t\t\toffsetParent = offsetParent.offsetParent;\r\n\t\t\t}\r\n\t\t\treturn offsetParent || docElem;\r\n\t\t});\r\n\t}\r\n});\r\n\r\n// Create scrollLeft and scrollTop methods\r\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\r\n\tvar top = /Y/.test( prop );\r\n\r\n\tjQuery.fn[ method ] = function( val ) {\r\n\t\treturn access( this, function( elem, method, val ) {\r\n\t\t\tvar win = getWindow( elem );\r\n\r\n\t\t\tif ( val === undefined ) {\r\n\t\t\t\treturn win ? (prop in win) ? win[ prop ] :\r\n\t\t\t\t\twin.document.documentElement[ method ] :\r\n\t\t\t\t\telem[ method ];\r\n\t\t\t}\r\n\r\n\t\t\tif ( win ) {\r\n\t\t\t\twin.scrollTo(\r\n\t\t\t\t\t!top ? val : jQuery( win ).scrollLeft(),\r\n\t\t\t\t\ttop ? val : jQuery( win ).scrollTop()\r\n\t\t\t\t);\r\n\r\n\t\t\t} else {\r\n\t\t\t\telem[ method ] = val;\r\n\t\t\t}\r\n\t\t}, method, val, arguments.length, null );\r\n\t};\r\n});\r\n\r\n// Add the top/left cssHooks using jQuery.fn.position\r\n// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\r\n// getComputedStyle returns percent when specified for top/left/bottom/right\r\n// rather than make the css module depend on the offset module, we just check for it here\r\njQuery.each( [ \"top\", \"left\" ], function( i, prop ) {\r\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\r\n\t\tfunction( elem, computed ) {\r\n\t\t\tif ( computed ) {\r\n\t\t\t\tcomputed = curCSS( elem, prop );\r\n\t\t\t\t// if curCSS returns percentage, fallback to offset\r\n\t\t\t\treturn rnumnonpx.test( computed ) ?\r\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\r\n\t\t\t\t\tcomputed;\r\n\t\t\t}\r\n\t\t}\r\n\t);\r\n});\r\n\r\n\r\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\r\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\r\n\tjQuery.each( { padding: \"inner\" + name, content: type, \"\": \"outer\" + name }, function( defaultExtra, funcName ) {\r\n\t\t// margin is only for outerHeight, outerWidth\r\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\r\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\r\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\r\n\r\n\t\t\treturn access( this, function( elem, type, value ) {\r\n\t\t\t\tvar doc;\r\n\r\n\t\t\t\tif ( jQuery.isWindow( elem ) ) {\r\n\t\t\t\t\t// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there\r\n\t\t\t\t\t// isn't a whole lot we can do. See pull request at this URL for discussion:\r\n\t\t\t\t\t// https://github.com/jquery/jquery/pull/764\r\n\t\t\t\t\treturn elem.document.documentElement[ \"client\" + name ];\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// Get document width or height\r\n\t\t\t\tif ( elem.nodeType === 9 ) {\r\n\t\t\t\t\tdoc = elem.documentElement;\r\n\r\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest\r\n\t\t\t\t\t// unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.\r\n\t\t\t\t\treturn Math.max(\r\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\r\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\r\n\t\t\t\t\t\tdoc[ \"client\" + name ]\r\n\t\t\t\t\t);\r\n\t\t\t\t}\r\n\r\n\t\t\t\treturn value === undefined ?\r\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\r\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\r\n\r\n\t\t\t\t\t// Set width or height on the element\r\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\r\n\t\t\t}, type, chainable ? margin : undefined, chainable, null );\r\n\t\t};\r\n\t});\r\n});\r\n\r\n\r\n// The number of elements contained in the matched element set\r\njQuery.fn.size = function() {\r\n\treturn this.length;\r\n};\r\n\r\njQuery.fn.andSelf = jQuery.fn.addBack;\r\n\r\n\r\n\r\n\r\n// Register as a named AMD module, since jQuery can be concatenated with other\r\n// files that may use define, but not via a proper concatenation script that\r\n// understands anonymous AMD modules. A named AMD is safest and most robust\r\n// way to register. Lowercase jquery is used because AMD module names are\r\n// derived from file names, and jQuery is normally delivered in a lowercase\r\n// file name. Do this after creating the global so that if an AMD module wants\r\n// to call noConflict to hide this version of jQuery, it will work.\r\n\r\n// Note that for maximum portability, libraries that are not jQuery should\r\n// declare themselves as anonymous modules, and avoid setting a global if an\r\n// AMD loader is present. jQuery is a special case. For more information, see\r\n// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\r\n\r\nif ( typeof define === \"function\" && define.amd ) {\r\n\tdefine( \"jquery\", [], function() {\r\n\t\treturn jQuery;\r\n\t});\r\n}\r\n\r\n\r\n\r\n\r\nvar\r\n\t// Map over jQuery in case of overwrite\r\n\t_jQuery = window.jQuery,\r\n\r\n\t// Map over the $ in case of overwrite\r\n\t_$ = window.$;\r\n\r\njQuery.noConflict = function( deep ) {\r\n\tif ( window.$ === jQuery ) {\r\n\t\twindow.$ = _$;\r\n\t}\r\n\r\n\tif ( deep && window.jQuery === jQuery ) {\r\n\t\twindow.jQuery = _jQuery;\r\n\t}\r\n\r\n\treturn jQuery;\r\n};\r\n\r\n// Expose jQuery and $ identifiers, even in\r\n// AMD (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\r\n// and CommonJS for browser emulators (#13566)\r\nif ( typeof noGlobal === strundefined ) {\r\n\twindow.jQuery = window.$ = jQuery;\r\n}\r\n\r\n\r\n\r\n\r\nreturn jQuery;\r\n\r\n}));\r\n","/**\r\n* Ajax Autocomplete for jQuery, version 1.2.7\r\n* (c) 2013 Tomas Kirda\r\n*\r\n* Ajax Autocomplete for jQuery is freely distributable under the terms of an MIT-style license.\r\n* For details, see the web site: http://www.devbridge.com/projects/autocomplete/jquery/\r\n*\r\n*/\r\n\r\n/*jslint browser: true, white: true, plusplus: true */\r\n/*global define, window, document, jQuery */\r\n\r\n// Expose plugin as an AMD module if AMD loader is present:\r\n(function (factory) {\r\n 'use strict';\r\n if (typeof define === 'function' && define.amd) {\r\n // AMD. Register as an anonymous module.\r\n define(['jquery'], factory);\r\n } else {\r\n // Browser globals\r\n factory(jQuery);\r\n }\r\n}(function ($) {\r\n 'use strict';\r\n\r\n var\r\n utils = (function () {\r\n return {\r\n\r\n extend: function (target, source) {\r\n return $.extend(target, source);\r\n },\r\n\r\n createNode: function (html) {\r\n var div = document.createElement('div');\r\n div.innerHTML = html;\r\n return div.firstChild;\r\n }\r\n\r\n };\r\n }()),\r\n\r\n keys = {\r\n ESC: 27,\r\n TAB: 9,\r\n RETURN: 13,\r\n UP: 38,\r\n DOWN: 40\r\n };\r\n\r\n function Autocomplete(el, options) {\r\n var noop = function () { },\r\n that = this,\r\n defaults = {\r\n autoSelectFirst: false,\r\n appendTo: 'body',\r\n serviceUrl: null,\r\n lookup: null,\r\n onSelect: null,\r\n width: 'auto',\r\n minChars: 1,\r\n maxHeight: 300,\r\n deferRequestBy: 0,\r\n params: {},\r\n formatResult: Autocomplete.formatResult,\r\n delimiter: null,\r\n zIndex: 9999,\r\n type: 'GET',\r\n noCache: false,\r\n onSearchStart: noop,\r\n onSearchComplete: noop,\r\n containerClass: 'autocomplete-suggestions',\r\n tabDisabled: false,\r\n dataType: 'text',\r\n lookupFilter: function (suggestion, originalQuery, queryLowerCase) {\r\n return suggestion.value.toLowerCase().indexOf(queryLowerCase) !== -1;\r\n },\r\n paramName: 'query',\r\n transformResult: function (response) {\r\n return typeof response === 'string' ? $.parseJSON(response) : response;\r\n }\r\n };\r\n\r\n // Shared variables:\r\n that.element = el;\r\n that.el = $(el);\r\n that.suggestions = [];\r\n that.badQueries = [];\r\n that.selectedIndex = -1;\r\n that.currentValue = that.element.value;\r\n that.intervalId = 0;\r\n that.cachedResponse = [];\r\n that.onChangeInterval = null;\r\n that.onChange = null;\r\n that.ignoreValueChange = false;\r\n that.isLocal = false;\r\n that.suggestionsContainer = null;\r\n that.options = $.extend({}, defaults, options);\r\n that.classes = {\r\n selected: 'autocomplete-selected',\r\n suggestion: 'autocomplete-suggestion'\r\n };\r\n\r\n // Initialize and set options:\r\n that.initialize();\r\n that.setOptions(options);\r\n }\r\n\r\n Autocomplete.utils = utils;\r\n\r\n $.Autocomplete = Autocomplete;\r\n\r\n Autocomplete.formatResult = function (suggestion, currentValue) {\r\n var reEscape = new RegExp('(\\\\' + ['/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\\\'].join('|\\\\') + ')', 'g'),\r\n pattern = '(' + currentValue.replace(reEscape, '\\\\$1') + ')';\r\n\r\n return suggestion.value.replace(new RegExp(pattern, 'gi'), '
$1<\\/strong>');\r\n };\r\n\r\n Autocomplete.prototype = {\r\n\r\n killerFn: null,\r\n\r\n initialize: function () {\r\n var that = this,\r\n suggestionSelector = '.' + that.classes.suggestion,\r\n selected = that.classes.selected,\r\n options = that.options,\r\n container;\r\n\r\n // Remove autocomplete attribute to prevent native suggestions:\r\n that.element.setAttribute('autocomplete', 'off');\r\n\r\n that.killerFn = function (e) {\r\n if ($(e.target).closest('.' + that.options.containerClass).length === 0) {\r\n that.killSuggestions();\r\n that.disableKillerFn();\r\n }\r\n };\r\n\r\n // Determine suggestions width:\r\n if (!options.width || options.width === 'auto') {\r\n options.width = that.el.outerWidth();\r\n }\r\n\r\n that.suggestionsContainer = Autocomplete.utils.createNode('');\r\n\r\n container = $(that.suggestionsContainer);\r\n\r\n container.appendTo(options.appendTo).width(options.width);\r\n\r\n // Listen for mouse over event on suggestions list:\r\n container.on('mouseover.autocomplete', suggestionSelector, function () {\r\n that.activate($(this).data('index'));\r\n });\r\n\r\n // Deselect active element when mouse leaves suggestions container:\r\n container.on('mouseout.autocomplete', function () {\r\n that.selectedIndex = -1;\r\n container.children('.' + selected).removeClass(selected);\r\n });\r\n\r\n // Listen for click event on suggestions list:\r\n container.on('click.autocomplete', suggestionSelector, function () {\r\n that.select($(this).data('index'), false);\r\n });\r\n\r\n that.fixPosition();\r\n\r\n // Opera does not like keydown:\r\n if (window.opera) {\r\n that.el.on('keypress.autocomplete', function (e) { that.onKeyPress(e); });\r\n } else {\r\n that.el.on('keydown.autocomplete', function (e) { that.onKeyPress(e); });\r\n }\r\n\r\n that.el.on('keyup.autocomplete', function (e) { that.onKeyUp(e); });\r\n that.el.on('blur.autocomplete', function () { that.onBlur(); });\r\n that.el.on('focus.autocomplete', function () { that.fixPosition(); });\r\n },\r\n\r\n onBlur: function () {\r\n this.enableKillerFn();\r\n },\r\n\r\n setOptions: function (suppliedOptions) {\r\n var that = this,\r\n options = that.options;\r\n\r\n utils.extend(options, suppliedOptions);\r\n\r\n that.isLocal = $.isArray(options.lookup);\r\n\r\n if (that.isLocal) {\r\n options.lookup = that.verifySuggestionsFormat(options.lookup);\r\n }\r\n\r\n // Adjust height, width and z-index:\r\n $(that.suggestionsContainer).css({\r\n 'max-height': options.maxHeight + 'px',\r\n 'width': options.width + 'px',\r\n 'z-index': options.zIndex\r\n });\r\n },\r\n\r\n clearCache: function () {\r\n this.cachedResponse = [];\r\n this.badQueries = [];\r\n },\r\n\r\n clear: function () {\r\n this.clearCache();\r\n this.currentValue = null;\r\n this.suggestions = [];\r\n },\r\n\r\n disable: function () {\r\n this.disabled = true;\r\n },\r\n\r\n enable: function () {\r\n this.disabled = false;\r\n },\r\n\r\n fixPosition: function () {\r\n var that = this,\r\n offset;\r\n\r\n // Don't adjsut position if custom container has been specified:\r\n if (that.options.appendTo !== 'body') {\r\n return;\r\n }\r\n\r\n offset = that.el.offset();\r\n\r\n $(that.suggestionsContainer).css({\r\n top: (offset.top + that.el.outerHeight()) + 'px',\r\n left: offset.left + 'px'\r\n });\r\n },\r\n\r\n enableKillerFn: function () {\r\n var that = this;\r\n $(document).on('click.autocomplete', that.killerFn);\r\n },\r\n\r\n disableKillerFn: function () {\r\n var that = this;\r\n $(document).off('click.autocomplete', that.killerFn);\r\n },\r\n\r\n killSuggestions: function () {\r\n var that = this;\r\n that.stopKillSuggestions();\r\n that.intervalId = window.setInterval(function () {\r\n that.hide();\r\n that.stopKillSuggestions();\r\n }, 300);\r\n },\r\n\r\n stopKillSuggestions: function () {\r\n window.clearInterval(this.intervalId);\r\n },\r\n\r\n onKeyPress: function (e) {\r\n var that = this;\r\n\r\n // If suggestions are hidden and user presses arrow down, display suggestions:\r\n if (!that.disabled && !that.visible && e.keyCode === keys.DOWN && that.currentValue) {\r\n that.suggest();\r\n return;\r\n }\r\n\r\n if (that.disabled || !that.visible) {\r\n return;\r\n }\r\n\r\n switch (e.keyCode) {\r\n case keys.ESC:\r\n that.el.val(that.currentValue);\r\n that.hide();\r\n break;\r\n case keys.TAB:\r\n case keys.RETURN:\r\n if (that.selectedIndex === -1) {\r\n that.hide();\r\n return;\r\n }\r\n that.select(that.selectedIndex, e.keyCode === keys.RETURN);\r\n if (e.keyCode === keys.TAB && this.options.tabDisabled === false) {\r\n return;\r\n }\r\n break;\r\n case keys.UP:\r\n that.moveUp();\r\n break;\r\n case keys.DOWN:\r\n that.moveDown();\r\n break;\r\n default:\r\n return;\r\n }\r\n\r\n // Cancel event if function did not return:\r\n e.stopImmediatePropagation();\r\n e.preventDefault();\r\n },\r\n\r\n onKeyUp: function (e) {\r\n var that = this;\r\n\r\n if (that.disabled) {\r\n return;\r\n }\r\n\r\n switch (e.keyCode) {\r\n case keys.UP:\r\n case keys.DOWN:\r\n return;\r\n }\r\n\r\n clearInterval(that.onChangeInterval);\r\n\r\n if (that.currentValue !== that.el.val()) {\r\n if (that.options.deferRequestBy > 0) {\r\n // Defer lookup in case when value changes very quickly:\r\n that.onChangeInterval = setInterval(function () {\r\n that.onValueChange();\r\n }, that.options.deferRequestBy);\r\n } else {\r\n that.onValueChange();\r\n }\r\n }\r\n },\r\n\r\n onValueChange: function () {\r\n var that = this,\r\n q;\r\n\r\n clearInterval(that.onChangeInterval);\r\n that.currentValue = that.element.value;\r\n\r\n q = that.getQuery(that.currentValue);\r\n that.selectedIndex = -1;\r\n\r\n if (that.ignoreValueChange) {\r\n that.ignoreValueChange = false;\r\n return;\r\n }\r\n\r\n if (q.length < that.options.minChars) {\r\n that.hide();\r\n } else {\r\n that.getSuggestions(q);\r\n }\r\n },\r\n\r\n getQuery: function (value) {\r\n var delimiter = this.options.delimiter,\r\n parts;\r\n\r\n if (!delimiter) {\r\n return $.trim(value);\r\n }\r\n parts = value.split(delimiter);\r\n return $.trim(parts[parts.length - 1]);\r\n },\r\n\r\n getSuggestionsLocal: function (query) {\r\n var that = this,\r\n queryLowerCase = query.toLowerCase(),\r\n filter = that.options.lookupFilter;\r\n\r\n return {\r\n suggestions: $.grep(that.options.lookup, function (suggestion) {\r\n return filter(suggestion, query, queryLowerCase);\r\n })\r\n };\r\n },\r\n\r\n getSuggestions: function (q) {\r\n var response,\r\n that = this,\r\n options = that.options,\r\n serviceUrl = options.serviceUrl;\r\n\r\n response = that.isLocal ? that.getSuggestionsLocal(q) : that.cachedResponse[q];\r\n\r\n if (response && $.isArray(response.suggestions)) {\r\n that.suggestions = response.suggestions;\r\n that.suggest();\r\n } else if (!that.isBadQuery(q)) {\r\n options.params[options.paramName] = q;\r\n if (options.onSearchStart.call(that.element, options.params) === false) {\r\n return;\r\n }\r\n if ($.isFunction(options.serviceUrl)) {\r\n serviceUrl = options.serviceUrl.call(that.element, q);\r\n }\r\n $.ajax({\r\n url: serviceUrl,\r\n data: options.ignoreParams ? null : options.params,\r\n type: options.type,\r\n dataType: options.dataType\r\n }).done(function (data) {\r\n that.processResponse(data, q);\r\n options.onSearchComplete.call(that.element, q);\r\n });\r\n }\r\n },\r\n\r\n isBadQuery: function (q) {\r\n var badQueries = this.badQueries,\r\n i = badQueries.length;\r\n\r\n while (i--) {\r\n if (q.indexOf(badQueries[i]) === 0) {\r\n return true;\r\n }\r\n }\r\n\r\n return false;\r\n },\r\n\r\n hide: function () {\r\n var that = this;\r\n that.visible = false;\r\n that.selectedIndex = -1;\r\n $(that.suggestionsContainer).hide();\r\n },\r\n\r\n suggest: function () {\r\n if (this.suggestions.length === 0) {\r\n this.hide();\r\n return;\r\n }\r\n\r\n var that = this,\r\n formatResult = that.options.formatResult,\r\n value = that.getQuery(that.currentValue),\r\n className = that.classes.suggestion,\r\n classSelected = that.classes.selected,\r\n container = $(that.suggestionsContainer),\r\n html = '';\r\n\r\n // Build suggestions inner HTML:\r\n $.each(that.suggestions, function (i, suggestion) {\r\n html += '' + formatResult(suggestion, value) + '
';\r\n });\r\n\r\n container.html(html).show();\r\n that.visible = true;\r\n\r\n // Select first value by default:\r\n if (that.options.autoSelectFirst) {\r\n that.selectedIndex = 0;\r\n container.children().first().addClass(classSelected);\r\n }\r\n },\r\n\r\n verifySuggestionsFormat: function (suggestions) {\r\n // If suggestions is string array, convert them to supported format:\r\n if (suggestions.length && typeof suggestions[0] === 'string') {\r\n return $.map(suggestions, function (value) {\r\n return { value: value, data: null };\r\n });\r\n }\r\n\r\n return suggestions;\r\n },\r\n\r\n processResponse: function (response, originalQuery) {\r\n var that = this,\r\n options = that.options,\r\n result = options.transformResult(response, originalQuery);\r\n\r\n result.suggestions = that.verifySuggestionsFormat(result.suggestions);\r\n\r\n // Cache results if cache is not disabled:\r\n if (!options.noCache) {\r\n that.cachedResponse[result[options.paramName]] = result;\r\n if (result.suggestions.length === 0) {\r\n that.badQueries.push(result[options.paramName]);\r\n }\r\n }\r\n\r\n // Display suggestions only if returned query matches current value:\r\n if (originalQuery === that.getQuery(that.currentValue)) {\r\n that.suggestions = result.suggestions;\r\n that.suggest();\r\n }\r\n },\r\n\r\n activate: function (index) {\r\n var that = this,\r\n activeItem,\r\n selected = that.classes.selected,\r\n container = $(that.suggestionsContainer),\r\n children = container.children();\r\n\r\n container.children('.' + selected).removeClass(selected);\r\n\r\n that.selectedIndex = index;\r\n\r\n if (that.selectedIndex !== -1 && children.length > that.selectedIndex) {\r\n activeItem = children.get(that.selectedIndex);\r\n $(activeItem).addClass(selected);\r\n return activeItem;\r\n }\r\n\r\n return null;\r\n },\r\n\r\n select: function (i, shouldIgnoreNextValueChange) {\r\n var that = this,\r\n selectedValue = that.suggestions[i];\r\n\r\n if (selectedValue) {\r\n that.el.val(selectedValue);\r\n that.ignoreValueChange = shouldIgnoreNextValueChange;\r\n that.hide();\r\n that.onSelect(i);\r\n }\r\n },\r\n\r\n moveUp: function () {\r\n var that = this;\r\n\r\n if (that.selectedIndex === -1) {\r\n return;\r\n }\r\n\r\n if (that.selectedIndex === 0) {\r\n $(that.suggestionsContainer).children().first().removeClass(that.classes.selected);\r\n that.selectedIndex = -1;\r\n that.el.val(that.currentValue);\r\n return;\r\n }\r\n\r\n that.adjustScroll(that.selectedIndex - 1);\r\n },\r\n\r\n moveDown: function () {\r\n var that = this;\r\n\r\n if (that.selectedIndex === (that.suggestions.length - 1)) {\r\n return;\r\n }\r\n\r\n that.adjustScroll(that.selectedIndex + 1);\r\n },\r\n\r\n adjustScroll: function (index) {\r\n var that = this,\r\n activeItem = that.activate(index),\r\n offsetTop,\r\n upperBound,\r\n lowerBound,\r\n heightDelta = 25;\r\n\r\n if (!activeItem) {\r\n return;\r\n }\r\n\r\n offsetTop = activeItem.offsetTop;\r\n upperBound = $(that.suggestionsContainer).scrollTop();\r\n lowerBound = upperBound + that.options.maxHeight - heightDelta;\r\n\r\n if (offsetTop < upperBound) {\r\n $(that.suggestionsContainer).scrollTop(offsetTop);\r\n } else if (offsetTop > lowerBound) {\r\n $(that.suggestionsContainer).scrollTop(offsetTop - that.options.maxHeight + heightDelta);\r\n }\r\n\r\n that.el.val(that.getValue(that.suggestions[index].value));\r\n },\r\n\r\n onSelect: function (index) {\r\n var that = this,\r\n onSelectCallback = that.options.onSelect,\r\n suggestion = that.suggestions[index];\r\n\r\n that.el.val(that.getValue(suggestion.value));\r\n\r\n if ($.isFunction(onSelectCallback)) {\r\n onSelectCallback.call(that.element, suggestion);\r\n }\r\n },\r\n\r\n getValue: function (value) {\r\n var that = this,\r\n delimiter = that.options.delimiter,\r\n currentValue,\r\n parts;\r\n\r\n if (!delimiter) {\r\n return value;\r\n }\r\n\r\n currentValue = that.currentValue;\r\n parts = currentValue.split(delimiter);\r\n\r\n if (parts.length === 1) {\r\n return value;\r\n }\r\n\r\n return currentValue.substr(0, currentValue.length - parts[parts.length - 1].length) + value;\r\n },\r\n\r\n dispose: function () {\r\n var that = this;\r\n that.el.off('.autocomplete').removeData('autocomplete');\r\n that.disableKillerFn();\r\n $(that.suggestionsContainer).remove();\r\n }\r\n };\r\n\r\n // Create chainable jQuery plugin:\r\n $.fn.autocomplete = function (options, args) {\r\n var dataKey = 'autocomplete';\r\n // If function invoked without argument return\r\n // instance of the first matched element:\r\n if (arguments.length === 0) {\r\n return this.first().data(dataKey);\r\n }\r\n\r\n return this.each(function () {\r\n var inputElement = $(this),\r\n instance = inputElement.data(dataKey);\r\n\r\n if (typeof options === 'string') {\r\n if (instance && typeof instance[options] === 'function') {\r\n instance[options](args);\r\n }\r\n } else {\r\n // If instance already exists, destroy it:\r\n if (instance && instance.dispose) {\r\n instance.dispose();\r\n }\r\n instance = new Autocomplete(this, options);\r\n inputElement.data(dataKey, instance);\r\n }\r\n });\r\n };\r\n}));\r\n","// Underscore.js 1.8.3\r\n// http://underscorejs.org\r\n// (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\r\n// Underscore may be freely distributed under the MIT license.\r\n\r\n(function() {\r\n\r\n // Baseline setup\r\n // --------------\r\n\r\n // Establish the root object, `window` in the browser, or `exports` on the server.\r\n var root = this;\r\n\r\n // Save the previous value of the `_` variable.\r\n var previousUnderscore = root._;\r\n\r\n // Save bytes in the minified (but not gzipped) version:\r\n var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\r\n\r\n // Create quick reference variables for speed access to core prototypes.\r\n var\r\n push = ArrayProto.push,\r\n slice = ArrayProto.slice,\r\n toString = ObjProto.toString,\r\n hasOwnProperty = ObjProto.hasOwnProperty;\r\n\r\n // All **ECMAScript 5** native function implementations that we hope to use\r\n // are declared here.\r\n var\r\n nativeIsArray = Array.isArray,\r\n nativeKeys = Object.keys,\r\n nativeBind = FuncProto.bind,\r\n nativeCreate = Object.create;\r\n\r\n // Naked function reference for surrogate-prototype-swapping.\r\n var Ctor = function(){};\r\n\r\n // Create a safe reference to the Underscore object for use below.\r\n var _ = function(obj) {\r\n if (obj instanceof _) return obj;\r\n if (!(this instanceof _)) return new _(obj);\r\n this._wrapped = obj;\r\n };\r\n\r\n // Export the Underscore object for **Node.js**, with\r\n // backwards-compatibility for the old `require()` API. If we're in\r\n // the browser, add `_` as a global object.\r\n if (typeof exports !== 'undefined') {\r\n if (typeof module !== 'undefined' && module.exports) {\r\n exports = module.exports = _;\r\n }\r\n exports._ = _;\r\n } else {\r\n root._ = _;\r\n }\r\n\r\n // Current version.\r\n _.VERSION = '1.8.3';\r\n\r\n // Internal function that returns an efficient (for current engines) version\r\n // of the passed-in callback, to be repeatedly applied in other Underscore\r\n // functions.\r\n var optimizeCb = function(func, context, argCount) {\r\n if (context === void 0) return func;\r\n switch (argCount == null ? 3 : argCount) {\r\n case 1: return function(value) {\r\n return func.call(context, value);\r\n };\r\n case 2: return function(value, other) {\r\n return func.call(context, value, other);\r\n };\r\n case 3: return function(value, index, collection) {\r\n return func.call(context, value, index, collection);\r\n };\r\n case 4: return function(accumulator, value, index, collection) {\r\n return func.call(context, accumulator, value, index, collection);\r\n };\r\n }\r\n return function() {\r\n return func.apply(context, arguments);\r\n };\r\n };\r\n\r\n // A mostly-internal function to generate callbacks that can be applied\r\n // to each element in a collection, returning the desired result — either\r\n // identity, an arbitrary callback, a property matcher, or a property accessor.\r\n var cb = function(value, context, argCount) {\r\n if (value == null) return _.identity;\r\n if (_.isFunction(value)) return optimizeCb(value, context, argCount);\r\n if (_.isObject(value)) return _.matcher(value);\r\n return _.property(value);\r\n };\r\n _.iteratee = function(value, context) {\r\n return cb(value, context, Infinity);\r\n };\r\n\r\n // An internal function for creating assigner functions.\r\n var createAssigner = function(keysFunc, undefinedOnly) {\r\n return function(obj) {\r\n var length = arguments.length;\r\n if (length < 2 || obj == null) return obj;\r\n for (var index = 1; index < length; index++) {\r\n var source = arguments[index],\r\n keys = keysFunc(source),\r\n l = keys.length;\r\n for (var i = 0; i < l; i++) {\r\n var key = keys[i];\r\n if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\r\n }\r\n }\r\n return obj;\r\n };\r\n };\r\n\r\n // An internal function for creating a new object that inherits from another.\r\n var baseCreate = function(prototype) {\r\n if (!_.isObject(prototype)) return {};\r\n if (nativeCreate) return nativeCreate(prototype);\r\n Ctor.prototype = prototype;\r\n var result = new Ctor;\r\n Ctor.prototype = null;\r\n return result;\r\n };\r\n\r\n var property = function(key) {\r\n return function(obj) {\r\n return obj == null ? void 0 : obj[key];\r\n };\r\n };\r\n\r\n // Helper for collection methods to determine whether a collection\r\n // should be iterated as an array or as an object\r\n // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\r\n // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\r\n var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\r\n var getLength = property('length');\r\n var isArrayLike = function(collection) {\r\n var length = getLength(collection);\r\n return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\r\n };\r\n\r\n // Collection Functions\r\n // --------------------\r\n\r\n // The cornerstone, an `each` implementation, aka `forEach`.\r\n // Handles raw objects in addition to array-likes. Treats all\r\n // sparse array-likes as if they were dense.\r\n _.each = _.forEach = function(obj, iteratee, context) {\r\n iteratee = optimizeCb(iteratee, context);\r\n var i, length;\r\n if (isArrayLike(obj)) {\r\n for (i = 0, length = obj.length; i < length; i++) {\r\n iteratee(obj[i], i, obj);\r\n }\r\n } else {\r\n var keys = _.keys(obj);\r\n for (i = 0, length = keys.length; i < length; i++) {\r\n iteratee(obj[keys[i]], keys[i], obj);\r\n }\r\n }\r\n return obj;\r\n };\r\n\r\n // Return the results of applying the iteratee to each element.\r\n _.map = _.collect = function(obj, iteratee, context) {\r\n iteratee = cb(iteratee, context);\r\n var keys = !isArrayLike(obj) && _.keys(obj),\r\n length = (keys || obj).length,\r\n results = Array(length);\r\n for (var index = 0; index < length; index++) {\r\n var currentKey = keys ? keys[index] : index;\r\n results[index] = iteratee(obj[currentKey], currentKey, obj);\r\n }\r\n return results;\r\n };\r\n\r\n // Create a reducing function iterating left or right.\r\n function createReduce(dir) {\r\n // Optimized iterator function as using arguments.length\r\n // in the main function will deoptimize the, see #1991.\r\n function iterator(obj, iteratee, memo, keys, index, length) {\r\n for (; index >= 0 && index < length; index += dir) {\r\n var currentKey = keys ? keys[index] : index;\r\n memo = iteratee(memo, obj[currentKey], currentKey, obj);\r\n }\r\n return memo;\r\n }\r\n\r\n return function(obj, iteratee, memo, context) {\r\n iteratee = optimizeCb(iteratee, context, 4);\r\n var keys = !isArrayLike(obj) && _.keys(obj),\r\n length = (keys || obj).length,\r\n index = dir > 0 ? 0 : length - 1;\r\n // Determine the initial value if none is provided.\r\n if (arguments.length < 3) {\r\n memo = obj[keys ? keys[index] : index];\r\n index += dir;\r\n }\r\n return iterator(obj, iteratee, memo, keys, index, length);\r\n };\r\n }\r\n\r\n // **Reduce** builds up a single result from a list of values, aka `inject`,\r\n // or `foldl`.\r\n _.reduce = _.foldl = _.inject = createReduce(1);\r\n\r\n // The right-associative version of reduce, also known as `foldr`.\r\n _.reduceRight = _.foldr = createReduce(-1);\r\n\r\n // Return the first value which passes a truth test. Aliased as `detect`.\r\n _.find = _.detect = function(obj, predicate, context) {\r\n var key;\r\n if (isArrayLike(obj)) {\r\n key = _.findIndex(obj, predicate, context);\r\n } else {\r\n key = _.findKey(obj, predicate, context);\r\n }\r\n if (key !== void 0 && key !== -1) return obj[key];\r\n };\r\n\r\n // Return all the elements that pass a truth test.\r\n // Aliased as `select`.\r\n _.filter = _.select = function(obj, predicate, context) {\r\n var results = [];\r\n predicate = cb(predicate, context);\r\n _.each(obj, function(value, index, list) {\r\n if (predicate(value, index, list)) results.push(value);\r\n });\r\n return results;\r\n };\r\n\r\n // Return all the elements for which a truth test fails.\r\n _.reject = function(obj, predicate, context) {\r\n return _.filter(obj, _.negate(cb(predicate)), context);\r\n };\r\n\r\n // Determine whether all of the elements match a truth test.\r\n // Aliased as `all`.\r\n _.every = _.all = function(obj, predicate, context) {\r\n predicate = cb(predicate, context);\r\n var keys = !isArrayLike(obj) && _.keys(obj),\r\n length = (keys || obj).length;\r\n for (var index = 0; index < length; index++) {\r\n var currentKey = keys ? keys[index] : index;\r\n if (!predicate(obj[currentKey], currentKey, obj)) return false;\r\n }\r\n return true;\r\n };\r\n\r\n // Determine if at least one element in the object matches a truth test.\r\n // Aliased as `any`.\r\n _.some = _.any = function(obj, predicate, context) {\r\n predicate = cb(predicate, context);\r\n var keys = !isArrayLike(obj) && _.keys(obj),\r\n length = (keys || obj).length;\r\n for (var index = 0; index < length; index++) {\r\n var currentKey = keys ? keys[index] : index;\r\n if (predicate(obj[currentKey], currentKey, obj)) return true;\r\n }\r\n return false;\r\n };\r\n\r\n // Determine if the array or object contains a given item (using `===`).\r\n // Aliased as `includes` and `include`.\r\n _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\r\n if (!isArrayLike(obj)) obj = _.values(obj);\r\n if (typeof fromIndex != 'number' || guard) fromIndex = 0;\r\n return _.indexOf(obj, item, fromIndex) >= 0;\r\n };\r\n\r\n // Invoke a method (with arguments) on every item in a collection.\r\n _.invoke = function(obj, method) {\r\n var args = slice.call(arguments, 2);\r\n var isFunc = _.isFunction(method);\r\n return _.map(obj, function(value) {\r\n var func = isFunc ? method : value[method];\r\n return func == null ? func : func.apply(value, args);\r\n });\r\n };\r\n\r\n // Convenience version of a common use case of `map`: fetching a property.\r\n _.pluck = function(obj, key) {\r\n return _.map(obj, _.property(key));\r\n };\r\n\r\n // Convenience version of a common use case of `filter`: selecting only objects\r\n // containing specific `key:value` pairs.\r\n _.where = function(obj, attrs) {\r\n return _.filter(obj, _.matcher(attrs));\r\n };\r\n\r\n // Convenience version of a common use case of `find`: getting the first object\r\n // containing specific `key:value` pairs.\r\n _.findWhere = function(obj, attrs) {\r\n return _.find(obj, _.matcher(attrs));\r\n };\r\n\r\n // Return the maximum element (or element-based computation).\r\n _.max = function(obj, iteratee, context) {\r\n var result = -Infinity, lastComputed = -Infinity,\r\n value, computed;\r\n if (iteratee == null && obj != null) {\r\n obj = isArrayLike(obj) ? obj : _.values(obj);\r\n for (var i = 0, length = obj.length; i < length; i++) {\r\n value = obj[i];\r\n if (value > result) {\r\n result = value;\r\n }\r\n }\r\n } else {\r\n iteratee = cb(iteratee, context);\r\n _.each(obj, function(value, index, list) {\r\n computed = iteratee(value, index, list);\r\n if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\r\n result = value;\r\n lastComputed = computed;\r\n }\r\n });\r\n }\r\n return result;\r\n };\r\n\r\n // Return the minimum element (or element-based computation).\r\n _.min = function(obj, iteratee, context) {\r\n var result = Infinity, lastComputed = Infinity,\r\n value, computed;\r\n if (iteratee == null && obj != null) {\r\n obj = isArrayLike(obj) ? obj : _.values(obj);\r\n for (var i = 0, length = obj.length; i < length; i++) {\r\n value = obj[i];\r\n if (value < result) {\r\n result = value;\r\n }\r\n }\r\n } else {\r\n iteratee = cb(iteratee, context);\r\n _.each(obj, function(value, index, list) {\r\n computed = iteratee(value, index, list);\r\n if (computed < lastComputed || computed === Infinity && result === Infinity) {\r\n result = value;\r\n lastComputed = computed;\r\n }\r\n });\r\n }\r\n return result;\r\n };\r\n\r\n // Shuffle a collection, using the modern version of the\r\n // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\r\n _.shuffle = function(obj) {\r\n var set = isArrayLike(obj) ? obj : _.values(obj);\r\n var length = set.length;\r\n var shuffled = Array(length);\r\n for (var index = 0, rand; index < length; index++) {\r\n rand = _.random(0, index);\r\n if (rand !== index) shuffled[index] = shuffled[rand];\r\n shuffled[rand] = set[index];\r\n }\r\n return shuffled;\r\n };\r\n\r\n // Sample **n** random values from a collection.\r\n // If **n** is not specified, returns a single random element.\r\n // The internal `guard` argument allows it to work with `map`.\r\n _.sample = function(obj, n, guard) {\r\n if (n == null || guard) {\r\n if (!isArrayLike(obj)) obj = _.values(obj);\r\n return obj[_.random(obj.length - 1)];\r\n }\r\n return _.shuffle(obj).slice(0, Math.max(0, n));\r\n };\r\n\r\n // Sort the object's values by a criterion produced by an iteratee.\r\n _.sortBy = function(obj, iteratee, context) {\r\n iteratee = cb(iteratee, context);\r\n return _.pluck(_.map(obj, function(value, index, list) {\r\n return {\r\n value: value,\r\n index: index,\r\n criteria: iteratee(value, index, list)\r\n };\r\n }).sort(function(left, right) {\r\n var a = left.criteria;\r\n var b = right.criteria;\r\n if (a !== b) {\r\n if (a > b || a === void 0) return 1;\r\n if (a < b || b === void 0) return -1;\r\n }\r\n return left.index - right.index;\r\n }), 'value');\r\n };\r\n\r\n // An internal function used for aggregate \"group by\" operations.\r\n var group = function(behavior) {\r\n return function(obj, iteratee, context) {\r\n var result = {};\r\n iteratee = cb(iteratee, context);\r\n _.each(obj, function(value, index) {\r\n var key = iteratee(value, index, obj);\r\n behavior(result, value, key);\r\n });\r\n return result;\r\n };\r\n };\r\n\r\n // Groups the object's values by a criterion. Pass either a string attribute\r\n // to group by, or a function that returns the criterion.\r\n _.groupBy = group(function(result, value, key) {\r\n if (_.has(result, key)) result[key].push(value); else result[key] = [value];\r\n });\r\n\r\n // Indexes the object's values by a criterion, similar to `groupBy`, but for\r\n // when you know that your index values will be unique.\r\n _.indexBy = group(function(result, value, key) {\r\n result[key] = value;\r\n });\r\n\r\n // Counts instances of an object that group by a certain criterion. Pass\r\n // either a string attribute to count by, or a function that returns the\r\n // criterion.\r\n _.countBy = group(function(result, value, key) {\r\n if (_.has(result, key)) result[key]++; else result[key] = 1;\r\n });\r\n\r\n // Safely create a real, live array from anything iterable.\r\n _.toArray = function(obj) {\r\n if (!obj) return [];\r\n if (_.isArray(obj)) return slice.call(obj);\r\n if (isArrayLike(obj)) return _.map(obj, _.identity);\r\n return _.values(obj);\r\n };\r\n\r\n // Return the number of elements in an object.\r\n _.size = function(obj) {\r\n if (obj == null) return 0;\r\n return isArrayLike(obj) ? obj.length : _.keys(obj).length;\r\n };\r\n\r\n // Split a collection into two arrays: one whose elements all satisfy the given\r\n // predicate, and one whose elements all do not satisfy the predicate.\r\n _.partition = function(obj, predicate, context) {\r\n predicate = cb(predicate, context);\r\n var pass = [], fail = [];\r\n _.each(obj, function(value, key, obj) {\r\n (predicate(value, key, obj) ? pass : fail).push(value);\r\n });\r\n return [pass, fail];\r\n };\r\n\r\n // Array Functions\r\n // ---------------\r\n\r\n // Get the first element of an array. Passing **n** will return the first N\r\n // values in the array. Aliased as `head` and `take`. The **guard** check\r\n // allows it to work with `_.map`.\r\n _.first = _.head = _.take = function(array, n, guard) {\r\n if (array == null) return void 0;\r\n if (n == null || guard) return array[0];\r\n return _.initial(array, array.length - n);\r\n };\r\n\r\n // Returns everything but the last entry of the array. Especially useful on\r\n // the arguments object. Passing **n** will return all the values in\r\n // the array, excluding the last N.\r\n _.initial = function(array, n, guard) {\r\n return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\r\n };\r\n\r\n // Get the last element of an array. Passing **n** will return the last N\r\n // values in the array.\r\n _.last = function(array, n, guard) {\r\n if (array == null) return void 0;\r\n if (n == null || guard) return array[array.length - 1];\r\n return _.rest(array, Math.max(0, array.length - n));\r\n };\r\n\r\n // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\r\n // Especially useful on the arguments object. Passing an **n** will return\r\n // the rest N values in the array.\r\n _.rest = _.tail = _.drop = function(array, n, guard) {\r\n return slice.call(array, n == null || guard ? 1 : n);\r\n };\r\n\r\n // Trim out all falsy values from an array.\r\n _.compact = function(array) {\r\n return _.filter(array, _.identity);\r\n };\r\n\r\n // Internal implementation of a recursive `flatten` function.\r\n var flatten = function(input, shallow, strict, startIndex) {\r\n var output = [], idx = 0;\r\n for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\r\n var value = input[i];\r\n if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\r\n //flatten current level of array or arguments object\r\n if (!shallow) value = flatten(value, shallow, strict);\r\n var j = 0, len = value.length;\r\n output.length += len;\r\n while (j < len) {\r\n output[idx++] = value[j++];\r\n }\r\n } else if (!strict) {\r\n output[idx++] = value;\r\n }\r\n }\r\n return output;\r\n };\r\n\r\n // Flatten out an array, either recursively (by default), or just one level.\r\n _.flatten = function(array, shallow) {\r\n return flatten(array, shallow, false);\r\n };\r\n\r\n // Return a version of the array that does not contain the specified value(s).\r\n _.without = function(array) {\r\n return _.difference(array, slice.call(arguments, 1));\r\n };\r\n\r\n // Produce a duplicate-free version of the array. If the array has already\r\n // been sorted, you have the option of using a faster algorithm.\r\n // Aliased as `unique`.\r\n _.uniq = _.unique = function(array, isSorted, iteratee, context) {\r\n if (!_.isBoolean(isSorted)) {\r\n context = iteratee;\r\n iteratee = isSorted;\r\n isSorted = false;\r\n }\r\n if (iteratee != null) iteratee = cb(iteratee, context);\r\n var result = [];\r\n var seen = [];\r\n for (var i = 0, length = getLength(array); i < length; i++) {\r\n var value = array[i],\r\n computed = iteratee ? iteratee(value, i, array) : value;\r\n if (isSorted) {\r\n if (!i || seen !== computed) result.push(value);\r\n seen = computed;\r\n } else if (iteratee) {\r\n if (!_.contains(seen, computed)) {\r\n seen.push(computed);\r\n result.push(value);\r\n }\r\n } else if (!_.contains(result, value)) {\r\n result.push(value);\r\n }\r\n }\r\n return result;\r\n };\r\n\r\n // Produce an array that contains the union: each distinct element from all of\r\n // the passed-in arrays.\r\n _.union = function() {\r\n return _.uniq(flatten(arguments, true, true));\r\n };\r\n\r\n // Produce an array that contains every item shared between all the\r\n // passed-in arrays.\r\n _.intersection = function(array) {\r\n var result = [];\r\n var argsLength = arguments.length;\r\n for (var i = 0, length = getLength(array); i < length; i++) {\r\n var item = array[i];\r\n if (_.contains(result, item)) continue;\r\n for (var j = 1; j < argsLength; j++) {\r\n if (!_.contains(arguments[j], item)) break;\r\n }\r\n if (j === argsLength) result.push(item);\r\n }\r\n return result;\r\n };\r\n\r\n // Take the difference between one array and a number of other arrays.\r\n // Only the elements present in just the first array will remain.\r\n _.difference = function(array) {\r\n var rest = flatten(arguments, true, true, 1);\r\n return _.filter(array, function(value){\r\n return !_.contains(rest, value);\r\n });\r\n };\r\n\r\n // Zip together multiple lists into a single array -- elements that share\r\n // an index go together.\r\n _.zip = function() {\r\n return _.unzip(arguments);\r\n };\r\n\r\n // Complement of _.zip. Unzip accepts an array of arrays and groups\r\n // each array's elements on shared indices\r\n _.unzip = function(array) {\r\n var length = array && _.max(array, getLength).length || 0;\r\n var result = Array(length);\r\n\r\n for (var index = 0; index < length; index++) {\r\n result[index] = _.pluck(array, index);\r\n }\r\n return result;\r\n };\r\n\r\n // Converts lists into objects. Pass either a single array of `[key, value]`\r\n // pairs, or two parallel arrays of the same length -- one of keys, and one of\r\n // the corresponding values.\r\n _.object = function(list, values) {\r\n var result = {};\r\n for (var i = 0, length = getLength(list); i < length; i++) {\r\n if (values) {\r\n result[list[i]] = values[i];\r\n } else {\r\n result[list[i][0]] = list[i][1];\r\n }\r\n }\r\n return result;\r\n };\r\n\r\n // Generator function to create the findIndex and findLastIndex functions\r\n function createPredicateIndexFinder(dir) {\r\n return function(array, predicate, context) {\r\n predicate = cb(predicate, context);\r\n var length = getLength(array);\r\n var index = dir > 0 ? 0 : length - 1;\r\n for (; index >= 0 && index < length; index += dir) {\r\n if (predicate(array[index], index, array)) return index;\r\n }\r\n return -1;\r\n };\r\n }\r\n\r\n // Returns the first index on an array-like that passes a predicate test\r\n _.findIndex = createPredicateIndexFinder(1);\r\n _.findLastIndex = createPredicateIndexFinder(-1);\r\n\r\n // Use a comparator function to figure out the smallest index at which\r\n // an object should be inserted so as to maintain order. Uses binary search.\r\n _.sortedIndex = function(array, obj, iteratee, context) {\r\n iteratee = cb(iteratee, context, 1);\r\n var value = iteratee(obj);\r\n var low = 0, high = getLength(array);\r\n while (low < high) {\r\n var mid = Math.floor((low + high) / 2);\r\n if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\r\n }\r\n return low;\r\n };\r\n\r\n // Generator function to create the indexOf and lastIndexOf functions\r\n function createIndexFinder(dir, predicateFind, sortedIndex) {\r\n return function(array, item, idx) {\r\n var i = 0, length = getLength(array);\r\n if (typeof idx == 'number') {\r\n if (dir > 0) {\r\n i = idx >= 0 ? idx : Math.max(idx + length, i);\r\n } else {\r\n length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\r\n }\r\n } else if (sortedIndex && idx && length) {\r\n idx = sortedIndex(array, item);\r\n return array[idx] === item ? idx : -1;\r\n }\r\n if (item !== item) {\r\n idx = predicateFind(slice.call(array, i, length), _.isNaN);\r\n return idx >= 0 ? idx + i : -1;\r\n }\r\n for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\r\n if (array[idx] === item) return idx;\r\n }\r\n return -1;\r\n };\r\n }\r\n\r\n // Return the position of the first occurrence of an item in an array,\r\n // or -1 if the item is not included in the array.\r\n // If the array is large and already in sort order, pass `true`\r\n // for **isSorted** to use binary search.\r\n _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\r\n _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\r\n\r\n // Generate an integer Array containing an arithmetic progression. A port of\r\n // the native Python `range()` function. See\r\n // [the Python documentation](http://docs.python.org/library/functions.html#range).\r\n _.range = function(start, stop, step) {\r\n if (stop == null) {\r\n stop = start || 0;\r\n start = 0;\r\n }\r\n step = step || 1;\r\n\r\n var length = Math.max(Math.ceil((stop - start) / step), 0);\r\n var range = Array(length);\r\n\r\n for (var idx = 0; idx < length; idx++, start += step) {\r\n range[idx] = start;\r\n }\r\n\r\n return range;\r\n };\r\n\r\n // Function (ahem) Functions\r\n // ------------------\r\n\r\n // Determines whether to execute a function as a constructor\r\n // or a normal function with the provided arguments\r\n var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\r\n if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\r\n var self = baseCreate(sourceFunc.prototype);\r\n var result = sourceFunc.apply(self, args);\r\n if (_.isObject(result)) return result;\r\n return self;\r\n };\r\n\r\n // Create a function bound to a given object (assigning `this`, and arguments,\r\n // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\r\n // available.\r\n _.bind = function(func, context) {\r\n if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\r\n if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\r\n var args = slice.call(arguments, 2);\r\n var bound = function() {\r\n return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\r\n };\r\n return bound;\r\n };\r\n\r\n // Partially apply a function by creating a version that has had some of its\r\n // arguments pre-filled, without changing its dynamic `this` context. _ acts\r\n // as a placeholder, allowing any combination of arguments to be pre-filled.\r\n _.partial = function(func) {\r\n var boundArgs = slice.call(arguments, 1);\r\n var bound = function() {\r\n var position = 0, length = boundArgs.length;\r\n var args = Array(length);\r\n for (var i = 0; i < length; i++) {\r\n args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\r\n }\r\n while (position < arguments.length) args.push(arguments[position++]);\r\n return executeBound(func, bound, this, this, args);\r\n };\r\n return bound;\r\n };\r\n\r\n // Bind a number of an object's methods to that object. Remaining arguments\r\n // are the method names to be bound. Useful for ensuring that all callbacks\r\n // defined on an object belong to it.\r\n _.bindAll = function(obj) {\r\n var i, length = arguments.length, key;\r\n if (length <= 1) throw new Error('bindAll must be passed function names');\r\n for (i = 1; i < length; i++) {\r\n key = arguments[i];\r\n obj[key] = _.bind(obj[key], obj);\r\n }\r\n return obj;\r\n };\r\n\r\n // Memoize an expensive function by storing its results.\r\n _.memoize = function(func, hasher) {\r\n var memoize = function(key) {\r\n var cache = memoize.cache;\r\n var address = '' + (hasher ? hasher.apply(this, arguments) : key);\r\n if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\r\n return cache[address];\r\n };\r\n memoize.cache = {};\r\n return memoize;\r\n };\r\n\r\n // Delays a function for the given number of milliseconds, and then calls\r\n // it with the arguments supplied.\r\n _.delay = function(func, wait) {\r\n var args = slice.call(arguments, 2);\r\n return setTimeout(function(){\r\n return func.apply(null, args);\r\n }, wait);\r\n };\r\n\r\n // Defers a function, scheduling it to run after the current call stack has\r\n // cleared.\r\n _.defer = _.partial(_.delay, _, 1);\r\n\r\n // Returns a function, that, when invoked, will only be triggered at most once\r\n // during a given window of time. Normally, the throttled function will run\r\n // as much as it can, without ever going more than once per `wait` duration;\r\n // but if you'd like to disable the execution on the leading edge, pass\r\n // `{leading: false}`. To disable execution on the trailing edge, ditto.\r\n _.throttle = function(func, wait, options) {\r\n var context, args, result;\r\n var timeout = null;\r\n var previous = 0;\r\n if (!options) options = {};\r\n var later = function() {\r\n previous = options.leading === false ? 0 : _.now();\r\n timeout = null;\r\n result = func.apply(context, args);\r\n if (!timeout) context = args = null;\r\n };\r\n return function() {\r\n var now = _.now();\r\n if (!previous && options.leading === false) previous = now;\r\n var remaining = wait - (now - previous);\r\n context = this;\r\n args = arguments;\r\n if (remaining <= 0 || remaining > wait) {\r\n if (timeout) {\r\n clearTimeout(timeout);\r\n timeout = null;\r\n }\r\n previous = now;\r\n result = func.apply(context, args);\r\n if (!timeout) context = args = null;\r\n } else if (!timeout && options.trailing !== false) {\r\n timeout = setTimeout(later, remaining);\r\n }\r\n return result;\r\n };\r\n };\r\n\r\n // Returns a function, that, as long as it continues to be invoked, will not\r\n // be triggered. The function will be called after it stops being called for\r\n // N milliseconds. If `immediate` is passed, trigger the function on the\r\n // leading edge, instead of the trailing.\r\n _.debounce = function(func, wait, immediate) {\r\n var timeout, args, context, timestamp, result;\r\n\r\n var later = function() {\r\n var last = _.now() - timestamp;\r\n\r\n if (last < wait && last >= 0) {\r\n timeout = setTimeout(later, wait - last);\r\n } else {\r\n timeout = null;\r\n if (!immediate) {\r\n result = func.apply(context, args);\r\n if (!timeout) context = args = null;\r\n }\r\n }\r\n };\r\n\r\n return function() {\r\n context = this;\r\n args = arguments;\r\n timestamp = _.now();\r\n var callNow = immediate && !timeout;\r\n if (!timeout) timeout = setTimeout(later, wait);\r\n if (callNow) {\r\n result = func.apply(context, args);\r\n context = args = null;\r\n }\r\n\r\n return result;\r\n };\r\n };\r\n\r\n // Returns the first function passed as an argument to the second,\r\n // allowing you to adjust arguments, run code before and after, and\r\n // conditionally execute the original function.\r\n _.wrap = function(func, wrapper) {\r\n return _.partial(wrapper, func);\r\n };\r\n\r\n // Returns a negated version of the passed-in predicate.\r\n _.negate = function(predicate) {\r\n return function() {\r\n return !predicate.apply(this, arguments);\r\n };\r\n };\r\n\r\n // Returns a function that is the composition of a list of functions, each\r\n // consuming the return value of the function that follows.\r\n _.compose = function() {\r\n var args = arguments;\r\n var start = args.length - 1;\r\n return function() {\r\n var i = start;\r\n var result = args[start].apply(this, arguments);\r\n while (i--) result = args[i].call(this, result);\r\n return result;\r\n };\r\n };\r\n\r\n // Returns a function that will only be executed on and after the Nth call.\r\n _.after = function(times, func) {\r\n return function() {\r\n if (--times < 1) {\r\n return func.apply(this, arguments);\r\n }\r\n };\r\n };\r\n\r\n // Returns a function that will only be executed up to (but not including) the Nth call.\r\n _.before = function(times, func) {\r\n var memo;\r\n return function() {\r\n if (--times > 0) {\r\n memo = func.apply(this, arguments);\r\n }\r\n if (times <= 1) func = null;\r\n return memo;\r\n };\r\n };\r\n\r\n // Returns a function that will be executed at most one time, no matter how\r\n // often you call it. Useful for lazy initialization.\r\n _.once = _.partial(_.before, 2);\r\n\r\n // Object Functions\r\n // ----------------\r\n\r\n // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\r\n var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\r\n var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\r\n 'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\r\n\r\n function collectNonEnumProps(obj, keys) {\r\n var nonEnumIdx = nonEnumerableProps.length;\r\n var constructor = obj.constructor;\r\n var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;\r\n\r\n // Constructor is a special case.\r\n var prop = 'constructor';\r\n if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\r\n\r\n while (nonEnumIdx--) {\r\n prop = nonEnumerableProps[nonEnumIdx];\r\n if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\r\n keys.push(prop);\r\n }\r\n }\r\n }\r\n\r\n // Retrieve the names of an object's own properties.\r\n // Delegates to **ECMAScript 5**'s native `Object.keys`\r\n _.keys = function(obj) {\r\n if (!_.isObject(obj)) return [];\r\n if (nativeKeys) return nativeKeys(obj);\r\n var keys = [];\r\n for (var key in obj) if (_.has(obj, key)) keys.push(key);\r\n // Ahem, IE < 9.\r\n if (hasEnumBug) collectNonEnumProps(obj, keys);\r\n return keys;\r\n };\r\n\r\n // Retrieve all the property names of an object.\r\n _.allKeys = function(obj) {\r\n if (!_.isObject(obj)) return [];\r\n var keys = [];\r\n for (var key in obj) keys.push(key);\r\n // Ahem, IE < 9.\r\n if (hasEnumBug) collectNonEnumProps(obj, keys);\r\n return keys;\r\n };\r\n\r\n // Retrieve the values of an object's properties.\r\n _.values = function(obj) {\r\n var keys = _.keys(obj);\r\n var length = keys.length;\r\n var values = Array(length);\r\n for (var i = 0; i < length; i++) {\r\n values[i] = obj[keys[i]];\r\n }\r\n return values;\r\n };\r\n\r\n // Returns the results of applying the iteratee to each element of the object\r\n // In contrast to _.map it returns an object\r\n _.mapObject = function(obj, iteratee, context) {\r\n iteratee = cb(iteratee, context);\r\n var keys = _.keys(obj),\r\n length = keys.length,\r\n results = {},\r\n currentKey;\r\n for (var index = 0; index < length; index++) {\r\n currentKey = keys[index];\r\n results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\r\n }\r\n return results;\r\n };\r\n\r\n // Convert an object into a list of `[key, value]` pairs.\r\n _.pairs = function(obj) {\r\n var keys = _.keys(obj);\r\n var length = keys.length;\r\n var pairs = Array(length);\r\n for (var i = 0; i < length; i++) {\r\n pairs[i] = [keys[i], obj[keys[i]]];\r\n }\r\n return pairs;\r\n };\r\n\r\n // Invert the keys and values of an object. The values must be serializable.\r\n _.invert = function(obj) {\r\n var result = {};\r\n var keys = _.keys(obj);\r\n for (var i = 0, length = keys.length; i < length; i++) {\r\n result[obj[keys[i]]] = keys[i];\r\n }\r\n return result;\r\n };\r\n\r\n // Return a sorted list of the function names available on the object.\r\n // Aliased as `methods`\r\n _.functions = _.methods = function(obj) {\r\n var names = [];\r\n for (var key in obj) {\r\n if (_.isFunction(obj[key])) names.push(key);\r\n }\r\n return names.sort();\r\n };\r\n\r\n // Extend a given object with all the properties in passed-in object(s).\r\n _.extend = createAssigner(_.allKeys);\r\n\r\n // Assigns a given object with all the own properties in the passed-in object(s)\r\n // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\r\n _.extendOwn = _.assign = createAssigner(_.keys);\r\n\r\n // Returns the first key on an object that passes a predicate test\r\n _.findKey = function(obj, predicate, context) {\r\n predicate = cb(predicate, context);\r\n var keys = _.keys(obj), key;\r\n for (var i = 0, length = keys.length; i < length; i++) {\r\n key = keys[i];\r\n if (predicate(obj[key], key, obj)) return key;\r\n }\r\n };\r\n\r\n // Return a copy of the object only containing the whitelisted properties.\r\n _.pick = function(object, oiteratee, context) {\r\n var result = {}, obj = object, iteratee, keys;\r\n if (obj == null) return result;\r\n if (_.isFunction(oiteratee)) {\r\n keys = _.allKeys(obj);\r\n iteratee = optimizeCb(oiteratee, context);\r\n } else {\r\n keys = flatten(arguments, false, false, 1);\r\n iteratee = function(value, key, obj) { return key in obj; };\r\n obj = Object(obj);\r\n }\r\n for (var i = 0, length = keys.length; i < length; i++) {\r\n var key = keys[i];\r\n var value = obj[key];\r\n if (iteratee(value, key, obj)) result[key] = value;\r\n }\r\n return result;\r\n };\r\n\r\n // Return a copy of the object without the blacklisted properties.\r\n _.omit = function(obj, iteratee, context) {\r\n if (_.isFunction(iteratee)) {\r\n iteratee = _.negate(iteratee);\r\n } else {\r\n var keys = _.map(flatten(arguments, false, false, 1), String);\r\n iteratee = function(value, key) {\r\n return !_.contains(keys, key);\r\n };\r\n }\r\n return _.pick(obj, iteratee, context);\r\n };\r\n\r\n // Fill in a given object with default properties.\r\n _.defaults = createAssigner(_.allKeys, true);\r\n\r\n // Creates an object that inherits from the given prototype object.\r\n // If additional properties are provided then they will be added to the\r\n // created object.\r\n _.create = function(prototype, props) {\r\n var result = baseCreate(prototype);\r\n if (props) _.extendOwn(result, props);\r\n return result;\r\n };\r\n\r\n // Create a (shallow-cloned) duplicate of an object.\r\n _.clone = function(obj) {\r\n if (!_.isObject(obj)) return obj;\r\n return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\r\n };\r\n\r\n // Invokes interceptor with the obj, and then returns obj.\r\n // The primary purpose of this method is to \"tap into\" a method chain, in\r\n // order to perform operations on intermediate results within the chain.\r\n _.tap = function(obj, interceptor) {\r\n interceptor(obj);\r\n return obj;\r\n };\r\n\r\n // Returns whether an object has a given set of `key:value` pairs.\r\n _.isMatch = function(object, attrs) {\r\n var keys = _.keys(attrs), length = keys.length;\r\n if (object == null) return !length;\r\n var obj = Object(object);\r\n for (var i = 0; i < length; i++) {\r\n var key = keys[i];\r\n if (attrs[key] !== obj[key] || !(key in obj)) return false;\r\n }\r\n return true;\r\n };\r\n\r\n\r\n // Internal recursive comparison function for `isEqual`.\r\n var eq = function(a, b, aStack, bStack) {\r\n // Identical objects are equal. `0 === -0`, but they aren't identical.\r\n // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\r\n if (a === b) return a !== 0 || 1 / a === 1 / b;\r\n // A strict comparison is necessary because `null == undefined`.\r\n if (a == null || b == null) return a === b;\r\n // Unwrap any wrapped objects.\r\n if (a instanceof _) a = a._wrapped;\r\n if (b instanceof _) b = b._wrapped;\r\n // Compare `[[Class]]` names.\r\n var className = toString.call(a);\r\n if (className !== toString.call(b)) return false;\r\n switch (className) {\r\n // Strings, numbers, regular expressions, dates, and booleans are compared by value.\r\n case '[object RegExp]':\r\n // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\r\n case '[object String]':\r\n // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\r\n // equivalent to `new String(\"5\")`.\r\n return '' + a === '' + b;\r\n case '[object Number]':\r\n // `NaN`s are equivalent, but non-reflexive.\r\n // Object(NaN) is equivalent to NaN\r\n if (+a !== +a) return +b !== +b;\r\n // An `egal` comparison is performed for other numeric values.\r\n return +a === 0 ? 1 / +a === 1 / b : +a === +b;\r\n case '[object Date]':\r\n case '[object Boolean]':\r\n // Coerce dates and booleans to numeric primitive values. Dates are compared by their\r\n // millisecond representations. Note that invalid dates with millisecond representations\r\n // of `NaN` are not equivalent.\r\n return +a === +b;\r\n }\r\n\r\n var areArrays = className === '[object Array]';\r\n if (!areArrays) {\r\n if (typeof a != 'object' || typeof b != 'object') return false;\r\n\r\n // Objects with different constructors are not equivalent, but `Object`s or `Array`s\r\n // from different frames are.\r\n var aCtor = a.constructor, bCtor = b.constructor;\r\n if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\r\n _.isFunction(bCtor) && bCtor instanceof bCtor)\r\n && ('constructor' in a && 'constructor' in b)) {\r\n return false;\r\n }\r\n }\r\n // Assume equality for cyclic structures. The algorithm for detecting cyclic\r\n // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\r\n\r\n // Initializing stack of traversed objects.\r\n // It's done here since we only need them for objects and arrays comparison.\r\n aStack = aStack || [];\r\n bStack = bStack || [];\r\n var length = aStack.length;\r\n while (length--) {\r\n // Linear search. Performance is inversely proportional to the number of\r\n // unique nested structures.\r\n if (aStack[length] === a) return bStack[length] === b;\r\n }\r\n\r\n // Add the first object to the stack of traversed objects.\r\n aStack.push(a);\r\n bStack.push(b);\r\n\r\n // Recursively compare objects and arrays.\r\n if (areArrays) {\r\n // Compare array lengths to determine if a deep comparison is necessary.\r\n length = a.length;\r\n if (length !== b.length) return false;\r\n // Deep compare the contents, ignoring non-numeric properties.\r\n while (length--) {\r\n if (!eq(a[length], b[length], aStack, bStack)) return false;\r\n }\r\n } else {\r\n // Deep compare objects.\r\n var keys = _.keys(a), key;\r\n length = keys.length;\r\n // Ensure that both objects contain the same number of properties before comparing deep equality.\r\n if (_.keys(b).length !== length) return false;\r\n while (length--) {\r\n // Deep compare each member\r\n key = keys[length];\r\n if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\r\n }\r\n }\r\n // Remove the first object from the stack of traversed objects.\r\n aStack.pop();\r\n bStack.pop();\r\n return true;\r\n };\r\n\r\n // Perform a deep comparison to check if two objects are equal.\r\n _.isEqual = function(a, b) {\r\n return eq(a, b);\r\n };\r\n\r\n // Is a given array, string, or object empty?\r\n // An \"empty\" object has no enumerable own-properties.\r\n _.isEmpty = function(obj) {\r\n if (obj == null) return true;\r\n if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\r\n return _.keys(obj).length === 0;\r\n };\r\n\r\n // Is a given value a DOM element?\r\n _.isElement = function(obj) {\r\n return !!(obj && obj.nodeType === 1);\r\n };\r\n\r\n // Is a given value an array?\r\n // Delegates to ECMA5's native Array.isArray\r\n _.isArray = nativeIsArray || function(obj) {\r\n return toString.call(obj) === '[object Array]';\r\n };\r\n\r\n // Is a given variable an object?\r\n _.isObject = function(obj) {\r\n var type = typeof obj;\r\n return type === 'function' || type === 'object' && !!obj;\r\n };\r\n\r\n // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\r\n _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {\r\n _['is' + name] = function(obj) {\r\n return toString.call(obj) === '[object ' + name + ']';\r\n };\r\n });\r\n\r\n // Define a fallback version of the method in browsers (ahem, IE < 9), where\r\n // there isn't any inspectable \"Arguments\" type.\r\n if (!_.isArguments(arguments)) {\r\n _.isArguments = function(obj) {\r\n return _.has(obj, 'callee');\r\n };\r\n }\r\n\r\n // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\r\n // IE 11 (#1621), and in Safari 8 (#1929).\r\n if (typeof /./ != 'function' && typeof Int8Array != 'object') {\r\n _.isFunction = function(obj) {\r\n return typeof obj == 'function' || false;\r\n };\r\n }\r\n\r\n // Is a given object a finite number?\r\n _.isFinite = function(obj) {\r\n return isFinite(obj) && !isNaN(parseFloat(obj));\r\n };\r\n\r\n // Is the given value `NaN`? (NaN is the only number which does not equal itself).\r\n _.isNaN = function(obj) {\r\n return _.isNumber(obj) && obj !== +obj;\r\n };\r\n\r\n // Is a given value a boolean?\r\n _.isBoolean = function(obj) {\r\n return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\r\n };\r\n\r\n // Is a given value equal to null?\r\n _.isNull = function(obj) {\r\n return obj === null;\r\n };\r\n\r\n // Is a given variable undefined?\r\n _.isUndefined = function(obj) {\r\n return obj === void 0;\r\n };\r\n\r\n // Shortcut function for checking if an object has a given property directly\r\n // on itself (in other words, not on a prototype).\r\n _.has = function(obj, key) {\r\n return obj != null && hasOwnProperty.call(obj, key);\r\n };\r\n\r\n // Utility Functions\r\n // -----------------\r\n\r\n // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\r\n // previous owner. Returns a reference to the Underscore object.\r\n _.noConflict = function() {\r\n root._ = previousUnderscore;\r\n return this;\r\n };\r\n\r\n // Keep the identity function around for default iteratees.\r\n _.identity = function(value) {\r\n return value;\r\n };\r\n\r\n // Predicate-generating functions. Often useful outside of Underscore.\r\n _.constant = function(value) {\r\n return function() {\r\n return value;\r\n };\r\n };\r\n\r\n _.noop = function(){};\r\n\r\n _.property = property;\r\n\r\n // Generates a function for a given object that returns a given property.\r\n _.propertyOf = function(obj) {\r\n return obj == null ? function(){} : function(key) {\r\n return obj[key];\r\n };\r\n };\r\n\r\n // Returns a predicate for checking whether an object has a given set of\r\n // `key:value` pairs.\r\n _.matcher = _.matches = function(attrs) {\r\n attrs = _.extendOwn({}, attrs);\r\n return function(obj) {\r\n return _.isMatch(obj, attrs);\r\n };\r\n };\r\n\r\n // Run a function **n** times.\r\n _.times = function(n, iteratee, context) {\r\n var accum = Array(Math.max(0, n));\r\n iteratee = optimizeCb(iteratee, context, 1);\r\n for (var i = 0; i < n; i++) accum[i] = iteratee(i);\r\n return accum;\r\n };\r\n\r\n // Return a random integer between min and max (inclusive).\r\n _.random = function(min, max) {\r\n if (max == null) {\r\n max = min;\r\n min = 0;\r\n }\r\n return min + Math.floor(Math.random() * (max - min + 1));\r\n };\r\n\r\n // A (possibly faster) way to get the current timestamp as an integer.\r\n _.now = Date.now || function() {\r\n return new Date().getTime();\r\n };\r\n\r\n // List of HTML entities for escaping.\r\n var escapeMap = {\r\n '&': '&',\r\n '<': '<',\r\n '>': '>',\r\n '\"': '"',\r\n \"'\": ''',\r\n '`': '`'\r\n };\r\n var unescapeMap = _.invert(escapeMap);\r\n\r\n // Functions for escaping and unescaping strings to/from HTML interpolation.\r\n var createEscaper = function(map) {\r\n var escaper = function(match) {\r\n return map[match];\r\n };\r\n // Regexes for identifying a key that needs to be escaped\r\n var source = '(?:' + _.keys(map).join('|') + ')';\r\n var testRegexp = RegExp(source);\r\n var replaceRegexp = RegExp(source, 'g');\r\n return function(string) {\r\n string = string == null ? '' : '' + string;\r\n return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\r\n };\r\n };\r\n _.escape = createEscaper(escapeMap);\r\n _.unescape = createEscaper(unescapeMap);\r\n\r\n // If the value of the named `property` is a function then invoke it with the\r\n // `object` as context; otherwise, return it.\r\n _.result = function(object, property, fallback) {\r\n var value = object == null ? void 0 : object[property];\r\n if (value === void 0) {\r\n value = fallback;\r\n }\r\n return _.isFunction(value) ? value.call(object) : value;\r\n };\r\n\r\n // Generate a unique integer id (unique within the entire client session).\r\n // Useful for temporary DOM ids.\r\n var idCounter = 0;\r\n _.uniqueId = function(prefix) {\r\n var id = ++idCounter + '';\r\n return prefix ? prefix + id : id;\r\n };\r\n\r\n // By default, Underscore uses ERB-style template delimiters, change the\r\n // following template settings to use alternative delimiters.\r\n _.templateSettings = {\r\n evaluate : /<%([\\s\\S]+?)%>/g,\r\n interpolate : /<%=([\\s\\S]+?)%>/g,\r\n escape : /<%-([\\s\\S]+?)%>/g\r\n };\r\n\r\n // When customizing `templateSettings`, if you don't want to define an\r\n // interpolation, evaluation or escaping regex, we need one that is\r\n // guaranteed not to match.\r\n var noMatch = /(.)^/;\r\n\r\n // Certain characters need to be escaped so that they can be put into a\r\n // string literal.\r\n var escapes = {\r\n \"'\": \"'\",\r\n '\\\\': '\\\\',\r\n '\\r': 'r',\r\n '\\n': 'n',\r\n '\\u2028': 'u2028',\r\n '\\u2029': 'u2029'\r\n };\r\n\r\n var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\r\n\r\n var escapeChar = function(match) {\r\n return '\\\\' + escapes[match];\r\n };\r\n\r\n // JavaScript micro-templating, similar to John Resig's implementation.\r\n // Underscore templating handles arbitrary delimiters, preserves whitespace,\r\n // and correctly escapes quotes within interpolated code.\r\n // NB: `oldSettings` only exists for backwards compatibility.\r\n _.template = function(text, settings, oldSettings) {\r\n if (!settings && oldSettings) settings = oldSettings;\r\n settings = _.defaults({}, settings, _.templateSettings);\r\n\r\n // Combine delimiters into one regular expression via alternation.\r\n var matcher = RegExp([\r\n (settings.escape || noMatch).source,\r\n (settings.interpolate || noMatch).source,\r\n (settings.evaluate || noMatch).source\r\n ].join('|') + '|$', 'g');\r\n\r\n // Compile the template source, escaping string literals appropriately.\r\n var index = 0;\r\n var source = \"__p+='\";\r\n text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\r\n source += text.slice(index, offset).replace(escaper, escapeChar);\r\n index = offset + match.length;\r\n\r\n if (escape) {\r\n source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\r\n } else if (interpolate) {\r\n source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\r\n } else if (evaluate) {\r\n source += \"';\\n\" + evaluate + \"\\n__p+='\";\r\n }\r\n\r\n // Adobe VMs need the match returned to produce the correct offest.\r\n return match;\r\n });\r\n source += \"';\\n\";\r\n\r\n // If a variable is not specified, place data values in local scope.\r\n if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\r\n\r\n source = \"var __t,__p='',__j=Array.prototype.join,\" +\r\n \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\r\n source + 'return __p;\\n';\r\n\r\n try {\r\n var render = new Function(settings.variable || 'obj', '_', source);\r\n } catch (e) {\r\n e.source = source;\r\n throw e;\r\n }\r\n\r\n var template = function(data) {\r\n return render.call(this, data, _);\r\n };\r\n\r\n // Provide the compiled source as a convenience for precompilation.\r\n var argument = settings.variable || 'obj';\r\n template.source = 'function(' + argument + '){\\n' + source + '}';\r\n\r\n return template;\r\n };\r\n\r\n // Add a \"chain\" function. Start chaining a wrapped Underscore object.\r\n _.chain = function(obj) {\r\n var instance = _(obj);\r\n instance._chain = true;\r\n return instance;\r\n };\r\n\r\n // OOP\r\n // ---------------\r\n // If Underscore is called as a function, it returns a wrapped object that\r\n // can be used OO-style. This wrapper holds altered versions of all the\r\n // underscore functions. Wrapped objects may be chained.\r\n\r\n // Helper function to continue chaining intermediate results.\r\n var result = function(instance, obj) {\r\n return instance._chain ? _(obj).chain() : obj;\r\n };\r\n\r\n // Add your own custom functions to the Underscore object.\r\n _.mixin = function(obj) {\r\n _.each(_.functions(obj), function(name) {\r\n var func = _[name] = obj[name];\r\n _.prototype[name] = function() {\r\n var args = [this._wrapped];\r\n push.apply(args, arguments);\r\n return result(this, func.apply(_, args));\r\n };\r\n });\r\n };\r\n\r\n // Add all of the Underscore functions to the wrapper object.\r\n _.mixin(_);\r\n\r\n // Add all mutator Array functions to the wrapper.\r\n _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\r\n var method = ArrayProto[name];\r\n _.prototype[name] = function() {\r\n var obj = this._wrapped;\r\n method.apply(obj, arguments);\r\n if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\r\n return result(this, obj);\r\n };\r\n });\r\n\r\n // Add all accessor Array functions to the wrapper.\r\n _.each(['concat', 'join', 'slice'], function(name) {\r\n var method = ArrayProto[name];\r\n _.prototype[name] = function() {\r\n return result(this, method.apply(this._wrapped, arguments));\r\n };\r\n });\r\n\r\n // Extracts the result from a wrapped and chained object.\r\n _.prototype.value = function() {\r\n return this._wrapped;\r\n };\r\n\r\n // Provide unwrapping proxy for some methods used in engine operations\r\n // such as arithmetic and JSON stringification.\r\n _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\r\n\r\n _.prototype.toString = function() {\r\n return '' + this._wrapped;\r\n };\r\n\r\n // AMD registration happens at the end for compatibility with AMD loaders\r\n // that may not enforce next-turn semantics on modules. Even though general\r\n // practice for AMD registration is to be anonymous, underscore registers\r\n // as a named module because, like jQuery, it is a base library that is\r\n // popular enough to be bundled in a third party lib, but not be part of\r\n // an AMD load request. Those cases could generate an error when an\r\n // anonymous define() is called outside of a loader request.\r\n if (typeof define === 'function' && define.amd) {\r\n define('underscore', [], function() {\r\n return _;\r\n });\r\n }\r\n}.call(this));\r\n","// Backbone.js 1.1.2\r\n\r\n// (c) 2010-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\r\n// Backbone may be freely distributed under the MIT license.\r\n// For all details and documentation:\r\n// http://backbonejs.org\r\n\r\n(function(root, factory) {\r\n\r\n // Set up Backbone appropriately for the environment. Start with AMD.\r\n if (typeof define === 'function' && define.amd) {\r\n define(['underscore', 'jquery', 'exports'], function(_, $, exports) {\r\n // Export global even in AMD case in case this script is loaded with\r\n // others that may still expect a global Backbone.\r\n root.Backbone = factory(root, exports, _, $);\r\n });\r\n\r\n // Next for Node.js or CommonJS. jQuery may not be needed as a module.\r\n } else if (typeof exports !== 'undefined') {\r\n var _ = require('underscore');\r\n factory(root, exports, _);\r\n\r\n // Finally, as a browser global.\r\n } else {\r\n root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));\r\n }\r\n\r\n}(this, function(root, Backbone, _, $) {\r\n\r\n // Initial Setup\r\n // -------------\r\n\r\n // Save the previous value of the `Backbone` variable, so that it can be\r\n // restored later on, if `noConflict` is used.\r\n var previousBackbone = root.Backbone;\r\n\r\n // Create local references to array methods we'll want to use later.\r\n var array = [];\r\n var push = array.push;\r\n var slice = array.slice;\r\n var splice = array.splice;\r\n\r\n // Current version of the library. Keep in sync with `package.json`.\r\n Backbone.VERSION = '1.1.2';\r\n\r\n // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns\r\n // the `$` variable.\r\n Backbone.$ = $;\r\n\r\n // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable\r\n // to its previous owner. Returns a reference to this Backbone object.\r\n Backbone.noConflict = function() {\r\n root.Backbone = previousBackbone;\r\n return this;\r\n };\r\n\r\n // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option\r\n // will fake `\"PATCH\"`, `\"PUT\"` and `\"DELETE\"` requests via the `_method` parameter and\r\n // set a `X-Http-Method-Override` header.\r\n Backbone.emulateHTTP = false;\r\n\r\n // Turn on `emulateJSON` to support legacy servers that can't deal with direct\r\n // `application/json` requests ... will encode the body as\r\n // `application/x-www-form-urlencoded` instead and will send the model in a\r\n // form param named `model`.\r\n Backbone.emulateJSON = false;\r\n\r\n // Backbone.Events\r\n // ---------------\r\n\r\n // A module that can be mixed in to *any object* in order to provide it with\r\n // custom events. You may bind with `on` or remove with `off` callback\r\n // functions to an event; `trigger`-ing an event fires all callbacks in\r\n // succession.\r\n //\r\n // var object = {};\r\n // _.extend(object, Backbone.Events);\r\n // object.on('expand', function(){ alert('expanded'); });\r\n // object.trigger('expand');\r\n //\r\n var Events = Backbone.Events = {\r\n\r\n // Bind an event to a `callback` function. Passing `\"all\"` will bind\r\n // the callback to all events fired.\r\n on: function(name, callback, context) {\r\n if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;\r\n this._events || (this._events = {});\r\n var events = this._events[name] || (this._events[name] = []);\r\n events.push({callback: callback, context: context, ctx: context || this});\r\n return this;\r\n },\r\n\r\n // Bind an event to only be triggered a single time. After the first time\r\n // the callback is invoked, it will be removed.\r\n once: function(name, callback, context) {\r\n if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;\r\n var self = this;\r\n var once = _.once(function() {\r\n self.off(name, once);\r\n callback.apply(this, arguments);\r\n });\r\n once._callback = callback;\r\n return this.on(name, once, context);\r\n },\r\n\r\n // Remove one or many callbacks. If `context` is null, removes all\r\n // callbacks with that function. If `callback` is null, removes all\r\n // callbacks for the event. If `name` is null, removes all bound\r\n // callbacks for all events.\r\n off: function(name, callback, context) {\r\n var retain, ev, events, names, i, l, j, k;\r\n if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;\r\n if (!name && !callback && !context) {\r\n this._events = void 0;\r\n return this;\r\n }\r\n names = name ? [name] : _.keys(this._events);\r\n for (i = 0, l = names.length; i < l; i++) {\r\n name = names[i];\r\n if (events = this._events[name]) {\r\n this._events[name] = retain = [];\r\n if (callback || context) {\r\n for (j = 0, k = events.length; j < k; j++) {\r\n ev = events[j];\r\n if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||\r\n (context && context !== ev.context)) {\r\n retain.push(ev);\r\n }\r\n }\r\n }\r\n if (!retain.length) delete this._events[name];\r\n }\r\n }\r\n\r\n return this;\r\n },\r\n\r\n // Trigger one or many events, firing all bound callbacks. Callbacks are\r\n // passed the same arguments as `trigger` is, apart from the event name\r\n // (unless you're listening on `\"all\"`, which will cause your callback to\r\n // receive the true name of the event as the first argument).\r\n trigger: function(name) {\r\n if (!this._events) return this;\r\n var args = slice.call(arguments, 1);\r\n if (!eventsApi(this, 'trigger', name, args)) return this;\r\n var events = this._events[name];\r\n var allEvents = this._events.all;\r\n if (events) triggerEvents(events, args);\r\n if (allEvents) triggerEvents(allEvents, arguments);\r\n return this;\r\n },\r\n\r\n // Tell this object to stop listening to either specific events ... or\r\n // to every object it's currently listening to.\r\n stopListening: function(obj, name, callback) {\r\n var listeningTo = this._listeningTo;\r\n if (!listeningTo) return this;\r\n var remove = !name && !callback;\r\n if (!callback && typeof name === 'object') callback = this;\r\n if (obj) (listeningTo = {})[obj._listenId] = obj;\r\n for (var id in listeningTo) {\r\n obj = listeningTo[id];\r\n obj.off(name, callback, this);\r\n if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];\r\n }\r\n return this;\r\n }\r\n\r\n };\r\n\r\n // Regular expression used to split event strings.\r\n var eventSplitter = /\\s+/;\r\n\r\n // Implement fancy features of the Events API such as multiple event\r\n // names `\"change blur\"` and jQuery-style event maps `{change: action}`\r\n // in terms of the existing API.\r\n var eventsApi = function(obj, action, name, rest) {\r\n if (!name) return true;\r\n\r\n // Handle event maps.\r\n if (typeof name === 'object') {\r\n for (var key in name) {\r\n obj[action].apply(obj, [key, name[key]].concat(rest));\r\n }\r\n return false;\r\n }\r\n\r\n // Handle space separated event names.\r\n if (eventSplitter.test(name)) {\r\n var names = name.split(eventSplitter);\r\n for (var i = 0, l = names.length; i < l; i++) {\r\n obj[action].apply(obj, [names[i]].concat(rest));\r\n }\r\n return false;\r\n }\r\n\r\n return true;\r\n };\r\n\r\n // A difficult-to-believe, but optimized internal dispatch function for\r\n // triggering events. Tries to keep the usual cases speedy (most internal\r\n // Backbone events have 3 arguments).\r\n var triggerEvents = function(events, args) {\r\n var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\r\n switch (args.length) {\r\n case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\r\n case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\r\n case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\r\n case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\r\n default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;\r\n }\r\n };\r\n\r\n var listenMethods = {listenTo: 'on', listenToOnce: 'once'};\r\n\r\n // Inversion-of-control versions of `on` and `once`. Tell *this* object to\r\n // listen to an event in another object ... keeping track of what it's\r\n // listening to.\r\n _.each(listenMethods, function(implementation, method) {\r\n Events[method] = function(obj, name, callback) {\r\n var listeningTo = this._listeningTo || (this._listeningTo = {});\r\n var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\r\n listeningTo[id] = obj;\r\n if (!callback && typeof name === 'object') callback = this;\r\n obj[implementation](name, callback, this);\r\n return this;\r\n };\r\n });\r\n\r\n // Aliases for backwards compatibility.\r\n Events.bind = Events.on;\r\n Events.unbind = Events.off;\r\n\r\n // Allow the `Backbone` object to serve as a global event bus, for folks who\r\n // want global \"pubsub\" in a convenient place.\r\n _.extend(Backbone, Events);\r\n\r\n // Backbone.Model\r\n // --------------\r\n\r\n // Backbone **Models** are the basic data object in the framework --\r\n // frequently representing a row in a table in a database on your server.\r\n // A discrete chunk of data and a bunch of useful, related methods for\r\n // performing computations and transformations on that data.\r\n\r\n // Create a new model with the specified attributes. A client id (`cid`)\r\n // is automatically generated and assigned for you.\r\n var Model = Backbone.Model = function(attributes, options) {\r\n var attrs = attributes || {};\r\n options || (options = {});\r\n this.cid = _.uniqueId('c');\r\n this.attributes = {};\r\n if (options.collection) this.collection = options.collection;\r\n if (options.parse) attrs = this.parse(attrs, options) || {};\r\n attrs = _.defaults({}, attrs, _.result(this, 'defaults'));\r\n this.set(attrs, options);\r\n this.changed = {};\r\n this.initialize.apply(this, arguments);\r\n };\r\n\r\n // Attach all inheritable methods to the Model prototype.\r\n _.extend(Model.prototype, Events, {\r\n\r\n // A hash of attributes whose current and previous value differ.\r\n changed: null,\r\n\r\n // The value returned during the last failed validation.\r\n validationError: null,\r\n\r\n // The default name for the JSON `id` attribute is `\"id\"`. MongoDB and\r\n // CouchDB users may want to set this to `\"_id\"`.\r\n idAttribute: 'id',\r\n\r\n // Initialize is an empty function by default. Override it with your own\r\n // initialization logic.\r\n initialize: function(){},\r\n\r\n // Return a copy of the model's `attributes` object.\r\n toJSON: function(options) {\r\n return _.clone(this.attributes);\r\n },\r\n\r\n // Proxy `Backbone.sync` by default -- but override this if you need\r\n // custom syncing semantics for *this* particular model.\r\n sync: function() {\r\n return Backbone.sync.apply(this, arguments);\r\n },\r\n\r\n // Get the value of an attribute.\r\n get: function(attr) {\r\n return this.attributes[attr];\r\n },\r\n\r\n // Get the HTML-escaped value of an attribute.\r\n escape: function(attr) {\r\n return _.escape(this.get(attr));\r\n },\r\n\r\n // Returns `true` if the attribute contains a value that is not null\r\n // or undefined.\r\n has: function(attr) {\r\n return this.get(attr) != null;\r\n },\r\n\r\n // Set a hash of model attributes on the object, firing `\"change\"`. This is\r\n // the core primitive operation of a model, updating the data and notifying\r\n // anyone who needs to know about the change in state. The heart of the beast.\r\n set: function(key, val, options) {\r\n var attr, attrs, unset, changes, silent, changing, prev, current;\r\n if (key == null) return this;\r\n\r\n // Handle both `\"key\", value` and `{key: value}` -style arguments.\r\n if (typeof key === 'object') {\r\n attrs = key;\r\n options = val;\r\n } else {\r\n (attrs = {})[key] = val;\r\n }\r\n\r\n options || (options = {});\r\n\r\n // Run validation.\r\n if (!this._validate(attrs, options)) return false;\r\n\r\n // Extract attributes and options.\r\n unset = options.unset;\r\n silent = options.silent;\r\n changes = [];\r\n changing = this._changing;\r\n this._changing = true;\r\n\r\n if (!changing) {\r\n this._previousAttributes = _.clone(this.attributes);\r\n this.changed = {};\r\n }\r\n current = this.attributes, prev = this._previousAttributes;\r\n\r\n // Check for changes of `id`.\r\n if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];\r\n\r\n // For each `set` attribute, update or delete the current value.\r\n for (attr in attrs) {\r\n val = attrs[attr];\r\n if (!_.isEqual(current[attr], val)) changes.push(attr);\r\n if (!_.isEqual(prev[attr], val)) {\r\n this.changed[attr] = val;\r\n } else {\r\n delete this.changed[attr];\r\n }\r\n unset ? delete current[attr] : current[attr] = val;\r\n }\r\n\r\n // Trigger all relevant attribute changes.\r\n if (!silent) {\r\n if (changes.length) this._pending = options;\r\n for (var i = 0, l = changes.length; i < l; i++) {\r\n this.trigger('change:' + changes[i], this, current[changes[i]], options);\r\n }\r\n }\r\n\r\n // You might be wondering why there's a `while` loop here. Changes can\r\n // be recursively nested within `\"change\"` events.\r\n if (changing) return this;\r\n if (!silent) {\r\n while (this._pending) {\r\n options = this._pending;\r\n this._pending = false;\r\n this.trigger('change', this, options);\r\n }\r\n }\r\n this._pending = false;\r\n this._changing = false;\r\n return this;\r\n },\r\n\r\n // Remove an attribute from the model, firing `\"change\"`. `unset` is a noop\r\n // if the attribute doesn't exist.\r\n unset: function(attr, options) {\r\n return this.set(attr, void 0, _.extend({}, options, {unset: true}));\r\n },\r\n\r\n // Clear all attributes on the model, firing `\"change\"`.\r\n clear: function(options) {\r\n var attrs = {};\r\n for (var key in this.attributes) attrs[key] = void 0;\r\n return this.set(attrs, _.extend({}, options, {unset: true}));\r\n },\r\n\r\n // Determine if the model has changed since the last `\"change\"` event.\r\n // If you specify an attribute name, determine if that attribute has changed.\r\n hasChanged: function(attr) {\r\n if (attr == null) return !_.isEmpty(this.changed);\r\n return _.has(this.changed, attr);\r\n },\r\n\r\n // Return an object containing all the attributes that have changed, or\r\n // false if there are no changed attributes. Useful for determining what\r\n // parts of a view need to be updated and/or what attributes need to be\r\n // persisted to the server. Unset attributes will be set to undefined.\r\n // You can also pass an attributes object to diff against the model,\r\n // determining if there *would be* a change.\r\n changedAttributes: function(diff) {\r\n if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;\r\n var val, changed = false;\r\n var old = this._changing ? this._previousAttributes : this.attributes;\r\n for (var attr in diff) {\r\n if (_.isEqual(old[attr], (val = diff[attr]))) continue;\r\n (changed || (changed = {}))[attr] = val;\r\n }\r\n return changed;\r\n },\r\n\r\n // Get the previous value of an attribute, recorded at the time the last\r\n // `\"change\"` event was fired.\r\n previous: function(attr) {\r\n if (attr == null || !this._previousAttributes) return null;\r\n return this._previousAttributes[attr];\r\n },\r\n\r\n // Get all of the attributes of the model at the time of the previous\r\n // `\"change\"` event.\r\n previousAttributes: function() {\r\n return _.clone(this._previousAttributes);\r\n },\r\n\r\n // Fetch the model from the server. If the server's representation of the\r\n // model differs from its current attributes, they will be overridden,\r\n // triggering a `\"change\"` event.\r\n fetch: function(options) {\r\n options = options ? _.clone(options) : {};\r\n if (options.parse === void 0) options.parse = true;\r\n var model = this;\r\n var success = options.success;\r\n options.success = function(resp) {\r\n if (!model.set(model.parse(resp, options), options)) return false;\r\n if (success) success(model, resp, options);\r\n model.trigger('sync', model, resp, options);\r\n };\r\n wrapError(this, options);\r\n return this.sync('read', this, options);\r\n },\r\n\r\n // Set a hash of model attributes, and sync the model to the server.\r\n // If the server returns an attributes hash that differs, the model's\r\n // state will be `set` again.\r\n save: function(key, val, options) {\r\n var attrs, method, xhr, attributes = this.attributes;\r\n\r\n // Handle both `\"key\", value` and `{key: value}` -style arguments.\r\n if (key == null || typeof key === 'object') {\r\n attrs = key;\r\n options = val;\r\n } else {\r\n (attrs = {})[key] = val;\r\n }\r\n\r\n options = _.extend({validate: true}, options);\r\n\r\n // If we're not waiting and attributes exist, save acts as\r\n // `set(attr).save(null, opts)` with validation. Otherwise, check if\r\n // the model will be valid when the attributes, if any, are set.\r\n if (attrs && !options.wait) {\r\n if (!this.set(attrs, options)) return false;\r\n } else {\r\n if (!this._validate(attrs, options)) return false;\r\n }\r\n\r\n // Set temporary attributes if `{wait: true}`.\r\n if (attrs && options.wait) {\r\n this.attributes = _.extend({}, attributes, attrs);\r\n }\r\n\r\n // After a successful server-side save, the client is (optionally)\r\n // updated with the server-side state.\r\n if (options.parse === void 0) options.parse = true;\r\n var model = this;\r\n var success = options.success;\r\n options.success = function(resp) {\r\n // Ensure attributes are restored during synchronous saves.\r\n model.attributes = attributes;\r\n var serverAttrs = model.parse(resp, options);\r\n if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);\r\n if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {\r\n return false;\r\n }\r\n if (success) success(model, resp, options);\r\n model.trigger('sync', model, resp, options);\r\n };\r\n wrapError(this, options);\r\n\r\n method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');\r\n if (method === 'patch') options.attrs = attrs;\r\n xhr = this.sync(method, this, options);\r\n\r\n // Restore attributes.\r\n if (attrs && options.wait) this.attributes = attributes;\r\n\r\n return xhr;\r\n },\r\n\r\n // Destroy this model on the server if it was already persisted.\r\n // Optimistically removes the model from its collection, if it has one.\r\n // If `wait: true` is passed, waits for the server to respond before removal.\r\n destroy: function(options) {\r\n options = options ? _.clone(options) : {};\r\n var model = this;\r\n var success = options.success;\r\n\r\n var destroy = function() {\r\n model.trigger('destroy', model, model.collection, options);\r\n };\r\n\r\n options.success = function(resp) {\r\n if (options.wait || model.isNew()) destroy();\r\n if (success) success(model, resp, options);\r\n if (!model.isNew()) model.trigger('sync', model, resp, options);\r\n };\r\n\r\n if (this.isNew()) {\r\n options.success();\r\n return false;\r\n }\r\n wrapError(this, options);\r\n\r\n var xhr = this.sync('delete', this, options);\r\n if (!options.wait) destroy();\r\n return xhr;\r\n },\r\n\r\n // Default URL for the model's representation on the server -- if you're\r\n // using Backbone's restful methods, override this to change the endpoint\r\n // that will be called.\r\n url: function() {\r\n var base =\r\n _.result(this, 'urlRoot') ||\r\n _.result(this.collection, 'url') ||\r\n urlError();\r\n if (this.isNew()) return base;\r\n return base.replace(/([^\\/])$/, '$1/') + encodeURIComponent(this.id);\r\n },\r\n\r\n // **parse** converts a response into the hash of attributes to be `set` on\r\n // the model. The default implementation is just to pass the response along.\r\n parse: function(resp, options) {\r\n return resp;\r\n },\r\n\r\n // Create a new model with identical attributes to this one.\r\n clone: function() {\r\n return new this.constructor(this.attributes);\r\n },\r\n\r\n // A model is new if it has never been saved to the server, and lacks an id.\r\n isNew: function() {\r\n return !this.has(this.idAttribute);\r\n },\r\n\r\n // Check if the model is currently in a valid state.\r\n isValid: function(options) {\r\n return this._validate({}, _.extend(options || {}, { validate: true }));\r\n },\r\n\r\n // Run validation against the next complete set of model attributes,\r\n // returning `true` if all is well. Otherwise, fire an `\"invalid\"` event.\r\n _validate: function(attrs, options) {\r\n if (!options.validate || !this.validate) return true;\r\n attrs = _.extend({}, this.attributes, attrs);\r\n var error = this.validationError = this.validate(attrs, options) || null;\r\n if (!error) return true;\r\n this.trigger('invalid', this, error, _.extend(options, {validationError: error}));\r\n return false;\r\n }\r\n\r\n });\r\n\r\n // Underscore methods that we want to implement on the Model.\r\n var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];\r\n\r\n // Mix in each Underscore method as a proxy to `Model#attributes`.\r\n _.each(modelMethods, function(method) {\r\n Model.prototype[method] = function() {\r\n var args = slice.call(arguments);\r\n args.unshift(this.attributes);\r\n return _[method].apply(_, args);\r\n };\r\n });\r\n\r\n // Backbone.Collection\r\n // -------------------\r\n\r\n // If models tend to represent a single row of data, a Backbone Collection is\r\n // more analagous to a table full of data ... or a small slice or page of that\r\n // table, or a collection of rows that belong together for a particular reason\r\n // -- all of the messages in this particular folder, all of the documents\r\n // belonging to this particular author, and so on. Collections maintain\r\n // indexes of their models, both in order, and for lookup by `id`.\r\n\r\n // Create a new **Collection**, perhaps to contain a specific type of `model`.\r\n // If a `comparator` is specified, the Collection will maintain\r\n // its models in sort order, as they're added and removed.\r\n var Collection = Backbone.Collection = function(models, options) {\r\n options || (options = {});\r\n if (options.model) this.model = options.model;\r\n if (options.comparator !== void 0) this.comparator = options.comparator;\r\n this._reset();\r\n this.initialize.apply(this, arguments);\r\n if (models) this.reset(models, _.extend({silent: true}, options));\r\n };\r\n\r\n // Default options for `Collection#set`.\r\n var setOptions = {add: true, remove: true, merge: true};\r\n var addOptions = {add: true, remove: false};\r\n\r\n // Define the Collection's inheritable methods.\r\n _.extend(Collection.prototype, Events, {\r\n\r\n // The default model for a collection is just a **Backbone.Model**.\r\n // This should be overridden in most cases.\r\n model: Model,\r\n\r\n // Initialize is an empty function by default. Override it with your own\r\n // initialization logic.\r\n initialize: function(){},\r\n\r\n // The JSON representation of a Collection is an array of the\r\n // models' attributes.\r\n toJSON: function(options) {\r\n return this.map(function(model){ return model.toJSON(options); });\r\n },\r\n\r\n // Proxy `Backbone.sync` by default.\r\n sync: function() {\r\n return Backbone.sync.apply(this, arguments);\r\n },\r\n\r\n // Add a model, or list of models to the set.\r\n add: function(models, options) {\r\n return this.set(models, _.extend({merge: false}, options, addOptions));\r\n },\r\n\r\n // Remove a model, or a list of models from the set.\r\n remove: function(models, options) {\r\n var singular = !_.isArray(models);\r\n models = singular ? [models] : _.clone(models);\r\n options || (options = {});\r\n var i, l, index, model;\r\n for (i = 0, l = models.length; i < l; i++) {\r\n model = models[i] = this.get(models[i]);\r\n if (!model) continue;\r\n delete this._byId[model.id];\r\n delete this._byId[model.cid];\r\n index = this.indexOf(model);\r\n this.models.splice(index, 1);\r\n this.length--;\r\n if (!options.silent) {\r\n options.index = index;\r\n model.trigger('remove', model, this, options);\r\n }\r\n this._removeReference(model, options);\r\n }\r\n return singular ? models[0] : models;\r\n },\r\n\r\n // Update a collection by `set`-ing a new list of models, adding new ones,\r\n // removing models that are no longer present, and merging models that\r\n // already exist in the collection, as necessary. Similar to **Model#set**,\r\n // the core operation for updating the data contained by the collection.\r\n set: function(models, options) {\r\n options = _.defaults({}, options, setOptions);\r\n if (options.parse) models = this.parse(models, options);\r\n var singular = !_.isArray(models);\r\n models = singular ? (models ? [models] : []) : _.clone(models);\r\n var i, l, id, model, attrs, existing, sort;\r\n var at = options.at;\r\n var targetModel = this.model;\r\n var sortable = this.comparator && (at == null) && options.sort !== false;\r\n var sortAttr = _.isString(this.comparator) ? this.comparator : null;\r\n var toAdd = [], toRemove = [], modelMap = {};\r\n var add = options.add, merge = options.merge, remove = options.remove;\r\n var order = !sortable && add && remove ? [] : false;\r\n\r\n // Turn bare objects into model references, and prevent invalid models\r\n // from being added.\r\n for (i = 0, l = models.length; i < l; i++) {\r\n attrs = models[i] || {};\r\n if (attrs instanceof Model) {\r\n id = model = attrs;\r\n } else {\r\n id = attrs[targetModel.prototype.idAttribute || 'id'];\r\n }\r\n\r\n // If a duplicate is found, prevent it from being added and\r\n // optionally merge it into the existing model.\r\n if (existing = this.get(id)) {\r\n if (remove) modelMap[existing.cid] = true;\r\n if (merge) {\r\n attrs = attrs === model ? model.attributes : attrs;\r\n if (options.parse) attrs = existing.parse(attrs, options);\r\n existing.set(attrs, options);\r\n if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;\r\n }\r\n models[i] = existing;\r\n\r\n // If this is a new, valid model, push it to the `toAdd` list.\r\n } else if (add) {\r\n model = models[i] = this._prepareModel(attrs, options);\r\n if (!model) continue;\r\n toAdd.push(model);\r\n this._addReference(model, options);\r\n }\r\n\r\n // Do not add multiple models with the same `id`.\r\n model = existing || model;\r\n if (order && (model.isNew() || !modelMap[model.id])) order.push(model);\r\n modelMap[model.id] = true;\r\n }\r\n\r\n // Remove nonexistent models if appropriate.\r\n if (remove) {\r\n for (i = 0, l = this.length; i < l; ++i) {\r\n if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);\r\n }\r\n if (toRemove.length) this.remove(toRemove, options);\r\n }\r\n\r\n // See if sorting is needed, update `length` and splice in new models.\r\n if (toAdd.length || (order && order.length)) {\r\n if (sortable) sort = true;\r\n this.length += toAdd.length;\r\n if (at != null) {\r\n for (i = 0, l = toAdd.length; i < l; i++) {\r\n this.models.splice(at + i, 0, toAdd[i]);\r\n }\r\n } else {\r\n if (order) this.models.length = 0;\r\n var orderedModels = order || toAdd;\r\n for (i = 0, l = orderedModels.length; i < l; i++) {\r\n this.models.push(orderedModels[i]);\r\n }\r\n }\r\n }\r\n\r\n // Silently sort the collection if appropriate.\r\n if (sort) this.sort({silent: true});\r\n\r\n // Unless silenced, it's time to fire all appropriate add/sort events.\r\n if (!options.silent) {\r\n for (i = 0, l = toAdd.length; i < l; i++) {\r\n (model = toAdd[i]).trigger('add', model, this, options);\r\n }\r\n if (sort || (order && order.length)) this.trigger('sort', this, options);\r\n }\r\n\r\n // Return the added (or merged) model (or models).\r\n return singular ? models[0] : models;\r\n },\r\n\r\n // When you have more items than you want to add or remove individually,\r\n // you can reset the entire set with a new list of models, without firing\r\n // any granular `add` or `remove` events. Fires `reset` when finished.\r\n // Useful for bulk operations and optimizations.\r\n reset: function(models, options) {\r\n options || (options = {});\r\n for (var i = 0, l = this.models.length; i < l; i++) {\r\n this._removeReference(this.models[i], options);\r\n }\r\n options.previousModels = this.models;\r\n this._reset();\r\n models = this.add(models, _.extend({silent: true}, options));\r\n if (!options.silent) this.trigger('reset', this, options);\r\n return models;\r\n },\r\n\r\n // Add a model to the end of the collection.\r\n push: function(model, options) {\r\n return this.add(model, _.extend({at: this.length}, options));\r\n },\r\n\r\n // Remove a model from the end of the collection.\r\n pop: function(options) {\r\n var model = this.at(this.length - 1);\r\n this.remove(model, options);\r\n return model;\r\n },\r\n\r\n // Add a model to the beginning of the collection.\r\n unshift: function(model, options) {\r\n return this.add(model, _.extend({at: 0}, options));\r\n },\r\n\r\n // Remove a model from the beginning of the collection.\r\n shift: function(options) {\r\n var model = this.at(0);\r\n this.remove(model, options);\r\n return model;\r\n },\r\n\r\n // Slice out a sub-array of models from the collection.\r\n slice: function() {\r\n return slice.apply(this.models, arguments);\r\n },\r\n\r\n // Get a model from the set by id.\r\n get: function(obj) {\r\n if (obj == null) return void 0;\r\n return this._byId[obj] || this._byId[obj.id] || this._byId[obj.cid];\r\n },\r\n\r\n // Get the model at the given index.\r\n at: function(index) {\r\n return this.models[index];\r\n },\r\n\r\n // Return models with matching attributes. Useful for simple cases of\r\n // `filter`.\r\n where: function(attrs, first) {\r\n if (_.isEmpty(attrs)) return first ? void 0 : [];\r\n return this[first ? 'find' : 'filter'](function(model) {\r\n for (var key in attrs) {\r\n if (attrs[key] !== model.get(key)) return false;\r\n }\r\n return true;\r\n });\r\n },\r\n\r\n // Return the first model with matching attributes. Useful for simple cases\r\n // of `find`.\r\n findWhere: function(attrs) {\r\n return this.where(attrs, true);\r\n },\r\n\r\n // Force the collection to re-sort itself. You don't need to call this under\r\n // normal circumstances, as the set will maintain sort order as each item\r\n // is added.\r\n sort: function(options) {\r\n if (!this.comparator) throw new Error('Cannot sort a set without a comparator');\r\n options || (options = {});\r\n\r\n // Run sort based on type of `comparator`.\r\n if (_.isString(this.comparator) || this.comparator.length === 1) {\r\n this.models = this.sortBy(this.comparator, this);\r\n } else {\r\n this.models.sort(_.bind(this.comparator, this));\r\n }\r\n\r\n if (!options.silent) this.trigger('sort', this, options);\r\n return this;\r\n },\r\n\r\n // Pluck an attribute from each model in the collection.\r\n pluck: function(attr) {\r\n return _.invoke(this.models, 'get', attr);\r\n },\r\n\r\n // Fetch the default set of models for this collection, resetting the\r\n // collection when they arrive. If `reset: true` is passed, the response\r\n // data will be passed through the `reset` method instead of `set`.\r\n fetch: function(options) {\r\n options = options ? _.clone(options) : {};\r\n if (options.parse === void 0) options.parse = true;\r\n var success = options.success;\r\n var collection = this;\r\n options.success = function(resp) {\r\n var method = options.reset ? 'reset' : 'set';\r\n collection[method](resp, options);\r\n if (success) success(collection, resp, options);\r\n collection.trigger('sync', collection, resp, options);\r\n };\r\n wrapError(this, options);\r\n return this.sync('read', this, options);\r\n },\r\n\r\n // Create a new instance of a model in this collection. Add the model to the\r\n // collection immediately, unless `wait: true` is passed, in which case we\r\n // wait for the server to agree.\r\n create: function(model, options) {\r\n options = options ? _.clone(options) : {};\r\n if (!(model = this._prepareModel(model, options))) return false;\r\n if (!options.wait) this.add(model, options);\r\n var collection = this;\r\n var success = options.success;\r\n options.success = function(model, resp) {\r\n if (options.wait) collection.add(model, options);\r\n if (success) success(model, resp, options);\r\n };\r\n model.save(null, options);\r\n return model;\r\n },\r\n\r\n // **parse** converts a response into a list of models to be added to the\r\n // collection. The default implementation is just to pass it through.\r\n parse: function(resp, options) {\r\n return resp;\r\n },\r\n\r\n // Create a new collection with an identical list of models as this one.\r\n clone: function() {\r\n return new this.constructor(this.models);\r\n },\r\n\r\n // Private method to reset all internal state. Called when the collection\r\n // is first initialized or reset.\r\n _reset: function() {\r\n this.length = 0;\r\n this.models = [];\r\n this._byId = {};\r\n },\r\n\r\n // Prepare a hash of attributes (or other model) to be added to this\r\n // collection.\r\n _prepareModel: function(attrs, options) {\r\n if (attrs instanceof Model) return attrs;\r\n options = options ? _.clone(options) : {};\r\n options.collection = this;\r\n var model = new this.model(attrs, options);\r\n if (!model.validationError) return model;\r\n this.trigger('invalid', this, model.validationError, options);\r\n return false;\r\n },\r\n\r\n // Internal method to create a model's ties to a collection.\r\n _addReference: function(model, options) {\r\n this._byId[model.cid] = model;\r\n if (model.id != null) this._byId[model.id] = model;\r\n if (!model.collection) model.collection = this;\r\n model.on('all', this._onModelEvent, this);\r\n },\r\n\r\n // Internal method to sever a model's ties to a collection.\r\n _removeReference: function(model, options) {\r\n if (this === model.collection) delete model.collection;\r\n model.off('all', this._onModelEvent, this);\r\n },\r\n\r\n // Internal method called every time a model in the set fires an event.\r\n // Sets need to update their indexes when models change ids. All other\r\n // events simply proxy through. \"add\" and \"remove\" events that originate\r\n // in other collections are ignored.\r\n _onModelEvent: function(event, model, collection, options) {\r\n if ((event === 'add' || event === 'remove') && collection !== this) return;\r\n if (event === 'destroy') this.remove(model, options);\r\n if (model && event === 'change:' + model.idAttribute) {\r\n delete this._byId[model.previous(model.idAttribute)];\r\n if (model.id != null) this._byId[model.id] = model;\r\n }\r\n this.trigger.apply(this, arguments);\r\n }\r\n\r\n });\r\n\r\n // Underscore methods that we want to implement on the Collection.\r\n // 90% of the core usefulness of Backbone Collections is actually implemented\r\n // right here:\r\n var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',\r\n 'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',\r\n 'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',\r\n 'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',\r\n 'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',\r\n 'lastIndexOf', 'isEmpty', 'chain', 'sample'];\r\n\r\n // Mix in each Underscore method as a proxy to `Collection#models`.\r\n _.each(methods, function(method) {\r\n Collection.prototype[method] = function() {\r\n var args = slice.call(arguments);\r\n args.unshift(this.models);\r\n return _[method].apply(_, args);\r\n };\r\n });\r\n\r\n // Underscore methods that take a property name as an argument.\r\n var attributeMethods = ['groupBy', 'countBy', 'sortBy', 'indexBy'];\r\n\r\n // Use attributes instead of properties.\r\n _.each(attributeMethods, function(method) {\r\n Collection.prototype[method] = function(value, context) {\r\n var iterator = _.isFunction(value) ? value : function(model) {\r\n return model.get(value);\r\n };\r\n return _[method](this.models, iterator, context);\r\n };\r\n });\r\n\r\n // Backbone.View\r\n // -------------\r\n\r\n // Backbone Views are almost more convention than they are actual code. A View\r\n // is simply a JavaScript object that represents a logical chunk of UI in the\r\n // DOM. This might be a single item, an entire list, a sidebar or panel, or\r\n // even the surrounding frame which wraps your whole app. Defining a chunk of\r\n // UI as a **View** allows you to define your DOM events declaratively, without\r\n // having to worry about render order ... and makes it easy for the view to\r\n // react to specific changes in the state of your models.\r\n\r\n // Creating a Backbone.View creates its initial element outside of the DOM,\r\n // if an existing element is not provided...\r\n var View = Backbone.View = function(options) {\r\n this.cid = _.uniqueId('view');\r\n options || (options = {});\r\n _.extend(this, _.pick(options, viewOptions));\r\n this._ensureElement();\r\n this.initialize.apply(this, arguments);\r\n this.delegateEvents();\r\n };\r\n\r\n // Cached regex to split keys for `delegate`.\r\n var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\r\n\r\n // List of view options to be merged as properties.\r\n var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];\r\n\r\n // Set up all inheritable **Backbone.View** properties and methods.\r\n _.extend(View.prototype, Events, {\r\n\r\n // The default `tagName` of a View's element is `\"div\"`.\r\n tagName: 'div',\r\n\r\n // jQuery delegate for element lookup, scoped to DOM elements within the\r\n // current view. This should be preferred to global lookups where possible.\r\n $: function(selector) {\r\n return this.$el.find(selector);\r\n },\r\n\r\n // Initialize is an empty function by default. Override it with your own\r\n // initialization logic.\r\n initialize: function(){},\r\n\r\n // **render** is the core function that your view should override, in order\r\n // to populate its element (`this.el`), with the appropriate HTML. The\r\n // convention is for **render** to always return `this`.\r\n render: function() {\r\n return this;\r\n },\r\n\r\n // Remove this view by taking the element out of the DOM, and removing any\r\n // applicable Backbone.Events listeners.\r\n remove: function() {\r\n this.$el.remove();\r\n this.stopListening();\r\n return this;\r\n },\r\n\r\n // Change the view's element (`this.el` property), including event\r\n // re-delegation.\r\n setElement: function(element, delegate) {\r\n if (this.$el) this.undelegateEvents();\r\n this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);\r\n this.el = this.$el[0];\r\n if (delegate !== false) this.delegateEvents();\r\n return this;\r\n },\r\n\r\n // Set callbacks, where `this.events` is a hash of\r\n //\r\n // *{\"event selector\": \"callback\"}*\r\n //\r\n // {\r\n // 'mousedown .title': 'edit',\r\n // 'click .button': 'save',\r\n // 'click .open': function(e) { ... }\r\n // }\r\n //\r\n // pairs. Callbacks will be bound to the view, with `this` set properly.\r\n // Uses event delegation for efficiency.\r\n // Omitting the selector binds the event to `this.el`.\r\n // This only works for delegate-able events: not `focus`, `blur`, and\r\n // not `change`, `submit`, and `reset` in Internet Explorer.\r\n delegateEvents: function(events) {\r\n if (!(events || (events = _.result(this, 'events')))) return this;\r\n this.undelegateEvents();\r\n for (var key in events) {\r\n var method = events[key];\r\n if (!_.isFunction(method)) method = this[events[key]];\r\n if (!method) continue;\r\n\r\n var match = key.match(delegateEventSplitter);\r\n var eventName = match[1], selector = match[2];\r\n method = _.bind(method, this);\r\n eventName += '.delegateEvents' + this.cid;\r\n if (selector === '') {\r\n this.$el.on(eventName, method);\r\n } else {\r\n this.$el.on(eventName, selector, method);\r\n }\r\n }\r\n return this;\r\n },\r\n\r\n // Clears all callbacks previously bound to the view with `delegateEvents`.\r\n // You usually don't need to use this, but may wish to if you have multiple\r\n // Backbone views attached to the same DOM element.\r\n undelegateEvents: function() {\r\n this.$el.off('.delegateEvents' + this.cid);\r\n return this;\r\n },\r\n\r\n // Ensure that the View has a DOM element to render into.\r\n // If `this.el` is a string, pass it through `$()`, take the first\r\n // matching element, and re-assign it to `el`. Otherwise, create\r\n // an element from the `id`, `className` and `tagName` properties.\r\n _ensureElement: function() {\r\n if (!this.el) {\r\n var attrs = _.extend({}, _.result(this, 'attributes'));\r\n if (this.id) attrs.id = _.result(this, 'id');\r\n if (this.className) attrs['class'] = _.result(this, 'className');\r\n var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);\r\n this.setElement($el, false);\r\n } else {\r\n this.setElement(_.result(this, 'el'), false);\r\n }\r\n }\r\n\r\n });\r\n\r\n // Backbone.sync\r\n // -------------\r\n\r\n // Override this function to change the manner in which Backbone persists\r\n // models to the server. You will be passed the type of request, and the\r\n // model in question. By default, makes a RESTful Ajax request\r\n // to the model's `url()`. Some possible customizations could be:\r\n //\r\n // * Use `setTimeout` to batch rapid-fire updates into a single request.\r\n // * Send up the models as XML instead of JSON.\r\n // * Persist models via WebSockets instead of Ajax.\r\n //\r\n // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests\r\n // as `POST`, with a `_method` parameter containing the true HTTP method,\r\n // as well as all requests with the body as `application/x-www-form-urlencoded`\r\n // instead of `application/json` with the model in a param named `model`.\r\n // Useful when interfacing with server-side languages like **PHP** that make\r\n // it difficult to read the body of `PUT` requests.\r\n Backbone.sync = function(method, model, options) {\r\n var type = methodMap[method];\r\n\r\n // Default options, unless specified.\r\n _.defaults(options || (options = {}), {\r\n emulateHTTP: Backbone.emulateHTTP,\r\n emulateJSON: Backbone.emulateJSON\r\n });\r\n\r\n // Default JSON-request options.\r\n var params = {type: type, dataType: 'json'};\r\n\r\n // Ensure that we have a URL.\r\n if (!options.url) {\r\n params.url = _.result(model, 'url') || urlError();\r\n }\r\n\r\n // Ensure that we have the appropriate request data.\r\n if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {\r\n params.contentType = 'application/json';\r\n params.data = JSON.stringify(options.attrs || model.toJSON(options));\r\n }\r\n\r\n // For older servers, emulate JSON by encoding the request into an HTML-form.\r\n if (options.emulateJSON) {\r\n params.contentType = 'application/x-www-form-urlencoded';\r\n params.data = params.data ? {model: params.data} : {};\r\n }\r\n\r\n // For older servers, emulate HTTP by mimicking the HTTP method with `_method`\r\n // And an `X-HTTP-Method-Override` header.\r\n if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {\r\n params.type = 'POST';\r\n if (options.emulateJSON) params.data._method = type;\r\n var beforeSend = options.beforeSend;\r\n options.beforeSend = function(xhr) {\r\n xhr.setRequestHeader('X-HTTP-Method-Override', type);\r\n if (beforeSend) return beforeSend.apply(this, arguments);\r\n };\r\n }\r\n\r\n // Don't process data on a non-GET request.\r\n if (params.type !== 'GET' && !options.emulateJSON) {\r\n params.processData = false;\r\n }\r\n\r\n // If we're sending a `PATCH` request, and we're in an old Internet Explorer\r\n // that still has ActiveX enabled by default, override jQuery to use that\r\n // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.\r\n if (params.type === 'PATCH' && noXhrPatch) {\r\n params.xhr = function() {\r\n return new ActiveXObject(\"Microsoft.XMLHTTP\");\r\n };\r\n }\r\n\r\n // Make the request, allowing the user to override any Ajax options.\r\n var xhr = options.xhr = Backbone.ajax(_.extend(params, options));\r\n model.trigger('request', model, xhr, options);\r\n return xhr;\r\n };\r\n\r\n var noXhrPatch =\r\n typeof window !== 'undefined' && !!window.ActiveXObject &&\r\n !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent);\r\n\r\n // Map from CRUD to HTTP for our default `Backbone.sync` implementation.\r\n var methodMap = {\r\n 'create': 'POST',\r\n 'update': 'PUT',\r\n 'patch': 'PATCH',\r\n 'delete': 'DELETE',\r\n 'read': 'GET'\r\n };\r\n\r\n // Set the default implementation of `Backbone.ajax` to proxy through to `$`.\r\n // Override this if you'd like to use a different library.\r\n Backbone.ajax = function() {\r\n return Backbone.$.ajax.apply(Backbone.$, arguments);\r\n };\r\n\r\n // Backbone.Router\r\n // ---------------\r\n\r\n // Routers map faux-URLs to actions, and fire events when routes are\r\n // matched. Creating a new one sets its `routes` hash, if not set statically.\r\n var Router = Backbone.Router = function(options) {\r\n options || (options = {});\r\n if (options.routes) this.routes = options.routes;\r\n this._bindRoutes();\r\n this.initialize.apply(this, arguments);\r\n };\r\n\r\n // Cached regular expressions for matching named param parts and splatted\r\n // parts of route strings.\r\n var optionalParam = /\\((.*?)\\)/g;\r\n var namedParam = /(\\(\\?)?:\\w+/g;\r\n var splatParam = /\\*\\w+/g;\r\n var escapeRegExp = /[\\-{}\\[\\]+?.,\\\\\\^$|#\\s]/g;\r\n\r\n // Set up all inheritable **Backbone.Router** properties and methods.\r\n _.extend(Router.prototype, Events, {\r\n\r\n // Initialize is an empty function by default. Override it with your own\r\n // initialization logic.\r\n initialize: function(){},\r\n\r\n // Manually bind a single named route to a callback. For example:\r\n //\r\n // this.route('search/:query/p:num', 'search', function(query, num) {\r\n // ...\r\n // });\r\n //\r\n route: function(route, name, callback) {\r\n if (!_.isRegExp(route)) route = this._routeToRegExp(route);\r\n if (_.isFunction(name)) {\r\n callback = name;\r\n name = '';\r\n }\r\n if (!callback) callback = this[name];\r\n var router = this;\r\n Backbone.history.route(route, function(fragment) {\r\n var args = router._extractParameters(route, fragment);\r\n router.execute(callback, args);\r\n router.trigger.apply(router, ['route:' + name].concat(args));\r\n router.trigger('route', name, args);\r\n Backbone.history.trigger('route', router, name, args);\r\n });\r\n return this;\r\n },\r\n\r\n // Execute a route handler with the provided parameters. This is an\r\n // excellent place to do pre-route setup or post-route cleanup.\r\n execute: function(callback, args) {\r\n if (callback) callback.apply(this, args);\r\n },\r\n\r\n // Simple proxy to `Backbone.history` to save a fragment into the history.\r\n navigate: function(fragment, options) {\r\n Backbone.history.navigate(fragment, options);\r\n return this;\r\n },\r\n\r\n // Bind all defined routes to `Backbone.history`. We have to reverse the\r\n // order of the routes here to support behavior where the most general\r\n // routes can be defined at the bottom of the route map.\r\n _bindRoutes: function() {\r\n if (!this.routes) return;\r\n this.routes = _.result(this, 'routes');\r\n var route, routes = _.keys(this.routes);\r\n while ((route = routes.pop()) != null) {\r\n this.route(route, this.routes[route]);\r\n }\r\n },\r\n\r\n // Convert a route string into a regular expression, suitable for matching\r\n // against the current location hash.\r\n _routeToRegExp: function(route) {\r\n route = route.replace(escapeRegExp, '\\\\$&')\r\n .replace(optionalParam, '(?:$1)?')\r\n .replace(namedParam, function(match, optional) {\r\n return optional ? match : '([^/?]+)';\r\n })\r\n .replace(splatParam, '([^?]*?)');\r\n return new RegExp('^' + route + '(?:\\\\?([\\\\s\\\\S]*))?$');\r\n },\r\n\r\n // Given a route, and a URL fragment that it matches, return the array of\r\n // extracted decoded parameters. Empty or unmatched parameters will be\r\n // treated as `null` to normalize cross-browser behavior.\r\n _extractParameters: function(route, fragment) {\r\n var params = route.exec(fragment).slice(1);\r\n return _.map(params, function(param, i) {\r\n // Don't decode the search params.\r\n if (i === params.length - 1) return param || null;\r\n return param ? decodeURIComponent(param) : null;\r\n });\r\n }\r\n\r\n });\r\n\r\n // Backbone.History\r\n // ----------------\r\n\r\n // Handles cross-browser history management, based on either\r\n // [pushState](http://diveintohtml5.info/history.html) and real URLs, or\r\n // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)\r\n // and URL fragments. If the browser supports neither (old IE, natch),\r\n // falls back to polling.\r\n var History = Backbone.History = function() {\r\n this.handlers = [];\r\n _.bindAll(this, 'checkUrl');\r\n\r\n // Ensure that `History` can be used outside of the browser.\r\n if (typeof window !== 'undefined') {\r\n this.location = window.location;\r\n this.history = window.history;\r\n }\r\n };\r\n\r\n // Cached regex for stripping a leading hash/slash and trailing space.\r\n var routeStripper = /^[#\\/]|\\s+$/g;\r\n\r\n // Cached regex for stripping leading and trailing slashes.\r\n var rootStripper = /^\\/+|\\/+$/g;\r\n\r\n // Cached regex for detecting MSIE.\r\n var isExplorer = /msie [\\w.]+/;\r\n\r\n // Cached regex for removing a trailing slash.\r\n var trailingSlash = /\\/$/;\r\n\r\n // Cached regex for stripping urls of hash.\r\n var pathStripper = /#.*$/;\r\n\r\n // Has the history handling already been started?\r\n History.started = false;\r\n\r\n // Set up all inheritable **Backbone.History** properties and methods.\r\n _.extend(History.prototype, Events, {\r\n\r\n // The default interval to poll for hash changes, if necessary, is\r\n // twenty times a second.\r\n interval: 50,\r\n\r\n // Are we at the app root?\r\n atRoot: function() {\r\n return this.location.pathname.replace(/[^\\/]$/, '$&/') === this.root;\r\n },\r\n\r\n // Gets the true hash value. Cannot use location.hash directly due to bug\r\n // in Firefox where location.hash will always be decoded.\r\n getHash: function(window) {\r\n var match = (window || this).location.href.match(/#(.*)$/);\r\n return match ? match[1] : '';\r\n },\r\n\r\n // Get the cross-browser normalized URL fragment, either from the URL,\r\n // the hash, or the override.\r\n getFragment: function(fragment, forcePushState) {\r\n if (fragment == null) {\r\n if (this._hasPushState || !this._wantsHashChange || forcePushState) {\r\n fragment = decodeURI(this.location.pathname + this.location.search);\r\n var root = this.root.replace(trailingSlash, '');\r\n if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);\r\n } else {\r\n fragment = this.getHash();\r\n }\r\n }\r\n return fragment.replace(routeStripper, '');\r\n },\r\n\r\n // Start the hash change handling, returning `true` if the current URL matches\r\n // an existing route, and `false` otherwise.\r\n start: function(options) {\r\n if (History.started) throw new Error(\"Backbone.history has already been started\");\r\n History.started = true;\r\n\r\n // Figure out the initial configuration. Do we need an iframe?\r\n // Is pushState desired ... is it available?\r\n this.options = _.extend({root: '/'}, this.options, options);\r\n this.root = this.options.root;\r\n this._wantsHashChange = this.options.hashChange !== false;\r\n this._wantsPushState = !!this.options.pushState;\r\n this._hasPushState = !!(this.options.pushState && this.history && this.history.pushState);\r\n var fragment = this.getFragment();\r\n var docMode = document.documentMode;\r\n var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));\r\n\r\n // Normalize root to always include a leading and trailing slash.\r\n this.root = ('/' + this.root + '/').replace(rootStripper, '/');\r\n\r\n if (oldIE && this._wantsHashChange) {\r\n var frame = Backbone.$('