/*!

 * CanJS - 1.1.6

 * http://canjs.us/

 * Copyright (c) 2013 Bitovi

 * Mon, 15 Jul 2013 04:14:43 GMT

 * Licensed MIT

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

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

 */

(function(undefined) {

    // ## can/util/can.js

    var __m5 = (function() {

        var can = window.can || {};

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

            window.can = can;

        }

        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) {

                return object._cid

            } else {

                return object._cid = (name || "") + (++cid)

            }

        }

        can.VERSION = '@EDGE';

        return can;

    })();

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

    var __m6 = (function(can) {

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

            var i = 0,

                key;

            if (elements) {

                if (typeof elements.length === 'number' && elements.pop) {

                    if (elements.attr) {

                        elements.attr('length');

                    }

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

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

                            break;

                        }

                    }

                } else if (elements.hasOwnProperty) {

                    for (key in elements) {

                        if (elements.hasOwnProperty(key)) {

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

                                break;

                            }

                        }

                    }

                }

            }

            return elements;

        };

        return can;

    })(__m5);

    // ## can/util/jquery/jquery.js

    var __m3 = (function($, can) {

        // _jQuery node list._

        $.extend(can, $, {

                trigger: function(obj, event, args) {

                    if (obj.trigger) {

                        obj.trigger(event, args);

                    } else {

                        $.event.trigger(event, args, obj, true);

                    }

                },

                addEvent: function(ev, cb) {

                    $([this]).bind(ev, cb);

                    return this;

                },

                removeEvent: function(ev, cb) {

                    $([this]).unbind(ev, cb);

                    return this;

                },

                // jquery caches fragments, we always needs a new one

                buildFragment: function(elems, context) {

                    var oldFragment = $.buildFragment,

                        ret;

                    elems = [elems];

                    // Set context per 1.8 logic

                    context = context || document;

                    context = !context.nodeType && context[0] || context;

                    context = context.ownerDocument || context;

                    ret = oldFragment.call(jQuery, elems, context);

                    return ret.cacheable ? $.clone(ret.fragment) : ret.fragment || ret;

                },

                $: $,

                each: can.each

            });

        // Wrap binding functions.

        $.each(['bind', 'unbind', 'undelegate', 'delegate'], function(i, func) {

            can[func] = function() {

                var t = this[func] ? this : $([this]);

                t[func].apply(t, arguments);

                return this;

            };

        });

        // Wrap modifier functions.

        $.each(["append", "filter", "addClass", "remove", "data", "get"], function(i, name) {

            can[name] = function(wrapped) {

                return wrapped[name].apply(wrapped, can.makeArray(arguments).slice(1));

            };

        });

        // Memory safe destruction.

        var oldClean = $.cleanData;

        $.cleanData = function(elems) {

            $.each(elems, function(i, elem) {

                if (elem) {

                    can.trigger(elem, "destroyed", [], false);

                }

            });

            oldClean(elems);

        };

        return can;

    })(jQuery, __m5, __m6);

    // ## can/util/string/string.js

    var __m2 = (function(can) {

        // ##string.js

        // _Miscellaneous string utility functions._  

        // Several of the methods in this plugin use code adapated from Prototype

        // Prototype JavaScript framework, version 1.6.0.1.

        // © 2005-2007 Sam Stephenson

        var strUndHash = /_|-/,

            strColons = /\=\=/,

            strWords = /([A-Z]+)([A-Z][a-z])/g,

            strLowUp = /([a-z\d])([A-Z])/g,

            strDash = /([a-z\d])([A-Z])/g,

            strReplacer = /\{([^\}]+)\}/g,

            strQuote = /"/g,

            strSingleQuote = /'/g,

            // Returns the `prop` property from `obj`.

            // If `add` is true and `prop` doesn't exist in `obj`, create it as an

            // empty object.

            getNext = function(obj, prop, add) {

                var result = obj[prop];

                if (result === undefined && add === true) {

                    result = obj[prop] = {}

                }

                return result

            },

            // Returns `true` if the object can have properties (no `null`s).

            isContainer = function(current) {

                return (/^f|^o/).test(typeof current);

            };

        can.extend(can, {

                // Escapes strings for HTML.

                esc: function(content) {

                    // Convert bad values into empty strings

                    var isInvalid = content === null || content === undefined || (isNaN(content) && ("" + content === 'NaN'));

                    return ("" + (isInvalid ? '' : content))

                        .replace(/&/g, '&')

                        .replace(/</g, '&lt;')

                        .replace(/>/g, '>')

                        .replace(strQuote, '"')

                        .replace(strSingleQuote, "'");

                },

                getObject: function(name, roots, add) {

                    // The parts of the name we are looking up

                    // `['App','Models','Recipe']`

                    var parts = name ? name.split('.') : [],

                        length = parts.length,

                        current,

                        r = 0,

                        i, container, rootsLength;

                    // Make sure roots is an `array`.

                    roots = can.isArray(roots) ? roots : [roots || window];

                    rootsLength = roots.length

                    if (!length) {

                        return roots[0];

                    }

                    // For each root, mark it as current.

                    for (r; r < rootsLength; r++) {

                        current = roots[r];

                        container = undefined;

                        // Walk current to the 2nd to last object or until there

                        // is not a container.

                        for (i = 0; i < length && isContainer(current); i++) {

                            container = current;

                            current = getNext(container, parts[i]);

                        }

                        // If we found property break cycle

                        if (container !== undefined && current !== undefined) {

                            break

                        }

                    }

                    // Remove property from found container

                    if (add === false && current !== undefined) {

                        delete container[parts[i - 1]]

                    }

                    // When adding property add it to the first root

                    if (add === true && current === undefined) {

                        current = roots[0]

                        for (i = 0; i < length && isContainer(current); i++) {

                            current = getNext(current, parts[i], true);

                        }

                    }

                    return current;

                },

                // Capitalizes a string.

                capitalize: function(s, cache) {

                    // Used to make newId.

                    return s.charAt(0).toUpperCase() + s.slice(1);

                },

                // Underscores a string.

                underscore: function(s) {

                    return s

                        .replace(strColons, '/')

                        .replace(strWords, '$1_$2')

                        .replace(strLowUp, '$1_$2')

                        .replace(strDash, '_')

                        .toLowerCase();

                },

                // Micro-templating.

                sub: function(str, data, remove) {

                    var obs = [];

                    str = str || '';

                    obs.push(str.replace(strReplacer, function(whole, inside) {

                                // Convert inside to type.

                                var ob = can.getObject(inside, data, remove === true ? false : undefined);

                                if (ob === undefined) {

                                    obs = null;

                                    return "";

                                }

                                // If a container, push into objs (which will return objects found).

                                if (isContainer(ob) && obs) {

                                    obs.push(ob);

                                    return "";

                                }

                                return "" + ob;

                            }));

                    return obs === null ? obs : (obs.length <= 1 ? obs[0] : obs);

                },

                // These regex's are used throughout the rest of can, so let's make

                // them available.

                replacer: strReplacer,

                undHash: strUndHash

            });

        return can;

    })(__m3);

    // ## can/construct/construct.js

    var __m1 = (function(can) {

        // ## construct.js

        // `can.Construct`  

        // _This is a modified version of

        // [John Resig's class](http://ejohn.org/blog/simple-javascript-inheritance/).  

        // It provides class level inheritance and callbacks._

        // A private flag used to initialize a new class instance without

        // initializing it's bindings.

        var initializing = 0;

        can.Construct = function() {

            if (arguments.length) {

                return can.Construct.extend.apply(can.Construct, arguments);

            }

        };

        can.extend(can.Construct, {

                newInstance: function() {

                    // Get a raw instance object (`init` is not called).

                    var inst = this.instance(),

                        arg = arguments,

                        args;

                    // Call `setup` if there is a `setup`

                    if (inst.setup) {

                        args = inst.setup.apply(inst, arguments);

                    }

                    // Call `init` if there is an `init`  

                    // If `setup` returned `args`, use those as the arguments

                    if (inst.init) {

                        inst.init.apply(inst, args || arguments);

                    }

                    return inst;

                },

                // Overwrites an object with methods. Used in the `super` plugin.

                // `newProps` - New properties to add.  

                // `oldProps` - Where the old properties might be (used with `super`).  

                // `addTo` - What we are adding to.

                _inherit: function(newProps, oldProps, addTo) {

                    can.extend(addTo || newProps, newProps || {})

                },

                // used for overwriting a single property.

                // this should be used for patching other objects

                // the super plugin overwrites this

                _overwrite: function(what, oldProps, propName, val) {

                    what[propName] = val;

                },

                // Set `defaults` as the merger of the parent `defaults` and this 

                // object's `defaults`. If you overwrite this method, make sure to

                // include option merging logic.

                setup: function(base, fullName) {

                    this.defaults = can.extend(true, {}, base.defaults, this.defaults);

                },

                // Create's a new `class` instance without initializing by setting the

                // `initializing` flag.

                instance: function() {

                    // Prevents running `init`.

                    initializing = 1;

                    var inst = new this();

                    // Allow running `init`.

                    initializing = 0;

                    return inst;

                },

                // Extends classes.

                extend: function(fullName, klass, proto) {

                    // Figure out what was passed and normalize it.

                    if (typeof fullName != 'string') {

                        proto = klass;

                        klass = fullName;

                        fullName = null;

                    }

                    if (!proto) {

                        proto = klass;

                        klass = null;

                    }

                    proto = proto || {};

                    var _super_class = this,

                        _super = this.prototype,

                        name, shortName, namespace, prototype;

                    // Instantiate a base class (but only create the instance,

                    // don't run the init constructor).

                    prototype = this.instance();

                    // Copy the properties over onto the new prototype.

                    can.Construct._inherit(proto, _super, prototype);

                    // The dummy class constructor.

                    function Constructor() {

                        // All construction is actually done in the init method.

                        if (!initializing) {

                            return this.constructor !== Constructor && arguments.length ?

                            // We are being called without `new` or we are extending.

                            arguments.callee.extend.apply(arguments.callee, arguments) :

                            // We are being called with `new`.

                            this.constructor.newInstance.apply(this.constructor, arguments);

                        }

                    }

                    // Copy old stuff onto class (can probably be merged w/ inherit)

                    for (name in _super_class) {

                        if (_super_class.hasOwnProperty(name)) {

                            Constructor[name] = _super_class[name];

                        }

                    }

                    // Copy new static properties on class.

                    can.Construct._inherit(klass, _super_class, Constructor);

                    // Setup namespaces.

                    if (fullName) {

                        var parts = fullName.split('.'),

                            shortName = parts.pop(),

                            current = can.getObject(parts.join('.'), window, true),

                            namespace = current,

                            _fullName = can.underscore(fullName.replace(/\./g, "_")),

                            _shortName = can.underscore(shortName);

                        current[shortName] = Constructor;

                    }

                    // Set things that shouldn't be overwritten.

                    can.extend(Constructor, {

                            constructor: Constructor,

                            prototype: prototype,

                            namespace: namespace,

                            _shortName: _shortName,

                            fullName: fullName,

                            _fullName: _fullName

                        });

                    // Dojo and YUI extend undefined

                    if (shortName !== undefined) {

                        Constructor.shortName = shortName;

                    }

                    // Make sure our prototype looks nice.

                    Constructor.prototype.constructor = Constructor;

                    // Call the class `setup` and `init`

                    var t = [_super_class].concat(can.makeArray(arguments)),

                        args = Constructor.setup.apply(Constructor, t);

                    if (Constructor.init) {

                        Constructor.init.apply(Constructor, args || t);

                    }

                    return Constructor;

                }

            });

        return can.Construct;

    })(__m2);

    // ## can/util/bind/bind.js

    var __m8 = (function(can) {

        // ## Bind helpers

        can.bindAndSetup = function() {

            // Add the event to this object

            can.addEvent.apply(this, arguments);

            // If not initializing, and the first binding

            // call bindsetup if the function exists.

            if (!this._init) {

                if (!this._bindings) {

                    this._bindings = 1;

                    // setup live-binding

                    this._bindsetup && this._bindsetup();

                } else {

                    this._bindings++;

                }

            }

            return this;

        };

        can.unbindAndTeardown = function(ev, handler) {

            // Remove the event handler

            can.removeEvent.apply(this, arguments);

            this._bindings--;

            // If there are no longer any bindings and

            // there is a bindteardown method, call it.

            if (!this._bindings) {

                this._bindteardown && this._bindteardown();

            }

            return this;

        }

        return can;

    })(__m3);

    // ## can/observe/observe.js

    var __m7 = (function(can, bind) {

        // ## observe.js  

        // `can.Observe`  

        // _Provides the observable pattern for JavaScript Objects._  

        // Returns `true` if something is an object with properties of its own.

        var canMakeObserve = function(obj) {

            return obj && !can.isDeferred(obj) && (can.isArray(obj) || can.isPlainObject(obj) || (obj instanceof can.Observe));

        },

            // Removes all listeners.

            unhookup = function(items, namespace) {

                return can.each(items, function(item) {

                    if (item && item.unbind) {

                        item.unbind("change" + namespace);