';\r\n }\r\n\r\n /**************************** MODAL ************************************/\r\n\r\n\r\n function show(content, options) {\r\n\r\n var dfd = $.Deferred();\r\n\r\n // init options\r\n _options = $.extend({}, DEFAULTS, options, {});\r\n\r\n // close the currently open modal;\r\n close();\r\n\r\n if (_isPhone) {\r\n return showPhone(content);\r\n }\r\n\r\n var containerEl = options.containerEl || _body;\r\n _current = setup(content, MODAL_CLASS, containerEl);\r\n\r\n // Store the container el\r\n if (options.containerEl) {\r\n _current.data('containerEl', options.containerEl);\r\n }\r\n\r\n _current.css('width', options.width);\r\n\r\n\r\n if (!options.skipOverlay) {\r\n var oc = OVERLAY_CLASS;\r\n if (options.overlayClass) {\r\n oc += (' ' + options.overlayClass);\r\n }\r\n\r\n // show overlay\r\n var o = overlay.show(_options.zIndex, oc, _options.overlayClose);\r\n\r\n // attach close\r\n if (_options.overlayClose) {\r\n o.done(close);\r\n }\r\n }\r\n\r\n // position\r\n position();\r\n\r\n if (options.resolveBeforeAnimation) {\r\n dfd.resolve(_current);\r\n }\r\n\r\n // apply show animation\r\n if (_options.animate) {\r\n animate('show', _current);\r\n }\r\n\r\n // resolve the deferred after the animation completion\r\n $.when(_current).done(dfd.resolve);\r\n\r\n // return deferred\r\n return dfd.promise();\r\n }\r\n\r\n function position() {\r\n if (!_current || _isPhone) return;\r\n var width = _current.width();\r\n var height = _current.height();\r\n\r\n var left = 0;\r\n var top = 0;\r\n\r\n if (_current.data('containerEl')) {\r\n var containerEl = _current.data('containerEl');\r\n\r\n var containerHeight = containerEl.height();\r\n var containerWidth = containerEl.width();\r\n\r\n // put at screen center\r\n top = (containerHeight / 2 ) - (height / 2);\r\n\r\n // if our modal is too big for the screen, position it 50 pixel from the top\r\n if (top < 0) {\r\n top = 50;\r\n }\r\n\r\n left = (containerWidth / 2) - (width / 2);\r\n\r\n\r\n } else {\r\n\r\n var scrollTop = _win.scrollTop();\r\n var scrollLeft = _win.scrollLeft();\r\n var screenWidth = window.innerWidth || _win.width();\r\n var screenHeight = window.innerHeight || _win.height();\r\n\r\n // put at screen center\r\n top = scrollTop + (screenHeight / 2 ) - (height / 2);\r\n\r\n // if our modal is too big for the screen, position it 50 pixel from the top\r\n if (top < scrollTop) {\r\n top = scrollTop + 50;\r\n }\r\n\r\n left = scrollLeft + (screenWidth / 2) - (width / 2);\r\n }\r\n\r\n\r\n _current.css({\r\n top: top,\r\n left: left\r\n });\r\n\r\n window.setTimeout(fixPlaceholders, 20);\r\n }\r\n\r\n function setup(content, modalClass, containerEl) {\r\n var c = $(content).show();\r\n\r\n var dom = $('').addClass(modalClass + ' ' + (_options.cssClass || ''));\r\n // wrap content with a wrapper div;\r\n _contentWrap = c.wrap('').parent().addClass(MODAL_CLASS + '-content');\r\n\r\n dom.append(_contentWrap);\r\n containerEl.append(dom);\r\n\r\n\r\n // delegate the 'fire-modal-close' class to close the modal\r\n dom.delegate('.' + MODAL_CLASS + '-close', 'click', onCloseClicked);\r\n\r\n return dom;\r\n }\r\n\r\n /***\r\n *\r\n * @param {string} type animation type (show/hide)\r\n */\r\n function animate(type, el) {\r\n if (!el) return $.when();\r\n\r\n // remove shadow for performance\r\n el.addClass('no-shadow');\r\n\r\n if (type === 'show') {\r\n el.css({'margin-top': '-50px', opacity: 0})\r\n .show()\r\n .animate({'margin-top': 0, 'opacity': 1}, ANIMATION_DURATION);\r\n }\r\n\r\n if (type === 'hide') {\r\n el\r\n .animate({'margin-top': '50px', 'opacity': 0}, ANIMATION_DURATION);\r\n }\r\n\r\n\r\n return $.when(el).done(function () {\r\n el.removeClass('no-shadow');\r\n });\r\n }\r\n\r\n /***\r\n *\r\n * @param {Boolean=} fast should we use animation for the close?\r\n */\r\n function close(fast) {\r\n if (!_current) return $.when();\r\n\r\n if (_isPhone) return closePhone();\r\n\r\n unlock();\r\n\r\n var cur = _current;\r\n // remove events\r\n _win.off('resize', position);\r\n\r\n // hide overlay\r\n var o = overlay.remove(!fast && _options.animate);\r\n\r\n // animate hide\r\n if (_options.animate && !fast) {\r\n animate('hide', cur);\r\n }\r\n\r\n // when done\r\n return $.when(o, cur).done(function () {\r\n // fix a tipsy issue\r\n $('div.tipsy').hide();\r\n\r\n if (_options && _options.close) {\r\n _options.close(cur);\r\n }\r\n cur.detach();\r\n var containerEl = _current.data('containerEl');\r\n\r\n _contentWrap = _current = _options = cur = null;\r\n\r\n\r\n if (containerEl) {\r\n containerEl.remove();\r\n }\r\n });\r\n }\r\n\r\n /*********************************************************************************\r\n * Phone width modal\r\n *********************************************************************************/\r\n\r\n // TODO - maybe restore the scroll position after a close?\r\n\r\n function closePhone() {\r\n\r\n var cur = _current;\r\n if (_options && _options.close) _options.close(cur);\r\n cur.remove();\r\n\r\n // clean up everything\r\n _contentWrap = _current = _options = cur = null;\r\n\r\n // restore the body state\r\n showBodyItems();\r\n\r\n _body.removeClass('mobile-modal-body');\r\n\r\n // restore the scroll top\r\n\r\n if (_prePhoneScrollTop) {\r\n _body.scrollTop(_prePhoneScrollTop);\r\n _prePhoneScrollTop = null;\r\n }\r\n\r\n return $.when();\r\n }\r\n\r\n var _prePhoneScrollTop = null;\r\n\r\n /***\r\n * Show phone content\r\n * @param content\r\n */\r\n function showPhone(content) {\r\n // store the scroll top value\r\n _prePhoneScrollTop = _body.scrollTop();\r\n\r\n // hide body items\r\n hideBodyItems();\r\n\r\n // setup phone view\r\n _current = setup(content, MOBILE_MODAL_CLASS,_body);\r\n\r\n _body.addClass('mobile-modal-body');\r\n\r\n // scroll to the top\r\n _body.scrollTop(0);\r\n return $.when(_current);\r\n }\r\n\r\n var _hiddenBodyItems;\r\n\r\n function showBodyItems() {\r\n // restore hidden body items\r\n _hiddenBodyItems.show();\r\n\r\n // remove current body items\r\n _hiddenBodyItems = null;\r\n }\r\n\r\n function hideBodyItems() {\r\n _hiddenBodyItems = _body.children(':visible').hide();\r\n }\r\n\r\n\r\n function fixPlaceholders() {\r\n var pf = $.fn.placeholderPolyfill;\r\n if (!_current || !pf) return;\r\n\r\n // apply the placeholder on child elements\r\n pf(_current, true);\r\n }\r\n\r\n\r\n function lock() {\r\n _locked = true;\r\n\r\n if (_current) _current.addClass('fire-modal-locked');\r\n }\r\n\r\n function unlock() {\r\n _locked = false;\r\n\r\n if (_current) _current.removeClass('fire-modal-locked');\r\n }\r\n\r\n\r\n function onCloseClicked(e) {\r\n e.preventDefault();\r\n e.stopImmediatePropagation();\r\n\r\n var t = $(e.currentTarget);\r\n if (_locked || t.hasClass('disabled')) return;\r\n\r\n close();\r\n }\r\n\r\n // setup events\r\n\r\n if (!isTouch) {\r\n _win.on('resize', position);\r\n }\r\n\r\n\r\n var module = {\r\n close: close,\r\n show: show,\r\n showUrl: showUrl,\r\n showDeferred: showDeferred,\r\n position: position,\r\n lock: lock,\r\n unlock: unlock\r\n };\r\n\r\n\r\n /*****\r\n * Backward compatibility\r\n * @deprecated\r\n */\r\n window.fire.modal = module;\r\n\r\n /*****\r\n * Backward compatibility\r\n * @deprecated\r\n */\r\n window.fire.modal.reposition = position;\r\n\r\n\r\n return module;\r\n});\r\n", "// Generated by CoffeeScript 1.12.3\ndefine('fire/util/eventEmitter', function(require) {\n\n /*\n Event emitter class\n \n TODO: this needs a proper documentation\n shlomiatar @ 16/04/13\n */\n var Emitter;\n Emitter = (function() {\n var _guid, getGuid;\n\n _guid = 0;\n\n getGuid = function() {\n\n /*\n Returns a new emitter guid\n */\n _guid += 1;\n return \"ev_\" + _guid;\n };\n\n function Emitter() {\n this.__ev = {};\n }\n\n Emitter.prototype.on = function(name, callback) {\n\n /*\n Register a callback\n */\n if (!callback) {\n return;\n }\n if (!(name in this.__ev)) {\n this.__ev[name] = [];\n }\n if (this.__findCallbackIdx(name, callback) > 0) {\n return;\n }\n if (!callback.guid) {\n callback.guid = getGuid();\n }\n this.__ev[name].push(callback);\n return this;\n };\n\n Emitter.prototype.one = function(name, callback) {\n\n /*\n Creates a callback that will fire only once\n */\n var handler, self;\n self = this;\n handler = function() {\n callback.apply(this, arguments);\n return self.off(name, callback);\n };\n if (!callback.guid) {\n callback.guid = getGuid();\n }\n handler.guid = callback.guid;\n return this.on(name, handler);\n };\n\n Emitter.prototype.off = function(name, callback) {\n\n /*\n Unregister an event/multiple events\n \n Params:\n - name The name of the event we dergisterring\n - callback (optional) the callback we want to de-register. if non was specified, removes all the callbacks for\n the event\n */\n var idx;\n if (!callback) {\n delete this.__ev[name];\n return;\n }\n idx = this.__findCallbackIdx(name, callback);\n if (idx > -1) {\n this.__ev[name].splice(idx, 1);\n }\n return this;\n };\n\n Emitter.prototype.trigger = function(name) {\n\n /*\n Trigger an event\n */\n var c, i, len, ref;\n if (!(name in this.__ev)) {\n return;\n }\n ref = this.__ev[name];\n for (i = 0, len = ref.length; i < len; i++) {\n c = ref[i];\n c.apply(this, Array.prototype.slice.call(arguments, 1));\n }\n return this;\n };\n\n Emitter.prototype.__findCallbackIdx = function(name, callback) {\n\n /*\n Locates the callback index by the event name and callback\n */\n var c, i, idx, len, ref;\n if (!(name in this.__ev)) {\n return -1;\n }\n ref = this.__ev[name];\n for (idx = i = 0, len = ref.length; i < len; idx = ++i) {\n c = ref[idx];\n if (c === callback) {\n return idx;\n }\n if (c.guid && c.guid === callback.guid) {\n return idx;\n }\n }\n return -1;\n };\n\n return Emitter;\n\n })();\n return {\n Emitter: Emitter\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty,\n slice = [].slice;\n\ndefine('fire/ui/view', function(require) {\n var View, em;\n em = require('fire/util/eventEmitter');\n\n /*\n The basic view building block\n */\n View = (function(superClass) {\n extend(View, superClass);\n\n function View(options) {\n if (options == null) {\n options = {};\n }\n this.options = options;\n if (this.defaultOptions) {\n this.options = $.extend({}, this.defaultOptions, options);\n }\n View.__super__.constructor.apply(this, arguments);\n this._modifiers = {};\n this.el = options.el;\n if (!this.el) {\n this.el = this.generate();\n } else {\n this.options = $.extend({}, this.defaultOptions, this.el.data(), options);\n }\n if (this.autoRender) {\n this.render();\n this.setup();\n }\n }\n\n View.prototype.autoRender = true;\n\n View.prototype.render = function() {\n return null;\n };\n\n View.prototype.setup = function() {\n if (this.attrs) {\n this.el.attr(this.attrs);\n }\n if (this.cssClass) {\n this.el.addClass(this.cssClass);\n }\n if (this.events) {\n return this.delegate(this._extractEvents(this.events));\n }\n };\n\n View.prototype.remove = function() {\n if (this.beforeRemove) {\n this.beforeRemove();\n }\n if (this.el) {\n this.el.remove();\n }\n return this.removed = true;\n };\n\n View.prototype.find = function(selector) {\n return this.el.find(selector);\n };\n\n View.prototype.delegate = function(events) {\n var e, j, len, results;\n results = [];\n for (j = 0, len = events.length; j < len; j++) {\n e = events[j];\n results.push(this.el.on(e.name, e.selector, e.handler));\n }\n return results;\n };\n\n View.prototype.undelegate = function(events) {\n var e, j, len, results;\n results = [];\n for (j = 0, len = events.length; j < len; j++) {\n e = events[j];\n results.push(this.el.off(e.name, e.selector, e.handler));\n }\n return results;\n };\n\n View.prototype.generate = function() {\n\n /*\n An override of view to allow quick generation of widget steps\n */\n var cls, h, selEl, selector;\n if (this.templateSelector) {\n selector = _.result(this, 'templateSelector');\n selEl = $(selector);\n h = selEl.html();\n cls = selEl.data('class') || '';\n if (!h) {\n throw \"Could not find html content with the selector \" + selector + \".\";\n }\n return $('
').addClass(cls).append(h);\n }\n };\n\n View.prototype._extractEvents = function(eventDict) {\n\n /*\n Converts an event dict to a list of event handlers\n */\n var extractEvent, k, v;\n if (!eventDict) {\n return [];\n }\n extractEvent = (function(_this) {\n return function(key, handlerName) {\n var handler, name, ref, selector;\n ref = key.split(' '), name = ref[0], selector = 2 <= ref.length ? slice.call(ref, 1) : [];\n handler = _this[handlerName];\n if (!handler) {\n throw \"The handler \" + handlerName + \" was not found in \" + _this;\n }\n return {\n name: name,\n selector: selector.join(' '),\n handler: $.proxy(handler, _this)\n };\n };\n })(this);\n return (function() {\n var results;\n results = [];\n for (k in eventDict) {\n v = eventDict[k];\n results.push(extractEvent(k, v));\n }\n return results;\n })();\n };\n\n View.prototype.addModifier = function(modifier, allowDomUpdate) {\n var u;\n if (allowDomUpdate == null) {\n allowDomUpdate = false;\n }\n\n /*\n Add a modifier to the current view\n \n Params:\n - modifier\n - allowDomUpdate Sets a delay so the browser could update the dom before applying the modifier\n */\n if (this.hasModifier(modifier)) {\n return;\n }\n this._modifiers[modifier] = true;\n u = (function(_this) {\n return function() {\n if (_this.el) {\n return _this.el.addClass(\"is-\" + modifier);\n }\n };\n })(this);\n if (allowDomUpdate) {\n return setTimeout(u, 20);\n } else {\n return u();\n }\n };\n\n View.prototype.removeModifier = function(modifier) {\n\n /*\n Remove the modifier from the view\n \n Params:\n - modifier\n */\n if (!this.hasModifier(modifier)) {\n return;\n }\n delete this._modifiers[modifier];\n if (this.el) {\n return this.el.removeClass(\"is-\" + modifier);\n }\n };\n\n View.prototype.hasModifier = function(modifier) {\n\n /*\n Checks if the given modifier is active\n \n Params:\n - Modifier The modifier\n \n Returns:\n true if the view has the given modifier, false if not\n */\n return modifier in this._modifiers;\n };\n\n View.prototype.modifiers = function() {\n\n /*\n Returns a list of the active modifiers\n */\n var i;\n return (function() {\n var results;\n results = [];\n for (i in this._modifiers) {\n results.push(i);\n }\n return results;\n }).call(this);\n };\n\n return View;\n\n })(em.Emitter);\n return {\n View: View\n };\n});\n", "// Generated by CoffeeScript 1.12.3\ndefine('fire/util/history', function(require) {\n var HISTORY_ID, HISTORY_KEY, StateHelper, getKey, hub, onHistoryPopState;\n HISTORY_ID = 0;\n HISTORY_KEY = '__history_key';\n getKey = function() {\n HISTORY_ID += 1;\n return \"history_key_\" + HISTORY_ID;\n };\n hub = $({});\n onHistoryPopState = function(e) {\n var k, state;\n state = e.originalEvent.state;\n if (!state) {\n return;\n }\n k = state[HISTORY_KEY];\n if (k) {\n return hub.trigger(k, state);\n }\n };\n $(window).on('popstate', onHistoryPopState);\n StateHelper = (function() {\n function StateHelper(callback) {\n this.id = getKey();\n hub.on(this.id, callback);\n }\n\n StateHelper.prototype.push = function(state) {\n var current;\n if (state == null) {\n state = {};\n }\n state[HISTORY_KEY] = this.id;\n if (!history.pushState) {\n return;\n }\n try {\n current = JSON.stringify(history.state);\n if (JSON.stringify(state) === current) {\n return;\n }\n return history.pushState(state, document.title, document.location.href);\n } catch (error) {}\n };\n\n StateHelper.prototype.pop = function() {\n return null;\n };\n\n StateHelper.prototype.remove = function() {\n return hub.off(this.id);\n };\n\n return StateHelper;\n\n })();\n return {\n getHelper: function(callback) {\n return new StateHelper(callback);\n }\n };\n});\n", "// Generated by CoffeeScript 1.12.3\n\n/*\n TODO - Proper view documentation\n */\nvar bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },\n extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('fire/ui/views/ModalView', function(require) {\n var ModalView, history, modal, view;\n modal = require('fire/ui/modal');\n view = require('fire/ui/view');\n history = require('fire/util/history');\n\n /*\n Provides a simple modal implementation\n \n @class ModalView\n */\n ModalView = (function(superClass) {\n var PRELOAD_CACHE;\n\n extend(ModalView, superClass);\n\n PRELOAD_CACHE = {};\n\n function ModalView(url1, options) {\n this.url = url1;\n this.onModalCompleted = bind(this.onModalCompleted, this);\n ModalView.__super__.constructor.call(this, options);\n if (this.enableHistory) {\n this.historyHelper = history.getHelper((function(_this) {\n return function(e, state) {\n if (state && state.init) {\n return _this.close();\n }\n };\n })(this));\n }\n if (this.preload) {\n this.getContent();\n }\n }\n\n ModalView.prototype.autoRender = false;\n\n ModalView.prototype.preload = false;\n\n ModalView.prototype.show = function(modalOptions) {\n var close;\n close = $.proxy(this.onClose, this);\n if (this.preload) {\n modalOptions = $.extend({}, {\n resolveBeforeAnimation: true,\n close: close\n }, modalOptions);\n }\n return modal.showDeferred(this.getContent(), modalOptions).always(this.onModalCompleted);\n };\n\n ModalView.prototype.onModalCompleted = function(el) {\n\n /*\n Happens when the modal creation is complete.\n \n We use this event to initalize the modal, setup history and call the render function\n */\n if (this.enableHistory) {\n this.historyHelper.push({\n init: true\n });\n }\n this.el = el;\n this.setup();\n this.setupModalEvents();\n this.render();\n return modal.position();\n };\n\n ModalView.prototype.close = function(fast) {\n return modal.close(fast);\n };\n\n ModalView.prototype.onClose = function() {\n\n /*\n Modals can override this to define behavior on close\n */\n return this.closed = true;\n };\n\n ModalView.prototype.setupModalEvents = function() {\n return null;\n };\n\n ModalView.prototype.getContent = function() {\n\n /*\n Loads the content from the given url, if preload is defined, the content will be cached\n */\n var result;\n if (this._loadedContent) {\n return $.when(this._loadedContent);\n }\n result = this._loadContent();\n if (this.preload) {\n result.done((function(_this) {\n return function(content) {\n return _this._loadedContent = content;\n };\n })(this));\n }\n return result;\n };\n\n ModalView.prototype._loadContent = function() {\n\n /*\n Loads the content, use the preload cache if possible\n */\n var name;\n if (!this.preload) {\n return $.get(this.url);\n }\n return PRELOAD_CACHE[name = this.url] != null ? PRELOAD_CACHE[name] : PRELOAD_CACHE[name] = $.get(this.url);\n };\n\n ModalView.preloadUrl = function(url) {\n\n /*\n Preloads the url and stores it in cache for all the modals\n */\n return PRELOAD_CACHE[url] = $.get(url);\n };\n\n return ModalView;\n\n })(view.View);\n return {\n ModalView: ModalView\n };\n});\n", "define('fire/util/array', function (require) {\r\n var _proto = Array.prototype;\r\n\r\n // polyfills flag\r\n // maybe in to future we could compile our code with legacy-ie flag to remove non important code\r\n var POLYFILLS = true;\r\n\r\n\r\n function normalize(items) {\r\n if (items === null) return null;\r\n if (Array.isArray(items)) return items.clone();\r\n return [items];\r\n }\r\n\r\n\r\n /****\r\n * Remove single or multiple items from the current array\r\n * @param {*|Array} input\r\n * @returns {Array}\r\n */\r\n _proto.remove = function (input) {\r\n var items = normalize(input);\r\n for (var i = 0; i < items.length; i++) {\r\n var idx = this.indexOf(items[i]);\r\n if (idx == -1) return this;\r\n this.splice(idx, 1);\r\n }\r\n return this;\r\n };\r\n\r\n\r\n /***\r\n * Removes elements that match the given lambda\r\n * @param {function(*):boolean} lambda\r\n * @returns {Array}\r\n */\r\n _proto.removeBy = function (lambda) {\r\n return this.remove(this.where(lambda));\r\n };\r\n\r\n /***\r\n * Insert the given item at the given index\r\n * @param {*} item\r\n * @param {number} idx\r\n */\r\n _proto.insert = function (item, idx) {\r\n this.splice(idx, 0, item);\r\n };\r\n\r\n\r\n /***\r\n * Inserts item before origItem\r\n * @param {*} item\r\n * @param {*} origItem\r\n */\r\n _proto.insertBefore = function (item, origItem) {\r\n var idx = this.indexOf(origItem);\r\n // if not found push it the the end\r\n if (idx == -1) {\r\n this.push(item);\r\n return;\r\n }\r\n\r\n this.insert(item, idx);\r\n };\r\n\r\n /***\r\n * Inserts item before origItem\r\n * @param {*} item\r\n * @param {*} origItem\r\n */\r\n _proto.insertAfter = function (item, origItem) {\r\n var idx = this.indexOf(origItem);\r\n // if not found push it the the end\r\n if (idx == -1 || (idx + 1) > this.length) {\r\n this.push(item);\r\n return;\r\n }\r\n\r\n this.insert(item, idx + 1);\r\n };\r\n\r\n\r\n /**\r\n * Duplicates the array\r\n * @returns {Array}\r\n */\r\n _proto.clone = _proto.slice;\r\n\r\n /***\r\n * Checks if the given item is inside the current array\r\n * @param {*} item\r\n *\r\n * @returns {boolean}\r\n */\r\n _proto.contains = function (item) {\r\n return this.indexOf(item) != -1;\r\n };\r\n\r\n\r\n /***\r\n * Returns the given array without the items from secondArray\r\n * @param {Array} secondArray\r\n * @returns {Array}\r\n */\r\n _proto.minus = function (secondArray) {\r\n return this.clone().remove(secondArray);\r\n };\r\n\r\n /***\r\n * Normalize input that can be single item or array to single array;\r\n * @param items {Array/object}\r\n * @returns {Array}\r\n */\r\n Array.normalize = normalize;\r\n\r\n /***\r\n * Returns the last element of the array\r\n *\r\n * @param {Function=} filter\r\n * @returns {*}\r\n */\r\n _proto.last = function (filter) {\r\n var arr = filter ? this.filter(filter) : this;\r\n return arr[arr.length - 1];\r\n };\r\n\r\n /***\r\n * Returns the first element of the array\r\n *\r\n * @param {Function=} filter\r\n * @returns {*}\r\n */\r\n _proto.first = function (filter) {\r\n var arr = filter ? this.filter(filter) : this;\r\n return arr[0];\r\n };\r\n\r\n\r\n /***\r\n * Adds the given item to the array only if not already inside\r\n * returns true if the item was added\r\n *\r\n * @param {*} item\r\n * @returns {boolean}\r\n */\r\n _proto.setPush = function (item) {\r\n return !this.contains(item) && this.push(item);\r\n };\r\n\r\n /***\r\n * Get a random item from the array\r\n *\r\n * @returns {*}\r\n */\r\n _proto.random = function () {\r\n var i = Math.round((this.length - 1) * Math.random());\r\n return this[i];\r\n };\r\n\r\n /****\r\n * returns a unique representation of the array\r\n *\r\n * @returns {Array}\r\n */\r\n _proto.unique = function () {\r\n var r = [];\r\n for (var i = 0; i < this.length; i++) {\r\n var el = this[i];\r\n var idx = this.indexOf(el);\r\n if (idx > -1 && idx < i) continue;\r\n r.push(el);\r\n }\r\n return r;\r\n };\r\n\r\n _proto.sum = function (func) {\r\n var o = 0;\r\n for (var i = 0; i < this.length; i++) {\r\n if (func) {\r\n o += func(this[i]);\r\n } else {\r\n o += this[i];\r\n }\r\n }\r\n return o;\r\n };\r\n\r\n /****\r\n * Converts an array with arrays to a normal array\r\n *\r\n * @returns {Array}\r\n */\r\n _proto.flatten = function () {\r\n var r = [];\r\n for (var i = 0; i < this.length; i++) {\r\n var o = this[i];\r\n if (Array.isArray(o)) {\r\n o.flatten().forEach(function (i) {\r\n r.push(i)\r\n });\r\n } else {\r\n r.push(o);\r\n }\r\n }\r\n return r;\r\n };\r\n\r\n /****\r\n * Converts the given array to a dictionary type object\r\n *\r\n * converts [1,2,3,5] to {1:true, 2:true,3:true,5:true}\r\n *\r\n * @param {Array} array\r\n * @returns {object.<*.boolean>}\r\n */\r\n Array.toObject = function (array) {\r\n // empty object if no array/no items in array\r\n if (!array || !array.length) return {};\r\n\r\n var result = {};\r\n for (var i = 0; i < array.length; i++) {\r\n result[array[i]] = true;\r\n }\r\n return result;\r\n };\r\n\r\n function objectKeys(obj) {\r\n var r = [];\r\n for (var k in obj) {\r\n r.push(k);\r\n }\r\n return r;\r\n }\r\n\r\n /**************************** POLYFILLS ************************************/\r\n\r\n if (POLYFILLS) {\r\n // isArray polyfill for older browsers\r\n if (!Array.isArray) {\r\n Array.isArray = function (val) {\r\n return val &&\r\n typeof(val) === 'object' &&\r\n typeof(val.length) === 'number' &&\r\n typeof(val.splice) === 'function' && !(val.propertyIsEnumerable('length'));\r\n }\r\n }\r\n\r\n\r\n // SUPPORT FOR ARRAYS IN IE8\r\n if (!_proto.indexOf) {\r\n _proto.indexOf = function (elt /*, from*/) {\r\n var len = this.length >>> 0;\r\n\r\n var from = Number(arguments[1]) || 0;\r\n from = (from < 0)\r\n ? Math.ceil(from)\r\n : Math.floor(from);\r\n if (from < 0)\r\n from += len;\r\n\r\n for (; from < len; from++) {\r\n if (from in this &&\r\n this[from] === elt)\r\n return from;\r\n }\r\n return -1;\r\n };\r\n }\r\n\r\n // polyfill for .some\r\n if (!_proto.some) {\r\n _proto.some = function (fn, scope) {\r\n if (!fn) return false;\r\n scope = scope || window;\r\n\r\n for (var i = 0; i < this.length; i++) {\r\n if (fn.call(scope, this[i], i)) return true;\r\n }\r\n\r\n return false;\r\n };\r\n }\r\n\r\n // polyfill for .forEach\r\n if (!_proto.forEach) {\r\n _proto.forEach = function (fn, scope) {\r\n for (var i = 0, len = this.length; i < len; ++i) {\r\n fn.call(scope || this, this[i], i, this);\r\n }\r\n }\r\n }\r\n\r\n // polyfill for .filter\r\n if (!_proto.filter) {\r\n _proto.filter = function (fn, scope) {\r\n var res = [];\r\n if (!fn) return res;\r\n scope = scope || window;\r\n\r\n for (var i = 0; i < this.length; i++) {\r\n var v = this[i];\r\n if (fn.call(scope, v, i)) {\r\n res.push(v);\r\n }\r\n }\r\n\r\n return res;\r\n };\r\n }\r\n\r\n if (!_proto.every) {\r\n _proto.every = function (fn, scope) {\r\n if (!fn) return true;\r\n scope = scope || window;\r\n\r\n for (var i = 0; i < this.length; i++) {\r\n if (!fn.call(scope, this[i], i)) return false;\r\n\r\n }\r\n return true;\r\n };\r\n }\r\n\r\n if (!_proto.map) {\r\n _proto.map = function (fn, scope) {\r\n if (!fn) return this;\r\n scope = scope || window;\r\n var res = [];\r\n for (var i = 0; i < this.length; i++) {\r\n res.push(fn.call(scope, this[i], i));\r\n }\r\n\r\n return res;\r\n }\r\n }\r\n }\r\n\r\n /**************************** BACKWARDS COMP ************************************/\r\n\r\n /***\r\n * @deprecated use .some\r\n */\r\n _proto.any = _proto.some;\r\n /***\r\n * @deprecated use .every\r\n */\r\n _proto.all = _proto.every;\r\n /***\r\n * @deprecated use .forEach\r\n */\r\n _proto.each = _proto.forEach;\r\n /***\r\n * @deprecated use .filter\r\n */\r\n _proto.where = _proto.filter;\r\n\r\n\r\n /**************************** jQuery support ************************************/\r\n if ('jQuery' in window) {\r\n ['forEach', 'every', 'some', 'sum'].forEach(function (k) {\r\n jQuery.fn[k] = _proto[k];\r\n });\r\n }\r\n\r\n\r\n /**************************** range ************************************/\r\n\r\n var FORMAT_REGXP = /\\{0\\}/g\r\n\r\n /****\r\n * Range function similar to python's range\r\n * @param {Number} start\r\n * @param {Number=} end\r\n * @param {String=} format String of the format 'molsh_{0}_1', the function will an array with the strings and\r\n * replace {0} with the index\r\n * @return {Array}\r\n */\r\n function range(start, end, format) {\r\n var r = [];\r\n\r\n if (!end) {\r\n end = start;\r\n start = 0;\r\n }\r\n\r\n for (var i = start; i < end; i++) {\r\n if (format) {\r\n r.push(format.replace(FORMAT_REGXP, i));\r\n } else {\r\n r.push(i);\r\n }\r\n }\r\n\r\n return r;\r\n }\r\n\r\n return {\r\n toObject:Array.toObject,\r\n keys:objectKeys,\r\n range:range\r\n }\r\n})\r\n;", "define('fire/net/safe', function (require) {\r\n \"use strict\";\r\n\r\n var GENERIC_ERROR_MESSAGE = 'Something went wrong :-/';\r\n var _body = $('body');\r\n\r\n /***\r\n *\r\n * @param {String} uri\r\n * @param {Object=} params\r\n * @param {Function=} successFunc\r\n * @param {Object=} opts\r\n *\r\n * @returns {$.Deferred}\r\n */\r\n function post(uri, params, successFunc, opts) {\r\n params = params || {};\r\n\r\n // add the smore token\r\n $.extend(params, {_token: token()});\r\n\r\n var o = $.extend({\r\n url: uri,\r\n type: 'POST',\r\n success: successFunc,\r\n data: params\r\n }, opts);\r\n\r\n var p = $.ajax(o);\r\n\r\n var call = p.then(handleRequest, handleFailedRequest);\r\n\r\n // setup shorthands for compatibility with $.post\r\n call.success = call.done;\r\n call.error = call.fail;\r\n call.complete = call.always;\r\n\r\n\r\n // compatibility with jqXhr\r\n call.abort = p.abort;\r\n call.setRequestHeader = p.setRequestHeader;\r\n call.getAllResponseHeaders = p.getAllResponseHeaders;\r\n call.getResponseHeader = p.getResponseHeader;\r\n\r\n // handle success callback\r\n if (successFunc) {\r\n call.done(successFunc);\r\n }\r\n return call;\r\n }\r\n\r\n function handleFailedRequest(jqXhr, statusText, error) {\r\n var dfd = $.Deferred();\r\n\r\n if (statusText === 'abort') {\r\n dfd.reject(statusText, jqXhr, error);\r\n } else {\r\n dfd.reject(GENERIC_ERROR_MESSAGE, jqXhr, error);\r\n }\r\n return dfd;\r\n }\r\n\r\n\r\n /****\r\n *\r\n * @param data\r\n * @param textStatus\r\n * @param jqXhr\r\n * @return {jQuery.Deferred}\r\n * @private\r\n */\r\n function handleRequest(data, textStatus, jqXhr) {\r\n // create the new deferred\r\n var dfd = $.Deferred();\r\n // if there is data, and no status information\r\n if (!data || data && !data.status) {\r\n dfd.resolve(data, textStatus, jqXhr);\r\n }\r\n\r\n // if we have status\r\n if (data.status) {\r\n if (data.status === 'success') {\r\n dfd.resolve(data.result, textStatus, jqXhr);\r\n }\r\n\r\n if (data.status === 'error') {\r\n dfd.reject(data.message || GENERIC_ERROR_MESSAGE, data, textStatus, jqXhr);\r\n }\r\n\r\n }\r\n\r\n\r\n // setup shorthands for compatibility with $.post\r\n return dfd;\r\n }\r\n\r\n\r\n function iframeEl(uri, params, fromForm) {\r\n var dfd = $.Deferred();\r\n var i = getIframe();\r\n var name = i.attr('name');\r\n\r\n registerCallback(name, dfd);\r\n\r\n params = $.extend({}, params, {'_iframe_id': name});\r\n\r\n // create a form and submit it\r\n form(uri, params, name, fromForm);\r\n\r\n var p = dfd.promise();\r\n\r\n p.abort = function () {\r\n dfd.reject(\"ABORT\");\r\n };\r\n\r\n return p;\r\n }\r\n\r\n function registerCallback(name, dfd) {\r\n if (!('smore' in window)) {\r\n window.smore = {};\r\n }\r\n\r\n\r\n window.smore[name] = function (data) {\r\n // if there is data, and no status information\r\n if (!data || data && !data.status) {\r\n dfd.resolve(data);\r\n }\r\n\r\n // if we have status\r\n if (data.status) {\r\n if (data.status === 'success') {\r\n dfd.resolve(data.result);\r\n }\r\n\r\n if (data.status === 'error') {\r\n dfd.reject(data.message, data);\r\n }\r\n }\r\n };\r\n\r\n // always remove the callback from the smore object\r\n dfd.always(function () {\r\n delete window.smore[name];\r\n });\r\n }\r\n\r\n\r\n var HIDDEN_CSS = {\r\n 'visibility': 'hidden',\r\n 'width': 1,\r\n 'height': 1,\r\n 'position': 'absolute',\r\n 'left': -10000,\r\n 'top': -10000\r\n };\r\n\r\n\r\n var _iframeId = 0;\r\n\r\n function getIframe() {\r\n\r\n var name = 'iframe_name_' + (++_iframeId);\r\n\r\n var iframeEl = $('')\r\n .css(HIDDEN_CSS)\r\n .attr('name', name);\r\n\r\n $(document.body).append(iframeEl);\r\n\r\n\r\n return iframeEl;\r\n }\r\n\r\n /***\r\n * Store the token\r\n *\r\n * @type {String|Function}\r\n * @private\r\n */\r\n var _token = '';\r\n\r\n /***\r\n * Gets or sets the token\r\n * @param {string|Function=} val\r\n * @return {*}\r\n */\r\n function token(val) {\r\n if (val) {\r\n _token = val;\r\n }\r\n\r\n // If we have a function stored\r\n if (typeof _token === 'function') {\r\n return _token();\r\n }\r\n\r\n return _token;\r\n }\r\n\r\n\r\n function form(uri, params, targetFrame, form) {\r\n params = $.extend({'_token': token()}, params);\r\n\r\n if (!form) {\r\n form = $('')\r\n .css(HIDDEN_CSS)\r\n .appendTo(_body);\r\n }\r\n\r\n\r\n form.attr({\r\n method: 'POST',\r\n // the target frame\r\n target: targetFrame,\r\n // the action uri\r\n action: uri,\r\n enctype: 'multipart/form-data'\r\n });\r\n\r\n for (var k in params) {\r\n $('').attr({\r\n name: k,\r\n type: 'hidden'\r\n })\r\n .appendTo(form)\r\n .val(params[k]);\r\n }\r\n\r\n form.submit();\r\n }\r\n\r\n function callbackForm(uri, params, targetFrame, baseForm, callbackParam) {\r\n callbackParam = callbackParam || 'cb';\r\n\r\n var cbName = 'form_cb_name_' + (++_iframeId);\r\n\r\n var dfd = $.Deferred();\r\n\r\n registerCallback(cbName, dfd);\r\n\r\n var base = {};\r\n base[callbackParam] = cbName;\r\n\r\n params = $.extend(base, params);\r\n\r\n form(uri, params, targetFrame, baseForm);\r\n\r\n return dfd;\r\n }\r\n\r\n\r\n return {\r\n token: token,\r\n post: post,\r\n iframe: iframeEl,\r\n form: form,\r\n callbackForm: callbackForm\r\n };\r\n});\r\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('fire/ui/forms/validators', function(require) {\n var RequiredValidator, VALIDATORS, Validator, fromField;\n VALIDATORS = [];\n Validator = (function() {\n function Validator(field1) {\n this.field = field1;\n null;\n }\n\n Validator.prototype.validate = function() {\n throw 'NotImplemented';\n };\n\n return Validator;\n\n })();\n RequiredValidator = (function(superClass) {\n var DEFAULT_REQUIRED_MESSAGE;\n\n extend(RequiredValidator, superClass);\n\n DEFAULT_REQUIRED_MESSAGE = 'This field is required';\n\n function RequiredValidator() {\n RequiredValidator.__super__.constructor.apply(this, arguments);\n this.message = this.field.options.required;\n if (this.message === true) {\n this.message = DEFAULT_REQUIRED_MESSAGE;\n }\n }\n\n RequiredValidator.prototype.validate = function() {\n if (this.field.isEmpty()) {\n return this.message;\n }\n };\n\n RequiredValidator.isFieldMatch = function(field) {\n return field.options.required;\n };\n\n return RequiredValidator;\n\n })(Validator);\n VALIDATORS.push(RequiredValidator);\n fromField = function(fieldView) {\n\n /*\n Get a list of validators for the given field\n \n We will iterate over all the registered validators and their 'isFieldMatch' static method\n */\n var i, len, result, validatorClass;\n result = [];\n for (i = 0, len = VALIDATORS.length; i < len; i++) {\n validatorClass = VALIDATORS[i];\n if (validatorClass.isFieldMatch(fieldView)) {\n result.push(new validatorClass(fieldView));\n }\n }\n return result;\n };\n return {\n fromField: fromField\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('fire/ui/forms/fieldView', function(require) {\n var FieldView, validators, vw;\n vw = require('fire/ui/view');\n validators = require('./validators');\n FieldView = (function(superClass) {\n extend(FieldView, superClass);\n\n function FieldView() {\n return FieldView.__super__.constructor.apply(this, arguments);\n }\n\n FieldView.prototype.render = function() {\n this.name = this.options.name || this.el.attr('name');\n this.id = this.options.id || this.el.attr('id');\n this.el.attr({\n 'name': this.name,\n 'id': this.id\n });\n this.setupInputEvents(this.el);\n return this.setupValidators();\n };\n\n FieldView.prototype.setupInputEvents = function(inputEl) {\n\n /*\n Register different input events\n */\n inputEl.on('focus', (function(_this) {\n return function(e) {\n return _this.onInputFocus(e);\n };\n })(this));\n return inputEl.on('blur', (function(_this) {\n return function(e) {\n return _this.onInputBlur(e);\n };\n })(this));\n };\n\n FieldView.prototype.setupValidators = function() {\n\n /*\n Initalize validation classes for the field\n */\n return this.validators = validators.fromField(this);\n };\n\n FieldView.prototype.onInputFocus = function(e) {\n return this.addModifier('active');\n };\n\n FieldView.prototype.onInputBlur = function(e) {\n return this.removeModifier('active');\n };\n\n FieldView.prototype.onChanged = function() {\n\n /*\n An internal event to update the empty modifier and status\n */\n if (this.isEmpty()) {\n this.addModifier('empty');\n } else {\n this.removeModifier('empty');\n }\n return this.setValid();\n };\n\n FieldView.prototype.validateField = function() {\n\n /*\n Start the validation of the field\n */\n var error;\n this.setValid();\n error = this.validate();\n if (error) {\n this.setInvalid(error);\n return false;\n }\n return true;\n };\n\n FieldView.prototype.validate = function() {\n\n /*\n handle the field validation.\n \n Returns\n - nothing if the field is valid\n - String if the field is invalid, the string will be used as the message\n */\n var error, i, len, ref, v;\n ref = this.validators;\n for (i = 0, len = ref.length; i < len; i++) {\n v = ref[i];\n error = v.validate();\n if (error) {\n return error;\n }\n }\n };\n\n FieldView.prototype.value = function() {\n\n /*\n Extract the value from the field\n */\n return $.trim(this.el.val());\n };\n\n FieldView.prototype.isEmpty = function() {\n\n /*\n Is this field empty\n */\n return !this.value();\n };\n\n FieldView.prototype.errorSpan = function() {\n\n /*\n Returns the error span element if available\n \n Error element id should be {original-field-id}-error.\n \n Returns\n - jQuery element for the errorSpan\n */\n return $(\"#\" + this.id + \"-error\");\n };\n\n FieldView.prototype.setInvalid = function(message) {\n\n /*\n Show the error label, mark the field as invalid\n \n Params:\n - message The message to show in the error label\n */\n this.addModifier('invalid');\n this.trigger('invalid', this);\n return this.errorSpan().show().text(message);\n };\n\n FieldView.prototype.setValid = function() {\n\n /*\n Mark the field as valid\n */\n this.removeModifier('invalid');\n this.trigger('valid', this);\n return this.errorSpan().hide();\n };\n\n FieldView.prototype.enable = function() {\n\n /*\n Enables the field\n */\n return this.removeModifier('disabled');\n };\n\n FieldView.prototype.disable = function() {\n\n /*\n Disables the field\n */\n return this.addModifier('disabled');\n };\n\n FieldView.prototype.focus = function() {\n\n /*\n Sets the focus on the field\n */\n return this.el.focus();\n };\n\n FieldView.fromEl = function(el) {\n\n /*\n Creates a new FieldView instance for the given element\n \n FieldView subsclasses needs to register themselves using FieldView.register(selector, subclass)\n \n For example, if we want to have a special FieldView for checkboxes, we'll use\n FieldView.register('input[type=checkbox]', CheckboxFieldView)\n \n \n Params:\n - el The element that we're creating a FieldView for\n */\n var i, item, len, selectors;\n el = $(el);\n selectors = FieldView.selectors;\n for (i = 0, len = selectors.length; i < len; i++) {\n item = selectors[i];\n if (el.is(item.selector)) {\n return new item.subclass({\n el: el\n });\n }\n }\n console.error(\"Can't find FieldView for \", el);\n throw \"Can't find a FieldView for the field \" + el;\n };\n\n FieldView.selectors = [];\n\n FieldView.register = function(selector, subclass) {\n\n /*\n * Registers FieldView subclass to a given selector.\n * When the FieldView.fromEl(el) static method is called, it will try to match\n * The field element to the selector. if the selector matches, it will instantiate the subclass\n *\n * Params:\n * - selector a selector to test the field with\n * - subclass The subclass of FieldView to instantiate if the selector matches\n */\n return FieldView.selectors.push({\n selector: selector,\n subclass: subclass\n });\n };\n\n return FieldView;\n\n })(vw.View);\n return {\n FieldView: FieldView\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('fire/ui/forms/fields/textFieldView', function(require) {\n var FIELD_VIEW_SELECTOR, TextFieldView, fv;\n FIELD_VIEW_SELECTOR = 'input[type=text],input[type=email],input[type=search],input[type=url],input[type=password],select,textarea';\n fv = require('fire/ui/forms/fieldView');\n TextFieldView = (function(superClass) {\n extend(TextFieldView, superClass);\n\n function TextFieldView() {\n return TextFieldView.__super__.constructor.apply(this, arguments);\n }\n\n TextFieldView.prototype.setupInputEvents = function() {\n TextFieldView.__super__.setupInputEvents.apply(this, arguments);\n this.el.on('input keyup', (function(_this) {\n return function(e) {\n return _this.onInput(e);\n };\n })(this));\n return this.el.on('paste cut', (function(_this) {\n return function(e) {\n return _this.onClipboardTextChanged(e);\n };\n })(this));\n };\n\n TextFieldView.prototype.onInput = function(e) {\n\n /*\n Handle key up events\n \n Params:\n - e jQuery.Event\n */\n return this.onChanged();\n };\n\n TextFieldView.prototype.onClipboardTextChanged = function(e) {\n\n /*\n Handle cut/paste events\n \n Params:\n - e jQuery.Event\n */\n return this.onChanged();\n };\n\n TextFieldView.prototype.disable = function() {\n\n /*\n Disable the field\n */\n TextFieldView.__super__.disable.apply(this, arguments);\n return this.el.attr('disabled', true);\n };\n\n TextFieldView.prototype.enable = function() {\n\n /*\n Enable the field\n */\n TextFieldView.__super__.enable.apply(this, arguments);\n return this.el.removeAttr('disabled');\n };\n\n return TextFieldView;\n\n })(fv.FieldView);\n fv.FieldView.register(FIELD_VIEW_SELECTOR, TextFieldView);\n return {\n TextFieldView: TextFieldView\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('fire/ui/forms/fields/checkboxFieldView', function(require) {\n var CheckboxFieldView, FIELD_VIEW_SELECTOR, fv;\n FIELD_VIEW_SELECTOR = 'input[type=checkbox]';\n fv = require('fire/ui/forms/fieldView');\n CheckboxFieldView = (function(superClass) {\n extend(CheckboxFieldView, superClass);\n\n function CheckboxFieldView() {\n return CheckboxFieldView.__super__.constructor.apply(this, arguments);\n }\n\n CheckboxFieldView.prototype.value = function() {\n\n /*\n Extract the value from the field\n */\n return this.el.is(':checked');\n };\n\n return CheckboxFieldView;\n\n })(fv.FieldView);\n fv.FieldView.register(FIELD_VIEW_SELECTOR, CheckboxFieldView);\n return {\n CheckboxFieldView: CheckboxFieldView\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('fire/ui/forms/fields/radioFieldView', function(require) {\n var FIELD_VIEW_SELECTOR, RadioFieldView, fv;\n FIELD_VIEW_SELECTOR = 'div.radio-container';\n fv = require('fire/ui/forms/fieldView');\n RadioFieldView = (function(superClass) {\n extend(RadioFieldView, superClass);\n\n function RadioFieldView() {\n return RadioFieldView.__super__.constructor.apply(this, arguments);\n }\n\n RadioFieldView.prototype.value = function() {\n\n /*\n Extract the value from the field\n */\n return this.el.find('input:radio:checked').val();\n };\n\n RadioFieldView.prototype.setupInputEvents = function() {\n var radios;\n RadioFieldView.__super__.setupInputEvents.apply(this, arguments);\n radios = this.el.find('input:radio');\n radios.on('focus', (function(_this) {\n return function(e) {\n return _this.onInputFocus(e);\n };\n })(this));\n radios.on('blur', (function(_this) {\n return function(e) {\n return _this.onInputBlur(e);\n };\n })(this));\n return radios.on('change', (function(_this) {\n return function(e) {\n return _this.onChanged();\n };\n })(this));\n };\n\n return RadioFieldView;\n\n })(fv.FieldView);\n fv.FieldView.register(FIELD_VIEW_SELECTOR, RadioFieldView);\n return {\n RadioFieldView: RadioFieldView\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('fire/ui/forms/fields/hiddenFieldView', function(require) {\n var FIELD_VIEW_SELECTOR, HiddenFieldView, fv;\n FIELD_VIEW_SELECTOR = 'input[type=hidden]';\n fv = require('fire/ui/forms/fieldView');\n HiddenFieldView = (function(superClass) {\n extend(HiddenFieldView, superClass);\n\n function HiddenFieldView() {\n return HiddenFieldView.__super__.constructor.apply(this, arguments);\n }\n\n HiddenFieldView.prototype.setupInputEvents = function() {\n return HiddenFieldView.__super__.setupInputEvents.apply(this, arguments);\n };\n\n HiddenFieldView.prototype.disable = function() {\n\n /*\n Disable the field\n */\n HiddenFieldView.__super__.disable.apply(this, arguments);\n return this.el.attr('disabled', true);\n };\n\n HiddenFieldView.prototype.enable = function() {\n\n /*\n Enable the field\n */\n HiddenFieldView.__super__.enable.apply(this, arguments);\n return this.el.removeAttr('disabled');\n };\n\n return HiddenFieldView;\n\n })(fv.FieldView);\n fv.FieldView.register(FIELD_VIEW_SELECTOR, HiddenFieldView);\n return {\n HiddenFieldView: HiddenFieldView\n };\n});\n", "// Generated by CoffeeScript 1.12.3\n\n/*\n * Fields loader\n * ==============\n *\n * This module loads the common fields from the fields folder.\n *\n * Require this file instead of the fieldView file\n */\ndefine('fire/ui/forms/fields', function(require) {\n var fv;\n fv = require('./fieldView');\n require('./fields/textFieldView');\n require('./fields/checkboxFieldView');\n require('./fields/radioFieldView');\n require('./fields/hiddenFieldView');\n return {\n FieldView: fv.FieldView\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty,\n indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };\n\ndefine('fire/ui/forms/formView', function(require) {\n var ErrorCollection, FormView, arr, fv, mobile, safe, vw;\n arr = require('fire/util/array');\n vw = require('fire/ui/view');\n safe = require('fire/net/safe');\n fv = require('./fields');\n mobile = require('fire/util/mobile');\n FormView = (function(superClass) {\n var ERROR_BOX_SELECTOR, SUBMIT_BUTTON_SELECTOR;\n\n extend(FormView, superClass);\n\n function FormView() {\n return FormView.__super__.constructor.apply(this, arguments);\n }\n\n SUBMIT_BUTTON_SELECTOR = '.submit-button,input[type=submit]';\n\n ERROR_BOX_SELECTOR = '.error-box';\n\n FormView.prototype.cssClass = 'form-view';\n\n FormView.prototype.defaultOptions = {\n pleaseWaitText: 'Please Wait...',\n fieldSelector: '.form-field',\n deliveryMethod: 'ajax',\n validationErrorMessage: 'Some of the fields are invalid.',\n deliveryDelay: 300\n };\n\n FormView.prototype.render = function() {\n\n /*\n Setup all the fields, etc\n */\n this.setupFields();\n this.setupSubmitButton();\n this.errorBox = this.find(ERROR_BOX_SELECTOR).hide();\n if (!this.options.action) {\n return this.options.action = this.el.attr('action');\n }\n };\n\n FormView.prototype.setupFields = function() {\n\n /*\n Initialize the fields for the form\n */\n var el, j, len, ref, results1;\n this.fields = [];\n ref = this.find(this.options.fieldSelector);\n results1 = [];\n for (j = 0, len = ref.length; j < len; j++) {\n el = ref[j];\n results1.push(this.fields.push(new fv.FieldView.fromEl(el)));\n }\n return results1;\n };\n\n FormView.prototype.setupSubmitButton = function() {\n\n /*\n Setup the submit button text\n */\n this.submitButton = this.find(SUBMIT_BUTTON_SELECTOR);\n if (this.options.submitText) {\n this.submitButtonText(this.options.submitText);\n } else {\n this.options.submitText = $.trim(this.submitButtonText());\n }\n return this.submitButton.click((function(_this) {\n return function(e) {\n return _this.onSubmitButtonClicked(e);\n };\n })(this));\n };\n\n FormView.prototype.onSubmitButtonClicked = function(e) {\n\n /*\n Handle clicks on the submission button\n */\n e.stopPropagation();\n e.preventDefault();\n return this.submit();\n };\n\n FormView.prototype.submit = function() {\n\n /*\n Tries to send the form\n \n Returns:\n true if the form was delivered, false if not\n */\n if (this.hasModifier('disabled') || this.hasModifier('submitting')) {\n return false;\n }\n if (this.validateForm()) {\n this.deliverForm();\n return true;\n }\n return false;\n };\n\n FormView.prototype.reset = function() {\n\n /*\n Clear the form\n */\n this.cleanup();\n this.hideErrors();\n return this.el[0].reset();\n };\n\n FormView.prototype.deliverForm = function() {\n\n /*\n Delivers the form, returns a deferred with completion/failure handling\n */\n var p, params, url;\n this.addModifier('submitting');\n this.trigger('submitstart', this);\n this.submitButtonText(this.options.pleaseWaitText);\n this.disable();\n params = this.values();\n url = this.options.action;\n p = $.Deferred();\n switch (this.options.deliveryMethod) {\n case 'ajax':\n p = safe.post(url, params);\n break;\n case 'form':\n safe.form(url, params);\n break;\n case 'iframe':\n p = safe.iframe(url, params);\n break;\n default:\n throw \"Bad deliveryMethod: \" + this.options.deliveryMethod;\n }\n p.done((function(_this) {\n return function(result) {\n return _this.onDeliveryCompleted(result);\n };\n })(this));\n p.fail((function(_this) {\n return function(error, data) {\n return _this.onDeliveryFailed(error, data);\n };\n })(this));\n return p.promise();\n };\n\n FormView.prototype.onDeliveryCompleted = function(result) {\n\n /*\n Handles the successful completion of the form\n \n Params:\n - form The FormView\n - result The response from the server\n */\n this.result = result;\n return setTimeout((function(_this) {\n return function() {\n _this.trigger('success', _this, result);\n return _this.cleanup();\n };\n })(this), this.options.deliveryDelay);\n };\n\n FormView.prototype.onDeliveryFailed = function(error, data) {\n\n /*\n Handles a failed submission of the form\n \n Params:\n - error Error message\n - data Error result from the server\n */\n this.result = null;\n return setTimeout((function(_this) {\n return function() {\n _this.errors = new ErrorCollection();\n _this.processServerErrors(error, data, _this.errors);\n _this.trigger('fail', _this, _this.error);\n _this.showErrors();\n return _this.cleanup();\n };\n })(this), this.options.deliveryDelay);\n };\n\n FormView.prototype.processServerErrors = function(message, data, error_collection) {\n\n /*\n Process the server error. return a proper error\n \n Params:\n - message The error value returned from the server\n - data The error data response from the server\n - error_collection The error collection. Implementations should append the errors to the collection\n */\n return error_collection.add('server_error', message, 'server_error');\n };\n\n FormView.prototype.cleanup = function() {\n\n /*\n Clean up the form\n */\n this.removeModifier('submitting');\n this.trigger('submitcomplete', this);\n this.submitButtonText(this.options.submitText);\n return this.enable();\n };\n\n FormView.prototype.submitButtonText = function(text) {\n\n /*\n Sets the submit button text\n */\n if (this.submitButton.is('input')) {\n if (text) {\n return this.submitButton.val(text);\n }\n return this.submitButton.val();\n }\n if (text) {\n return this.submitButton.text(text);\n }\n return this.submitButton.text();\n };\n\n FormView.prototype.values = function() {\n\n /*\n Extract the fields and get the values\n */\n var f, j, len, ref, values;\n values = $.extend({}, this.options.extraParams);\n ref = this.fields;\n for (j = 0, len = ref.length; j < len; j++) {\n f = ref[j];\n values[f.name] = f.value();\n }\n return values;\n };\n\n FormView.prototype.validateForm = function() {\n\n /*\n Validates the fields and call a custom validation method\n \n Returns:\n true if the form is valid, false if not\n */\n var field, results;\n this.errors = new ErrorCollection();\n this.validate(this.fields, this.errors);\n results = (function() {\n var j, len, ref, results1;\n ref = this.fields;\n results1 = [];\n for (j = 0, len = ref.length; j < len; j++) {\n field = ref[j];\n results1.push(field.validateField());\n }\n return results1;\n }).call(this);\n if (indexOf.call(results, false) >= 0) {\n this.errors.add('validation_error', this.options.validationErrorMessage);\n }\n if (this.errors.length) {\n this.trigger('invalid', this);\n this.addModifier('invalid');\n this.showErrors();\n return false;\n } else {\n this.trigger('valid', this);\n this.removeModifier('invalid');\n this.hideErrors();\n return true;\n }\n };\n\n FormView.prototype.validate = function(fields, errorCollecion) {\n\n /*\n An extra validation method that can be overriden by implemntations\n \n Params\n - fields A list of FieldView objects\n - errorCollection An ErrorCollection object that can be used to add errors to the form\n */\n return null;\n };\n\n FormView.prototype.showErrors = function() {\n\n /*\n Show the active errors\n */\n var e, h, j, len, ref;\n h = '';\n ref = this.errors.errors;\n for (j = 0, len = ref.length; j < len; j++) {\n e = ref[j];\n if (e.description) {\n h += \"
\" + e.description + \"
\";\n }\n }\n if (h) {\n return this.errorBox.html(h).show();\n }\n };\n\n FormView.prototype.setError = function(message) {\n\n /*\n Override the errors with a custom message, show errors\n \n Params:\n - message Error message to show\n */\n this.errors = new ErrorCollection();\n this.errors.add('custom', message);\n return this.showErrors();\n };\n\n FormView.prototype.hideErrors = function() {\n\n /*\n Hide the errors\n */\n return this.errorBox.hide();\n };\n\n FormView.prototype.disable = function() {\n\n /*\n Disable the form.\n \n This method will:\n - Add the `disabled` modifier to the form\n - Call the `disable` method for all of the fields\n - Add the `is-disabled` class to the submit button\n */\n var f, j, len, ref;\n this.addModifier('disabled');\n ref = this.fields;\n for (j = 0, len = ref.length; j < len; j++) {\n f = ref[j];\n f.disable();\n }\n return this.submitButton.addClass('is-disabled');\n };\n\n FormView.prototype.enable = function() {\n\n /*\n Enables the form\n \n This method will:\n - Remove the `disabled` modifier from the form\n - Call the `enable` method for all of the fields\n - Remove the `is-disabled` class from the submit button\n */\n var f, j, len, ref;\n this.removeModifier('disabled');\n ref = this.fields;\n for (j = 0, len = ref.length; j < len; j++) {\n f = ref[j];\n f.enable();\n }\n return this.submitButton.removeClass('is-disabled');\n };\n\n FormView.prototype.field = function(fieldName) {\n\n /*\n Gets an instance of a field by name\n */\n return this.fields.filter(function(i) {\n return i.name === fieldName;\n })[0];\n };\n\n FormView.prototype.focus = function(fieldName) {\n var ref, ref1;\n if (fieldName == null) {\n fieldName = null;\n }\n\n /*\n Focus the form.\n \n If a field name is given, the form will try to focus on that field\n If not - the form will focus on the first element\n \n Params:\n - fieldName (Optional) The field name to try and focus on\n */\n if (mobile.isPhone()) {\n return;\n }\n if (fieldName) {\n return (ref = this.field(fieldName)) != null ? ref.focus() : void 0;\n } else {\n return (ref1 = this.fields[0]) != null ? ref1.focus() : void 0;\n }\n };\n\n return FormView;\n\n })(vw.View);\n ErrorCollection = (function() {\n function ErrorCollection() {\n this.clear();\n }\n\n ErrorCollection.prototype.add = function(name, description, type) {\n if (type == null) {\n type = null;\n }\n this.errors.push({\n name: name,\n description: description,\n type: type\n });\n return this.length += 1;\n };\n\n ErrorCollection.prototype.clear = function() {\n this.errors = [];\n return this.length = 0;\n };\n\n return ErrorCollection;\n\n })();\n return {\n FormView: FormView\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('smore/ui/login/signupFormView', function(require) {\n var SignupFormView, fv;\n fv = require('fire/ui/forms/formView');\n SignupFormView = (function(superClass) {\n extend(SignupFormView, superClass);\n\n function SignupFormView() {\n SignupFormView.__super__.constructor.apply(this, arguments);\n this.options.validationErrorMessage = '';\n }\n\n SignupFormView.prototype.processServerErrors = function(errorMessage, errorData, errorCollection) {\n\n /*\n Process the server error. return a proper error\n \n Params:\n - errorMessage The error value returned from the server\n - errorData The error data, as returned from the server\n - errorCollection The error collection. Implementations should append the errors to the collection\n */\n var field, firstProblem, i, len, p, problem, problems, ref;\n switch (errorMessage) {\n case 'invalid':\n problems = errorData.code;\n firstProblem = '';\n for (i = 0, len = problems.length; i < len; i++) {\n p = problems[i];\n field = p[0], problem = p[1];\n if ((ref = this.field(field)) != null) {\n ref.setInvalid(problem);\n }\n firstProblem = firstProblem || problem;\n }\n return errorCollection.add('invalid', false);\n case 'tryfacebook':\n return errorCollection.add('tryfacebook', 'Try logging in with your Facebook account.');\n case 'tryemail':\n return errorCollection.add('tryemail', 'Try logging in with email.');\n case 'user exists':\n return errorCollection.add('user exists', 'We already have a user with that email.', 'field_error', {\n target: 'email'\n });\n default:\n return errorCollection.add('unkown', 'Something is broken. Try again later :(');\n }\n };\n\n return SignupFormView;\n\n })(fv.FormView);\n return {\n SignupFormView: SignupFormView\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('smore/ui/login/loginFormView', function(require) {\n var LoginFormView, fv;\n fv = require('fire/ui/forms/formView');\n LoginFormView = (function(superClass) {\n extend(LoginFormView, superClass);\n\n function LoginFormView() {\n LoginFormView.__super__.constructor.apply(this, arguments);\n this.options.validationErrorMessage = '';\n }\n\n LoginFormView.prototype.processServerErrors = function(errorMessage, errorData, errorCollection) {\n\n /*\n Process the server error. return a proper error\n \n Params:\n - errorMessage The error value returned from the server\n - errorData The error data, as returned from the server\n - errorCollection The error collection. Implementations should append the errors to the collection\n */\n switch (errorMessage) {\n case 'tryfacebook':\n return errorCollection.add('tryfacebook', 'Try logging in with your Facebook account.');\n case 'invaliduser':\n return errorCollection.add('invaliduser', 'Please enter your email', 'field_error', {\n target: 'email'\n });\n case 'nouser':\n return errorCollection.add('nouser', 'Not registered', 'field_error', {\n target: 'email'\n });\n case 'tryemail':\n return errorCollection.add('tryemail', 'Try logging in with email.');\n case 'badpassword':\n return errorCollection.add('badpassword', 'Password is incorrect. Did you forget it?', 'field_error', {\n target: 'email'\n });\n default:\n return errorCollection.add('unkown', 'Something is broken. Try again later :(');\n }\n };\n\n return LoginFormView;\n\n })(fv.FormView);\n return {\n LoginFormView: LoginFormView\n };\n});\n", "define('fire/util/strings', function(require) {\r\n\r\n var _proto = String.prototype;\r\n\r\n /****\r\n * Simple string format\r\n *\r\n * format('molsh {0}', 'dolsh')\r\n * => 'molsh dolsh'\r\n *\r\n * @param {String} string\r\n * @param {...string} varArgs\r\n * @returns {string}\r\n */\r\n function format(string, varArgs) {\r\n var s = arguments[0];\r\n for (var i = 0; i < arguments.length - 1; i++) {\r\n var reg = new RegExp(\"\\\\{\" + i + \"\\\\}\", \"gm\");\r\n s = s.replace(reg, arguments[i + 1]);\r\n }\r\n\r\n return s;\r\n }\r\n\r\n // shortcut\r\n _proto.format = format;\r\n\r\n return {\r\n format: format\r\n };\r\n});", "define('fire/net/popup', function (require) {\r\n var str = require('fire/util/strings');\r\n\r\n var NO_DATA_CODE = 'NO_DATA';\r\n var POPUP_CLOSED = 'POPUP_CLOSED';\r\n\r\n /*****\r\n * Opens a popup to the given url with the given width/height.\r\n *\r\n * Returns a deferred object that will be resolved with the value returned from the popup.\r\n *\r\n * This method generates a callback inside the window object and cleans up afterwards.\r\n * The generated callback name is than sent with the url, so the popup will use it to resolve the call\r\n *\r\n * The deferred will be rejected if:\r\n * - The server returned an error\r\n * - The popup was closed before it was resolved\r\n *\r\n *\r\n * The results from the server should be in the form:\r\n *\r\n * Success:\r\n * {status: 'success', result: }\r\n *\r\n * Error:\r\n * {status: 'error', message: }\r\n *\r\n *\r\n * @param {String} url the url for the popup\r\n * @param {Number} width popup width\r\n * @param {Number} height popup height\r\n * @param {String=} callbackParam an optional callback param. defaults to 'cb'\r\n *\r\n * @returns {jQuery.Deferred}\r\n */\r\n function popup(url, width, height, callbackParam) {\r\n if (!url) {\r\n throw \"Url must be defined!\";\r\n }\r\n\r\n // setup defaults\r\n callbackParam = callbackParam || 'cb';\r\n\r\n // create a new deferred\r\n var dfd = $.Deferred();\r\n\r\n // setup callback name\r\n var cbName = '__pop_cb_' + (++_callbackId);\r\n\r\n\r\n // an inner function to handle the result\r\n function handleResult(data) {\r\n // do nothing if we already handled it\r\n if (dfd.state() !== 'pending') {\r\n return;\r\n }\r\n\r\n // if there is no data or data is from an unexpected type\r\n if (!data || typeof data !== 'object') {\r\n // reject it\r\n dfd.reject('NO_DATA');\r\n }\r\n\r\n // Switch by status code\r\n switch (data.status) {\r\n case 'success':\r\n dfd.resolve(data.result);\r\n break;\r\n case 'error':\r\n dfd.reject(data.message);\r\n break;\r\n default:\r\n dfd.reject(NO_DATA_CODE);\r\n }\r\n\r\n // cleanup\r\n delete window[cbName];\r\n }\r\n\r\n // store the\r\n window[cbName] = handleResult;\r\n\r\n // setup the url\r\n var popUrl = setupUrl(url, callbackParam, cbName);\r\n\r\n //console.debug(\"Opening popup\", popUrl);\r\n\r\n // open the popup\r\n var popRef = openPopup(popUrl, width, height, function () {\r\n handleResult({status: 'error', message: POPUP_CLOSED});\r\n });\r\n\r\n // return a read only promise\r\n var promise = dfd.promise();\r\n\r\n // add an abort method\r\n promise.abort = function () {\r\n tryAbort(popRef, dfd);\r\n };\r\n\r\n return promise;\r\n }\r\n\r\n\r\n /***\r\n * We store the callback id\r\n * @type {Number}\r\n * @private\r\n */\r\n var _callbackId = 0;\r\n\r\n\r\n /****\r\n * Generate a url with the callback name and param\r\n * @param {String} url\r\n * @param {String} callbackParam\r\n * @param {String} cbName\r\n *\r\n * @returns {String} the url with the callback\r\n */\r\n function setupUrl(url, callbackParam, cbName) {\r\n\r\n var cb = callbackParam + '=' + cbName;\r\n\r\n // Support for placeholder\r\n if (url.indexOf('%{cb}') !== -1) {\r\n return url.replace('%{cb}', cb);\r\n }\r\n\r\n\r\n // do we have a ? inside the url?\r\n if (url.indexOf('?') === -1) {\r\n // not? just add the cb with a ?\r\n return url + '?' + cb;\r\n } else {\r\n return url + '&' + cb;\r\n }\r\n }\r\n\r\n /***\r\n * Opens the popup, fires the closeCb function when it is closed\r\n *\r\n * @param {String} url\r\n * @param {Number} width\r\n * @param {Number} height\r\n * @param {Function} closeCb\r\n * @param {String} frameName\r\n */\r\n function openPopup(url, width, height, closeCb, frameName) {\r\n var popup = window.open(url, frameName || '', popupSettings(width, height));\r\n\r\n // create an interval that test the popup\r\n var interval = setInterval(function () {\r\n // die if it's still open\r\n if (popup && !popup.closed) {\r\n return;\r\n }\r\n // else:\r\n\r\n // stop interval\r\n clearInterval(interval);\r\n\r\n // call the closeCb:\r\n closeCb();\r\n }, 20);\r\n\r\n return popup;\r\n }\r\n\r\n /***\r\n * Tries to abort the given popup\r\n * @param popRef\r\n * @param {jQuery.Deferred} dfd\r\n */\r\n function tryAbort(popRef, dfd) {\r\n // if the popup is already resolved, exit\r\n if (dfd.state() !== 'pending') {\r\n return;\r\n }\r\n\r\n // try to close the popup\r\n try {\r\n popRef.close();\r\n } catch (e) {\r\n // no-op\r\n }\r\n }\r\n\r\n /***\r\n *\r\n * @param width\r\n * @param height\r\n * @returns {String} a string that represent popup settings\r\n */\r\n function popupSettings(width, height) {\r\n return str.format('width={0},height={1},location=no,status=no', width, height);\r\n }\r\n\r\n\r\n return {\r\n open: popup,\r\n openPopup: openPopup\r\n };\r\n});", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('smore/ui/login/facebookConnectView', function(require) {\n var FacebookConnectView, popup, vw;\n vw = require('fire/ui/view');\n popup = require('fire/net/popup');\n FacebookConnectView = (function(superClass) {\n var POPUP_SIZE;\n\n extend(FacebookConnectView, superClass);\n\n function FacebookConnectView() {\n return FacebookConnectView.__super__.constructor.apply(this, arguments);\n }\n\n POPUP_SIZE = {\n width: 600,\n height: 450\n };\n\n FacebookConnectView.prototype.cssClass = 'facebook-connect-button';\n\n FacebookConnectView.prototype.events = {\n 'click': 'onConnectClicked'\n };\n\n FacebookConnectView.prototype.defaultOptions = {\n pleaseWaitText: 'Please wait...',\n connectUrl: '/app/users/connect'\n };\n\n FacebookConnectView.prototype.render = function() {\n\n /*\n */\n this.textSpan = this.find('.text-content');\n if (this.options.text) {\n return this.textSpan.text(this.options.text);\n } else {\n return this.options.text = $.trim(this.textSpan.text());\n }\n };\n\n FacebookConnectView.prototype.onConnectClicked = function(e) {\n\n /*\n Hanldes clicks on the button element\n */\n if (this.hasModifier('disabled') || this.hasModifier('connecting')) {\n return;\n }\n this.addModifier('connecting');\n this.trigger('connectstart', this);\n this.disable();\n this.textSpan.text(this.options.pleaseWaitText);\n this.popup = popup.open(this.generateUrl(), POPUP_SIZE.width, POPUP_SIZE.height);\n this.popup.done((function(_this) {\n return function(r) {\n return _this.onPopupComplete(r);\n };\n })(this));\n return this.popup.fail((function(_this) {\n return function(r) {\n return _this.onPopupFailed(r);\n };\n })(this));\n };\n\n FacebookConnectView.prototype.generateUrl = function() {\n\n /*\n Generate url for the connect popup\n \n We're composing the url from three parts\n - options.connectUrl\n - options.buttonId\n - options.connectParams\n */\n var params, query, url;\n params = $.extend({}, this.options.connectParams);\n if (this.options.buttonId) {\n params['signup_button'] = this.options.buttonId;\n }\n if (this.options.signupSegment) {\n params['segment'] = this.options.signupSegment;\n }\n query = $.param(params);\n url = this.options.connectUrl;\n if (url.indexOf('?') > 0) {\n url += '&';\n } else {\n url += '?';\n }\n return url + query;\n };\n\n FacebookConnectView.prototype.onPopupComplete = function(result) {\n\n /*\n When the popup action is completed\n */\n var connectType;\n if (result.is_new) {\n connectType = 'signup';\n } else {\n connectType = 'login';\n }\n this.trigger('success', this, connectType, result);\n this.trigger(connectType, this, result);\n return this.cleanup();\n };\n\n FacebookConnectView.prototype.onPopupFailed = function(message) {\n\n /*\n When the popup action has failed\n */\n switch (message) {\n case 'POPUP_CLOSED':\n case 'fb_cancel':\n this.trigger('cancel', this);\n break;\n default:\n this.trigger('fail', this, message);\n }\n return this.cleanup();\n };\n\n FacebookConnectView.prototype.cleanup = function() {\n\n /*\n Clean up after successful/failed connection.\n We need to enable buttons and remove connecting modifier\n */\n this.textSpan.text(this.options.text);\n this.removeModifier('connecting');\n this.trigger('connectcomplete', this);\n this.enable();\n return this.popup.abort();\n };\n\n FacebookConnectView.prototype.enable = function() {\n\n /*\n Enables the button\n */\n return this.removeModifier('disabled');\n };\n\n FacebookConnectView.prototype.disable = function() {\n\n /*\n Disables the button\n */\n return this.addModifier('disabled');\n };\n\n FacebookConnectView.prototype.beforeRemove = function() {\n\n /*\n Before remove, cleanup some resources, abort the popup etc\n */\n var ref;\n return (ref = this.popup) != null ? ref.abort() : void 0;\n };\n\n return FacebookConnectView;\n\n })(vw.View);\n return {\n FacebookConnectView: FacebookConnectView\n };\n});\n", "// Generated by CoffeeScript 1.12.3\n\n/*\n * Report module\n * =============\n *\n * This is the new version of smore.report\n *\n * Reports events to mixpanel/google analytics\n *\n * Public Methods\n * --------------\n * - event(name, props={},unique=false} Sends an event to mixpanel. returns a deferred object when the event\n * has been sent successfully\n * - ab() Returns a dict with the results of the current active a/b tests\n *\n */\ndefine('smore/util/report', function(require) {\n var MIXPANEL_TIMEOUT, _uniqueEvents, getAbTestValues, track;\n MIXPANEL_TIMEOUT = 300;\n _uniqueEvents = {};\n track = function(name, props, unique) {\n var analytics, dfd, key;\n if (props == null) {\n props = {};\n }\n if (unique == null) {\n unique = false;\n }\n\n /*\n \n Report an event to segment.io\n \n Params:\n - name Event name\n - props Optional properties to sedn with the event\n - unique Only send once for the given name and props\n \n Returns:\n A deferred object, that will be resolve on success or rejected after MIXPANEL_TIMEOUT ms\n */\n analytics = window.analytics;\n if (!name || !analytics.track) {\n DEVMODE && console.error(\"analytics is not loaded or event name wasn't provided!\");\n return;\n }\n props = $.extend(getAbTestValues(), props);\n if (unique && window.JSON) {\n key = name + \"-\" + (JSON.stringify(props));\n if (key in _uniqueEvents) {\n return;\n }\n _uniqueEvents[key] = true;\n }\n dfd = $.Deferred();\n DEVMODE && console.log(\"%cevent:\", 'color:green', name, props, unique);\n analytics.track(name, props, dfd.resolve);\n setTimeout(dfd.reject, MIXPANEL_TIMEOUT);\n return dfd.promise();\n };\n getAbTestValues = function() {\n\n /*\n Extract the a/b test values from the meta tags\n \n Returns:\n A dict from the ab test key to the value\n */\n var el, els, i, key, len, values;\n values = {};\n els = $('.smore-ab-test-meta');\n for (i = 0, len = els.length; i < len; i++) {\n el = els[i];\n key = el.getAttribute('key');\n if (key) {\n values[\"ab_test_\" + key] = el.getAttribute('content');\n }\n }\n return values;\n };\n return {\n track: track,\n ab: getAbTestValues\n };\n});\n", "// Generated by CoffeeScript 1.12.3\nvar extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },\n hasProp = {}.hasOwnProperty;\n\ndefine('smore/ui/login/modal', function(require) {\n var CONTENT_ENDPOINT, DEFAULT_AFTER_SUCCESS_URL, LoginModalView, MODAL_OPTIONS, autoLogin, fbv, isLoggedIn, lfv, mv, report, sfv, show;\n mv = require('fire/ui/views/ModalView');\n sfv = require('./signupFormView');\n lfv = require('./loginFormView');\n fbv = require('./facebookConnectView');\n report = require('smore/util/report');\n CONTENT_ENDPOINT = '/app/users/login_modal';\n if (DEVMODE) {\n CONTENT_ENDPOINT += '?_t=' + Number(new Date());\n }\n MODAL_OPTIONS = {\n cssClass: 'base-modal login-modal',\n width: 406,\n overlayClose: true,\n overlayClass: 'login-modal-overlay'\n };\n DEFAULT_AFTER_SUCCESS_URL = '/app';\n LoginModalView = (function(superClass) {\n var EVENTS;\n\n extend(LoginModalView, superClass);\n\n EVENTS = {\n login_modal_open: 'LOGIN MODAL: Open'\n };\n\n\n /*\n LoginModalViews\n \n @extends {ModalView}\n @class\n */\n\n LoginModalView.prototype.preload = true;\n\n LoginModalView.prototype.enableHistory = true;\n\n LoginModalView.prototype.events = {\n 'click .switch-state': 'onSwitchStateClicked'\n };\n\n LoginModalView.prototype.defaultOptions = {\n state: 'signup'\n };\n\n function LoginModalView(options) {\n\n /*\n \n @param {String} state Starts the modal in a specifc state. state can be 'login' or 'signup'\n */\n LoginModalView.__super__.constructor.call(this, CONTENT_ENDPOINT, options);\n this.state = this.options.state;\n }\n\n LoginModalView.prototype.render = function() {\n\n /*\n Initialize sub-views, like signup,login and facbook connect\n */\n var buttonId, segment, signupParams;\n buttonId = this.options.buttonId;\n signupParams = {\n 'signup_button': buttonId\n };\n segment = this._signupSegment();\n if (segment) {\n signupParams['segment'] = segment;\n }\n this.loginForm = new lfv.LoginFormView({\n el: this.find('.login-form')\n });\n this.loginForm.on('success', (function(_this) {\n return function(f, result) {\n return _this.onSuccess('login', result);\n };\n })(this));\n this.signupForm = new sfv.SignupFormView({\n el: this.find('.signup-form'),\n extraParams: signupParams\n });\n this.signupForm.on('success', (function(_this) {\n return function(f, result) {\n return _this.onSuccess('signup', result);\n };\n })(this));\n this.signupfbConnect = new fbv.FacebookConnectView({\n el: this.find('.only-signup .facebook-connect-button'),\n buttonId: buttonId,\n signupSegment: segment\n });\n this.signupfbConnect.on('success', (function(_this) {\n return function(f, type, result) {\n return _this.onSuccess(type, result);\n };\n })(this)).on('fail', (function(_this) {\n return function(fbc, msg) {\n return _this.onSignupFbFailed(msg);\n };\n })(this));\n this.loginfbConnect = new fbv.FacebookConnectView({\n el: this.find('.only-login .facebook-connect-button'),\n buttonId: buttonId,\n signupSegment: segment\n });\n this.loginfbConnect.on('success', (function(_this) {\n return function(f, type, result) {\n return _this.onSuccess(type, result);\n };\n })(this)).on('fail', (function(_this) {\n return function(fbc, msg) {\n return _this.onLoginFbFailed(msg);\n };\n })(this));\n this.setState(this.state);\n this.setupDisableState(this.loginForm, this.loginfbConnect);\n return this.setupDisableState(this.signupForm, this.signupfbConnect);\n };\n\n LoginModalView.prototype._signupSegment = function() {\n\n /*\n Get the the segment information from the meta tag \"smore:signup_segemnt\"\n */\n return $('meta[name=\"smore:signup_segment\"]').attr('value');\n };\n\n LoginModalView.prototype.setupDisableState = function(form, fbConnect) {\n\n /*\n Setup events to disable/enable the form when the fb-connect button is connecting.\n Same thing goes the other way around: disable/enable fb-connect button when the form is being proccessed\n */\n form.on('submitstart', (function(_this) {\n return function(f) {\n fbConnect.disable();\n return _this.addModifier('pending', true);\n };\n })(this));\n form.on('submitcomplete', (function(_this) {\n return function(f) {\n fbConnect.enable();\n return _this.removeModifier('pending');\n };\n })(this));\n fbConnect.on('connectstart', (function(_this) {\n return function(f) {\n form.disable();\n return _this.addModifier('pending', true);\n };\n })(this));\n return fbConnect.on('connectcomplete', (function(_this) {\n return function(f) {\n form.enable();\n return _this.removeModifier('pending');\n };\n })(this));\n };\n\n LoginModalView.prototype.setState = function(state) {\n\n /*\n Switch between states for the modal\n \n State can be 'login' or 'signup'\n */\n this.removeModifier(this.state);\n this.addModifier(state);\n this.state = state;\n if (state === 'login') {\n return this.loginForm.focus();\n } else {\n return this.signupForm.focus();\n }\n };\n\n LoginModalView.prototype.onSwitchStateClicked = function(e) {\n\n /*\n When someone clicks on the switch state label\n */\n var state;\n state = $(e.currentTarget).data('target');\n if (state) {\n return this.setState(state);\n }\n };\n\n LoginModalView.prototype.show = function() {\n LoginModalView.__super__.show.call(this, MODAL_OPTIONS);\n if (window.ga) {\n return ga(\"send\", \"pageview\", \"/app/users/signup_modal\");\n }\n };\n\n LoginModalView.prototype.onSuccess = function(type, result) {\n\n /*\n Login/Signup was successfully completed\n \n Params:\n - type login if we had a successful login, signup if we had a successful signup\n - result The result dictionary from the server\n */\n var r;\n if (this.closed) {\n return;\n }\n if (this.options.onSuccess) {\n return this.options.onSuccess(this, type, result);\n }\n $('body').hide();\n if (this.options.reloadOnly) {\n return document.location.reload();\n } else {\n r = result.redirect_url || DEFAULT_AFTER_SUCCESS_URL;\n if (r === 'app/reporting/report_errors') {\n r = '/app';\n }\n return document.location = r;\n }\n };\n\n LoginModalView.prototype.onLoginFbFailed = function(msg) {\n\n /*\n Handle failed fb logins\n */\n return this.handleFbError(msg, this.loginForm);\n };\n\n LoginModalView.prototype.onSignupFbFailed = function(msg) {\n\n /*\n Handle failed fb logins\n */\n return this.handleFbError(msg, this.signupForm);\n };\n\n LoginModalView.prototype.handleFbError = function(msg, form) {\n\n /*\n Handles fb error\n */\n var error;\n error = \"Something is broken.Try again later: (\";\n if (msg === 'tryemail') {\n error = 'Already registered via email';\n }\n return form.setError(error);\n };\n\n LoginModalView.prototype.onClose = function() {\n LoginModalView.__super__.onClose.apply(this, arguments);\n this.signupfbConnect.remove();\n return this.loginfbConnect.remove();\n };\n\n return LoginModalView;\n\n })(mv.ModalView);\n show = function(el, options) {\n var m, opts;\n if (options == null) {\n options = {};\n }\n\n /*\n Show the login modal in case of\n \n Params:\n - el jQuery The button element\n - options Optional options to add\n */\n opts = $.extend({}, el.data(), options);\n m = new LoginModalView(opts);\n m.show();\n return m;\n };\n isLoggedIn = function() {\n\n /*\n Test if the user has a login cookie\n */\n var m;\n m = document.cookie.match(/FP=\"?([A-Za-z0-9\\+\\/\\\\]*)\"?/);\n return m && m.length >= 2;\n };\n autoLogin = function() {\n $('.auto-quick-login').on('click', function(e) {\n var t;\n e.preventDefault();\n t = $(e.currentTarget);\n return show(t);\n });\n return mv.ModalView.preloadUrl(CONTENT_ENDPOINT);\n };\n $(autoLogin);\n return {\n LoginModalView: LoginModalView,\n show: show,\n isLoggedIn: isLoggedIn\n };\n});\n", "define('billing/stripe', function (require) {\r\n // Stripe js is loaded externally;\r\n var Stripe = window.Stripe;\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n /*********************************************************************************\r\n * Strip key\r\n *********************************************************************************/\r\n\r\n function setKey(key) {\r\n Stripe.setPublishableKey(key);\r\n }\r\n\r\n return {\r\n setKey: setKey\r\n }\r\n\r\n});\r\n\r\n\r\nfire.provide('smore.StripePaymentProvider');\r\n\r\nsmore.StripePaymentProvider = function (stripePublishableKey) {\r\n Stripe.setPublishableKey(stripePublishableKey);\r\n};\r\n\r\nsmore.StripePaymentProvider.prototype = {\r\n getProviderName: function () {\r\n return 'stripe';\r\n },\r\n\r\n /*\r\n checkCCData: Checks credit card data, and returns a dict:\r\n {\r\n valid: true or false, whether the given CC data is valid.\r\n reason: If the CC data is invalid, the reason why. Otherwise a blank string.\r\n cardType: The type of credit card - i.e. Visa, MasterCard, etc.\r\n }\r\n\r\n ccData must contain at least the following keys:\r\n number: Credit card number\r\n cvc: Credit card CVC code\r\n exp_month: Credit card expiry month\r\n exp_year: Credit card expiry year\r\n All other keys are ignored.\r\n */\r\n checkCCData: function (ccData) {\r\n var valid = false;\r\n var reason = '';\r\n var cardType = Stripe.cardType(ccData.number);\r\n\r\n if (!Stripe.validateCardNumber(ccData.number)) {\r\n reason = 'Invalid credit card number.';\r\n } else if (!Stripe.validateCVC(ccData.cvc)) {\r\n reason = 'Invalid CVC.';\r\n } else if (!Stripe.validateExpiry(ccData.exp_month, ccData.exp_year)) {\r\n reason = 'Invalid expiry date.';\r\n } else {\r\n valid = true;\r\n }\r\n\r\n return { valid: valid, reason: reason, cardType: cardType };\r\n },\r\n\r\n /*\r\n convertCCDataToSafePaymentData: Converts sensitive credit card data to payment data that may be\r\n safely sent to the Smore server.\r\n\r\n In ccData, the keys 'number', 'cvc', 'exp_month' and 'exp_year' are required.\r\n Other (optional) keys: 'name', 'address_line1', 'address_line2', 'address_city',\r\n 'address_state', 'address_zip', 'address_country'.\r\n\r\n Callback prototypes:\r\n successCallback(paymentData)\r\n failureCallback(errorMessage)\r\n */\r\n convertCCDataToSafePaymentData: function (ccData, successCallback, failureCallback) {\r\n var checkResult = this.checkCCData(ccData);\r\n if (checkResult.valid) {\r\n Stripe.createToken(ccData, function (status, response) {\r\n if (response.error) {\r\n failureCallback(response.error.message);\r\n } else {\r\n var paymentData = {\r\n stripe_token: response['id']\r\n };\r\n\r\n successCallback(paymentData);\r\n }\r\n });\r\n } else {\r\n failureCallback(checkResult.reason);\r\n }\r\n }\r\n};\r\n", "/* globals smore */\r\ndefine('billing/events', function (require) {\r\n /***\r\n * Utilities and tools to track events inside the pricing/billing process\r\n */\r\n\r\n var PREFIX = 'BILLING: ';\r\n\r\n // the mixpanel call\r\n var track = smore.report.track;\r\n\r\n\r\n var Events = {\r\n opened_pricing_page: 'Opened pricing page',\r\n opened_education_pricing_page: 'Opened education pricing page',\r\n opened_education_bulk_page: 'Opened education bulk page',\r\n opened_standalone_upgrade_page: 'Opened standalone upgrade page',\r\n clicked_choose_this_plan: 'Clicked choose this plan',\r\n signup_modal_opened: 'Signup modal opened',\r\n signup_modal_closed: 'Signup modal closed',\r\n entered_name_in_signup_form: 'Entered name in signup form',\r\n entered_cc_in_signup_flow: 'Entered cc in signup form',\r\n clicked_completed_purchase: 'Clicked on Complete Purchase',\r\n validation_error_before_complete_purchase: 'Validation error before complete purchase',\r\n server_error_in_signing_up: 'Server error in signing up',\r\n signup_complete: 'Signup complete',\r\n\r\n focused_on_cc_field: 'Focused on the cc field',\r\n focused_on_name_field: 'Focused on the name field',\r\n focused_on_cvc_field: 'Focused on the cvc field',\r\n\r\n // Downgrade/Upgrade\r\n opened_downgrade_modal: 'Opened downgrade modal',\r\n opened_upgrade_modal: 'Opened upgrade modal',\r\n completed_upgrade: 'Completed upgrade',\r\n completed_downgrade: 'Completed downgrade',\r\n\r\n // Cancel modal\r\n opened_cancel_modal: 'Opened cancel modal',\r\n completed_cancel: 'Completed cancel',\r\n took_cancel_offer: 'Took cancel offer',\r\n\r\n // Credits modal\r\n\r\n opened_credits_modal: 'Opened credits modal',\r\n opened_credits_modal_plan_upgrade: 'Opened credits modal plan upgrade',\r\n upgraded_to_plan_from_credits_modal: 'Upgraded to plan through credits modal',\r\n opened_flyer_packs_intro: 'Opened flyer packs intro step',\r\n opened_flyer_pack_option: 'Opened flyer pack option',\r\n opened_share_for_credits: 'Opened share for credits',\r\n completed_share_for_credits: 'Completed share for credits',\r\n completed_flyer_pack_purchase: 'Completed flyer pack purchase',\r\n\r\n // Annual upgrade\r\n opened_switch_to_yearly_plan_page: 'Opened switch to yearly plan page'\r\n };\r\n\r\n\r\n /***\r\n * Get a parameter from query string\r\n * http://stackoverflow.com/a/901144\r\n *\r\n * @param name\r\n * @returns {string}\r\n */\r\n function getParameterByName(name) {\r\n name = name.replace(/[\\[]/, \"\\\\\\[\").replace(/[\\]]/, \"\\\\\\]\");\r\n var regexS = \"[\\\\?&]\" + name + \"=([^&#]*)\";\r\n var regex = new RegExp(regexS);\r\n var results = regex.exec(window.location.search);\r\n if (results === null) {\r\n return \"\";\r\n }\r\n else {\r\n return decodeURIComponent(results[1].replace(/\\+/g, \" \"));\r\n }\r\n\r\n }\r\n\r\n // extract the upgrade reason if relevant\r\n var _upgradeReason = getParameterByName('ur') || 'N/A';\r\n\r\n\r\n /***\r\n * Report an event\r\n * @param eventName\r\n * @param extraProps\r\n * @param once\r\n * @returns {jQuery.Deferred}\r\n */\r\n function report(eventName, extraProps, once) {\r\n if (!eventName) {\r\n return $.when();\r\n }\r\n\r\n\r\n var base = {};\r\n\r\n if (_upgradeReason) {\r\n base.upgrade_reason = _upgradeReason;\r\n }\r\n\r\n var props = $.extend(base, extraProps || {});\r\n\r\n\r\n return track(PREFIX + eventName, props, once);\r\n }\r\n\r\n\r\n return {\r\n report: report,\r\n Events: Events,\r\n reason: _upgradeReason\r\n };\r\n});", "// Underscore.js 1.5.2\n// http://underscorejs.org\n// (c) 2009-2013 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n// Underscore may be freely distributed under the MIT license.\n\n(function () {\n\n // Baseline setup\n // --------------\n\n // Establish the root object, `window` in the browser, or `exports` on the server.\n var root = this;\n\n // Save the previous value of the `_` variable.\n var previousUnderscore = root._;\n\n // Establish the object that gets returned to break out of a loop iteration.\n var breaker = {};\n\n // Save bytes in the minified (but not gzipped) version:\n var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n // Create quick reference variables for speed access to core prototypes.\n var\n push = ArrayProto.push,\n slice = ArrayProto.slice,\n concat = ArrayProto.concat,\n toString = ObjProto.toString,\n hasOwnProperty = ObjProto.hasOwnProperty;\n\n // All **ECMAScript 5** native function implementations that we hope to use\n // are declared here.\n var\n nativeForEach = ArrayProto.forEach,\n nativeMap = ArrayProto.map,\n nativeReduce = ArrayProto.reduce,\n nativeReduceRight = ArrayProto.reduceRight,\n nativeFilter = ArrayProto.filter,\n nativeEvery = ArrayProto.every,\n nativeSome = ArrayProto.some,\n nativeIndexOf = ArrayProto.indexOf,\n nativeLastIndexOf = ArrayProto.lastIndexOf,\n nativeIsArray = Array.isArray,\n nativeKeys = Object.keys,\n nativeBind = FuncProto.bind;\n\n // Create a safe reference to the Underscore object for use below.\n var _ = function (obj) {\n if (obj instanceof _) return obj;\n if (!(this instanceof _)) return new _(obj);\n this._wrapped = obj;\n };\n\n // Export the Underscore object for **Node.js**, with\n // backwards-compatibility for the old `require()` API. If we're in\n // the browser, add `_` as a global object via a string identifier,\n // for Closure Compiler \"advanced\" mode.\n if (typeof exports !== 'undefined') {\n if (typeof module !== 'undefined' && module.exports) {\n exports = module.exports = _;\n }\n exports._ = _;\n } else {\n root._ = _;\n root._underscore = _;\n }\n\n // Current version.\n _.VERSION = '1.5.2';\n\n // Collection Functions\n // --------------------\n\n // The cornerstone, an `each` implementation, aka `forEach`.\n // Handles objects with the built-in `forEach`, arrays, and raw objects.\n // Delegates to **ECMAScript 5**'s native `forEach` if available.\n var each = _.each = _.forEach = function (obj, iterator, context) {\n if (obj == null) return;\n if (nativeForEach && obj.forEach === nativeForEach) {\n obj.forEach(iterator, context);\n } else if (obj.length === +obj.length) {\n for (var i = 0, length = obj.length; i < length; i++) {\n if (iterator.call(context, obj[i], i, obj) === breaker) return;\n }\n } else {\n var keys = _.keys(obj);\n for (var i = 0, length = keys.length; i < length; i++) {\n if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;\n }\n }\n };\n\n // Return the results of applying the iterator to each element.\n // Delegates to **ECMAScript 5**'s native `map` if available.\n _.map = _.collect = function (obj, iterator, context) {\n var results = [];\n if (obj == null) return results;\n if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);\n each(obj, function (value, index, list) {\n results.push(iterator.call(context, value, index, list));\n });\n return results;\n };\n\n var reduceError = 'Reduce of empty array with no initial value';\n\n // **Reduce** builds up a single result from a list of values, aka `inject`,\n // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.\n _.reduce = _.foldl = _.inject = function (obj, iterator, memo, context) {\n var initial = arguments.length > 2;\n if (obj == null) obj = [];\n if (nativeReduce && obj.reduce === nativeReduce) {\n if (context) iterator = _.bind(iterator, context);\n return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);\n }\n each(obj, function (value, index, list) {\n if (!initial) {\n memo = value;\n initial = true;\n } else {\n memo = iterator.call(context, memo, value, index, list);\n }\n });\n if (!initial) throw new TypeError(reduceError);\n return memo;\n };\n\n // The right-associative version of reduce, also known as `foldr`.\n // Delegates to **ECMAScript 5**'s native `reduceRight` if available.\n _.reduceRight = _.foldr = function (obj, iterator, memo, context) {\n var initial = arguments.length > 2;\n if (obj == null) obj = [];\n if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {\n if (context) iterator = _.bind(iterator, context);\n return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);\n }\n var length = obj.length;\n if (length !== +length) {\n var keys = _.keys(obj);\n length = keys.length;\n }\n each(obj, function (value, index, list) {\n index = keys ? keys[--length] : --length;\n if (!initial) {\n memo = obj[index];\n initial = true;\n } else {\n memo = iterator.call(context, memo, obj[index], index, list);\n }\n });\n if (!initial) throw new TypeError(reduceError);\n return memo;\n };\n\n // Return the first value which passes a truth test. Aliased as `detect`.\n _.find = _.detect = function (obj, iterator, context) {\n var result;\n any(obj, function (value, index, list) {\n if (iterator.call(context, value, index, list)) {\n result = value;\n return true;\n }\n });\n return result;\n };\n\n // Return all the elements that pass a truth test.\n // Delegates to **ECMAScript 5**'s native `filter` if available.\n // Aliased as `select`.\n _.filter = _.select = function (obj, iterator, context) {\n var results = [];\n if (obj == null) return results;\n if (nativeFilter && obj.filter === nativeFilter) return obj.filter(iterator, context);\n each(obj, function (value, index, list) {\n if (iterator.call(context, value, index, list)) results.push(value);\n });\n return results;\n };\n\n // Return all the elements for which a truth test fails.\n _.reject = function (obj, iterator, context) {\n return _.filter(obj, function (value, index, list) {\n return !iterator.call(context, value, index, list);\n }, context);\n };\n\n // Determine whether all of the elements match a truth test.\n // Delegates to **ECMAScript 5**'s native `every` if available.\n // Aliased as `all`.\n _.every = _.all = function (obj, iterator, context) {\n iterator || (iterator = _.identity);\n var result = true;\n if (obj == null) return result;\n if (nativeEvery && obj.every === nativeEvery) return obj.every(iterator, context);\n each(obj, function (value, index, list) {\n if (!(result = result && iterator.call(context, value, index, list))) return breaker;\n });\n return !!result;\n };\n\n // Determine if at least one element in the object matches a truth test.\n // Delegates to **ECMAScript 5**'s native `some` if available.\n // Aliased as `any`.\n var any = _.some = _.any = function (obj, iterator, context) {\n iterator || (iterator = _.identity);\n var result = false;\n if (obj == null) return result;\n if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);\n each(obj, function (value, index, list) {\n if (result || (result = iterator.call(context, value, index, list))) return breaker;\n });\n return !!result;\n };\n\n // Determine if the array or object contains a given value (using `===`).\n // Aliased as `include`.\n _.contains = _.include = function (obj, target) {\n if (obj == null) return false;\n if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;\n return any(obj, function (value) {\n return value === target;\n });\n };\n\n // Invoke a method (with arguments) on every item in a collection.\n _.invoke = function (obj, method) {\n var args = slice.call(arguments, 2);\n var isFunc = _.isFunction(method);\n return _.map(obj, function (value) {\n return (isFunc ? method : value[method]).apply(value, args);\n });\n };\n\n // Convenience version of a common use case of `map`: fetching a property.\n _.pluck = function (obj, key) {\n return _.map(obj, function (value) {\n return value[key];\n });\n };\n\n // Convenience version of a common use case of `filter`: selecting only objects\n // containing specific `key:value` pairs.\n _.where = function (obj, attrs, first) {\n if (_.isEmpty(attrs)) return first ? void 0 : [];\n return _[first ? 'find' : 'filter'](obj, function (value) {\n for (var key in attrs) {\n if (attrs[key] !== value[key]) return false;\n }\n return true;\n });\n };\n\n // Convenience version of a common use case of `find`: getting the first object\n // containing specific `key:value` pairs.\n _.findWhere = function (obj, attrs) {\n return _.where(obj, attrs, true);\n };\n\n // Return the maximum element or (element-based computation).\n // Can't optimize arrays of integers longer than 65,535 elements.\n // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)\n _.max = function (obj, iterator, context) {\n if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {\n return Math.max.apply(Math, obj);\n }\n if (!iterator && _.isEmpty(obj)) return -Infinity;\n var result = {computed: -Infinity, value: -Infinity};\n each(obj, function (value, index, list) {\n var computed = iterator ? iterator.call(context, value, index, list) : value;\n computed > result.computed && (result = {value: value, computed: computed});\n });\n return result.value;\n };\n\n // Return the minimum element (or element-based computation).\n _.min = function (obj, iterator, context) {\n if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {\n return Math.min.apply(Math, obj);\n }\n if (!iterator && _.isEmpty(obj)) return Infinity;\n var result = {computed: Infinity, value: Infinity};\n each(obj, function (value, index, list) {\n var computed = iterator ? iterator.call(context, value, index, list) : value;\n computed < result.computed && (result = {value: value, computed: computed});\n });\n return result.value;\n };\n\n // Shuffle an array, using the modern version of the\n // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher\u00e2\u20ac\u201cYates_shuffle).\n _.shuffle = function (obj) {\n var rand;\n var index = 0;\n var shuffled = [];\n each(obj, function (value) {\n rand = _.random(index++);\n shuffled[index - 1] = shuffled[rand];\n shuffled[rand] = value;\n });\n return shuffled;\n };\n\n // Sample **n** random values from an array.\n // If **n** is not specified, returns a single random element from the array.\n // The internal `guard` argument allows it to work with `map`.\n _.sample = function (obj, n, guard) {\n if (arguments.length < 2 || guard) {\n return obj[_.random(obj.length - 1)];\n }\n return _.shuffle(obj).slice(0, Math.max(0, n));\n };\n\n // An internal function to generate lookup iterators.\n var lookupIterator = function (value) {\n return _.isFunction(value) ? value : function (obj) {\n return obj[value];\n };\n };\n\n // Sort the object's values by a criterion produced by an iterator.\n _.sortBy = function (obj, value, context) {\n var iterator = lookupIterator(value);\n return _.pluck(_.map(obj, function (value, index, list) {\n return {\n value: value,\n index: index,\n criteria: iterator.call(context, value, index, list)\n };\n }).sort(function (left, right) {\n var a = left.criteria;\n var b = right.criteria;\n if (a !== b) {\n if (a > b || a === void 0) return 1;\n if (a < b || b === void 0) return -1;\n }\n return left.index - right.index;\n }), 'value');\n };\n\n // An internal function used for aggregate \"group by\" operations.\n var group = function (behavior) {\n return function (obj, value, context) {\n var result = {};\n var iterator = value == null ? _.identity : lookupIterator(value);\n each(obj, function (value, index) {\n var key = iterator.call(context, value, index, obj);\n behavior(result, key, value);\n });\n return result;\n };\n };\n\n // Groups the object's values by a criterion. Pass either a string attribute\n // to group by, or a function that returns the criterion.\n _.groupBy = group(function (result, key, value) {\n (_.has(result, key) ? result[key] : (result[key] = [])).push(value);\n });\n\n // Indexes the object's values by a criterion, similar to `groupBy`, but for\n // when you know that your index values will be unique.\n _.indexBy = group(function (result, key, value) {\n result[key] = value;\n });\n\n // Counts instances of an object that group by a certain criterion. Pass\n // either a string attribute to count by, or a function that returns the\n // criterion.\n _.countBy = group(function (result, key) {\n _.has(result, key) ? result[key]++ : result[key] = 1;\n });\n\n // Use a comparator function to figure out the smallest index at which\n // an object should be inserted so as to maintain order. Uses binary search.\n _.sortedIndex = function (array, obj, iterator, context) {\n iterator = iterator == null ? _.identity : lookupIterator(iterator);\n var value = iterator.call(context, obj);\n var low = 0, high = array.length;\n while (low < high) {\n var mid = (low + high) >>> 1;\n iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;\n }\n return low;\n };\n\n // Safely create a real, live array from anything iterable.\n _.toArray = function (obj) {\n if (!obj) return [];\n if (_.isArray(obj)) return slice.call(obj);\n if (obj.length === +obj.length) return _.map(obj, _.identity);\n return _.values(obj);\n };\n\n // Return the number of elements in an object.\n _.size = function (obj) {\n if (obj == null) return 0;\n return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;\n };\n\n // Array Functions\n // ---------------\n\n // Get the first element of an array. Passing **n** will return the first N\n // values in the array. Aliased as `head` and `take`. The **guard** check\n // allows it to work with `_.map`.\n _.first = _.head = _.take = function (array, n, guard) {\n if (array == null) return void 0;\n return (n == null) || guard ? array[0] : slice.call(array, 0, n);\n };\n\n // Returns everything but the last entry of the array. Especially useful on\n // the arguments object. Passing **n** will return all the values in\n // the array, excluding the last N. The **guard** check allows it to work with\n // `_.map`.\n _.initial = function (array, n, guard) {\n return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));\n };\n\n // Get the last element of an array. Passing **n** will return the last N\n // values in the array. The **guard** check allows it to work with `_.map`.\n _.last = function (array, n, guard) {\n if (array == null) return void 0;\n if ((n == null) || guard) {\n return array[array.length - 1];\n } else {\n return slice.call(array, Math.max(array.length - n, 0));\n }\n };\n\n // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n // Especially useful on the arguments object. Passing an **n** will return\n // the rest N values in the array. The **guard**\n // check allows it to work with `_.map`.\n _.rest = _.tail = _.drop = function (array, n, guard) {\n return slice.call(array, (n == null) || guard ? 1 : n);\n };\n\n // Trim out all falsy values from an array.\n _.compact = function (array) {\n return _.filter(array, _.identity);\n };\n\n // Internal implementation of a recursive `flatten` function.\n var flatten = function (input, shallow, output) {\n if (shallow && _.every(input, _.isArray)) {\n return concat.apply(output, input);\n }\n each(input, function (value) {\n if (_.isArray(value) || _.isArguments(value)) {\n shallow ? push.apply(output, value) : flatten(value, shallow, output);\n } else {\n output.push(value);\n }\n });\n return output;\n };\n\n // Flatten out an array, either recursively (by default), or just one level.\n _.flatten = function (array, shallow) {\n return flatten(array, shallow, []);\n };\n\n // Return a version of the array that does not contain the specified value(s).\n _.without = function (array) {\n return _.difference(array, slice.call(arguments, 1));\n };\n\n // Produce a duplicate-free version of the array. If the array has already\n // been sorted, you have the option of using a faster algorithm.\n // Aliased as `unique`.\n _.uniq = _.unique = function (array, isSorted, iterator, context) {\n if (_.isFunction(isSorted)) {\n context = iterator;\n iterator = isSorted;\n isSorted = false;\n }\n var initial = iterator ? _.map(array, iterator, context) : array;\n var results = [];\n var seen = [];\n each(initial, function (value, index) {\n if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {\n seen.push(value);\n results.push(array[index]);\n }\n });\n return results;\n };\n\n // Produce an array that contains the union: each distinct element from all of\n // the passed-in arrays.\n _.union = function () {\n return _.uniq(_.flatten(arguments, true));\n };\n\n // Produce an array that contains every item shared between all the\n // passed-in arrays.\n _.intersection = function (array) {\n var rest = slice.call(arguments, 1);\n return _.filter(_.uniq(array), function (item) {\n return _.every(rest, function (other) {\n return _.indexOf(other, item) >= 0;\n });\n });\n };\n\n // Take the difference between one array and a number of other arrays.\n // Only the elements present in just the first array will remain.\n _.difference = function (array) {\n var rest = concat.apply(ArrayProto, slice.call(arguments, 1));\n return _.filter(array, function (value) {\n return !_.contains(rest, value);\n });\n };\n\n // Zip together multiple lists into a single array -- elements that share\n // an index go together.\n _.zip = function () {\n var length = _.max(_.pluck(arguments, \"length\").concat(0));\n var results = new Array(length);\n for (var i = 0; i < length; i++) {\n results[i] = _.pluck(arguments, '' + i);\n }\n return results;\n };\n\n // Converts lists into objects. Pass either a single array of `[key, value]`\n // pairs, or two parallel arrays of the same length -- one of keys, and one of\n // the corresponding values.\n _.object = function (list, values) {\n if (list == null) return {};\n var result = {};\n for (var i = 0, length = list.length; i < length; i++) {\n if (values) {\n result[list[i]] = values[i];\n } else {\n result[list[i][0]] = list[i][1];\n }\n }\n return result;\n };\n\n // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),\n // we need this function. Return the position of the first occurrence of an\n // item in an array, or -1 if the item is not included in the array.\n // Delegates to **ECMAScript 5**'s native `indexOf` if available.\n // If the array is large and already in sort order, pass `true`\n // for **isSorted** to use binary search.\n _.indexOf = function (array, item, isSorted) {\n if (array == null) return -1;\n var i = 0, length = array.length;\n if (isSorted) {\n if (typeof isSorted == 'number') {\n i = (isSorted < 0 ? Math.max(0, length + isSorted) : isSorted);\n } else {\n i = _.sortedIndex(array, item);\n return array[i] === item ? i : -1;\n }\n }\n if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);\n for (; i < length; i++) if (array[i] === item) return i;\n return -1;\n };\n\n // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.\n _.lastIndexOf = function (array, item, from) {\n if (array == null) return -1;\n var hasIndex = from != null;\n if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {\n return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);\n }\n var i = (hasIndex ? from : array.length);\n while (i--) if (array[i] === item) return i;\n return -1;\n };\n\n // Generate an integer Array containing an arithmetic progression. A port of\n // the native Python `range()` function. See\n // [the Python documentation](http://docs.python.org/library/functions.html#range).\n _.range = function (start, stop, step) {\n if (arguments.length <= 1) {\n stop = start || 0;\n start = 0;\n }\n step = arguments[2] || 1;\n\n var length = Math.max(Math.ceil((stop - start) / step), 0);\n var idx = 0;\n var range = new Array(length);\n\n while (idx < length) {\n range[idx++] = start;\n start += step;\n }\n\n return range;\n };\n\n // Function (ahem) Functions\n // ------------------\n\n // Reusable constructor function for prototype setting.\n var ctor = function () {\n };\n\n // Create a function bound to a given object (assigning `this`, and arguments,\n // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n // available.\n _.bind = function (func, context) {\n var args, bound;\n if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n if (!_.isFunction(func)) throw new TypeError;\n args = slice.call(arguments, 2);\n return bound = function () {\n if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));\n ctor.prototype = func.prototype;\n var self = new ctor;\n ctor.prototype = null;\n var result = func.apply(self, args.concat(slice.call(arguments)));\n if (Object(result) === result) return result;\n return self;\n };\n };\n\n // Partially apply a function by creating a version that has had some of its\n // arguments pre-filled, without changing its dynamic `this` context.\n _.partial = function (func) {\n var args = slice.call(arguments, 1);\n return function () {\n return func.apply(this, args.concat(slice.call(arguments)));\n };\n };\n\n // Bind all of an object's methods to that object. Useful for ensuring that\n // all callbacks defined on an object belong to it.\n _.bindAll = function (obj) {\n var funcs = slice.call(arguments, 1);\n if (funcs.length === 0) throw new Error(\"bindAll must be passed function names\");\n each(funcs, function (f) {\n obj[f] = _.bind(obj[f], obj);\n });\n return obj;\n };\n\n // Memoize an expensive function by storing its results.\n _.memoize = function (func, hasher) {\n var memo = {};\n hasher || (hasher = _.identity);\n return function () {\n var key = hasher.apply(this, arguments);\n return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));\n };\n };\n\n // Delays a function for the given number of milliseconds, and then calls\n // it with the arguments supplied.\n _.delay = function (func, wait) {\n var args = slice.call(arguments, 2);\n return setTimeout(function () {\n return func.apply(null, args);\n }, wait);\n };\n\n // Defers a function, scheduling it to run after the current call stack has\n // cleared.\n _.defer = function (func) {\n return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));\n };\n\n // Returns a function, that, when invoked, will only be triggered at most once\n // during a given window of time. Normally, the throttled function will run\n // as much as it can, without ever going more than once per `wait` duration;\n // but if you'd like to disable the execution on the leading edge, pass\n // `{leading: false}`. To disable execution on the trailing edge, ditto.\n _.throttle = function (func, wait, options) {\n var context, args, result;\n var timeout = null;\n var previous = 0;\n options || (options = {});\n var later = function () {\n previous = options.leading === false ? 0 : new Date;\n timeout = null;\n result = func.apply(context, args);\n };\n return function () {\n var now = new Date;\n if (!previous && options.leading === false) previous = now;\n var remaining = wait - (now - previous);\n context = this;\n args = arguments;\n if (remaining <= 0) {\n clearTimeout(timeout);\n timeout = null;\n previous = now;\n result = func.apply(context, args);\n } else if (!timeout && options.trailing !== false) {\n timeout = setTimeout(later, remaining);\n }\n return result;\n };\n };\n\n // Returns a function, that, as long as it continues to be invoked, will not\n // be triggered. The function will be called after it stops being called for\n // N milliseconds. If `immediate` is passed, trigger the function on the\n // leading edge, instead of the trailing.\n _.debounce = function (func, wait, immediate) {\n var timeout, args, context, timestamp, result;\n return function () {\n context = this;\n args = arguments;\n timestamp = new Date();\n var later = function () {\n var last = (new Date()) - timestamp;\n if (last < wait) {\n timeout = setTimeout(later, wait - last);\n } else {\n timeout = null;\n if (!immediate) result = func.apply(context, args);\n }\n };\n var callNow = immediate && !timeout;\n if (!timeout) {\n timeout = setTimeout(later, wait);\n }\n if (callNow) result = func.apply(context, args);\n return result;\n };\n };\n\n // Returns a function that will be executed at most one time, no matter how\n // often you call it. Useful for lazy initialization.\n _.once = function (func) {\n var ran = false, memo;\n return function () {\n if (ran) return memo;\n ran = true;\n memo = func.apply(this, arguments);\n func = null;\n return memo;\n };\n };\n\n // Returns the first function passed as an argument to the second,\n // allowing you to adjust arguments, run code before and after, and\n // conditionally execute the original function.\n _.wrap = function (func, wrapper) {\n return function () {\n var args = [func];\n push.apply(args, arguments);\n return wrapper.apply(this, args);\n };\n };\n\n // Returns a function that is the composition of a list of functions, each\n // consuming the return value of the function that follows.\n _.compose = function () {\n var funcs = arguments;\n return function () {\n var args = arguments;\n for (var i = funcs.length - 1; i >= 0; i--) {\n args = [funcs[i].apply(this, args)];\n }\n return args[0];\n };\n };\n\n // Returns a function that will only be executed after being called N times.\n _.after = function (times, func) {\n return function () {\n if (--times < 1) {\n return func.apply(this, arguments);\n }\n };\n };\n\n // Object Functions\n // ----------------\n\n // Retrieve the names of an object's properties.\n // Delegates to **ECMAScript 5**'s native `Object.keys`\n _.keys = nativeKeys || function (obj) {\n if (obj !== Object(obj)) throw new TypeError('Invalid object');\n var keys = [];\n for (var key in obj) if (_.has(obj, key)) keys.push(key);\n return keys;\n };\n\n // Retrieve the values of an object's properties.\n _.values = function (obj) {\n var keys = _.keys(obj);\n var length = keys.length;\n var values = new Array(length);\n for (var i = 0; i < length; i++) {\n values[i] = obj[keys[i]];\n }\n return values;\n };\n\n // Convert an object into a list of `[key, value]` pairs.\n _.pairs = function (obj) {\n var keys = _.keys(obj);\n var length = keys.length;\n var pairs = new Array(length);\n for (var i = 0; i < length; i++) {\n pairs[i] = [keys[i], obj[keys[i]]];\n }\n return pairs;\n };\n\n // Invert the keys and values of an object. The values must be serializable.\n _.invert = function (obj) {\n var result = {};\n var keys = _.keys(obj);\n for (var i = 0, length = keys.length; i < length; i++) {\n result[obj[keys[i]]] = keys[i];\n }\n return result;\n };\n\n // Return a sorted list of the function names available on the object.\n // Aliased as `methods`\n _.functions = _.methods = function (obj) {\n var names = [];\n for (var key in obj) {\n if (_.isFunction(obj[key])) names.push(key);\n }\n return names.sort();\n };\n\n // Extend a given object with all the properties in passed-in object(s).\n _.extend = function (obj) {\n each(slice.call(arguments, 1), function (source) {\n if (source) {\n for (var prop in source) {\n obj[prop] = source[prop];\n }\n }\n });\n return obj;\n };\n\n // Return a copy of the object only containing the whitelisted properties.\n _.pick = function (obj) {\n var copy = {};\n var keys = concat.apply(ArrayProto, slice.call(arguments, 1));\n each(keys, function (key) {\n if (key in obj) copy[key] = obj[key];\n });\n return copy;\n };\n\n // Return a copy of the object without the blacklisted properties.\n _.omit = function (obj) {\n var copy = {};\n var keys = concat.apply(ArrayProto, slice.call(arguments, 1));\n for (var key in obj) {\n if (!_.contains(keys, key)) copy[key] = obj[key];\n }\n return copy;\n };\n\n // Fill in a given object with default properties.\n _.defaults = function (obj) {\n each(slice.call(arguments, 1), function (source) {\n if (source) {\n for (var prop in source) {\n if (obj[prop] === void 0) obj[prop] = source[prop];\n }\n }\n });\n return obj;\n };\n\n // Create a (shallow-cloned) duplicate of an object.\n _.clone = function (obj) {\n if (!_.isObject(obj)) return obj;\n return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n };\n\n // Invokes interceptor with the obj, and then returns obj.\n // The primary purpose of this method is to \"tap into\" a method chain, in\n // order to perform operations on intermediate results within the chain.\n _.tap = function (obj, interceptor) {\n interceptor(obj);\n return obj;\n };\n\n // Internal recursive comparison function for `isEqual`.\n var eq = function (a, b, aStack, bStack) {\n // Identical objects are equal. `0 === -0`, but they aren't identical.\n // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n if (a === b) return a !== 0 || 1 / a == 1 / b;\n // A strict comparison is necessary because `null == undefined`.\n if (a == null || b == null) return a === b;\n // Unwrap any wrapped objects.\n if (a instanceof _) a = a._wrapped;\n if (b instanceof _) b = b._wrapped;\n // Compare `[[Class]]` names.\n var className = toString.call(a);\n if (className != toString.call(b)) return false;\n switch (className) {\n // Strings, numbers, dates, and booleans are compared by value.\n case '[object String]':\n // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n // equivalent to `new String(\"5\")`.\n return a == String(b);\n case '[object Number]':\n // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for\n // other numeric values.\n return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);\n case '[object Date]':\n case '[object Boolean]':\n // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n // millisecond representations. Note that invalid dates with millisecond representations\n // of `NaN` are not equivalent.\n return +a == +b;\n // RegExps are compared by their source patterns and flags.\n case '[object RegExp]':\n return a.source == b.source &&\n a.global == b.global &&\n a.multiline == b.multiline &&\n a.ignoreCase == b.ignoreCase;\n }\n if (typeof a != 'object' || typeof b != 'object') return false;\n // Assume equality for cyclic structures. The algorithm for detecting cyclic\n // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n var length = aStack.length;\n while (length--) {\n // Linear search. Performance is inversely proportional to the number of\n // unique nested structures.\n if (aStack[length] == a) return bStack[length] == b;\n }\n // Objects with different constructors are not equivalent, but `Object`s\n // from different frames are.\n var aCtor = a.constructor, bCtor = b.constructor;\n if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&\n _.isFunction(bCtor) && (bCtor instanceof bCtor))) {\n return false;\n }\n // Add the first object to the stack of traversed objects.\n aStack.push(a);\n bStack.push(b);\n var size = 0, result = true;\n // Recursively compare objects and arrays.\n if (className == '[object Array]') {\n // Compare array lengths to determine if a deep comparison is necessary.\n size = a.length;\n result = size == b.length;\n if (result) {\n // Deep compare the contents, ignoring non-numeric properties.\n while (size--) {\n if (!(result = eq(a[size], b[size], aStack, bStack))) break;\n }\n }\n } else {\n // Deep compare objects.\n for (var key in a) {\n if (_.has(a, key)) {\n // Count the expected number of properties.\n size++;\n // Deep compare each member.\n if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;\n }\n }\n // Ensure that both objects contain the same number of properties.\n if (result) {\n for (key in b) {\n if (_.has(b, key) && !(size--)) break;\n }\n result = !size;\n }\n }\n // Remove the first object from the stack of traversed objects.\n aStack.pop();\n bStack.pop();\n return result;\n };\n\n // Perform a deep comparison to check if two objects are equal.\n _.isEqual = function (a, b) {\n return eq(a, b, [], []);\n };\n\n // Is a given array, string, or object empty?\n // An \"empty\" object has no enumerable own-properties.\n _.isEmpty = function (obj) {\n if (obj == null) return true;\n if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;\n for (var key in obj) if (_.has(obj, key)) return false;\n return true;\n };\n\n // Is a given value a DOM element?\n _.isElement = function (obj) {\n return !!(obj && obj.nodeType === 1);\n };\n\n // Is a given value an array?\n // Delegates to ECMA5's native Array.isArray\n _.isArray = nativeIsArray || function (obj) {\n return toString.call(obj) == '[object Array]';\n };\n\n // Is a given variable an object?\n _.isObject = function (obj) {\n return obj === Object(obj);\n };\n\n // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.\n each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function (name) {\n _['is' + name] = function (obj) {\n return toString.call(obj) == '[object ' + name + ']';\n };\n });\n\n // Define a fallback version of the method in browsers (ahem, IE), where\n // there isn't any inspectable \"Arguments\" type.\n if (!_.isArguments(arguments)) {\n _.isArguments = function (obj) {\n return !!(obj && _.has(obj, 'callee'));\n };\n }\n\n // Optimize `isFunction` if appropriate.\n if (typeof (/./) !== 'function') {\n _.isFunction = function (obj) {\n return typeof obj === 'function';\n };\n }\n\n // Is a given object a finite number?\n _.isFinite = function (obj) {\n return isFinite(obj) && !isNaN(parseFloat(obj));\n };\n\n // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n _.isNaN = function (obj) {\n return _.isNumber(obj) && obj != +obj;\n };\n\n // Is a given value a boolean?\n _.isBoolean = function (obj) {\n return obj === true || obj === false || toString.call(obj) == '[object Boolean]';\n };\n\n // Is a given value equal to null?\n _.isNull = function (obj) {\n return obj === null;\n };\n\n // Is a given variable undefined?\n _.isUndefined = function (obj) {\n return obj === void 0;\n };\n\n // Shortcut function for checking if an object has a given property directly\n // on itself (in other words, not on a prototype).\n _.has = function (obj, key) {\n return hasOwnProperty.call(obj, key);\n };\n\n // Utility Functions\n // -----------------\n\n // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n // previous owner. Returns a reference to the Underscore object.\n _.noConflict = function () {\n root._ = previousUnderscore;\n return this;\n };\n\n // Keep the identity function around for default iterators.\n _.identity = function (value) {\n return value;\n };\n\n // Run a function **n** times.\n _.times = function (n, iterator, context) {\n var accum = Array(Math.max(0, n));\n for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);\n return accum;\n };\n\n // Return a random integer between min and max (inclusive).\n _.random = function (min, max) {\n if (max == null) {\n max = min;\n min = 0;\n }\n return min + Math.floor(Math.random() * (max - min + 1));\n };\n\n // List of HTML entities for escaping.\n var entityMap = {\n escape: {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": '''\n }\n };\n entityMap.unescape = _.invert(entityMap.escape);\n\n // Regexes containing the keys and values listed immediately above.\n var entityRegexes = {\n escape: new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),\n unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')\n };\n\n // Functions for escaping and unescaping strings to/from HTML interpolation.\n _.each(['escape', 'unescape'], function (method) {\n _[method] = function (string) {\n if (string == null) return '';\n return ('' + string).replace(entityRegexes[method], function (match) {\n return entityMap[method][match];\n });\n };\n });\n\n // If the value of the named `property` is a function then invoke it with the\n // `object` as context; otherwise, return it.\n _.result = function (object, property) {\n if (object == null) return void 0;\n var value = object[property];\n return _.isFunction(value) ? value.call(object) : value;\n };\n\n // Add your own custom functions to the Underscore object.\n _.mixin = function (obj) {\n each(_.functions(obj), function (name) {\n var func = _[name] = obj[name];\n _.prototype[name] = function () {\n var args = [this._wrapped];\n push.apply(args, arguments);\n return result.call(this, func.apply(_, args));\n };\n });\n };\n\n // Generate a unique integer id (unique within the entire client session).\n // Useful for temporary DOM ids.\n var idCounter = 0;\n _.uniqueId = function (prefix) {\n var id = ++idCounter + '';\n return prefix ? prefix + id : id;\n };\n\n // By default, Underscore uses ERB-style template delimiters, change the\n // following template settings to use alternative delimiters.\n _.templateSettings = {\n evaluate: /<%([\\s\\S]+?)%>/g,\n interpolate: /<%=([\\s\\S]+?)%>/g,\n escape: /<%-([\\s\\S]+?)%>/g\n };\n\n // When customizing `templateSettings`, if you don't want to define an\n // interpolation, evaluation or escaping regex, we need one that is\n // guaranteed not to match.\n var noMatch = /(.)^/;\n\n // Certain characters need to be escaped so that they can be put into a\n // string literal.\n var escapes = {\n \"'\": \"'\",\n '\\\\': '\\\\',\n '\\r': 'r',\n '\\n': 'n',\n '\\t': 't',\n '\\u2028': 'u2028',\n '\\u2029': 'u2029'\n };\n\n var escaper = /\\\\|'|\\r|\\n|\\t|\\u2028|\\u2029/g;\n\n // JavaScript micro-templating, similar to John Resig's implementation.\n // Underscore templating handles arbitrary delimiters, preserves whitespace,\n // and correctly escapes quotes within interpolated code.\n _.template = function (text, data, settings) {\n var render;\n settings = _.defaults({}, settings, _.templateSettings);\n\n // Combine delimiters into one regular expression via alternation.\n var matcher = new RegExp([\n (settings.escape || noMatch).source,\n (settings.interpolate || noMatch).source,\n (settings.evaluate || noMatch).source\n ].join('|') + '|$', 'g');\n\n // Compile the template source, escaping string literals appropriately.\n var index = 0;\n var source = \"__p+='\";\n text.replace(matcher, function (match, escape, interpolate, evaluate, offset) {\n source += text.slice(index, offset)\n .replace(escaper, function (match) {\n return '\\\\' + escapes[match];\n });\n\n if (escape) {\n source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n }\n if (interpolate) {\n source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n }\n if (evaluate) {\n source += \"';\\n\" + evaluate + \"\\n__p+='\";\n }\n index = offset + match.length;\n return match;\n });\n source += \"';\\n\";\n\n // If a variable is not specified, place data values in local scope.\n if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n source = \"var __t,__p='',__j=Array.prototype.join,\" +\n \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n source + \"return __p;\\n\";\n\n try {\n render = new Function(settings.variable || 'obj', '_', source);\n } catch (e) {\n e.source = source;\n throw e;\n }\n\n if (data) return render(data, _);\n var template = function (data) {\n return render.call(this, data, _);\n };\n\n // Provide the compiled function source as a convenience for precompilation.\n template.source = 'function(' + (settings.variable || 'obj') + '){\\n' + source + '}';\n\n return template;\n };\n\n // Add a \"chain\" function, which will delegate to the wrapper.\n _.chain = function (obj) {\n return _(obj).chain();\n };\n\n // OOP\n // ---------------\n // If Underscore is called as a function, it returns a wrapped object that\n // can be used OO-style. This wrapper holds altered versions of all the\n // underscore functions. Wrapped objects may be chained.\n\n // Helper function to continue chaining intermediate results.\n var result = function (obj) {\n return this._chain ? _(obj).chain() : obj;\n };\n\n // Add all of the Underscore functions to the wrapper object.\n _.mixin(_);\n\n // Add all mutator Array functions to the wrapper.\n each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function (name) {\n var method = ArrayProto[name];\n _.prototype[name] = function () {\n var obj = this._wrapped;\n method.apply(obj, arguments);\n if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];\n return result.call(this, obj);\n };\n });\n\n // Add all accessor Array functions to the wrapper.\n each(['concat', 'join', 'slice'], function (name) {\n var method = ArrayProto[name];\n _.prototype[name] = function () {\n return result.call(this, method.apply(this._wrapped, arguments));\n };\n });\n\n _.extend(_.prototype, {\n\n // Start chaining a wrapped Underscore object.\n chain: function () {\n this._chain = true;\n return this;\n },\n\n // Extracts the result from a wrapped and chained object.\n value: function () {\n return this._wrapped;\n }\n\n });\n\n}).call(window);", "// Backbone.js 1.1.2\n\n// (c) 2010-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n// Backbone may be freely distributed under the MIT license.\n// For all details and documentation:\n// http://backbonejs.org\n\n(function(root, factory) {\n\n // Set up Backbone appropriately for the environment. Start with AMD.\n if (typeof define === 'function' && define.amd) {\n define(['underscore', 'jquery', 'exports'], function(_, $, exports) {\n // Export global even in AMD case in case this script is loaded with\n // others that may still expect a global Backbone.\n root.Backbone = factory(root, exports, _, $);\n });\n\n // Next for Node.js or CommonJS. jQuery may not be needed as a module.\n } else if (typeof exports !== 'undefined') {\n factory(root, exports, _);\n\n // Finally, as a browser global.\n } else {\n root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));\n }\n\n}(this, function(root, Backbone, _, $) {\n\n // Initial Setup\n // -------------\n\n // Save the previous value of the `Backbone` variable, so that it can be\n // restored later on, if `noConflict` is used.\n var previousBackbone = root.Backbone;\n\n // Create local references to array methods we'll want to use later.\n var array = [];\n var push = array.push;\n var slice = array.slice;\n var splice = array.splice;\n\n // Current version of the library. Keep in sync with `package.json`.\n Backbone.VERSION = '1.1.2';\n\n // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns\n // the `$` variable.\n Backbone.$ = $;\n\n // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable\n // to its previous owner. Returns a reference to this Backbone object.\n Backbone.noConflict = function() {\n root.Backbone = previousBackbone;\n return this;\n };\n\n // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option\n // will fake `\"PATCH\"`, `\"PUT\"` and `\"DELETE\"` requests via the `_method` parameter and\n // set a `X-Http-Method-Override` header.\n Backbone.emulateHTTP = false;\n\n // Turn on `emulateJSON` to support legacy servers that can't deal with direct\n // `application/json` requests ... will encode the body as\n // `application/x-www-form-urlencoded` instead and will send the model in a\n // form param named `model`.\n Backbone.emulateJSON = false;\n\n // Backbone.Events\n // ---------------\n\n // A module that can be mixed in to *any object* in order to provide it with\n // custom events. You may bind with `on` or remove with `off` callback\n // functions to an event; `trigger`-ing an event fires all callbacks in\n // succession.\n //\n // var object = {};\n // _.extend(object, Backbone.Events);\n // object.on('expand', function(){ alert('expanded'); });\n // object.trigger('expand');\n //\n var Events = Backbone.Events = {\n\n // Bind an event to a `callback` function. Passing `\"all\"` will bind\n // the callback to all events fired.\n on: function(name, callback, context) {\n if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;\n this._events || (this._events = {});\n var events = this._events[name] || (this._events[name] = []);\n events.push({callback: callback, context: context, ctx: context || this});\n return this;\n },\n\n // Bind an event to only be triggered a single time. After the first time\n // the callback is invoked, it will be removed.\n once: function(name, callback, context) {\n if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;\n var self = this;\n var once = _.once(function() {\n self.off(name, once);\n callback.apply(this, arguments);\n });\n once._callback = callback;\n return this.on(name, once, context);\n },\n\n // Remove one or many callbacks. If `context` is null, removes all\n // callbacks with that function. If `callback` is null, removes all\n // callbacks for the event. If `name` is null, removes all bound\n // callbacks for all events.\n off: function(name, callback, context) {\n var retain, ev, events, names, i, l, j, k;\n if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;\n if (!name && !callback && !context) {\n this._events = void 0;\n return this;\n }\n names = name ? [name] : _.keys(this._events);\n for (i = 0, l = names.length; i < l; i++) {\n name = names[i];\n if (events = this._events[name]) {\n this._events[name] = retain = [];\n if (callback || context) {\n for (j = 0, k = events.length; j < k; j++) {\n ev = events[j];\n if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||\n (context && context !== ev.context)) {\n retain.push(ev);\n }\n }\n }\n if (!retain.length) delete this._events[name];\n }\n }\n\n return this;\n },\n\n // Trigger one or many events, firing all bound callbacks. Callbacks are\n // passed the same arguments as `trigger` is, apart from the event name\n // (unless you're listening on `\"all\"`, which will cause your callback to\n // receive the true name of the event as the first argument).\n trigger: function(name) {\n if (!this._events) return this;\n var args = slice.call(arguments, 1);\n if (!eventsApi(this, 'trigger', name, args)) return this;\n var events = this._events[name];\n var allEvents = this._events.all;\n if (events) triggerEvents(events, args);\n if (allEvents) triggerEvents(allEvents, arguments);\n return this;\n },\n\n // Tell this object to stop listening to either specific events ... or\n // to every object it's currently listening to.\n stopListening: function(obj, name, callback) {\n var listeningTo = this._listeningTo;\n if (!listeningTo) return this;\n var remove = !name && !callback;\n if (!callback && typeof name === 'object') callback = this;\n if (obj) (listeningTo = {})[obj._listenId] = obj;\n for (var id in listeningTo) {\n obj = listeningTo[id];\n obj.off(name, callback, this);\n if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];\n }\n return this;\n }\n\n };\n\n // Regular expression used to split event strings.\n var eventSplitter = /\\s+/;\n\n // Implement fancy features of the Events API such as multiple event\n // names `\"change blur\"` and jQuery-style event maps `{change: action}`\n // in terms of the existing API.\n var eventsApi = function(obj, action, name, rest) {\n if (!name) return true;\n\n // Handle event maps.\n if (typeof name === 'object') {\n for (var key in name) {\n obj[action].apply(obj, [key, name[key]].concat(rest));\n }\n return false;\n }\n\n // Handle space separated event names.\n if (eventSplitter.test(name)) {\n var names = name.split(eventSplitter);\n for (var i = 0, l = names.length; i < l; i++) {\n obj[action].apply(obj, [names[i]].concat(rest));\n }\n return false;\n }\n\n return true;\n };\n\n // A difficult-to-believe, but optimized internal dispatch function for\n // triggering events. Tries to keep the usual cases speedy (most internal\n // Backbone events have 3 arguments).\n var triggerEvents = function(events, args) {\n var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\n switch (args.length) {\n case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\n case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\n case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\n case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\n default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;\n }\n };\n\n var listenMethods = {listenTo: 'on', listenToOnce: 'once'};\n\n // Inversion-of-control versions of `on` and `once`. Tell *this* object to\n // listen to an event in another object ... keeping track of what it's\n // listening to.\n _.each(listenMethods, function(implementation, method) {\n Events[method] = function(obj, name, callback) {\n var listeningTo = this._listeningTo || (this._listeningTo = {});\n var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n listeningTo[id] = obj;\n if (!callback && typeof name === 'object') callback = this;\n obj[implementation](name, callback, this);\n return this;\n };\n });\n\n // Aliases for backwards compatibility.\n Events.bind = Events.on;\n Events.unbind = Events.off;\n\n // Allow the `Backbone` object to serve as a global event bus, for folks who\n // want global \"pubsub\" in a convenient place.\n _.extend(Backbone, Events);\n\n // Backbone.Model\n // --------------\n\n // Backbone **Models** are the basic data object in the framework --\n // frequently representing a row in a table in a database on your server.\n // A discrete chunk of data and a bunch of useful, related methods for\n // performing computations and transformations on that data.\n\n // Create a new model with the specified attributes. A client id (`cid`)\n // is automatically generated and assigned for you.\n var Model = Backbone.Model = function(attributes, options) {\n var attrs = attributes || {};\n options || (options = {});\n this.cid = _.uniqueId('c');\n this.attributes = {};\n if (options.collection) this.collection = options.collection;\n if (options.parse) attrs = this.parse(attrs, options) || {};\n attrs = _.defaults({}, attrs, _.result(this, 'defaults'));\n this.set(attrs, options);\n this.changed = {};\n this.initialize.apply(this, arguments);\n };\n\n // Attach all inheritable methods to the Model prototype.\n _.extend(Model.prototype, Events, {\n\n // A hash of attributes whose current and previous value differ.\n changed: null,\n\n // The value returned during the last failed validation.\n validationError: null,\n\n // The default name for the JSON `id` attribute is `\"id\"`. MongoDB and\n // CouchDB users may want to set this to `\"_id\"`.\n idAttribute: 'id',\n\n // Initialize is an empty function by default. Override it with your own\n // initialization logic.\n initialize: function(){},\n\n // Return a copy of the model's `attributes` object.\n toJSON: function(options) {\n return _.clone(this.attributes);\n },\n\n // Proxy `Backbone.sync` by default -- but override this if you need\n // custom syncing semantics for *this* particular model.\n sync: function() {\n return Backbone.sync.apply(this, arguments);\n },\n\n // Get the value of an attribute.\n get: function(attr) {\n return this.attributes[attr];\n },\n\n // Get the HTML-escaped value of an attribute.\n escape: function(attr) {\n return _.escape(this.get(attr));\n },\n\n // Returns `true` if the attribute contains a value that is not null\n // or undefined.\n has: function(attr) {\n return this.get(attr) != null;\n },\n\n // Set a hash of model attributes on the object, firing `\"change\"`. This is\n // the core primitive operation of a model, updating the data and notifying\n // anyone who needs to know about the change in state. The heart of the beast.\n set: function(key, val, options) {\n var attr, attrs, unset, changes, silent, changing, prev, current;\n if (key == null) return this;\n\n // Handle both `\"key\", value` and `{key: value}` -style arguments.\n if (typeof key === 'object') {\n attrs = key;\n options = val;\n } else {\n (attrs = {})[key] = val;\n }\n\n options || (options = {});\n\n // Run validation.\n if (!this._validate(attrs, options)) return false;\n\n // Extract attributes and options.\n unset = options.unset;\n silent = options.silent;\n changes = [];\n changing = this._changing;\n this._changing = true;\n\n if (!changing) {\n this._previousAttributes = _.clone(this.attributes);\n this.changed = {};\n }\n current = this.attributes, prev = this._previousAttributes;\n\n // Check for changes of `id`.\n if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];\n\n // For each `set` attribute, update or delete the current value.\n for (attr in attrs) {\n val = attrs[attr];\n if (!_.isEqual(current[attr], val)) changes.push(attr);\n if (!_.isEqual(prev[attr], val)) {\n this.changed[attr] = val;\n } else {\n delete this.changed[attr];\n }\n unset ? delete current[attr] : current[attr] = val;\n }\n\n // Trigger all relevant attribute changes.\n if (!silent) {\n if (changes.length) this._pending = options;\n for (var i = 0, l = changes.length; i < l; i++) {\n this.trigger('change:' + changes[i], this, current[changes[i]], options);\n }\n }\n\n // You might be wondering why there's a `while` loop here. Changes can\n // be recursively nested within `\"change\"` events.\n if (changing) return this;\n if (!silent) {\n while (this._pending) {\n options = this._pending;\n this._pending = false;\n this.trigger('change', this, options);\n }\n }\n this._pending = false;\n this._changing = false;\n return this;\n },\n\n // Remove an attribute from the model, firing `\"change\"`. `unset` is a noop\n // if the attribute doesn't exist.\n unset: function(attr, options) {\n return this.set(attr, void 0, _.extend({}, options, {unset: true}));\n },\n\n // Clear all attributes on the model, firing `\"change\"`.\n clear: function(options) {\n var attrs = {};\n for (var key in this.attributes) attrs[key] = void 0;\n return this.set(attrs, _.extend({}, options, {unset: true}));\n },\n\n // Determine if the model has changed since the last `\"change\"` event.\n // If you specify an attribute name, determine if that attribute has changed.\n hasChanged: function(attr) {\n if (attr == null) return !_.isEmpty(this.changed);\n return _.has(this.changed, attr);\n },\n\n // Return an object containing all the attributes that have changed, or\n // false if there are no changed attributes. Useful for determining what\n // parts of a view need to be updated and/or what attributes need to be\n // persisted to the server. Unset attributes will be set to undefined.\n // You can also pass an attributes object to diff against the model,\n // determining if there *would be* a change.\n changedAttributes: function(diff) {\n if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;\n var val, changed = false;\n var old = this._changing ? this._previousAttributes : this.attributes;\n for (var attr in diff) {\n if (_.isEqual(old[attr], (val = diff[attr]))) continue;\n (changed || (changed = {}))[attr] = val;\n }\n return changed;\n },\n\n // Get the previous value of an attribute, recorded at the time the last\n // `\"change\"` event was fired.\n previous: function(attr) {\n if (attr == null || !this._previousAttributes) return null;\n return this._previousAttributes[attr];\n },\n\n // Get all of the attributes of the model at the time of the previous\n // `\"change\"` event.\n previousAttributes: function() {\n return _.clone(this._previousAttributes);\n },\n\n // Fetch the model from the server. If the server's representation of the\n // model differs from its current attributes, they will be overridden,\n // triggering a `\"change\"` event.\n fetch: function(options) {\n options = options ? _.clone(options) : {};\n if (options.parse === void 0) options.parse = true;\n var model = this;\n var success = options.success;\n options.success = function(resp) {\n if (!model.set(model.parse(resp, options), options)) return false;\n if (success) success(model, resp, options);\n model.trigger('sync', model, resp, options);\n };\n wrapError(this, options);\n return this.sync('read', this, options);\n },\n\n // Set a hash of model attributes, and sync the model to the server.\n // If the server returns an attributes hash that differs, the model's\n // state will be `set` again.\n save: function(key, val, options) {\n var attrs, method, xhr, attributes = this.attributes;\n\n // Handle both `\"key\", value` and `{key: value}` -style arguments.\n if (key == null || typeof key === 'object') {\n attrs = key;\n options = val;\n } else {\n (attrs = {})[key] = val;\n }\n\n options = _.extend({validate: true}, options);\n\n // If we're not waiting and attributes exist, save acts as\n // `set(attr).save(null, opts)` with validation. Otherwise, check if\n // the model will be valid when the attributes, if any, are set.\n if (attrs && !options.wait) {\n if (!this.set(attrs, options)) return false;\n } else {\n if (!this._validate(attrs, options)) return false;\n }\n\n // Set temporary attributes if `{wait: true}`.\n if (attrs && options.wait) {\n this.attributes = _.extend({}, attributes, attrs);\n }\n\n // After a successful server-side save, the client is (optionally)\n // updated with the server-side state.\n if (options.parse === void 0) options.parse = true;\n var model = this;\n var success = options.success;\n options.success = function(resp) {\n // Ensure attributes are restored during synchronous saves.\n model.attributes = attributes;\n var serverAttrs = model.parse(resp, options);\n if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);\n if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {\n return false;\n }\n if (success) success(model, resp, options);\n model.trigger('sync', model, resp, options);\n };\n wrapError(this, options);\n\n method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');\n if (method === 'patch') options.attrs = attrs;\n xhr = this.sync(method, this, options);\n\n // Restore attributes.\n if (attrs && options.wait) this.attributes = attributes;\n\n return xhr;\n },\n\n // Destroy this model on the server if it was already persisted.\n // Optimistically removes the model from its collection, if it has one.\n // If `wait: true` is passed, waits for the server to respond before removal.\n destroy: function(options) {\n options = options ? _.clone(options) : {};\n var model = this;\n var success = options.success;\n\n var destroy = function() {\n model.trigger('destroy', model, model.collection, options);\n };\n\n options.success = function(resp) {\n if (options.wait || model.isNew()) destroy();\n if (success) success(model, resp, options);\n if (!model.isNew()) model.trigger('sync', model, resp, options);\n };\n\n if (this.isNew()) {\n options.success();\n return false;\n }\n wrapError(this, options);\n\n var xhr = this.sync('delete', this, options);\n if (!options.wait) destroy();\n return xhr;\n },\n\n // Default URL for the model's representation on the server -- if you're\n // using Backbone's restful methods, override this to change the endpoint\n // that will be called.\n url: function() {\n var base =\n _.result(this, 'urlRoot') ||\n _.result(this.collection, 'url') ||\n urlError();\n if (this.isNew()) return base;\n return base.replace(/([^\\/])$/, '$1/') + encodeURIComponent(this.id);\n },\n\n // **parse** converts a response into the hash of attributes to be `set` on\n // the model. The default implementation is just to pass the response along.\n parse: function(resp, options) {\n return resp;\n },\n\n // Create a new model with identical attributes to this one.\n clone: function() {\n return new this.constructor(this.attributes);\n },\n\n // A model is new if it has never been saved to the server, and lacks an id.\n isNew: function() {\n return !this.has(this.idAttribute);\n },\n\n // Check if the model is currently in a valid state.\n isValid: function(options) {\n return this._validate({}, _.extend(options || {}, { validate: true }));\n },\n\n // Run validation against the next complete set of model attributes,\n // returning `true` if all is well. Otherwise, fire an `\"invalid\"` event.\n _validate: function(attrs, options) {\n if (!options.validate || !this.validate) return true;\n attrs = _.extend({}, this.attributes, attrs);\n var error = this.validationError = this.validate(attrs, options) || null;\n if (!error) return true;\n this.trigger('invalid', this, error, _.extend(options, {validationError: error}));\n return false;\n }\n\n });\n\n // Underscore methods that we want to implement on the Model.\n var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];\n\n // Mix in each Underscore method as a proxy to `Model#attributes`.\n _.each(modelMethods, function(method) {\n Model.prototype[method] = function() {\n var args = slice.call(arguments);\n args.unshift(this.attributes);\n return _[method].apply(_, args);\n };\n });\n\n // Backbone.Collection\n // -------------------\n\n // If models tend to represent a single row of data, a Backbone Collection is\n // more analagous to a table full of data ... or a small slice or page of that\n // table, or a collection of rows that belong together for a particular reason\n // -- all of the messages in this particular folder, all of the documents\n // belonging to this particular author, and so on. Collections maintain\n // indexes of their models, both in order, and for lookup by `id`.\n\n // Create a new **Collection**, perhaps to contain a specific type of `model`.\n // If a `comparator` is specified, the Collection will maintain\n // its models in sort order, as they're added and removed.\n var Collection = Backbone.Collection = function(models, options) {\n options || (options = {});\n if (options.model) this.model = options.model;\n if (options.comparator !== void 0) this.comparator = options.comparator;\n this._reset();\n this.initialize.apply(this, arguments);\n if (models) this.reset(models, _.extend({silent: true}, options));\n };\n\n // Default options for `Collection#set`.\n var setOptions = {add: true, remove: true, merge: true};\n var addOptions = {add: true, remove: false};\n\n // Define the Collection's inheritable methods.\n _.extend(Collection.prototype, Events, {\n\n // The default model for a collection is just a **Backbone.Model**.\n // This should be overridden in most cases.\n model: Model,\n\n // Initialize is an empty function by default. Override it with your own\n // initialization logic.\n initialize: function(){},\n\n // The JSON representation of a Collection is an array of the\n // models' attributes.\n toJSON: function(options) {\n return this.map(function(model){ return model.toJSON(options); });\n },\n\n // Proxy `Backbone.sync` by default.\n sync: function() {\n return Backbone.sync.apply(this, arguments);\n },\n\n // Add a model, or list of models to the set.\n add: function(models, options) {\n return this.set(models, _.extend({merge: false}, options, addOptions));\n },\n\n // Remove a model, or a list of models from the set.\n remove: function(models, options) {\n var singular = !_.isArray(models);\n models = singular ? [models] : _.clone(models);\n options || (options = {});\n var i, l, index, model;\n for (i = 0, l = models.length; i < l; i++) {\n model = models[i] = this.get(models[i]);\n if (!model) continue;\n delete this._byId[model.id];\n delete this._byId[model.cid];\n index = this.indexOf(model);\n this.models.splice(index, 1);\n this.length--;\n if (!options.silent) {\n options.index = index;\n model.trigger('remove', model, this, options);\n }\n this._removeReference(model, options);\n }\n return singular ? models[0] : models;\n },\n\n // Update a collection by `set`-ing a new list of models, adding new ones,\n // removing models that are no longer present, and merging models that\n // already exist in the collection, as necessary. Similar to **Model#set**,\n // the core operation for updating the data contained by the collection.\n set: function(models, options) {\n options = _.defaults({}, options, setOptions);\n if (options.parse) models = this.parse(models, options);\n var singular = !_.isArray(models);\n models = singular ? (models ? [models] : []) : _.clone(models);\n var i, l, id, model, attrs, existing, sort;\n var at = options.at;\n var targetModel = this.model;\n var sortable = this.comparator && (at == null) && options.sort !== false;\n var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n var toAdd = [], toRemove = [], modelMap = {};\n var add = options.add, merge = options.merge, remove = options.remove;\n var order = !sortable && add && remove ? [] : false;\n\n // Turn bare objects into model references, and prevent invalid models\n // from being added.\n for (i = 0, l = models.length; i < l; i++) {\n attrs = models[i] || {};\n if (attrs instanceof Model) {\n id = model = attrs;\n } else {\n id = attrs[targetModel.prototype.idAttribute || 'id'];\n }\n\n // If a duplicate is found, prevent it from being added and\n // optionally merge it into the existing model.\n if (existing = this.get(id)) {\n if (remove) modelMap[existing.cid] = true;\n if (merge) {\n attrs = attrs === model ? model.attributes : attrs;\n if (options.parse) attrs = existing.parse(attrs, options);\n existing.set(attrs, options);\n if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;\n }\n models[i] = existing;\n\n // If this is a new, valid model, push it to the `toAdd` list.\n } else if (add) {\n model = models[i] = this._prepareModel(attrs, options);\n if (!model) continue;\n toAdd.push(model);\n this._addReference(model, options);\n }\n\n // Do not add multiple models with the same `id`.\n model = existing || model;\n if (order && (model.isNew() || !modelMap[model.id])) order.push(model);\n modelMap[model.id] = true;\n }\n\n // Remove nonexistent models if appropriate.\n if (remove) {\n for (i = 0, l = this.length; i < l; ++i) {\n if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);\n }\n if (toRemove.length) this.remove(toRemove, options);\n }\n\n // See if sorting is needed, update `length` and splice in new models.\n if (toAdd.length || (order && order.length)) {\n if (sortable) sort = true;\n this.length += toAdd.length;\n if (at != null) {\n for (i = 0, l = toAdd.length; i < l; i++) {\n this.models.splice(at + i, 0, toAdd[i]);\n }\n } else {\n if (order) this.models.length = 0;\n var orderedModels = order || toAdd;\n for (i = 0, l = orderedModels.length; i < l; i++) {\n this.models.push(orderedModels[i]);\n }\n }\n }\n\n // Silently sort the collection if appropriate.\n if (sort) this.sort({silent: true});\n\n // Unless silenced, it's time to fire all appropriate add/sort events.\n if (!options.silent) {\n for (i = 0, l = toAdd.length; i < l; i++) {\n (model = toAdd[i]).trigger('add', model, this, options);\n }\n if (sort || (order && order.length)) this.trigger('sort', this, options);\n }\n\n // Return the added (or merged) model (or models).\n return singular ? models[0] : models;\n },\n\n // When you have more items than you want to add or remove individually,\n // you can reset the entire set with a new list of models, without firing\n // any granular `add` or `remove` events. Fires `reset` when finished.\n // Useful for bulk operations and optimizations.\n reset: function(models, options) {\n options || (options = {});\n for (var i = 0, l = this.models.length; i < l; i++) {\n this._removeReference(this.models[i], options);\n }\n options.previousModels = this.models;\n this._reset();\n models = this.add(models, _.extend({silent: true}, options));\n if (!options.silent) this.trigger('reset', this, options);\n return models;\n },\n\n // Add a model to the end of the collection.\n push: function(model, options) {\n return this.add(model, _.extend({at: this.length}, options));\n },\n\n // Remove a model from the end of the collection.\n pop: function(options) {\n var model = this.at(this.length - 1);\n this.remove(model, options);\n return model;\n },\n\n // Add a model to the beginning of the collection.\n unshift: function(model, options) {\n return this.add(model, _.extend({at: 0}, options));\n },\n\n // Remove a model from the beginning of the collection.\n shift: function(options) {\n var model = this.at(0);\n this.remove(model, options);\n return model;\n },\n\n // Slice out a sub-array of models from the collection.\n slice: function() {\n return slice.apply(this.models, arguments);\n },\n\n // Get a model from the set by id.\n get: function(obj) {\n if (obj == null) return void 0;\n return this._byId[obj] || this._byId[obj.id] || this._byId[obj.cid];\n },\n\n // Get the model at the given index.\n at: function(index) {\n return this.models[index];\n },\n\n // Return models with matching attributes. Useful for simple cases of\n // `filter`.\n where: function(attrs, first) {\n if (_.isEmpty(attrs)) return first ? void 0 : [];\n return this[first ? 'find' : 'filter'](function(model) {\n for (var key in attrs) {\n if (attrs[key] !== model.get(key)) return false;\n }\n return true;\n });\n },\n\n // Return the first model with matching attributes. Useful for simple cases\n // of `find`.\n findWhere: function(attrs) {\n return this.where(attrs, true);\n },\n\n // Force the collection to re-sort itself. You don't need to call this under\n // normal circumstances, as the set will maintain sort order as each item\n // is added.\n sort: function(options) {\n if (!this.comparator) throw new Error('Cannot sort a set without a comparator');\n options || (options = {});\n\n // Run sort based on type of `comparator`.\n if (_.isString(this.comparator) || this.comparator.length === 1) {\n this.models = this.sortBy(this.comparator, this);\n } else {\n this.models.sort(_.bind(this.comparator, this));\n }\n\n if (!options.silent) this.trigger('sort', this, options);\n return this;\n },\n\n // Pluck an attribute from each model in the collection.\n pluck: function(attr) {\n return _.invoke(this.models, 'get', attr);\n },\n\n // Fetch the default set of models for this collection, resetting the\n // collection when they arrive. If `reset: true` is passed, the response\n // data will be passed through the `reset` method instead of `set`.\n fetch: function(options) {\n options = options ? _.clone(options) : {};\n if (options.parse === void 0) options.parse = true;\n var success = options.success;\n var collection = this;\n options.success = function(resp) {\n var method = options.reset ? 'reset' : 'set';\n collection[method](resp, options);\n if (success) success(collection, resp, options);\n collection.trigger('sync', collection, resp, options);\n };\n wrapError(this, options);\n return this.sync('read', this, options);\n },\n\n // Create a new instance of a model in this collection. Add the model to the\n // collection immediately, unless `wait: true` is passed, in which case we\n // wait for the server to agree.\n create: function(model, options) {\n options = options ? _.clone(options) : {};\n if (!(model = this._prepareModel(model, options))) return false;\n if (!options.wait) this.add(model, options);\n var collection = this;\n var success = options.success;\n options.success = function(model, resp) {\n if (options.wait) collection.add(model, options);\n if (success) success(model, resp, options);\n };\n model.save(null, options);\n return model;\n },\n\n // **parse** converts a response into a list of models to be added to the\n // collection. The default implementation is just to pass it through.\n parse: function(resp, options) {\n return resp;\n },\n\n // Create a new collection with an identical list of models as this one.\n clone: function() {\n return new this.constructor(this.models);\n },\n\n // Private method to reset all internal state. Called when the collection\n // is first initialized or reset.\n _reset: function() {\n this.length = 0;\n this.models = [];\n this._byId = {};\n },\n\n // Prepare a hash of attributes (or other model) to be added to this\n // collection.\n _prepareModel: function(attrs, options) {\n if (attrs instanceof Model) return attrs;\n options = options ? _.clone(options) : {};\n options.collection = this;\n var model = new this.model(attrs, options);\n if (!model.validationError) return model;\n this.trigger('invalid', this, model.validationError, options);\n return false;\n },\n\n // Internal method to create a model's ties to a collection.\n _addReference: function(model, options) {\n this._byId[model.cid] = model;\n if (model.id != null) this._byId[model.id] = model;\n if (!model.collection) model.collection = this;\n model.on('all', this._onModelEvent, this);\n },\n\n // Internal method to sever a model's ties to a collection.\n _removeReference: function(model, options) {\n if (this === model.collection) delete model.collection;\n model.off('all', this._onModelEvent, this);\n },\n\n // Internal method called every time a model in the set fires an event.\n // Sets need to update their indexes when models change ids. All other\n // events simply proxy through. \"add\" and \"remove\" events that originate\n // in other collections are ignored.\n _onModelEvent: function(event, model, collection, options) {\n if ((event === 'add' || event === 'remove') && collection !== this) return;\n if (event === 'destroy') this.remove(model, options);\n if (model && event === 'change:' + model.idAttribute) {\n delete this._byId[model.previous(model.idAttribute)];\n if (model.id != null) this._byId[model.id] = model;\n }\n this.trigger.apply(this, arguments);\n }\n\n });\n\n // Underscore methods that we want to implement on the Collection.\n // 90% of the core usefulness of Backbone Collections is actually implemented\n // right here:\n var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',\n 'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',\n 'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',\n 'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',\n 'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',\n 'lastIndexOf', 'isEmpty', 'chain', 'sample'];\n\n // Mix in each Underscore method as a proxy to `Collection#models`.\n _.each(methods, function(method) {\n Collection.prototype[method] = function() {\n var args = slice.call(arguments);\n args.unshift(this.models);\n return _[method].apply(_, args);\n };\n });\n\n // Underscore methods that take a property name as an argument.\n var attributeMethods = ['groupBy', 'countBy', 'sortBy', 'indexBy'];\n\n // Use attributes instead of properties.\n _.each(attributeMethods, function(method) {\n Collection.prototype[method] = function(value, context) {\n var iterator = _.isFunction(value) ? value : function(model) {\n return model.get(value);\n };\n return _[method](this.models, iterator, context);\n };\n });\n\n // Backbone.View\n // -------------\n\n // Backbone Views are almost more convention than they are actual code. A View\n // is simply a JavaScript object that represents a logical chunk of UI in the\n // DOM. This might be a single item, an entire list, a sidebar or panel, or\n // even the surrounding frame which wraps your whole app. Defining a chunk of\n // UI as a **View** allows you to define your DOM events declaratively, without\n // having to worry about render order ... and makes it easy for the view to\n // react to specific changes in the state of your models.\n\n // Creating a Backbone.View creates its initial element outside of the DOM,\n // if an existing element is not provided...\n var View = Backbone.View = function(options) {\n this.cid = _.uniqueId('view');\n options || (options = {});\n _.extend(this, _.pick(options, viewOptions));\n this._ensureElement();\n this.initialize.apply(this, arguments);\n this.delegateEvents();\n };\n\n // Cached regex to split keys for `delegate`.\n var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n // List of view options to be merged as properties.\n var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];\n\n // Set up all inheritable **Backbone.View** properties and methods.\n _.extend(View.prototype, Events, {\n\n // The default `tagName` of a View's element is `\"div\"`.\n tagName: 'div',\n\n // jQuery delegate for element lookup, scoped to DOM elements within the\n // current view. This should be preferred to global lookups where possible.\n $: function(selector) {\n return this.$el.find(selector);\n },\n\n // Initialize is an empty function by default. Override it with your own\n // initialization logic.\n initialize: function(){},\n\n // **render** is the core function that your view should override, in order\n // to populate its element (`this.el`), with the appropriate HTML. The\n // convention is for **render** to always return `this`.\n render: function() {\n return this;\n },\n\n // Remove this view by taking the element out of the DOM, and removing any\n // applicable Backbone.Events listeners.\n remove: function() {\n this.$el.remove();\n this.stopListening();\n return this;\n },\n\n // Change the view's element (`this.el` property), including event\n // re-delegation.\n setElement: function(element, delegate) {\n if (this.$el) this.undelegateEvents();\n this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);\n this.el = this.$el[0];\n if (delegate !== false) this.delegateEvents();\n return this;\n },\n\n // Set callbacks, where `this.events` is a hash of\n //\n // *{\"event selector\": \"callback\"}*\n //\n // {\n // 'mousedown .title': 'edit',\n // 'click .button': 'save',\n // 'click .open': function(e) { ... }\n // }\n //\n // pairs. Callbacks will be bound to the view, with `this` set properly.\n // Uses event delegation for efficiency.\n // Omitting the selector binds the event to `this.el`.\n // This only works for delegate-able events: not `focus`, `blur`, and\n // not `change`, `submit`, and `reset` in Internet Explorer.\n delegateEvents: function(events) {\n if (!(events || (events = _.result(this, 'events')))) return this;\n this.undelegateEvents();\n for (var key in events) {\n var method = events[key];\n if (!_.isFunction(method)) method = this[events[key]];\n if (!method) continue;\n\n var match = key.match(delegateEventSplitter);\n var eventName = match[1], selector = match[2];\n method = _.bind(method, this);\n eventName += '.delegateEvents' + this.cid;\n if (selector === '') {\n this.$el.on(eventName, method);\n } else {\n this.$el.on(eventName, selector, method);\n }\n }\n return this;\n },\n\n // Clears all callbacks previously bound to the view with `delegateEvents`.\n // You usually don't need to use this, but may wish to if you have multiple\n // Backbone views attached to the same DOM element.\n undelegateEvents: function() {\n this.$el.off('.delegateEvents' + this.cid);\n return this;\n },\n\n // Ensure that the View has a DOM element to render into.\n // If `this.el` is a string, pass it through `$()`, take the first\n // matching element, and re-assign it to `el`. Otherwise, create\n // an element from the `id`, `className` and `tagName` properties.\n _ensureElement: function() {\n if (!this.el) {\n var attrs = _.extend({}, _.result(this, 'attributes'));\n if (this.id) attrs.id = _.result(this, 'id');\n if (this.className) attrs['class'] = _.result(this, 'className');\n var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);\n this.setElement($el, false);\n } else {\n this.setElement(_.result(this, 'el'), false);\n }\n }\n\n });\n\n // Backbone.sync\n // -------------\n\n // Override this function to change the manner in which Backbone persists\n // models to the server. You will be passed the type of request, and the\n // model in question. By default, makes a RESTful Ajax request\n // to the model's `url()`. Some possible customizations could be:\n //\n // * Use `setTimeout` to batch rapid-fire updates into a single request.\n // * Send up the models as XML instead of JSON.\n // * Persist models via WebSockets instead of Ajax.\n //\n // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests\n // as `POST`, with a `_method` parameter containing the true HTTP method,\n // as well as all requests with the body as `application/x-www-form-urlencoded`\n // instead of `application/json` with the model in a param named `model`.\n // Useful when interfacing with server-side languages like **PHP** that make\n // it difficult to read the body of `PUT` requests.\n Backbone.sync = function(method, model, options) {\n var type = methodMap[method];\n\n // Default options, unless specified.\n _.defaults(options || (options = {}), {\n emulateHTTP: Backbone.emulateHTTP,\n emulateJSON: Backbone.emulateJSON\n });\n\n // Default JSON-request options.\n var params = {type: type, dataType: 'json'};\n\n // Ensure that we have a URL.\n if (!options.url) {\n params.url = _.result(model, 'url') || urlError();\n }\n\n // Ensure that we have the appropriate request data.\n if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {\n params.contentType = 'application/json';\n params.data = JSON.stringify(options.attrs || model.toJSON(options));\n }\n\n // For older servers, emulate JSON by encoding the request into an HTML-form.\n if (options.emulateJSON) {\n params.contentType = 'application/x-www-form-urlencoded';\n params.data = params.data ? {model: params.data} : {};\n }\n\n // For older servers, emulate HTTP by mimicking the HTTP method with `_method`\n // And an `X-HTTP-Method-Override` header.\n if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {\n params.type = 'POST';\n if (options.emulateJSON) params.data._method = type;\n var beforeSend = options.beforeSend;\n options.beforeSend = function(xhr) {\n xhr.setRequestHeader('X-HTTP-Method-Override', type);\n if (beforeSend) return beforeSend.apply(this, arguments);\n };\n }\n\n // Don't process data on a non-GET request.\n if (params.type !== 'GET' && !options.emulateJSON) {\n params.processData = false;\n }\n\n // If we're sending a `PATCH` request, and we're in an old Internet Explorer\n // that still has ActiveX enabled by default, override jQuery to use that\n // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.\n if (params.type === 'PATCH' && noXhrPatch) {\n params.xhr = function() {\n return new ActiveXObject(\"Microsoft.XMLHTTP\");\n };\n }\n\n // Make the request, allowing the user to override any Ajax options.\n var xhr = options.xhr = Backbone.ajax(_.extend(params, options));\n model.trigger('request', model, xhr, options);\n return xhr;\n };\n\n var noXhrPatch =\n typeof window !== 'undefined' && !!window.ActiveXObject &&\n !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent);\n\n // Map from CRUD to HTTP for our default `Backbone.sync` implementation.\n var methodMap = {\n 'create': 'POST',\n 'update': 'PUT',\n 'patch': 'PATCH',\n 'delete': 'DELETE',\n 'read': 'GET'\n };\n\n // Set the default implementation of `Backbone.ajax` to proxy through to `$`.\n // Override this if you'd like to use a different library.\n Backbone.ajax = function() {\n return Backbone.$.ajax.apply(Backbone.$, arguments);\n };\n\n // Backbone.Router\n // ---------------\n\n // Routers map faux-URLs to actions, and fire events when routes are\n // matched. Creating a new one sets its `routes` hash, if not set statically.\n var Router = Backbone.Router = function(options) {\n options || (options = {});\n if (options.routes) this.routes = options.routes;\n this._bindRoutes();\n this.initialize.apply(this, arguments);\n };\n\n // Cached regular expressions for matching named param parts and splatted\n // parts of route strings.\n var optionalParam = /\\((.*?)\\)/g;\n var namedParam = /(\\(\\?)?:\\w+/g;\n var splatParam = /\\*\\w+/g;\n var escapeRegExp = /[\\-{}\\[\\]+?.,\\\\\\^$|#\\s]/g;\n\n // Set up all inheritable **Backbone.Router** properties and methods.\n _.extend(Router.prototype, Events, {\n\n // Initialize is an empty function by default. Override it with your own\n // initialization logic.\n initialize: function(){},\n\n // Manually bind a single named route to a callback. For example:\n //\n // this.route('search/:query/p:num', 'search', function(query, num) {\n // ...\n // });\n //\n route: function(route, name, callback) {\n if (!_.isRegExp(route)) route = this._routeToRegExp(route);\n if (_.isFunction(name)) {\n callback = name;\n name = '';\n }\n if (!callback) callback = this[name];\n var router = this;\n Backbone.history.route(route, function(fragment) {\n var args = router._extractParameters(route, fragment);\n router.execute(callback, args);\n router.trigger.apply(router, ['route:' + name].concat(args));\n router.trigger('route', name, args);\n Backbone.history.trigger('route', router, name, args);\n });\n return this;\n },\n\n // Execute a route handler with the provided parameters. This is an\n // excellent place to do pre-route setup or post-route cleanup.\n execute: function(callback, args) {\n if (callback) callback.apply(this, args);\n },\n\n // Simple proxy to `Backbone.history` to save a fragment into the history.\n navigate: function(fragment, options) {\n Backbone.history.navigate(fragment, options);\n return this;\n },\n\n // Bind all defined routes to `Backbone.history`. We have to reverse the\n // order of the routes here to support behavior where the most general\n // routes can be defined at the bottom of the route map.\n _bindRoutes: function() {\n if (!this.routes) return;\n this.routes = _.result(this, 'routes');\n var route, routes = _.keys(this.routes);\n while ((route = routes.pop()) != null) {\n this.route(route, this.routes[route]);\n }\n },\n\n // Convert a route string into a regular expression, suitable for matching\n // against the current location hash.\n _routeToRegExp: function(route) {\n route = route.replace(escapeRegExp, '\\\\$&')\n .replace(optionalParam, '(?:$1)?')\n .replace(namedParam, function(match, optional) {\n return optional ? match : '([^/?]+)';\n })\n .replace(splatParam, '([^?]*?)');\n return new RegExp('^' + route + '(?:\\\\?([\\\\s\\\\S]*))?$');\n },\n\n // Given a route, and a URL fragment that it matches, return the array of\n // extracted decoded parameters. Empty or unmatched parameters will be\n // treated as `null` to normalize cross-browser behavior.\n _extractParameters: function(route, fragment) {\n var params = route.exec(fragment).slice(1);\n return _.map(params, function(param, i) {\n // Don't decode the search params.\n if (i === params.length - 1) return param || null;\n return param ? decodeURIComponent(param) : null;\n });\n }\n\n });\n\n // Backbone.History\n // ----------------\n\n // Handles cross-browser history management, based on either\n // [pushState](http://diveintohtml5.info/history.html) and real URLs, or\n // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)\n // and URL fragments. If the browser supports neither (old IE, natch),\n // falls back to polling.\n var History = Backbone.History = function() {\n this.handlers = [];\n _.bindAll(this, 'checkUrl');\n\n // Ensure that `History` can be used outside of the browser.\n if (typeof window !== 'undefined') {\n this.location = window.location;\n this.history = window.history;\n }\n };\n\n // Cached regex for stripping a leading hash/slash and trailing space.\n var routeStripper = /^[#\\/]|\\s+$/g;\n\n // Cached regex for stripping leading and trailing slashes.\n var rootStripper = /^\\/+|\\/+$/g;\n\n // Cached regex for detecting MSIE.\n var isExplorer = /msie [\\w.]+/;\n\n // Cached regex for removing a trailing slash.\n var trailingSlash = /\\/$/;\n\n // Cached regex for stripping urls of hash.\n var pathStripper = /#.*$/;\n\n // Has the history handling already been started?\n History.started = false;\n\n // Set up all inheritable **Backbone.History** properties and methods.\n _.extend(History.prototype, Events, {\n\n // The default interval to poll for hash changes, if necessary, is\n // twenty times a second.\n interval: 50,\n\n // Are we at the app root?\n atRoot: function() {\n return this.location.pathname.replace(/[^\\/]$/, '$&/') === this.root;\n },\n\n // Gets the true hash value. Cannot use location.hash directly due to bug\n // in Firefox where location.hash will always be decoded.\n getHash: function(window) {\n var match = (window || this).location.href.match(/#(.*)$/);\n return match ? match[1] : '';\n },\n\n // Get the cross-browser normalized URL fragment, either from the URL,\n // the hash, or the override.\n getFragment: function(fragment, forcePushState) {\n if (fragment == null) {\n if (this._hasPushState || !this._wantsHashChange || forcePushState) {\n fragment = decodeURI(this.location.pathname + this.location.search);\n var root = this.root.replace(trailingSlash, '');\n if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);\n } else {\n fragment = this.getHash();\n }\n }\n return fragment.replace(routeStripper, '');\n },\n\n // Start the hash change handling, returning `true` if the current URL matches\n // an existing route, and `false` otherwise.\n start: function(options) {\n if (History.started) throw new Error(\"Backbone.history has already been started\");\n History.started = true;\n\n // Figure out the initial configuration. Do we need an iframe?\n // Is pushState desired ... is it available?\n this.options = _.extend({root: '/'}, this.options, options);\n this.root = this.options.root;\n this._wantsHashChange = this.options.hashChange !== false;\n this._wantsPushState = !!this.options.pushState;\n this._hasPushState = !!(this.options.pushState && this.history && this.history.pushState);\n var fragment = this.getFragment();\n var docMode = document.documentMode;\n var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));\n\n // Normalize root to always include a leading and trailing slash.\n this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n if (oldIE && this._wantsHashChange) {\n var frame = Backbone.$('').appendTo(content);\r\n }\r\n\r\n wrap.show();\r\n\r\n busy = false;\r\n\r\n $.fancybox.center();\r\n\r\n currentOpts.onComplete(currentArray, currentIndex, currentOpts);\r\n\r\n _preload_images();\r\n },\r\n\r\n _preload_images = function () {\r\n var href,\r\n objNext;\r\n\r\n if ((currentArray.length - 1) > currentIndex) {\r\n href = currentArray[ currentIndex + 1 ].href;\r\n\r\n if (typeof href !== 'undefined' && href.match(imgRegExp)) {\r\n objNext = new Image();\r\n objNext.src = href;\r\n }\r\n }\r\n\r\n if (currentIndex > 0) {\r\n href = currentArray[ currentIndex - 1 ].href;\r\n\r\n if (typeof href !== 'undefined' && href.match(imgRegExp)) {\r\n objNext = new Image();\r\n objNext.src = href;\r\n }\r\n }\r\n },\r\n\r\n _draw = function (pos) {\r\n var dim = {\r\n width: parseInt(start_pos.width + (final_pos.width - start_pos.width) * pos, 10),\r\n height: parseInt(start_pos.height + (final_pos.height - start_pos.height) * pos, 10),\r\n\r\n top: parseInt(start_pos.top + (final_pos.top - start_pos.top) * pos, 10),\r\n left: parseInt(start_pos.left + (final_pos.left - start_pos.left) * pos, 10)\r\n };\r\n\r\n if (typeof final_pos.opacity !== 'undefined') {\r\n dim.opacity = pos < 0.5 ? 0.5 : pos;\r\n }\r\n\r\n wrap.css(dim);\r\n\r\n content.css({\r\n 'width': dim.width - currentOpts.padding * 2,\r\n 'height': dim.height - (titleHeight * pos) - currentOpts.padding * 2\r\n });\r\n },\r\n\r\n _get_viewport = function () {\r\n return [\r\n $(window).width() - (currentOpts.margin * 2),\r\n $(window).height() - (currentOpts.margin * 2),\r\n $(document).scrollLeft() + currentOpts.margin,\r\n $(document).scrollTop() + currentOpts.margin\r\n ];\r\n },\r\n\r\n _get_zoom_to = function () {\r\n var view = _get_viewport(),\r\n to = {},\r\n resize = currentOpts.autoScale,\r\n double_padding = currentOpts.padding * 2,\r\n ratio;\r\n\r\n if (currentOpts.width.toString().indexOf('%') > -1) {\r\n to.width = parseInt((view[0] * parseFloat(currentOpts.width)) / 100, 10);\r\n } else {\r\n to.width = currentOpts.width + double_padding;\r\n }\r\n\r\n if (currentOpts.height.toString().indexOf('%') > -1) {\r\n to.height = parseInt((view[1] * parseFloat(currentOpts.height)) / 100, 10);\r\n } else {\r\n to.height = currentOpts.height + double_padding;\r\n }\r\n\r\n if (resize && (to.width > view[0] || to.height > view[1])) {\r\n if (selectedOpts.type == 'image' || selectedOpts.type == 'swf') {\r\n ratio = (currentOpts.width ) / (currentOpts.height );\r\n\r\n if ((to.width ) > view[0]) {\r\n to.width = view[0];\r\n to.height = parseInt(((to.width - double_padding) / ratio) + double_padding, 10);\r\n }\r\n\r\n if ((to.height) > view[1]) {\r\n to.height = view[1];\r\n to.width = parseInt(((to.height - double_padding) * ratio) + double_padding, 10);\r\n }\r\n\r\n } else {\r\n to.width = Math.min(to.width, view[0]);\r\n to.height = Math.min(to.height, view[1]);\r\n }\r\n }\r\n\r\n to.top = parseInt(Math.max(view[3] - 20, view[3] + ((view[1] - to.height - 40) * 0.5)), 10);\r\n to.left = parseInt(Math.max(view[2] - 20, view[2] + ((view[0] - to.width - 40) * 0.5)), 10);\r\n\r\n return to;\r\n },\r\n\r\n _get_obj_pos = function (obj) {\r\n var pos = obj.offset();\r\n\r\n pos.top += parseInt(obj.css('paddingTop'), 10) || 0;\r\n pos.left += parseInt(obj.css('paddingLeft'), 10) || 0;\r\n\r\n pos.top += parseInt(obj.css('border-top-width'), 10) || 0;\r\n pos.left += parseInt(obj.css('border-left-width'), 10) || 0;\r\n\r\n pos.width = obj.width();\r\n pos.height = obj.height();\r\n\r\n return pos;\r\n },\r\n\r\n _get_zoom_from = function () {\r\n var orig = selectedOpts.orig ? $(selectedOpts.orig) : false,\r\n from = {},\r\n pos,\r\n view;\r\n\r\n if (orig && orig.length) {\r\n pos = _get_obj_pos(orig);\r\n\r\n from = {\r\n width: pos.width + (currentOpts.padding * 2),\r\n height: pos.height + (currentOpts.padding * 2),\r\n top: pos.top - currentOpts.padding - 20,\r\n left: pos.left - currentOpts.padding - 20\r\n };\r\n\r\n } else {\r\n view = _get_viewport();\r\n\r\n from = {\r\n width: currentOpts.padding * 2,\r\n height: currentOpts.padding * 2,\r\n top: parseInt(view[3] + view[1] * 0.5, 10),\r\n left: parseInt(view[2] + view[0] * 0.5, 10)\r\n };\r\n }\r\n\r\n return from;\r\n },\r\n\r\n _animate_loading = function () {\r\n if (!loading.is(':visible')) {\r\n clearInterval(loadingTimer);\r\n return;\r\n }\r\n\r\n $('div', loading).css('top', (loadingFrame * -40) + 'px');\r\n\r\n loadingFrame = (loadingFrame + 1) % 12;\r\n };\r\n\r\n /*\r\n * Public methods\r\n */\r\n\r\n $.fn.fancybox = function (options) {\r\n if (!$(this).length) {\r\n return this;\r\n }\r\n\r\n $(this)\r\n .data('fancybox', $.extend({}, options, ($.metadata ? $(this).metadata() : {})))\r\n .unbind('click.fb')\r\n .bind('click.fb', function (e) {\r\n e.preventDefault();\r\n\r\n if (busy) {\r\n return;\r\n }\r\n\r\n busy = true;\r\n\r\n $(this).blur();\r\n\r\n selectedArray = [];\r\n selectedIndex = 0;\r\n\r\n var rel = $(this).attr('rel') || '';\r\n\r\n if (!rel || rel == '' || rel === 'nofollow') {\r\n selectedArray.push(this);\r\n\r\n } else {\r\n selectedArray = $(\"a[rel=\" + rel + \"], area[rel=\" + rel + \"]\");\r\n selectedIndex = selectedArray.index(this);\r\n }\r\n\r\n _start();\r\n\r\n return;\r\n });\r\n\r\n return this;\r\n };\r\n\r\n $.fancybox = function (obj) {\r\n var opts;\r\n\r\n if (busy) {\r\n return;\r\n }\r\n\r\n busy = true;\r\n opts = typeof arguments[1] !== 'undefined' ? arguments[1] : {};\r\n\r\n selectedArray = [];\r\n selectedIndex = parseInt(opts.index, 10) || 0;\r\n\r\n if ($.isArray(obj)) {\r\n for (var i = 0, j = obj.length; i < j; i++) {\r\n if (typeof obj[i] == 'object') {\r\n $(obj[i]).data('fancybox', $.extend({}, opts, obj[i]));\r\n } else {\r\n obj[i] = $({}).data('fancybox', $.extend({content: obj[i]}, opts));\r\n }\r\n }\r\n\r\n selectedArray = jQuery.merge(selectedArray, obj);\r\n\r\n } else {\r\n if (typeof obj == 'object') {\r\n $(obj).data('fancybox', $.extend({}, opts, obj));\r\n } else {\r\n obj = $({}).data('fancybox', $.extend({content: obj}, opts));\r\n }\r\n\r\n selectedArray.push(obj);\r\n }\r\n\r\n if (selectedIndex > selectedArray.length || selectedIndex < 0) {\r\n selectedIndex = 0;\r\n }\r\n\r\n _start();\r\n };\r\n\r\n $.fancybox.showActivity = function () {\r\n clearInterval(loadingTimer);\r\n\r\n loading.show();\r\n loadingTimer = setInterval(_animate_loading, 66);\r\n };\r\n\r\n $.fancybox.hideActivity = function () {\r\n loading.hide();\r\n };\r\n\r\n $.fancybox.next = function () {\r\n return $.fancybox.pos(currentIndex + 1);\r\n };\r\n\r\n $.fancybox.prev = function () {\r\n return $.fancybox.pos(currentIndex - 1);\r\n };\r\n\r\n $.fancybox.pos = function (pos) {\r\n if (busy) {\r\n return;\r\n }\r\n\r\n pos = parseInt(pos);\r\n\r\n selectedArray = currentArray;\r\n\r\n if (pos > -1 && pos < currentArray.length) {\r\n selectedIndex = pos;\r\n _start();\r\n\r\n } else if (currentOpts.cyclic && currentArray.length > 1) {\r\n selectedIndex = pos >= currentArray.length ? 0 : currentArray.length - 1;\r\n _start();\r\n }\r\n\r\n return;\r\n };\r\n\r\n $.fancybox.cancel = function () {\r\n if (busy) {\r\n return;\r\n }\r\n\r\n busy = true;\r\n\r\n $.event.trigger('fancybox-cancel');\r\n\r\n _abort();\r\n\r\n selectedOpts.onCancel(selectedArray, selectedIndex, selectedOpts);\r\n\r\n busy = false;\r\n };\r\n\r\n // Note: within an iframe use - parent.$.fancybox.close();\r\n $.fancybox.close = function () {\r\n if (busy || wrap.is(':hidden')) {\r\n return;\r\n }\r\n\r\n busy = true;\r\n\r\n if (currentOpts && false === currentOpts.onCleanup(currentArray, currentIndex, currentOpts)) {\r\n busy = false;\r\n return;\r\n }\r\n\r\n _abort();\r\n\r\n $(close.add(nav_left).add(nav_right)).hide();\r\n\r\n $(content.add(overlay)).unbind();\r\n\r\n $(window).unbind(\"resize.fb scroll.fb\");\r\n $(document).unbind('keydown.fb');\r\n\r\n content.find('iframe').attr('src', isIE6 && /^https/i.test(window.location.href || '') ? 'javascript:void(false)' : 'about:blank');\r\n\r\n if (currentOpts.titlePosition !== 'inside') {\r\n title.empty();\r\n }\r\n\r\n wrap.stop();\r\n\r\n function _cleanup() {\r\n overlay.fadeOut('fast');\r\n\r\n title.empty().hide();\r\n wrap.hide();\r\n\r\n $.event.trigger('fancybox-cleanup');\r\n\r\n content.empty();\r\n\r\n currentOpts.onClosed(currentArray, currentIndex, currentOpts);\r\n\r\n currentArray = selectedOpts = [];\r\n currentIndex = selectedIndex = 0;\r\n currentOpts = selectedOpts = {};\r\n\r\n busy = false;\r\n }\r\n\r\n if (currentOpts.transitionOut == 'elastic') {\r\n start_pos = _get_zoom_from();\r\n\r\n var pos = wrap.position();\r\n\r\n final_pos = {\r\n top: pos.top,\r\n left: pos.left,\r\n width: wrap.width(),\r\n height: wrap.height()\r\n };\r\n\r\n if (currentOpts.opacity) {\r\n final_pos.opacity = 1;\r\n }\r\n\r\n title.empty().hide();\r\n\r\n fx.prop = 1;\r\n\r\n $(fx).animate({ prop: 0 }, {\r\n duration: currentOpts.speedOut,\r\n easing: currentOpts.easingOut,\r\n step: _draw,\r\n complete: _cleanup\r\n });\r\n\r\n } else {\r\n wrap.fadeOut(currentOpts.transitionOut == 'none' ? 0 : currentOpts.speedOut, _cleanup);\r\n }\r\n };\r\n\r\n $.fancybox.resize = function () {\r\n if (overlay.is(':visible')) {\r\n overlay.css('height', $(document).height());\r\n }\r\n\r\n $.fancybox.center(true);\r\n };\r\n\r\n $.fancybox.center = function () {\r\n var view, align;\r\n\r\n if (busy) {\r\n return;\r\n }\r\n\r\n align = arguments[0] === true ? 1 : 0;\r\n view = _get_viewport();\r\n\r\n if (!align && (wrap.width() > view[0] || wrap.height() > view[1])) {\r\n return;\r\n }\r\n\r\n wrap\r\n .stop()\r\n .animate({\r\n 'top': parseInt(Math.max(view[3] - 20, view[3] + ((view[1] - content.height() - 40) * 0.5) - currentOpts.padding)),\r\n 'left': parseInt(Math.max(view[2] - 20, view[2] + ((view[0] - content.width() - 40) * 0.5) - currentOpts.padding))\r\n }, typeof arguments[0] == 'number' ? arguments[0] : 200);\r\n };\r\n\r\n $.fancybox.init = function () {\r\n if ($(\"#fancybox-wrap\").length) {\r\n return;\r\n }\r\n\r\n $('body').append(\r\n tmp = $(''),\r\n loading = $('