/*!

 * CanJS - 2.1.1

 * http://canjs.us/

 * Copyright (c) 2014 Bitovi

 * Fri, 23 May 2014 15:47:45 GMT

 * Licensed MIT

 * Includes: can/construct/construct.js,can/map/map.js,can/list/list.js,can/compute/compute.js,can/model/model.js,can/view/view.js,can/control/control.js,can/route/route.js,can/control/route/route.js,can/view/ejs/ejs.js,can/map/backup/backup.js,can/util/object/object.js

 * Download from: http://bitbuilder.herokuapp.com/can.custom.js?configuration=jquery&plugins=can%2Fconstruct%2Fconstruct.js&plugins=can%2Fmap%2Fmap.js&plugins=can%2Flist%2Flist.js&plugins=can%2Fcompute%2Fcompute.js&plugins=can%2Fmodel%2Fmodel.js&plugins=can%2Fview%2Fview.js&plugins=can%2Fcontrol%2Fcontrol.js&plugins=can%2Froute%2Froute.js&plugins=can%2Fcontrol%2Froute%2Froute.js&plugins=can%2Fview%2Fejs%2Fejs.js&plugins=can%2Fmap%2Fbackup%2Fbackup.js&plugins=can%2Futil%2Fobject%2Fobject.js

 */

(function(undefined) {

    // ## can/util/can.js

    var __m5 = (function() {

        var can = window.can || {};

        if (typeof GLOBALCAN === 'undefined' || GLOBALCAN !== false) {

            window.can = can;

        }

        // An empty function useful for where you need a dummy callback.

        can.k = function() {};

        can.isDeferred = function(obj) {

            var isFunction = this.isFunction;

            // Returns `true` if something looks like a deferred.

            return obj && isFunction(obj.then) && isFunction(obj.pipe);

        };

        var cid = 0;

        can.cid = function(object, name) {

            if (!object._cid) {

                cid++;

                object._cid = (name || '') + cid;

            }

            return object._cid;

        };

        can.VERSION = '@EDGE';

        can.simpleExtend = function(d, s) {

            for (var prop in s) {

                d[prop] = s[prop];

            }

            return d;

        };

        can.frag = function(item) {

            var frag;

            if (!item || typeof item === "string") {

                frag = can.buildFragment(item == null ? "" : "" + item, document.body);

                // If we have an empty frag...

                if (!frag.childNodes.length) {

                    frag.appendChild(document.createTextNode(''));

                }

                return frag;

            } else if (item.nodeType === 11) {

                return item;

            } else if (typeof item.nodeType === "number") {

                frag = document.createDocumentFragment();

                frag.appendChild(item);

                return frag;

            } else if (typeof item.length === "number") {

                frag = document.createDocumentFragment();

                can.each(item, function(item) {

                    frag.appendChild(can.frag(item));

                });

                return frag;

            } else {

                frag = can.buildFragment("" + item, document.body);

                // If we have an empty frag...

                if (!frag.childNodes.length) {

                    frag.appendChild(document.createTextNode(''));

                }

                return frag;

            }

        };

        // this is here in case can.compute hasn't loaded

        can.__reading = function() {};

        return can;

    })();

    // ## can/util/attr/attr.js

    var __m6 = (function(can) {

        // Acts as a polyfill for setImmediate which only works in IE 10+. Needed to make

        // the triggering of `attributes` event async.

        var setImmediate = window.setImmediate || function(cb) {

                return setTimeout(cb, 0);

            },

            attr = {

                // This property lets us know if the browser supports mutation observers.

                // If they are supported then that will be setup in can/util/jquery and those native events will be used to inform observers of attribute changes.

                // Otherwise this module handles triggering an `attributes` event on the element.

                MutationObserver: window.MutationObserver || window.WebKitMutationObserver || window.MozMutationObserver,

                map: {

                    "class": "className",

                    "value": "value",

                    "innerText": "innerText",

                    "textContent": "textContent",

                    "checked": true,

                    "disabled": true,

                    "readonly": true,

                    "required": true,

                    // For the `src` attribute we are using a setter function to prevent values such as an empty string or null from being set.

                    // An `img` tag attempts to fetch the `src` when it is set, so we need to prevent that from happening by removing the attribute instead.

                    src: function(el, val) {

                        if (val == null || val === "") {

                            el.removeAttribute("src");

                            return null;

                        } else {

                            el.setAttribute("src", val);

                            return val;

                        }

                    },

                    style: function(el, val) {

                        return el.style.cssText = val || "";

                    }

                },

                // These are elements whos default value we should set.

                defaultValue: ["input", "textarea"],

                // ## attr.set

                // Set the value an attribute on an element.

                set: function(el, attrName, val) {

                    var oldValue;

                    // In order to later trigger an event we need to compare the new value to the old value, so here we go ahead and retrieve the old value for browsers that don't have native MutationObservers.

                    if (!attr.MutationObserver) {

                        oldValue = attr.get(el, attrName);

                    }

                    var tagName = el.nodeName.toString()

                        .toLowerCase(),

                        prop = attr.map[attrName],

                        newValue;

                    // Using the property of `attr.map`, go through and check if the property is a function, and if so call it. Then check if the property is `true`, and if so set the value to `true`, also making sure to set `defaultChecked` to `true` for elements of `attr.defaultValue`. We always set the value to true because for these boolean properties, setting them to false would be the same as removing the attribute.

                    // For all other attributes use `setAttribute` to set the new value.

                    if (typeof prop === "function") {

                        newValue = prop(el, val);

                    } else if (prop === true) {

                        newValue = el[attrName] = true;

                        if (attrName === "checked" && el.type === "radio") {

                            if (can.inArray(tagName, attr.defaultValue) >= 0) {

                                el.defaultChecked = true;

                            }

                        }

                    } else if (prop) {

                        newValue = el[prop] = val;

                        if (prop === "value" && can.inArray(tagName, attr.defaultValue) >= 0) {

                            el.defaultValue = val;

                        }

                    } else {

                        el.setAttribute(attrName, val);

                        newValue = val;

                    }

                    // Now that the value has been set, for browsers without MutationObservers, check to see that value has changed and if so trigger the "attributes" event on the element.

                    if (!attr.MutationObserver && newValue !== oldValue) {

                        attr.trigger(el, attrName, oldValue);

                    }

                },

                // ## attr.trigger

                // Used to trigger an "attributes" event on an element. Checks to make sure that someone is listening for the event and then queues a function to be called asynchronously using `setImmediate.

                trigger: function(el, attrName, oldValue) {

                    if (can.data(can.$(el), "canHasAttributesBindings")) {

                        return setImmediate(function() {

                            can.trigger(el, {

                                    type: "attributes",

                                    attributeName: attrName,

                                    target: el,

                                    oldValue: oldValue,

                                    bubbles: false

                                }, []);

                        });

                    }

                },

                // ## attr.get

                // Gets the value of an attribute. First checks to see if the property is a string on `attr.map` and if so returns the value from the element's property. Otherwise uses `getAttribute` to retrieve the value.

                get: function(el, attrName) {

                    var prop = attr.map[attrName];

                    if (typeof prop === "string" && el[prop]) {

                        return el[prop];

                    }

                    return el.getAttribute(attrName);

                },

                // ## attr.remove

                // Removes an attribute from an element. Works by using the `attr.map` to see if the attribute is a special type of property. If the property is a function then the fuction is called with `undefined` as the value. If the property is `true` then the attribute is set to false. If the property is a string then the attribute is set to an empty string. Otherwise `removeAttribute` is used.

                // If the attribute previously had a value and the browser doesn't support MutationObservers we then trigger an "attributes" event.

                remove: function(el, attrName) {

                    var oldValue;

                    if (!attr.MutationObserver) {

                        oldValue = attr.get(el, attrName);

                    }

                    var setter = attr.map[attrName];

                    if (typeof setter === "function") {

                        setter(el, undefined);

                    }

                    if (setter === true) {

                        el[attrName] = false;

                    } else if (typeof setter === "string") {

                        el[setter] = "";

                    } else {

                        el.removeAttribute(attrName);

                    }

                    if (!attr.MutationObserver && oldValue != null) {

                        attr.trigger(el, attrName, oldValue);

                    }

                },

                // ## attr.has

                // Checks if an element contains an attribute.

                // For browsers that support `hasAttribute`, creates a function that calls hasAttribute, otherwise creates a function that uses `getAttribute` to check that the attribute is not null.

                has: (function() {

                    var el = document.createElement('div');

                    if (el.hasAttribute) {

                        return function(el, name) {

                            return el.hasAttribute(name);

                        };

                    } else {

                        return function(el, name) {

                            return el.getAttribute(name) !== null;

                        };

                    }

                })()

            };

        return attr;

    })(__m5);

    // ## can/event/event.js

    var __m7 = (function(can) {

        // ## can.event.addEvent

        // Adds a basic event listener to an object.

        // This consists of storing a cache of event listeners on each object,

        // that are iterated through later when events are dispatched.

        can.addEvent = function(event, handler) {

            // Initialize event cache.

            var allEvents = this.__bindEvents || (this.__bindEvents = {}),

                eventList = allEvents[event] || (allEvents[event] = []);

            // Add the event

            eventList.push({

                    handler: handler,

                    name: event

                });

            return this;

        };

        // ## can.event.listenTo

        // Listens to an event without know how bind is implemented.

        // The primary use for this is to listen to another's objects event while 

        // tracking events on the local object (similar to namespacing).

        // The API was heavily influenced by BackboneJS: http://backbonejs.org/

        can.listenTo = function(other, event, handler) {

            // Initialize event cache

            var idedEvents = this.__listenToEvents;

            if (!idedEvents) {

                idedEvents = this.__listenToEvents = {};

            }

            // Identify the other object

            var otherId = can.cid(other);

            var othersEvents = idedEvents[otherId];

            // Create a local event cache

            if (!othersEvents) {

                othersEvents = idedEvents[otherId] = {

                    obj: other,

                    events: {}

                };

            }

            var eventsEvents = othersEvents.events[event];

            if (!eventsEvents) {

                eventsEvents = othersEvents.events[event] = [];

            }

            // Add the event, both locally and to the other object

            eventsEvents.push(handler);

            can.bind.call(other, event, handler);

        };

        // ## can.event.stopListening

        // Stops listening for events on other objects

        can.stopListening = function(other, event, handler) {

            var idedEvents = this.__listenToEvents,

                iterIdedEvents = idedEvents,

                i = 0;

            if (!idedEvents) {

                return this;

            }

            if (other) {

                var othercid = can.cid(other);

                (iterIdedEvents = {})[othercid] = idedEvents[othercid];

                // you might be trying to listen to something that is not there

                if (!idedEvents[othercid]) {

                    return this;

                }

            }

            // Clean up events on the other object

            for (var cid in iterIdedEvents) {

                var othersEvents = iterIdedEvents[cid],

                    eventsEvents;

                other = idedEvents[cid].obj;

                // Find the cache of events

                if (!event) {

                    eventsEvents = othersEvents.events;

                } else {

                    (eventsEvents = {})[event] = othersEvents.events[event];

                }

                // Unbind event handlers, both locally and on the other object

                for (var eventName in eventsEvents) {

                    var handlers = eventsEvents[eventName] || [];

                    i = 0;

                    while (i < handlers.length) {

                        if (handler && handler === handlers[i] || !handler) {

                            can.unbind.call(other, eventName, handlers[i]);

                            handlers.splice(i, 1);

                        } else {

                            i++;

                        }

                    }

                    // no more handlers?

                    if (!handlers.length) {

                        delete othersEvents.events[eventName];

                    }

                }

                if (can.isEmptyObject(othersEvents.events)) {

                    delete idedEvents[cid];

                }

            }

            return this;

        };

        // ## can.event.removeEvent

        // Removes a basic event listener from an object.

        // This removes event handlers from the cache of listened events.

        can.removeEvent = function(event, fn, __validate) {

            if (!this.__bindEvents) {

                return this;

            }

            var events = this.__bindEvents[event] || [],

                i = 0,

                ev, isFunction = typeof fn === 'function';

            while (i < events.length) {

                ev = events[i];

                // Determine whether this event handler is "equivalent" to the one requested

                // Generally this requires the same event/function, but a validation function 

                // can be included for extra conditions. This is used in some plugins like `can/event/namespace`.

                if (__validate ? __validate(ev, event, fn) : isFunction && ev.handler === fn || !isFunction && (ev.cid === fn || !fn)) {

                    events.splice(i, 1);

                } else {

                    i++;

                }

            }

            return this;

        };

        // ## can.event.dispatch

        // Dispatches/triggers a basic event on an object.

        can.dispatch = function(event, args) {

            var events = this.__bindEvents;

            if (!events) {

                return;

            }

            // Initialize the event object

            if (typeof event === 'string') {

                event = {

                    type: event

                };

            }

            // Grab event listeners

            var eventName = event.type,

                handlers = (events[eventName] || []).slice(0);

            // Execute handlers listening for this event.

            args = [event].concat(args || []);

            for (var i = 0, len = handlers.length; i < len; i++) {

                handlers[i].handler.apply(this, args);

            }

            return event;

        };

        // ## can.event.one

        // Adds a basic event listener that listens to an event once and only once.

        can.one = function(event, handler) {

            // Unbind the listener after it has been executed

            var one = function() {

                can.unbind.call(this, event, one);

                return handler.apply(this, arguments);

            };

            // Bind the altered listener

            can.bind.call(this, event, one);

            return this;

        };

        // ## can.event

        // Create and export the `can.event` mixin

        can.event = {

            // Event method aliases

            on: function() {

                if (arguments.length === 0 && can.Control && this instanceof can.Control) {

                    return can.Control.prototype.on.call(this);

                } else {

                    return can.addEvent.apply(this, arguments);

                }

            },

            off: function() {

                if (arguments.length === 0 && can.Control && this instanceof can.Control) {

                    return can.Control.prototype.off.call(this);

                } else {

                    return can.removeEvent.apply(this, arguments);

                }

            },

            bind: can.addEvent,

            unbind: can.removeEvent,

            delegate: function(selector, event, handler) {

                return can.addEvent.call(event, handler);

            },

            undelegate: function(selector, event, handler) {

                return can.removeEvent.call(event, handler);

            },

            trigger: can.dispatch,

            // Normal can/event methods

            one: can.one,

            addEvent: can.addEvent,

            removeEvent: can.removeEvent,

            listenTo: can.listenTo,

            stopListening: can.stopListening,

            dispatch: can.dispatch

        };

        return can.event;

    })(__m5);

    // ## can/util/array/each.js

    var __m8 = (function(can) {

        // The following is from jQuery

        var isArrayLike = function(obj) {

            var length = obj.length;

            return typeof arr !== "function" &&

            (length === 0 || typeof length === "number" && length > 0 && (length - 1) in obj);

        };

        can.each = function(elements, callback, context) {

            var i = 0,

                key,

                len,

                item;

            if (elements) {

                if (isArrayLike(elements)) {

                    if (can.List && elements instanceof can.List) {

                        for (len = elements.attr("length"); i < len; i++) {

                            item = elements.attr(i);

                            if (callback.call(context || item, item, i, elements) === false) {

                                break;

                            }

                        }

                    } else {

                        for (len = elements.length; i < len; i++) {

                            item = elements[i];

                            if (callback.call(context || item, item, i, elements) === false) {

                                break;

                            }

                        }

                    }

                } else if (typeof elements === "object") {

                    if (can.Map && elements instanceof can.Map || elements === can.route) {

                        var keys = can.Map.keys(elements);

                        for (i = 0, len = keys.length; i < len; i++) {

                            key = keys[i];

                            item = elements.attr(key);

                            if (callback.call(context || item, item, key, elements) === false) {

                                break;

                            }

                        }

                    } else {

                        for (key in elements) {

                            if (elements.hasOwnProperty(key) && callback.call(context || elements[key], elements[key], key, elements) === false) {

                                break;

                            }

                        }

                    }

                }

            }

            return elements;

        };

        return can;

    })(__m5);

    // ## can/util/inserted/inserted.js

    var __m9 = (function(can) {

        can.inserted = function(elems) {

            // Turn the `elems` property into an array to prevent mutations from changing the looping.

            elems = can.makeArray(elems);

            var inDocument = false,