/*!

* jQuery JavaScript Library v1.7.2
* http://jquery.com/
*
* Copyright 2011, John Resig
* Dual licensed under the MIT or GPL Version 2 licenses.
* http://jquery.org/license
*
* Includes Sizzle.js
* http://sizzlejs.com/
* Copyright 2011, The Dojo Foundation
* Released under the MIT, BSD, and GPL Licenses.
*
* Date: Wed Mar 21 12:46:34 2012 -0700
*/

(function( window, undefined ) { 'use strict';

// Use the correct document accordingly with window argument (sandbox) var document = window.document,

navigator = window.navigator,
location = window.location;

var jQuery = (function() {

// Define a local copy of jQuery var jQuery = function( selector, context ) {

        // The jQuery object is actually just the init constructor 'enhanced'
        return new jQuery.fn.init( selector, context, rootjQuery );
},

// Map over jQuery in case of overwrite
_jQuery = window.jQuery,

// Map over the $ in case of overwrite
_$ = window.$,

// A central reference to the root jQuery(document)
rootjQuery,

// A simple way to check for HTML strings or ID strings
// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
quickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,

// Check if a string has a non-whitespace character in it
rnotwhite = /\S/,

// Used for trimming whitespace
trimLeft = /^\s+/,
trimRight = /\s+$/,

// Match a standalone tag
rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,

// JSON RegExp
rvalidchars = /^[\],:{}\s]*$/,
rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,

// Useragent RegExp
rwebkit = /(webkit)[ \/]([\w.]+)/,
ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
rmsie = /(msie) ([\w.]+)/,
rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,

// Matches dashed string for camelizing
rdashAlpha = /-([a-z]|[0-9])/ig,
rmsPrefix = /^-ms-/,

// Used by jQuery.camelCase as callback to replace()
fcamelCase = function( all, letter ) {
        return ( letter + "" ).toUpperCase();
},

// Keep a UserAgent string for use with jQuery.browser
userAgent = navigator.userAgent,

// For matching the engine and version of the browser
browserMatch,

// The deferred used on DOM ready
readyList,

// The ready event handler
DOMContentLoaded,

// Save a reference to some core methods
toString = Object.prototype.toString,
hasOwn = Object.prototype.hasOwnProperty,
push = Array.prototype.push,
slice = Array.prototype.slice,
trim = String.prototype.trim,
indexOf = Array.prototype.indexOf,

// [[Class]] -> type pairs
class2type = {};

jQuery.fn = jQuery.prototype = {

constructor: jQuery,
init: function( selector, context, rootjQuery ) {
        var match, elem, ret, doc;

        // Handle $(""), $(null), or $(undefined)
        if ( !selector ) {
                return this;
        }

        // Handle $(DOMElement)
        if ( selector.nodeType ) {
                this.context = this[0] = selector;
                this.length = 1;
                return this;
        }

        // The body element only exists once, optimize finding it
        if ( selector === "body" && !context && document.body ) {
                this.context = document;
                this[0] = document.body;
                this.selector = selector;
                this.length = 1;
                return this;
        }

        // Handle HTML strings
        if ( typeof selector === "string" ) {
                // Are we dealing with HTML string or an ID?
                if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
                        // Assume that strings that start and end with <> are HTML and skip the regex check
                        match = [ null, selector, null ];

                } else {
                        match = quickExpr.exec( selector );
                }

                // Verify a match, and that no context was specified for #id
                if ( match && (match[1] || !context) ) {

                        // HANDLE: $(html) -> $(array)
                        if ( match[1] ) {
                                context = context instanceof jQuery ? context[0] : context;
                                doc = ( context ? context.ownerDocument || context : document );

                                // If a single string is passed in and it's a single tag
                                // just do a createElement and skip the rest
                                ret = rsingleTag.exec( selector );

                                if ( ret ) {
                                        if ( jQuery.isPlainObject( context ) ) {
                                                selector = [ document.createElement( ret[1] ) ];
                                                jQuery.fn.attr.call( selector, context, true );

                                        } else {
                                                selector = [ doc.createElement( ret[1] ) ];
                                        }

                                } else {
                                        ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
                                        selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes;
                                }

                                return jQuery.merge( this, selector );

                        // HANDLE: $("#id")
                        } else {
                                elem = document.getElementById( match[2] );

                                // Check parentNode to catch when Blackberry 4.6 returns
                                // nodes that are no longer in the document #6963
                                if ( elem && elem.parentNode ) {
                                        // Handle the case where IE and Opera return items
                                        // by name instead of ID
                                        if ( elem.id !== match[2] ) {
                                                return rootjQuery.find( selector );
                                        }

                                        // Otherwise, we inject the element directly into the jQuery object
                                        this.length = 1;
                                        this[0] = elem;
                                }

                                this.context = document;
                                this.selector = selector;
                                return this;
                        }

                // HANDLE: $(expr, $(...))
                } else if ( !context || context.jquery ) {
                        return ( context || rootjQuery ).find( selector );

                // HANDLE: $(expr, context)
                // (which is just equivalent to: $(context).find(expr)
                } else {
                        return this.constructor( context ).find( selector );
                }

        // HANDLE: $(function)
        // Shortcut for document ready
        } else if ( jQuery.isFunction( selector ) ) {
                return rootjQuery.ready( selector );
        }

        if ( selector.selector !== undefined ) {
                this.selector = selector.selector;
                this.context = selector.context;
        }

        return jQuery.makeArray( selector, this );
},

// Start with an empty selector
selector: "",

// The current version of jQuery being used
jquery: "1.7.2",

// The default length of a jQuery object is 0
length: 0,

// The number of elements contained in the matched element set
size: function() {
        return this.length;
},

toArray: function() {
        return slice.call( this, 0 );
},

// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function( num ) {
        return num == null ?

                // Return a 'clean' array
                this.toArray() :

                // Return just the object
                ( num < 0 ? this[ this.length + num ] : this[ num ] );
},

// Take an array of elements and push it onto the stack
// (returning the new matched element set)
pushStack: function( elems, name, selector ) {
        // Build a new jQuery matched element set
        var ret = this.constructor();

        if ( jQuery.isArray( elems ) ) {
                push.apply( ret, elems );

        } else {
                jQuery.merge( ret, elems );
        }

        // Add the old object onto the stack (as a reference)
        ret.prevObject = this;

        ret.context = this.context;

        if ( name === "find" ) {
                ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
        } else if ( name ) {
                ret.selector = this.selector + "." + name + "(" + selector + ")";
        }

        // Return the newly-formed element set
        return ret;
},

// Execute a callback for every element in the matched set.
// (You can seed the arguments with an array of args, but this is
// only used internally.)
each: function( callback, args ) {
        return jQuery.each( this, callback, args );
},

ready: function( fn ) {
        // Attach the listeners
        jQuery.bindReady();

        // Add the callback
        readyList.add( fn );

        return this;
},

eq: function( i ) {
        i = +i;
        return i === -1 ?
                this.slice( i ) :
                this.slice( i, i + 1 );
},

first: function() {
        return this.eq( 0 );
},

last: function() {
        return this.eq( -1 );
},

slice: function() {
        return this.pushStack( slice.apply( this, arguments ),
                "slice", slice.call(arguments).join(",") );
},

map: function( callback ) {
        return this.pushStack( jQuery.map(this, function( elem, i ) {
                return callback.call( elem, i, elem );
        }));
},

end: function() {
        return this.prevObject || this.constructor(null);
},

// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: push,
sort: [].sort,
splice: [].splice

};

// Give the init function the jQuery prototype for later instantiation jQuery.fn.init.prototype = jQuery.fn;

jQuery.extend = jQuery.fn.extend = function() {

var options, name, src, copy, copyIsArray, clone,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length,
        deep = false;

// Handle a deep copy situation
if ( typeof target === "boolean" ) {
        deep = target;
        target = arguments[1] || {};
        // skip the boolean and the target
        i = 2;
}

// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
        target = {};
}

// extend jQuery itself if only one argument is passed
if ( length === i ) {
        target = this;
        --i;
}

for ( ; i < length; i++ ) {
        // Only deal with non-null/undefined values
        if ( (options = arguments[ i ]) != null ) {
                // Extend the base object
                for ( name in options ) {
                        src = target[ name ];
                        copy = options[ name ];

                        // Prevent never-ending loop
                        if ( target === copy ) {
                                continue;
                        }

                        // Recurse if we're merging plain objects or arrays
                        if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
                                if ( copyIsArray ) {
                                        copyIsArray = false;
                                        clone = src && jQuery.isArray(src) ? src : [];

                                } else {
                                        clone = src && jQuery.isPlainObject(src) ? src : {};
                                }

                                // Never move original objects, clone them
                                target[ name ] = jQuery.extend( deep, clone, copy );

                        // Don't bring in undefined values
                        } else if ( copy !== undefined ) {
                                target[ name ] = copy;
                        }
                }
        }
}

// Return the modified object
return target;

};

jQuery.extend({

noConflict: function( deep ) {
        if ( window.$ === jQuery ) {
                window.$ = _$;
        }

        if ( deep && window.jQuery === jQuery ) {
                window.jQuery = _jQuery;
        }

        return jQuery;
},

// Is the DOM ready to be used? Set to true once it occurs.
isReady: false,

// A counter to track how many items to wait for before
// the ready event fires. See #6781
readyWait: 1,

// Hold (or release) the ready event
holdReady: function( hold ) {
        if ( hold ) {
                jQuery.readyWait++;
        } else {
                jQuery.ready( true );
        }
},

// Handle when the DOM is ready
ready: function( wait ) {
        // Either a released hold or an DOMready/load event and not yet ready
        if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
                // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
                if ( !document.body ) {
                        return setTimeout( jQuery.ready, 1 );
                }

                // Remember that the DOM is ready
                jQuery.isReady = true;

                // If a normal DOM Ready event fired, decrement, and wait if need be
                if ( wait !== true && --jQuery.readyWait > 0 ) {
                        return;
                }

                // If there are functions bound, to execute
                readyList.fireWith( document, [ jQuery ] );

                // Trigger any bound ready events
                if ( jQuery.fn.trigger ) {
                        jQuery( document ).trigger( "ready" ).off( "ready" );
                }
        }
},

bindReady: function() {
        if ( readyList ) {
                return;
        }

        readyList = jQuery.Callbacks( "once memory" );

        // Catch cases where $(document).ready() is called after the
        // browser event has already occurred.
        if ( document.readyState === "complete" ) {
                // Handle it asynchronously to allow scripts the opportunity to delay ready
                return setTimeout( jQuery.ready, 1 );
        }

        // Mozilla, Opera and webkit nightlies currently support this event
        if ( document.addEventListener ) {
                // Use the handy event callback
                document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );

                // A fallback to window.onload, that will always work
                window.addEventListener( "load", jQuery.ready, false );

        // If IE event model is used
        } else if ( document.attachEvent ) {
                // ensure firing before onload,
                // maybe late but safe also for iframes
                document.attachEvent( "onreadystatechange", DOMContentLoaded );

                // A fallback to window.onload, that will always work
                window.attachEvent( "onload", jQuery.ready );

                // If IE and not a frame
                // continually check to see if the document is ready
                var toplevel = false;

                try {
                        toplevel = window.frameElement == null;
                } catch(e) {}

                if ( document.documentElement.doScroll && toplevel ) {
                        doScrollCheck();
                }
        }
},

// See test/unit/core.js for details concerning isFunction.
// Since version 1.3, DOM methods and functions like alert
// aren't supported. They return false on IE (#2968).
isFunction: function( obj ) {
        return jQuery.type(obj) === "function";
},

isArray: Array.isArray || function( obj ) {
        return jQuery.type(obj) === "array";
},

isWindow: function( obj ) {
        return obj != null && obj == obj.window;
},

isNumeric: function( obj ) {
        return !isNaN( parseFloat(obj) ) && isFinite( obj );
},

type: function( obj ) {
        return obj == null ?
                String( obj ) :
                class2type[ toString.call(obj) ] || "object";
},

isPlainObject: function( obj ) {
        // Must be an Object.
        // Because of IE, we also have to check the presence of the constructor property.
        // Make sure that DOM nodes and window objects don't pass through, as well
        if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
                return false;
        }

        try {
                // Not own constructor property must be Object
                if ( obj.constructor &&
                        !hasOwn.call(obj, "constructor") &&
                        !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
                        return false;
                }
        } catch ( e ) {
                // IE8,9 Will throw exceptions on certain host objects #9897
                return false;
        }

        // Own properties are enumerated firstly, so to speed up,
        // if last one is own, then all properties are own.

        var key;
        for ( key in obj ) {}

        return key === undefined || hasOwn.call( obj, key );
},

isEmptyObject: function( obj ) {
        for ( var name in obj ) {
                return false;
        }
        return true;
},

error: function( msg ) {
        throw new Error( msg );
},

parseJSON: function( data ) {
        if ( typeof data !== "string" || !data ) {
                return null;
        }

        // Make sure leading/trailing whitespace is removed (IE can't handle it)
        data = jQuery.trim( data );

        // Attempt to parse using the native JSON parser first
        if ( window.JSON && window.JSON.parse ) {
                return window.JSON.parse( data );
        }

        // Make sure the incoming data is actual JSON
        // Logic borrowed from http://json.org/json2.js
        if ( rvalidchars.test( data.replace( rvalidescape, "@" )
                .replace( rvalidtokens, "]" )
                .replace( rvalidbraces, "")) ) {

                return ( new Function( "return " + data ) )();

        }
        jQuery.error( "Invalid JSON: " + data );
},

// Cross-browser xml parsing
parseXML: function( data ) {
        if ( typeof data !== "string" || !data ) {
                return null;
        }
        var xml, tmp;
        try {
                if ( window.DOMParser ) { // Standard
                        tmp = new DOMParser();
                        xml = tmp.parseFromString( data , "text/xml" );
                } else { // IE
                        xml = new ActiveXObject( "Microsoft.XMLDOM" );
                        xml.async = "false";
                        xml.loadXML( data );
                }
        } catch( e ) {
                xml = undefined;
        }
        if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
                jQuery.error( "Invalid XML: " + data );
        }
        return xml;
},

noop: function() {},

// Evaluates a script in a global context
// Workarounds based on findings by Jim Driscoll
// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
globalEval: function( data ) {
        if ( data && rnotwhite.test( data ) ) {
                // We use execScript on Internet Explorer
                // We use an anonymous function so that context is window
                // rather than jQuery in Firefox
                ( window.execScript || function( data ) {
                        window[ "eval" ].call( window, data );
                } )( data );
        }
},

// Convert dashed to camelCase; used by the css and data modules
// Microsoft forgot to hump their vendor prefix (#9572)
camelCase: function( string ) {
        return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
},

nodeName: function( elem, name ) {
        return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
},

// args is for internal usage only
each: function( object, callback, args ) {
        var name, i = 0,
                length = object.length,
                isObj = length === undefined || jQuery.isFunction( object );

        if ( args ) {
                if ( isObj ) {
                        for ( name in object ) {
                                if ( callback.apply( object[ name ], args ) === false ) {
                                        break;
                                }
                        }
                } else {
                        for ( ; i < length; ) {
                                if ( callback.apply( object[ i++ ], args ) === false ) {
                                        break;
                                }
                        }
                }

        // A special, fast, case for the most common use of each
        } else {
                if ( isObj ) {
                        for ( name in object ) {
                                if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
                                        break;
                                }
                        }
                } else {
                        for ( ; i < length; ) {
                                if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
                                        break;
                                }
                        }
                }
        }

        return object;
},

// Use native String.trim function wherever possible
trim: trim ?
        function( text ) {
                return text == null ?
                        "" :
                        trim.call( text );
        } :

        // Otherwise use our own trimming functionality
        function( text ) {
                return text == null ?
                        "" :
                        text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
        },

// results is for internal usage only
makeArray: function( array, results ) {
        var ret = results || [];

        if ( array != null ) {
                // The window, strings (and functions) also have 'length'
                // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
                var type = jQuery.type( array );

                if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
                        push.call( ret, array );
                } else {
                        jQuery.merge( ret, array );
                }
        }

        return ret;
},

inArray: function( elem, array, i ) {
        var len;

        if ( array ) {
                if ( indexOf ) {
                        return indexOf.call( array, elem, i );
                }

                len = array.length;
                i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;

                for ( ; i < len; i++ ) {
                        // Skip accessing in sparse arrays
                        if ( i in array && array[ i ] === elem ) {
                                return i;
                        }
                }
        }

        return -1;
},

merge: function( first, second ) {
        var i = first.length,
                j = 0;

        if ( typeof second.length === "number" ) {
                for ( var l = second.length; j < l; j++ ) {
                        first[ i++ ] = second[ j ];
                }

        } else {
                while ( second[j] !== undefined ) {
                        first[ i++ ] = second[ j++ ];
                }
        }

        first.length = i;

        return first;
},

grep: function( elems, callback, inv ) {
        var ret = [], retVal;
        inv = !!inv;

        // Go through the array, only saving the items
        // that pass the validator function
        for ( var i = 0, length = elems.length; i < length; i++ ) {
                retVal = !!callback( elems[ i ], i );
                if ( inv !== retVal ) {
                        ret.push( elems[ i ] );
                }
        }

        return ret;
},

// arg is for internal usage only
map: function( elems, callback, arg ) {
        var value, key, ret = [],
                i = 0,
                length = elems.length,
                // jquery objects are treated as arrays
                isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;

        // Go through the array, translating each of the items to their
        if ( isArray ) {
                for ( ; i < length; i++ ) {
                        value = callback( elems[ i ], i, arg );

                        if ( value != null ) {
                                ret[ ret.length ] = value;
                        }
                }

        // Go through every key on the object,
        } else {
                for ( key in elems ) {
                        value = callback( elems[ key ], key, arg );

                        if ( value != null ) {
                                ret[ ret.length ] = value;
                        }
                }
        }

        // Flatten any nested arrays
        return ret.concat.apply( [], ret );
},

// A global GUID counter for objects
guid: 1,

// Bind a function to a context, optionally partially applying any
// arguments.
proxy: function( fn, context ) {
        if ( typeof context === "string" ) {
                var tmp = fn[ context ];
                context = fn;
                fn = tmp;
        }

        // Quick check to determine if target is callable, in the spec
        // this throws a TypeError, but we will just return undefined.
        if ( !jQuery.isFunction( fn ) ) {
                return undefined;
        }

        // Simulated bind
        var args = slice.call( arguments, 2 ),
                proxy = function() {
                        return fn.apply( context, args.concat( slice.call( arguments ) ) );
                };

        // Set the guid of unique handler to the same of original handler, so it can be removed
        proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;

        return proxy;
},

// Mutifunctional method to get and set values to a collection
// The value/s can optionally be executed if it's a function
access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
        var exec,
                bulk = key == null,
                i = 0,
                length = elems.length;

        // Sets many values
        if ( key && typeof key === "object" ) {
                for ( i in key ) {
                        jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
                }
                chainable = 1;

        // Sets one value
        } else if ( value !== undefined ) {
                // Optionally, function values get executed if exec is true
                exec = pass === undefined && jQuery.isFunction( value );

                if ( bulk ) {
                        // Bulk operations only iterate when executing function values
                        if ( exec ) {
                                exec = fn;
                                fn = function( elem, key, value ) {
                                        return exec.call( jQuery( elem ), value );
                                };

                        // Otherwise they run against the entire set
                        } else {
                                fn.call( elems, value );
                                fn = null;
                        }
                }

                if ( fn ) {
                        for (; i < length; i++ ) {
                                fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
                        }
                }

                chainable = 1;
        }

        return chainable ?
                elems :

                // Gets
                bulk ?
                        fn.call( elems ) :
                        length ? fn( elems[0], key ) : emptyGet;
},

now: function() {
        return ( new Date() ).getTime();
},

// Use of jQuery.browser is frowned upon.
// More details: http://docs.jquery.com/Utilities/jQuery.browser
uaMatch: function( ua ) {
        ua = ua.toLowerCase();

        var match = rwebkit.exec( ua ) ||
                ropera.exec( ua ) ||
                rmsie.exec( ua ) ||
                ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
                [];

        return { browser: match[1] || "", version: match[2] || "0" };
},

sub: function() {
        function jQuerySub( selector, context ) {
                return new jQuerySub.fn.init( selector, context );
        }
        jQuery.extend( true, jQuerySub, this );
        jQuerySub.superclass = this;
        jQuerySub.fn = jQuerySub.prototype = this();
        jQuerySub.fn.constructor = jQuerySub;
        jQuerySub.sub = this.sub;
        jQuerySub.fn.init = function init( selector, context ) {
                if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
                        context = jQuerySub( context );
                }

                return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
        };
        jQuerySub.fn.init.prototype = jQuerySub.fn;
        var rootjQuerySub = jQuerySub(document);
        return jQuerySub;
},

browser: {}

});

// Populate the class2type map jQuery.each(“Boolean Number String Function Array Date RegExp Object”.split(“ ”), function(i, name) {

class2type[ "[object " + name + "]" ] = name.toLowerCase();

});

browserMatch = jQuery.uaMatch( userAgent ); if ( browserMatch.browser ) {

jQuery.browser[ browserMatch.browser ] = true;
jQuery.browser.version = browserMatch.version;

}

// Deprecated, use jQuery.browser.webkit instead if ( jQuery.browser.webkit ) {

jQuery.browser.safari = true;

}

// IE doesn't match non-breaking spaces with s if ( rnotwhite.test( “xA0” ) ) {

trimLeft = /^[\s\xA0]+/;
trimRight = /[\s\xA0]+$/;

}

// All jQuery objects should point back to these rootjQuery = jQuery(document);

// Cleanup functions for the document ready method if ( document.addEventListener ) {

DOMContentLoaded = function() {
        document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
        jQuery.ready();
};

} else if ( document.attachEvent ) {

DOMContentLoaded = function() {
        // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
        if ( document.readyState === "complete" ) {
                document.detachEvent( "onreadystatechange", DOMContentLoaded );
                jQuery.ready();
        }
};

}

// The DOM ready check for Internet Explorer function doScrollCheck() {

if ( jQuery.isReady ) {
        return;
}

try {
        // If IE is used, use the trick by Diego Perini
        // http://javascript.nwbox.com/IEContentLoaded/
        document.documentElement.doScroll("left");
} catch(e) {
        setTimeout( doScrollCheck, 1 );
        return;
}

// and execute any waiting functions
jQuery.ready();

}

return jQuery;

})();

// String to Object flags format cache var flagsCache = {};

// Convert String-formatted flags into Object-formatted ones and store in cache function createFlags( flags ) {

var object = flagsCache[ flags ] = {},
        i, length;
flags = flags.split( /\s+/ );
for ( i = 0, length = flags.length; i < length; i++ ) {
        object[ flags[i] ] = true;
}
return object;

}

/*

* Create a callback list using the following parameters:
*
*      flags:  an optional list of space-separated flags that will change how
*                      the callback list behaves
*
* By default a callback list will act like an event callback list and can be
* "fired" multiple times.
*
* Possible flags:
*
*      once:                   will ensure the callback list can only be fired once (like a Deferred)
*
*      memory:                 will keep track of previous values and will call any callback added
*                                      after the list has been fired right away with the latest "memorized"
*                                      values (like a Deferred)
*
*      unique:                 will ensure a callback can only be added once (no duplicate in the list)
*
*      stopOnFalse:    interrupt callings when a callback returns false
*
*/

jQuery.Callbacks = function( flags ) {

// Convert flags from String-formatted to Object-formatted
// (we check in cache first)
flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {};

var // Actual callback list
        list = [],
        // Stack of fire calls for repeatable lists
        stack = [],
        // Last fire value (for non-forgettable lists)
        memory,
        // Flag to know if list was already fired
        fired,
        // Flag to know if list is currently firing
        firing,
        // First callback to fire (used internally by add and fireWith)
        firingStart,
        // End of the loop when firing
        firingLength,
        // Index of currently firing callback (modified by remove if needed)
        firingIndex,
        // Add one or several callbacks to the list
        add = function( args ) {
                var i,
                        length,
                        elem,
                        type,
                        actual;
                for ( i = 0, length = args.length; i < length; i++ ) {
                        elem = args[ i ];
                        type = jQuery.type( elem );
                        if ( type === "array" ) {
                                // Inspect recursively
                                add( elem );
                        } else if ( type === "function" ) {
                                // Add if not in unique mode and callback is not in
                                if ( !flags.unique || !self.has( elem ) ) {
                                        list.push( elem );
                                }
                        }
                }
        },
        // Fire callbacks
        fire = function( context, args ) {
                args = args || [];
                memory = !flags.memory || [ context, args ];
                fired = true;
                firing = true;
                firingIndex = firingStart || 0;
                firingStart = 0;
                firingLength = list.length;
                for ( ; list && firingIndex < firingLength; firingIndex++ ) {
                        if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) {
                                memory = true; // Mark as halted
                                break;
                        }
                }
                firing = false;
                if ( list ) {
                        if ( !flags.once ) {
                                if ( stack && stack.length ) {
                                        memory = stack.shift();
                                        self.fireWith( memory[ 0 ], memory[ 1 ] );
                                }
                        } else if ( memory === true ) {
                                self.disable();
                        } else {
                                list = [];
                        }
                }
        },
        // Actual Callbacks object
        self = {
                // Add a callback or a collection of callbacks to the list
                add: function() {
                        if ( list ) {
                                var length = list.length;
                                add( arguments );
                                // Do we need to add the callbacks to the
                                // current firing batch?
                                if ( firing ) {
                                        firingLength = list.length;
                                // With memory, if we're not firing then
                                // we should call right away, unless previous
                                // firing was halted (stopOnFalse)
                                } else if ( memory && memory !== true ) {
                                        firingStart = length;
                                        fire( memory[ 0 ], memory[ 1 ] );
                                }
                        }
                        return this;
                },
                // Remove a callback from the list
                remove: function() {
                        if ( list ) {
                                var args = arguments,
                                        argIndex = 0,
                                        argLength = args.length;
                                for ( ; argIndex < argLength ; argIndex++ ) {
                                        for ( var i = 0; i < list.length; i++ ) {
                                                if ( args[ argIndex ] === list[ i ] ) {
                                                        // Handle firingIndex and firingLength
                                                        if ( firing ) {
                                                                if ( i <= firingLength ) {
                                                                        firingLength--;
                                                                        if ( i <= firingIndex ) {
                                                                                firingIndex--;
                                                                        }
                                                                }
                                                        }
                                                        // Remove the element
                                                        list.splice( i--, 1 );
                                                        // If we have some unicity property then
                                                        // we only need to do this once
                                                        if ( flags.unique ) {
                                                                break;
                                                        }
                                                }
                                        }
                                }
                        }
                        return this;
                },
                // Control if a given callback is in the list
                has: function( fn ) {
                        if ( list ) {
                                var i = 0,
                                        length = list.length;
                                for ( ; i < length; i++ ) {
                                        if ( fn === list[ i ] ) {
                                                return true;
                                        }
                                }
                        }
                        return false;
                },
                // Remove all callbacks from the list
                empty: function() {
                        list = [];
                        return this;
                },
                // Have the list do nothing anymore
                disable: function() {
                        list = stack = memory = undefined;
                        return this;
                },
                // Is it disabled?
                disabled: function() {
                        return !list;
                },
                // Lock the list in its current state
                lock: function() {
                        stack = undefined;
                        if ( !memory || memory === true ) {
                                self.disable();
                        }
                        return this;
                },
                // Is it locked?
                locked: function() {
                        return !stack;
                },
                // Call all callbacks with the given context and arguments
                fireWith: function( context, args ) {
                        if ( stack ) {
                                if ( firing ) {
                                        if ( !flags.once ) {
                                                stack.push( [ context, args ] );
                                        }
                                } else if ( !( flags.once && memory ) ) {
                                        fire( context, args );
                                }
                        }
                        return this;
                },
                // Call all the callbacks with the given arguments
                fire: function() {
                        self.fireWith( this, arguments );
                        return this;
                },
                // To know if the callbacks have already been called at least once
                fired: function() {
                        return !!fired;
                }
        };

return self;

};

var // Static reference to slice

sliceDeferred = [].slice;

jQuery.extend({

Deferred: function( func ) {
        var doneList = jQuery.Callbacks( "once memory" ),
                failList = jQuery.Callbacks( "once memory" ),
                progressList = jQuery.Callbacks( "memory" ),
                state = "pending",
                lists = {
                        resolve: doneList,
                        reject: failList,
                        notify: progressList
                },
                promise = {
                        done: doneList.add,
                        fail: failList.add,
                        progress: progressList.add,

                        state: function() {
                                return state;
                        },

                        // Deprecated
                        isResolved: doneList.fired,
                        isRejected: failList.fired,

                        then: function( doneCallbacks, failCallbacks, progressCallbacks ) {
                                deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks );
                                return this;
                        },
                        always: function() {
                                deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
                                return this;
                        },
                        pipe: function( fnDone, fnFail, fnProgress ) {
                                return jQuery.Deferred(function( newDefer ) {
                                        jQuery.each( {
                                                done: [ fnDone, "resolve" ],
                                                fail: [ fnFail, "reject" ],
                                                progress: [ fnProgress, "notify" ]
                                        }, function( handler, data ) {
                                                var fn = data[ 0 ],
                                                        action = data[ 1 ],
                                                        returned;
                                                if ( jQuery.isFunction( fn ) ) {
                                                        deferred[ handler ](function() {
                                                                returned = fn.apply( this, arguments );
                                                                if ( returned && jQuery.isFunction( returned.promise ) ) {
                                                                        returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify );
                                                                } else {
                                                                        newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
                                                                }
                                                        });
                                                } else {
                                                        deferred[ handler ]( newDefer[ action ] );
                                                }
                                        });
                                }).promise();
                        },
                        // Get a promise for this deferred
                        // If obj is provided, the promise aspect is added to the object
                        promise: function( obj ) {
                                if ( obj == null ) {
                                        obj = promise;
                                } else {
                                        for ( var key in promise ) {
                                                obj[ key ] = promise[ key ];
                                        }
                                }
                                return obj;
                        }
                },
                deferred = promise.promise({}),
                key;

        for ( key in lists ) {
                deferred[ key ] = lists[ key ].fire;
                deferred[ key + "With" ] = lists[ key ].fireWith;
        }

        // Handle state
        deferred.done( function() {
                state = "resolved";
        }, failList.disable, progressList.lock ).fail( function() {
                state = "rejected";
        }, doneList.disable, progressList.lock );

        // Call given func if any
        if ( func ) {
                func.call( deferred, deferred );
        }

        // All done!
        return deferred;
},

// Deferred helper
when: function( firstParam ) {
        var args = sliceDeferred.call( arguments, 0 ),
                i = 0,
                length = args.length,
                pValues = new Array( length ),
                count = length,
                pCount = length,
                deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
                        firstParam :
                        jQuery.Deferred(),
                promise = deferred.promise();
        function resolveFunc( i ) {
                return function( value ) {
                        args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
                        if ( !( --count ) ) {
                                deferred.resolveWith( deferred, args );
                        }
                };
        }
        function progressFunc( i ) {
                return function( value ) {
                        pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
                        deferred.notifyWith( promise, pValues );
                };
        }
        if ( length > 1 ) {
                for ( ; i < length; i++ ) {
                        if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) {
                                args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) );
                        } else {
                                --count;
                        }
                }
                if ( !count ) {
                        deferred.resolveWith( deferred, args );
                }
        } else if ( deferred !== firstParam ) {
                deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
        }
        return promise;
}

});

jQuery.support = (function() {

var support,
        all,
        a,
        select,
        opt,
        input,
        fragment,
        tds,
        events,
        eventName,
        i,
        isSupported,
        div = document.createElement( "div" ),
        documentElement = document.documentElement;

// Preliminary tests
div.setAttribute("className", "t");
div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";

all = div.getElementsByTagName( "*" );
a = div.getElementsByTagName( "a" )[ 0 ];

// Can't get basic test support
if ( !all || !all.length || !a ) {
        return {};
}

// First batch of supports tests
select = document.createElement( "select" );
opt = select.appendChild( document.createElement("option") );
input = div.getElementsByTagName( "input" )[ 0 ];

support = {
        // IE strips leading whitespace when .innerHTML is used
        leadingWhitespace: ( div.firstChild.nodeType === 3 ),

        // Make sure that tbody elements aren't automatically inserted
        // IE will insert them into empty tables
        tbody: !div.getElementsByTagName("tbody").length,

        // Make sure that link elements get serialized correctly by innerHTML
        // This requires a wrapper element in IE
        htmlSerialize: !!div.getElementsByTagName("link").length,

        // Get the style information from getAttribute
        // (IE uses .cssText instead)
        style: /top/.test( a.getAttribute("style") ),

        // Make sure that URLs aren't manipulated
        // (IE normalizes it by default)
        hrefNormalized: ( a.getAttribute("href") === "/a" ),

        // Make sure that element opacity exists
        // (IE uses filter instead)
        // Use a regex to work around a WebKit issue. See #5145
        opacity: /^0.55/.test( a.style.opacity ),

        // Verify style float existence
        // (IE uses styleFloat instead of cssFloat)
        cssFloat: !!a.style.cssFloat,

        // Make sure that if no value is specified for a checkbox
        // that it defaults to "on".
        // (WebKit defaults to "" instead)
        checkOn: ( input.value === "on" ),

        // Make sure that a selected-by-default option has a working selected property.
        // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
        optSelected: opt.selected,

        // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
        getSetAttribute: div.className !== "t",

        // Tests for enctype support on a form(#6743)
        enctype: !!document.createElement("form").enctype,

        // Makes sure cloning an html5 element does not cause problems
        // Where outerHTML is undefined, this still works
        html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",

        // Will be defined later
        submitBubbles: true,
        changeBubbles: true,
        focusinBubbles: false,
        deleteExpando: true,
        noCloneEvent: true,
        inlineBlockNeedsLayout: false,
        shrinkWrapBlocks: false,
        reliableMarginRight: true,
        pixelMargin: true
};

// jQuery.boxModel DEPRECATED in 1.3, use jQuery.support.boxModel instead
jQuery.boxModel = support.boxModel = (document.compatMode === "CSS1Compat");

// Make sure checked status is properly cloned
input.checked = true;
support.noCloneChecked = input.cloneNode( true ).checked;

// Make sure that the options inside disabled selects aren't marked as disabled
// (WebKit marks them as disabled)
select.disabled = true;
support.optDisabled = !opt.disabled;

// Test to see if it's possible to delete an expando from an element
// Fails in Internet Explorer
try {
        delete div.test;
} catch( e ) {
        support.deleteExpando = false;
}

if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
        div.attachEvent( "onclick", function() {
                // Cloning a node shouldn't copy over any
                // bound event handlers (IE does this)
                support.noCloneEvent = false;
        });
        div.cloneNode( true ).fireEvent( "onclick" );
}

// Check if a radio maintains its value
// after being appended to the DOM
input = document.createElement("input");
input.value = "t";
input.setAttribute("type", "radio");
support.radioValue = input.value === "t";

input.setAttribute("checked", "checked");

// #11217 - WebKit loses check when the name is after the checked attribute
input.setAttribute( "name", "t" );

div.appendChild( input );
fragment = document.createDocumentFragment();
fragment.appendChild( div.lastChild );

// WebKit doesn't clone checked state correctly in fragments
support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;

// Check if a disconnected checkbox will retain its checked
// value of true after appended to the DOM (IE6/7)
support.appendChecked = input.checked;

fragment.removeChild( input );
fragment.appendChild( div );

// Technique from Juriy Zaytsev
// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
// We only care about the case where non-standard event systems
// are used, namely in IE. Short-circuiting here helps us to
// avoid an eval call (in setAttribute) which can cause CSP
// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
if ( div.attachEvent ) {
        for ( i in {
                submit: 1,
                change: 1,
                focusin: 1
        }) {
                eventName = "on" + i;
                isSupported = ( eventName in div );
                if ( !isSupported ) {
                        div.setAttribute( eventName, "return;" );
                        isSupported = ( typeof div[ eventName ] === "function" );
                }
                support[ i + "Bubbles" ] = isSupported;
        }
}

fragment.removeChild( div );

// Null elements to avoid leaks in IE
fragment = select = opt = div = input = null;

// Run tests that need a body at doc ready
jQuery(function() {
        var container, outer, inner, table, td, offsetSupport,
                marginDiv, conMarginTop, style, html, positionTopLeftWidthHeight,
                paddingMarginBorderVisibility, paddingMarginBorder,
                body = document.getElementsByTagName("body")[0];

        if ( !body ) {
                // Return for frameset docs that don't have a body
                return;
        }

        conMarginTop = 1;
        paddingMarginBorder = "padding:0;margin:0;border:";
        positionTopLeftWidthHeight = "position:absolute;top:0;left:0;width:1px;height:1px;";
        paddingMarginBorderVisibility = paddingMarginBorder + "0;visibility:hidden;";
        style = "style='" + positionTopLeftWidthHeight + paddingMarginBorder + "5px solid #000;";
        html = "<div " + style + "display:block;'><div style='" + paddingMarginBorder + "0;display:block;overflow:hidden;'></div></div>" +
                "<table " + style + "' cellpadding='0' cellspacing='0'>" +
                "<tr><td></td></tr></table>";

        container = document.createElement("div");
        container.style.cssText = paddingMarginBorderVisibility + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px";
        body.insertBefore( container, body.firstChild );

        // Construct the test element
        div = document.createElement("div");
        container.appendChild( div );

        // Check if table cells still have offsetWidth/Height when they are set
        // to display:none and there are still other visible table cells in a
        // table row; if so, offsetWidth/Height are not reliable for use when
        // determining if an element has been hidden directly using
        // display:none (it is still safe to use offsets if a parent element is
        // hidden; don safety goggles and see bug #4512 for more information).
        // (only IE 8 fails this test)
        div.innerHTML = "<table><tr><td style='" + paddingMarginBorder + "0;display:none'></td><td>t</td></tr></table>";
        tds = div.getElementsByTagName( "td" );
        isSupported = ( tds[ 0 ].offsetHeight === 0 );

        tds[ 0 ].style.display = "";
        tds[ 1 ].style.display = "none";

        // Check if empty table cells still have offsetWidth/Height
        // (IE <= 8 fail this test)
        support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );

        // Check if div with explicit width and no margin-right incorrectly
        // gets computed margin-right based on width of container. For more
        // info see bug #3333
        // Fails in WebKit before Feb 2011 nightlies
        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
        if ( window.getComputedStyle ) {
                div.innerHTML = "";
                marginDiv = document.createElement( "div" );
                marginDiv.style.width = "0";
                marginDiv.style.marginRight = "0";
                div.style.width = "2px";
                div.appendChild( marginDiv );
                support.reliableMarginRight =
                        ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
        }

        if ( typeof div.style.zoom !== "undefined" ) {
                // Check if natively block-level elements act like inline-block
                // elements when setting their display to 'inline' and giving
                // them layout
                // (IE < 8 does this)
                div.innerHTML = "";
                div.style.width = div.style.padding = "1px";
                div.style.border = 0;
                div.style.overflow = "hidden";
                div.style.display = "inline";
                div.style.zoom = 1;
                support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );

                // Check if elements with layout shrink-wrap their children
                // (IE 6 does this)
                div.style.display = "block";
                div.style.overflow = "visible";
                div.innerHTML = "<div style='width:5px;'></div>";
                support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
        }

        div.style.cssText = positionTopLeftWidthHeight + paddingMarginBorderVisibility;
        div.innerHTML = html;

        outer = div.firstChild;
        inner = outer.firstChild;
        td = outer.nextSibling.firstChild.firstChild;

        offsetSupport = {
                doesNotAddBorder: ( inner.offsetTop !== 5 ),
                doesAddBorderForTableAndCells: ( td.offsetTop === 5 )
        };

        inner.style.position = "fixed";
        inner.style.top = "20px";

        // safari subtracts parent border width here which is 5px
        offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 );
        inner.style.position = inner.style.top = "";

        outer.style.overflow = "hidden";
        outer.style.position = "relative";

        offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 );
        offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop );

        if ( window.getComputedStyle ) {
                div.style.marginTop = "1%";
                support.pixelMargin = ( window.getComputedStyle( div, null ) || { marginTop: 0 } ).marginTop !== "1%";
        }

        if ( typeof container.style.zoom !== "undefined" ) {
                container.style.zoom = 1;
        }

        body.removeChild( container );
        marginDiv = div = container = null;

        jQuery.extend( support, offsetSupport );
});

return support;

})();

var rbrace = /^(?:{.*}|[.*])$/,

rmultiDash = /([A-Z])/g;

jQuery.extend({

cache: {},

// Please use with caution
uuid: 0,

// Unique for each copy of jQuery on the page
// Non-digits removed to match rinlinejQuery
expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),

// The following elements throw uncatchable exceptions if you
// attempt to add expando properties to them.
noData: {
        "embed": true,
        // Ban all objects except for Flash (which handle expandos)
        "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
        "applet": true
},

hasData: function( elem ) {
        elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
        return !!elem && !isEmptyDataObject( elem );
},

data: function( elem, name, data, pvt /* Internal Use Only */ ) {
        if ( !jQuery.acceptData( elem ) ) {
                return;
        }

        var privateCache, thisCache, ret,
                internalKey = jQuery.expando,
                getByName = typeof name === "string",

                // We have to handle DOM nodes and JS objects differently because IE6-7
                // can't GC object references properly across the DOM-JS boundary
                isNode = elem.nodeType,

                // Only DOM nodes need the global jQuery cache; JS object data is
                // attached directly to the object so GC can occur automatically
                cache = isNode ? jQuery.cache : elem,

                // Only defining an ID for JS objects if its cache already exists allows
                // the code to shortcut on the same path as a DOM node with no cache
                id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey,
                isEvents = name === "events";

        // Avoid doing any more work than we need to when trying to get data on an
        // object that has no data at all
        if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) {
                return;
        }

        if ( !id ) {
                // Only DOM nodes need a new unique ID for each element since their data
                // ends up in the global cache
                if ( isNode ) {
                        elem[ internalKey ] = id = ++jQuery.uuid;
                } else {
                        id = internalKey;
                }
        }

        if ( !cache[ id ] ) {
                cache[ id ] = {};

                // Avoids exposing jQuery metadata on plain JS objects when the object
                // is serialized using JSON.stringify
                if ( !isNode ) {
                        cache[ id ].toJSON = jQuery.noop;
                }
        }

        // An object can be passed to jQuery.data instead of a key/value pair; this gets
        // shallow copied over onto the existing cache
        if ( typeof name === "object" || typeof name === "function" ) {
                if ( pvt ) {
                        cache[ id ] = jQuery.extend( cache[ id ], name );
                } else {
                        cache[ id ].data = jQuery.extend( cache[ id ].data, name );
                }
        }

        privateCache = thisCache = cache[ id ];

        // jQuery data() is stored in a separate object inside the object's internal data
        // cache in order to avoid key collisions between internal data and user-defined
        // data.
        if ( !pvt ) {
                if ( !thisCache.data ) {
                        thisCache.data = {};
                }

                thisCache = thisCache.data;
        }

        if ( data !== undefined ) {
                thisCache[ jQuery.camelCase( name ) ] = data;
        }

        // Users should not attempt to inspect the internal events object using jQuery.data,
        // it is undocumented and subject to change. But does anyone listen? No.
        if ( isEvents && !thisCache[ name ] ) {
                return privateCache.events;
        }

        // Check for both converted-to-camel and non-converted data property names
        // If a data property was specified
        if ( getByName ) {

                // First Try to find as-is property data
                ret = thisCache[ name ];

                // Test for null|undefined property data
                if ( ret == null ) {

                        // Try to find the camelCased property
                        ret = thisCache[ jQuery.camelCase( name ) ];
                }
        } else {
                ret = thisCache;
        }

        return ret;
},

removeData: function( elem, name, pvt /* Internal Use Only */ ) {
        if ( !jQuery.acceptData( elem ) ) {
                return;
        }

        var thisCache, i, l,

                // Reference to internal data cache key
                internalKey = jQuery.expando,

                isNode = elem.nodeType,

                // See jQuery.data for more information
                cache = isNode ? jQuery.cache : elem,

                // See jQuery.data for more information
                id = isNode ? elem[ internalKey ] : internalKey;

        // If there is already no cache entry for this object, there is no
        // purpose in continuing
        if ( !cache[ id ] ) {
                return;
        }

        if ( name ) {

                thisCache = pvt ? cache[ id ] : cache[ id ].data;

                if ( thisCache ) {

                        // Support array or space separated string names for data keys
                        if ( !jQuery.isArray( name ) ) {

                                // try the string as a key before any manipulation
                                if ( name in thisCache ) {
                                        name = [ name ];
                                } else {

                                        // split the camel cased version by spaces unless a key with the spaces exists
                                        name = jQuery.camelCase( name );
                                        if ( name in thisCache ) {
                                                name = [ name ];
                                        } else {
                                                name = name.split( " " );
                                        }
                                }
                        }

                        for ( i = 0, l = name.length; i < l; i++ ) {
                                delete thisCache[ name[i] ];
                        }

                        // If there is no data left in the cache, we want to continue
                        // and let the cache object itself get destroyed
                        if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
                                return;
                        }
                }
        }

        // See jQuery.data for more information
        if ( !pvt ) {
                delete cache[ id ].data;

                // Don't destroy the parent cache unless the internal data object
                // had been the only thing left in it
                if ( !isEmptyDataObject(cache[ id ]) ) {
                        return;
                }
        }

        // Browsers that fail expando deletion also refuse to delete expandos on
        // the window, but it will allow it on all other JS objects; other browsers
        // don't care
        // Ensure that `cache` is not a window object #10080
        if ( jQuery.support.deleteExpando || !cache.setInterval ) {
                delete cache[ id ];
        } else {
                cache[ id ] = null;
        }

        // We destroyed the cache and need to eliminate the expando on the node to avoid
        // false lookups in the cache for entries that no longer exist
        if ( isNode ) {
                // IE does not allow us to delete expando properties from nodes,
                // nor does it have a removeAttribute function on Document nodes;
                // we must handle all of these cases
                if ( jQuery.support.deleteExpando ) {
                        delete elem[ internalKey ];
                } else if ( elem.removeAttribute ) {
                        elem.removeAttribute( internalKey );
                } else {
                        elem[ internalKey ] = null;
                }
        }
},

// For internal use only.
_data: function( elem, name, data ) {
        return jQuery.data( elem, name, data, true );
},

// A method for determining if a DOM node can handle the data expando
acceptData: function( elem ) {
        if ( elem.nodeName ) {
                var match = jQuery.noData[ elem.nodeName.toLowerCase() ];

                if ( match ) {
                        return !(match === true || elem.getAttribute("classid") !== match);
                }
        }

        return true;
}

});

jQuery.fn.extend({

data: function( key, value ) {
        var parts, part, attr, name, l,
                elem = this[0],
                i = 0,
                data = null;

        // Gets all values
        if ( key === undefined ) {
                if ( this.length ) {
                        data = jQuery.data( elem );

                        if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
                                attr = elem.attributes;
                                for ( l = attr.length; i < l; i++ ) {
                                        name = attr[i].name;

                                        if ( name.indexOf( "data-" ) === 0 ) {
                                                name = jQuery.camelCase( name.substring(5) );

                                                dataAttr( elem, name, data[ name ] );
                                        }
                                }
                                jQuery._data( elem, "parsedAttrs", true );
                        }
                }

                return data;
        }

        // Sets multiple values
        if ( typeof key === "object" ) {
                return this.each(function() {
                        jQuery.data( this, key );
                });
        }

        parts = key.split( ".", 2 );
        parts[1] = parts[1] ? "." + parts[1] : "";
        part = parts[1] + "!";

        return jQuery.access( this, function( value ) {

                if ( value === undefined ) {
                        data = this.triggerHandler( "getData" + part, [ parts[0] ] );

                        // Try to fetch any internally stored data first
                        if ( data === undefined && elem ) {
                                data = jQuery.data( elem, key );
                                data = dataAttr( elem, key, data );
                        }

                        return data === undefined && parts[1] ?
                                this.data( parts[0] ) :
                                data;
                }

                parts[1] = value;
                this.each(function() {
                        var self = jQuery( this );

                        self.triggerHandler( "setData" + part, parts );
                        jQuery.data( this, key, value );
                        self.triggerHandler( "changeData" + part, parts );
                });
        }, null, value, arguments.length > 1, null, false );
},

removeData: function( key ) {
        return this.each(function() {
                jQuery.removeData( this, key );
        });
}

});

function dataAttr( elem, key, data ) {

// If nothing was found internally, try to fetch any
// data from the HTML5 data-* attribute
if ( data === undefined && elem.nodeType === 1 ) {

        var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();

        data = elem.getAttribute( name );

        if ( typeof data === "string" ) {
                try {
                        data = data === "true" ? true :
                        data === "false" ? false :
                        data === "null" ? null :
                        jQuery.isNumeric( data ) ? +data :
                                rbrace.test( data ) ? jQuery.parseJSON( data ) :
                                data;
                } catch( e ) {}

                // Make sure we set the data so it isn't changed later
                jQuery.data( elem, key, data );

        } else {
                data = undefined;
        }
}

return data;

}

// checks a cache object for emptiness function isEmptyDataObject( obj ) {

for ( var name in obj ) {

        // if the public data object is empty, the private is still empty
        if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
                continue;
        }
        if ( name !== "toJSON" ) {
                return false;
        }
}

return true;

}

function handleQueueMarkDefer( elem, type, src ) {

var deferDataKey = type + "defer",
        queueDataKey = type + "queue",
        markDataKey = type + "mark",
        defer = jQuery._data( elem, deferDataKey );
if ( defer &&
        ( src === "queue" || !jQuery._data(elem, queueDataKey) ) &&
        ( src === "mark" || !jQuery._data(elem, markDataKey) ) ) {
        // Give room for hard-coded callbacks to fire first
        // and eventually mark/queue something else on the element
        setTimeout( function() {
                if ( !jQuery._data( elem, queueDataKey ) &&
                        !jQuery._data( elem, markDataKey ) ) {
                        jQuery.removeData( elem, deferDataKey, true );
                        defer.fire();
                }
        }, 0 );
}

}

jQuery.extend({

_mark: function( elem, type ) {
        if ( elem ) {
                type = ( type || "fx" ) + "mark";
                jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 );
        }
},

_unmark: function( force, elem, type ) {
        if ( force !== true ) {
                type = elem;
                elem = force;
                force = false;
        }
        if ( elem ) {
                type = type || "fx";
                var key = type + "mark",
                        count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 );
                if ( count ) {
                        jQuery._data( elem, key, count );
                } else {
                        jQuery.removeData( elem, key, true );
                        handleQueueMarkDefer( elem, type, "mark" );
                }
        }
},

queue: function( elem, type, data ) {
        var q;
        if ( elem ) {
                type = ( type || "fx" ) + "queue";
                q = jQuery._data( elem, type );

                // Speed up dequeue by getting out quickly if this is just a lookup
                if ( data ) {
                        if ( !q || jQuery.isArray(data) ) {
                                q = jQuery._data( elem, type, jQuery.makeArray(data) );
                        } else {
                                q.push( data );
                        }
                }
                return q || [];
        }
},

dequeue: function( elem, type ) {
        type = type || "fx";

        var queue = jQuery.queue( elem, type ),
                fn = queue.shift(),
                hooks = {};

        // If the fx queue is dequeued, always remove the progress sentinel
        if ( fn === "inprogress" ) {
                fn = queue.shift();
        }

        if ( fn ) {
                // Add a progress sentinel to prevent the fx queue from being
                // automatically dequeued
                if ( type === "fx" ) {
                        queue.unshift( "inprogress" );
                }

                jQuery._data( elem, type + ".run", hooks );
                fn.call( elem, function() {
                        jQuery.dequeue( elem, type );
                }, hooks );
        }

        if ( !queue.length ) {
                jQuery.removeData( elem, type + "queue " + type + ".run", true );
                handleQueueMarkDefer( elem, type, "queue" );
        }
}

});

jQuery.fn.extend({

queue: function( type, data ) {
        var setter = 2;

        if ( typeof type !== "string" ) {
                data = type;
                type = "fx";
                setter--;
        }

        if ( arguments.length < setter ) {
                return jQuery.queue( this[0], type );
        }

        return data === undefined ?
                this :
                this.each(function() {
                        var queue = jQuery.queue( this, type, data );

                        if ( type === "fx" && queue[0] !== "inprogress" ) {
                                jQuery.dequeue( this, type );
                        }
                });
},
dequeue: function( type ) {
        return this.each(function() {
                jQuery.dequeue( this, type );
        });
},
// Based off of the plugin by Clint Helfers, with permission.
// http://blindsignals.com/index.php/2009/07/jquery-delay/
delay: function( time, type ) {
        time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
        type = type || "fx";

        return this.queue( type, function( next, hooks ) {
                var timeout = setTimeout( next, time );
                hooks.stop = function() {
                        clearTimeout( timeout );
                };
        });
},
clearQueue: function( type ) {
        return this.queue( type || "fx", [] );
},
// Get a promise resolved when queues of a certain type
// are emptied (fx is the type by default)
promise: function( type, object ) {
        if ( typeof type !== "string" ) {
                object = type;
                type = undefined;
        }
        type = type || "fx";
        var defer = jQuery.Deferred(),
                elements = this,
                i = elements.length,
                count = 1,
                deferDataKey = type + "defer",
                queueDataKey = type + "queue",
                markDataKey = type + "mark",
                tmp;
        function resolve() {
                if ( !( --count ) ) {
                        defer.resolveWith( elements, [ elements ] );
                }
        }
        while( i-- ) {
                if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
                                ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
                                        jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
                                jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) {
                        count++;
                        tmp.add( resolve );
                }
        }
        resolve();
        return defer.promise( object );
}

});

var rclass = /[ntr]/g,

rspace = /\s+/,
rreturn = /\r/g,
rtype = /^(?:button|input)$/i,
rfocusable = /^(?:button|input|object|select|textarea)$/i,
rclickable = /^a(?:rea)?$/i,
rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
getSetAttribute = jQuery.support.getSetAttribute,
nodeHook, boolHook, fixSpecified;

jQuery.fn.extend({

attr: function( name, value ) {
        return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
},

removeAttr: function( name ) {
        return this.each(function() {
                jQuery.removeAttr( this, name );
        });
},

prop: function( name, value ) {
        return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
},

removeProp: function( name ) {
        name = jQuery.propFix[ name ] || name;
        return this.each(function() {
                // try/catch handles cases where IE balks (such as removing a property on window)
                try {
                        this[ name ] = undefined;
                        delete this[ name ];
                } catch( e ) {}
        });
},

addClass: function( value ) {
        var classNames, i, l, elem,
                setClass, c, cl;

        if ( jQuery.isFunction( value ) ) {
                return this.each(function( j ) {
                        jQuery( this ).addClass( value.call(this, j, this.className) );
                });
        }

        if ( value && typeof value === "string" ) {
                classNames = value.split( rspace );

                for ( i = 0, l = this.length; i < l; i++ ) {
                        elem = this[ i ];

                        if ( elem.nodeType === 1 ) {
                                if ( !elem.className && classNames.length === 1 ) {
                                        elem.className = value;

                                } else {
                                        setClass = " " + elem.className + " ";

                                        for ( c = 0, cl = classNames.length; c < cl; c++ ) {
                                                if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
                                                        setClass += classNames[ c ] + " ";
                                                }
                                        }
                                        elem.className = jQuery.trim( setClass );
                                }
                        }
                }
        }

        return this;
},

removeClass: function( value ) {
        var classNames, i, l, elem, className, c, cl;

        if ( jQuery.isFunction( value ) ) {
                return this.each(function( j ) {
                        jQuery( this ).removeClass( value.call(this, j, this.className) );
                });
        }

        if ( (value && typeof value === "string") || value === undefined ) {
                classNames = ( value || "" ).split( rspace );

                for ( i = 0, l = this.length; i < l; i++ ) {
                        elem = this[ i ];

                        if ( elem.nodeType === 1 && elem.className ) {
                                if ( value ) {
                                        className = (" " + elem.className + " ").replace( rclass, " " );
                                        for ( c = 0, cl = classNames.length; c < cl; c++ ) {
                                                className = className.replace(" " + classNames[ c ] + " ", " ");
                                        }
                                        elem.className = jQuery.trim( className );

                                } else {
                                        elem.className = "";
                                }
                        }
                }
        }

        return this;
},

toggleClass: function( value, stateVal ) {
        var type = typeof value,
                isBool = typeof stateVal === "boolean";

        if ( jQuery.isFunction( value ) ) {
                return this.each(function( i ) {
                        jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
                });
        }

        return this.each(function() {
                if ( type === "string" ) {
                        // toggle individual class names
                        var className,
                                i = 0,
                                self = jQuery( this ),
                                state = stateVal,
                                classNames = value.split( rspace );

                        while ( (className = classNames[ i++ ]) ) {
                                // check each className given, space seperated list
                                state = isBool ? state : !self.hasClass( className );
                                self[ state ? "addClass" : "removeClass" ]( className );
                        }

                } else if ( type === "undefined" || type === "boolean" ) {
                        if ( this.className ) {
                                // store className if set
                                jQuery._data( this, "__className__", this.className );
                        }

                        // toggle whole className
                        this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
                }
        });
},

hasClass: function( selector ) {
        var className = " " + selector + " ",
                i = 0,
                l = this.length;
        for ( ; i < l; i++ ) {
                if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
                        return true;
                }
        }

        return false;
},

val: function( value ) {
        var hooks, ret, isFunction,
                elem = this[0];

        if ( !arguments.length ) {
                if ( elem ) {
                        hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];

                        if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
                                return ret;
                        }

                        ret = elem.value;

                        return typeof ret === "string" ?
                                // handle most common string cases
                                ret.replace(rreturn, "") :
                                // handle cases where value is null/undef or number
                                ret == null ? "" : ret;
                }

                return;
        }

        isFunction = jQuery.isFunction( value );

        return this.each(function( i ) {
                var self = jQuery(this), val;

                if ( this.nodeType !== 1 ) {
                        return;
                }

                if ( isFunction ) {
                        val = value.call( this, i, self.val() );
                } else {
                        val = value;
                }

                // Treat null/undefined as ""; convert numbers to string
                if ( val == null ) {
                        val = "";
                } else if ( typeof val === "number" ) {
                        val += "";
                } else if ( jQuery.isArray( val ) ) {
                        val = jQuery.map(val, function ( value ) {
                                return value == null ? "" : value + "";
                        });
                }

                hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];

                // If set returns undefined, fall back to normal setting
                if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
                        this.value = val;
                }
        });
}

});

jQuery.extend({

valHooks: {
        option: {
                get: function( elem ) {
                        // attributes.value is undefined in Blackberry 4.7 but
                        // uses .value. See #6932
                        var val = elem.attributes.value;
                        return !val || val.specified ? elem.value : elem.text;
                }
        },
        select: {
                get: function( elem ) {
                        var value, i, max, option,
                                index = elem.selectedIndex,
                                values = [],
                                options = elem.options,
                                one = elem.type === "select-one";

                        // Nothing was selected
                        if ( index < 0 ) {
                                return null;
                        }

                        // Loop through all the selected options
                        i = one ? index : 0;
                        max = one ? index + 1 : options.length;
                        for ( ; i < max; i++ ) {
                                option = options[ i ];

                                // Don't return options that are disabled or in a disabled optgroup
                                if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
                                                (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {

                                        // Get the specific value for the option
                                        value = jQuery( option ).val();

                                        // We don't need an array for one selects
                                        if ( one ) {
                                                return value;
                                        }

                                        // Multi-Selects return an array
                                        values.push( value );
                                }
                        }

                        // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
                        if ( one && !values.length && options.length ) {
                                return jQuery( options[ index ] ).val();
                        }

                        return values;
                },

                set: function( elem, value ) {
                        var values = jQuery.makeArray( value );

                        jQuery(elem).find("option").each(function() {
                                this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
                        });

                        if ( !values.length ) {
                                elem.selectedIndex = -1;
                        }
                        return values;
                }
        }
},

attrFn: {
        val: true,
        css: true,
        html: true,
        text: true,
        data: true,
        width: true,
        height: true,
        offset: true
},

attr: function( elem, name, value, pass ) {
        var ret, hooks, notxml,
                nType = elem.nodeType;

        // don't get/set attributes on text, comment and attribute nodes
        if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
                return;
        }

        if ( pass && name in jQuery.attrFn ) {
                return jQuery( elem )[ name ]( value );
        }

        // Fallback to prop when attributes are not supported
        if ( typeof elem.getAttribute === "undefined" ) {
                return jQuery.prop( elem, name, value );
        }

        notxml = nType !== 1 || !jQuery.isXMLDoc( elem );

        // All attributes are lowercase
        // Grab necessary hook if one is defined
        if ( notxml ) {
                name = name.toLowerCase();
                hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
        }

        if ( value !== undefined ) {

                if ( value === null ) {
                        jQuery.removeAttr( elem, name );
                        return;

                } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
                        return ret;

                } else {
                        elem.setAttribute( name, "" + value );
                        return value;
                }

        } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
                return ret;

        } else {

                ret = elem.getAttribute( name );

                // Non-existent attributes return null, we normalize to undefined
                return ret === null ?
                        undefined :
                        ret;
        }
},

removeAttr: function( elem, value ) {
        var propName, attrNames, name, l, isBool,
                i = 0;

        if ( value && elem.nodeType === 1 ) {
                attrNames = value.toLowerCase().split( rspace );
                l = attrNames.length;

                for ( ; i < l; i++ ) {
                        name = attrNames[ i ];

                        if ( name ) {
                                propName = jQuery.propFix[ name ] || name;
                                isBool = rboolean.test( name );

                                // See #9699 for explanation of this approach (setting first, then removal)
                                // Do not do this for boolean attributes (see #10870)
                                if ( !isBool ) {
                                        jQuery.attr( elem, name, "" );
                                }
                                elem.removeAttribute( getSetAttribute ? name : propName );

                                // Set corresponding property to false for boolean attributes
                                if ( isBool && propName in elem ) {
                                        elem[ propName ] = false;
                                }
                        }
                }
        }
},

attrHooks: {
        type: {
                set: function( elem, value ) {
                        // We can't allow the type property to be changed (since it causes problems in IE)
                        if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
                                jQuery.error( "type property can't be changed" );
                        } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
                                // Setting the type on a radio button after the value resets the value in IE6-9
                                // Reset value to it's default in case type is set after value
                                // This is for element creation
                                var val = elem.value;
                                elem.setAttribute( "type", value );
                                if ( val ) {
                                        elem.value = val;
                                }
                                return value;
                        }
                }
        },
        // Use the value property for back compat
        // Use the nodeHook for button elements in IE6/7 (#1954)
        value: {
                get: function( elem, name ) {
                        if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
                                return nodeHook.get( elem, name );
                        }
                        return name in elem ?
                                elem.value :
                                null;
                },
                set: function( elem, value, name ) {
                        if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
                                return nodeHook.set( elem, value, name );
                        }
                        // Does not return so that setAttribute is also used
                        elem.value = value;
                }
        }
},

propFix: {
        tabindex: "tabIndex",
        readonly: "readOnly",
        "for": "htmlFor",
        "class": "className",
        maxlength: "maxLength",
        cellspacing: "cellSpacing",
        cellpadding: "cellPadding",
        rowspan: "rowSpan",
        colspan: "colSpan",
        usemap: "useMap",
        frameborder: "frameBorder",
        contenteditable: "contentEditable"
},

prop: function( elem, name, value ) {
        var ret, hooks, notxml,
                nType = elem.nodeType;

        // don't get/set properties on text, comment and attribute nodes
        if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
                return;
        }

        notxml = nType !== 1 || !jQuery.isXMLDoc( elem );

        if ( notxml ) {
                // Fix name and attach hooks
                name = jQuery.propFix[ name ] || name;
                hooks = jQuery.propHooks[ name ];
        }

        if ( value !== undefined ) {
                if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
                        return ret;

                } else {
                        return ( elem[ name ] = value );
                }

        } else {
                if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
                        return ret;

                } else {
                        return elem[ name ];
                }
        }
},

propHooks: {
        tabIndex: {
                get: function( elem ) {
                        // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
                        // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
                        var attributeNode = elem.getAttributeNode("tabindex");

                        return attributeNode && attributeNode.specified ?
                                parseInt( attributeNode.value, 10 ) :
                                rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
                                        0 :
                                        undefined;
                }
        }
}

});

// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional) jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex;

// Hook for boolean attributes boolHook = {

get: function( elem, name ) {
        // Align boolean attributes with corresponding properties
        // Fall back to attribute presence where some booleans are not supported
        var attrNode,
                property = jQuery.prop( elem, name );
        return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
                name.toLowerCase() :
                undefined;
},
set: function( elem, value, name ) {
        var propName;
        if ( value === false ) {
                // Remove boolean attributes when set to false
                jQuery.removeAttr( elem, name );
        } else {
                // value is true since we know at this point it's type boolean and not false
                // Set boolean attributes to the same name and set the DOM property
                propName = jQuery.propFix[ name ] || name;
                if ( propName in elem ) {
                        // Only set the IDL specifically if it already exists on the element
                        elem[ propName ] = true;
                }

                elem.setAttribute( name, name.toLowerCase() );
        }
        return name;
}

};

// IE6/7 do not support getting/setting some attributes with get/setAttribute if ( !getSetAttribute ) {

fixSpecified = {
        name: true,
        id: true,
        coords: true
};

// Use this for any attribute in IE6/7
// This fixes almost every IE6/7 issue
nodeHook = jQuery.valHooks.button = {
        get: function( elem, name ) {
                var ret;
                ret = elem.getAttributeNode( name );
                return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ?
                        ret.nodeValue :
                        undefined;
        },
        set: function( elem, value, name ) {
                // Set the existing or create a new attribute node
                var ret = elem.getAttributeNode( name );
                if ( !ret ) {
                        ret = document.createAttribute( name );
                        elem.setAttributeNode( ret );
                }
                return ( ret.nodeValue = value + "" );
        }
};

// Apply the nodeHook to tabindex
jQuery.attrHooks.tabindex.set = nodeHook.set;

// Set width and height to auto instead of 0 on empty string( Bug #8150 )
// This is for removals
jQuery.each([ "width", "height" ], function( i, name ) {
        jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
                set: function( elem, value ) {
                        if ( value === "" ) {
                                elem.setAttribute( name, "auto" );
                                return value;
                        }
                }
        });
});

// Set contenteditable to false on removals(#10429)
// Setting to empty string throws an error as an invalid value
jQuery.attrHooks.contenteditable = {
        get: nodeHook.get,
        set: function( elem, value, name ) {
                if ( value === "" ) {
                        value = "false";
                }
                nodeHook.set( elem, value, name );
        }
};

}

// Some attributes require a special call on IE if ( !jQuery.support.hrefNormalized ) {

jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
        jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
                get: function( elem ) {
                        var ret = elem.getAttribute( name, 2 );
                        return ret === null ? undefined : ret;
                }
        });
});

}

if ( !jQuery.support.style ) {

jQuery.attrHooks.style = {
        get: function( elem ) {
                // Return undefined in the case of empty string
                // Normalize to lowercase since IE uppercases css property names
                return elem.style.cssText.toLowerCase() || undefined;
        },
        set: function( elem, value ) {
                return ( elem.style.cssText = "" + value );
        }
};

}

// Safari mis-reports the default selected property of an option // Accessing the parent's selectedIndex property fixes it if ( !jQuery.support.optSelected ) {

jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
        get: function( elem ) {
                var parent = elem.parentNode;

                if ( parent ) {
                        parent.selectedIndex;

                        // Make sure that it also works with optgroups, see #5701
                        if ( parent.parentNode ) {
                                parent.parentNode.selectedIndex;
                        }
                }
                return null;
        }
});

}

// IE6/7 call enctype encoding if ( !jQuery.support.enctype ) {

jQuery.propFix.enctype = "encoding";

}

// Radios and checkboxes getter/setter if ( !jQuery.support.checkOn ) {

jQuery.each([ "radio", "checkbox" ], function() {
        jQuery.valHooks[ this ] = {
                get: function( elem ) {
                        // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
                        return elem.getAttribute("value") === null ? "on" : elem.value;
                }
        };
});

} jQuery.each([ “radio”, “checkbox” ], function() {

jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
        set: function( elem, value ) {
                if ( jQuery.isArray( value ) ) {
                        return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
                }
        }
});

});

var rformElems = /^(?:textarea|input|select)$/i,

rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
rhoverHack = /(?:^|\s)hover(\.\S+)?\b/,
rkeyEvent = /^key/,
rmouseEvent = /^(?:mouse|contextmenu)|click/,
rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
quickParse = function( selector ) {
        var quick = rquickIs.exec( selector );
        if ( quick ) {
                //   0  1    2   3
                // [ _, tag, id, class ]
                quick[1] = ( quick[1] || "" ).toLowerCase();
                quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
        }
        return quick;
},
quickIs = function( elem, m ) {
        var attrs = elem.attributes || {};
        return (
                (!m[1] || elem.nodeName.toLowerCase() === m[1]) &&
                (!m[2] || (attrs.id || {}).value === m[2]) &&
                (!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
        );
},
hoverHack = function( events ) {
        return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
};

/*

* Helper functions for managing events -- not part of the public interface.
* Props to Dean Edwards' addEvent library for many of the ideas.
*/

jQuery.event = {

add: function( elem, types, handler, data, selector ) {

        var elemData, eventHandle, events,
                t, tns, type, namespaces, handleObj,
                handleObjIn, quick, handlers, special;

        // Don't attach events to noData or text/comment nodes (allow plain objects tho)
        if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
                return;
        }

        // Caller can pass in an object of custom data in lieu of the handler
        if ( handler.handler ) {
                handleObjIn = handler;
                handler = handleObjIn.handler;
                selector = handleObjIn.selector;
        }

        // Make sure that the handler has a unique ID, used to find/remove it later
        if ( !handler.guid ) {
                handler.guid = jQuery.guid++;
        }

        // Init the element's event structure and main handler, if this is the first
        events = elemData.events;
        if ( !events ) {
                elemData.events = events = {};
        }
        eventHandle = elemData.handle;
        if ( !eventHandle ) {
                elemData.handle = eventHandle = function( e ) {
                        // Discard the second event of a jQuery.event.trigger() and
                        // when an event is called after a page has unloaded
                        return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
                                jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
                                undefined;
                };
                // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
                eventHandle.elem = elem;
        }

        // Handle multiple events separated by a space
        // jQuery(...).bind("mouseover mouseout", fn);
        types = jQuery.trim( hoverHack(types) ).split( " " );
        for ( t = 0; t < types.length; t++ ) {

                tns = rtypenamespace.exec( types[t] ) || [];
                type = tns[1];
                namespaces = ( tns[2] || "" ).split( "." ).sort();

                // If event changes its type, use the special event handlers for the changed type
                special = jQuery.event.special[ type ] || {};

                // If selector defined, determine special event api type, otherwise given type
                type = ( selector ? special.delegateType : special.bindType ) || type;

                // Update special based on newly reset type
                special = jQuery.event.special[ type ] || {};

                // handleObj is passed to all event handlers
                handleObj = jQuery.extend({
                        type: type,
                        origType: tns[1],
                        data: data,
                        handler: handler,
                        guid: handler.guid,
                        selector: selector,
                        quick: selector && quickParse( selector ),
                        namespace: namespaces.join(".")
                }, handleObjIn );

                // Init the event handler queue if we're the first
                handlers = events[ type ];
                if ( !handlers ) {
                        handlers = events[ type ] = [];
                        handlers.delegateCount = 0;

                        // Only use addEventListener/attachEvent if the special events handler returns false
                        if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
                                // Bind the global event handler to the element
                                if ( elem.addEventListener ) {
                                        elem.addEventListener( type, eventHandle, false );

                                } else if ( elem.attachEvent ) {
                                        elem.attachEvent( "on" + type, eventHandle );
                                }
                        }
                }

                if ( special.add ) {
                        special.add.call( elem, handleObj );

                        if ( !handleObj.handler.guid ) {
                                handleObj.handler.guid = handler.guid;
                        }
                }

                // Add to the element's handler list, delegates in front
                if ( selector ) {
                        handlers.splice( handlers.delegateCount++, 0, handleObj );
                } else {
                        handlers.push( handleObj );
                }

                // Keep track of which events have ever been used, for event optimization
                jQuery.event.global[ type ] = true;
        }

        // Nullify elem to prevent memory leaks in IE
        elem = null;
},

global: {},

// Detach an event or set of events from an element
remove: function( elem, types, handler, selector, mappedTypes ) {

        var elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
                t, tns, type, origType, namespaces, origCount,
                j, events, special, handle, eventType, handleObj;

        if ( !elemData || !(events = elemData.events) ) {
                return;
        }

        // Once for each type.namespace in types; type may be omitted
        types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
        for ( t = 0; t < types.length; t++ ) {
                tns = rtypenamespace.exec( types[t] ) || [];
                type = origType = tns[1];
                namespaces = tns[2];

                // Unbind all events (on this namespace, if provided) for the element
                if ( !type ) {
                        for ( type in events ) {
                                jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
                        }
                        continue;
                }

                special = jQuery.event.special[ type ] || {};
                type = ( selector? special.delegateType : special.bindType ) || type;
                eventType = events[ type ] || [];
                origCount = eventType.length;
                namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;

                // Remove matching events
                for ( j = 0; j < eventType.length; j++ ) {
                        handleObj = eventType[ j ];

                        if ( ( mappedTypes || origType === handleObj.origType ) &&
                                 ( !handler || handler.guid === handleObj.guid ) &&
                                 ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
                                 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
                                eventType.splice( j--, 1 );

                                if ( handleObj.selector ) {
                                        eventType.delegateCount--;
                                }
                                if ( special.remove ) {
                                        special.remove.call( elem, handleObj );
                                }
                        }
                }

                // Remove generic event handler if we removed something and no more handlers exist
                // (avoids potential for endless recursion during removal of special event handlers)
                if ( eventType.length === 0 && origCount !== eventType.length ) {
                        if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
                                jQuery.removeEvent( elem, type, elemData.handle );
                        }

                        delete events[ type ];
                }
        }

        // Remove the expando if it's no longer used
        if ( jQuery.isEmptyObject( events ) ) {
                handle = elemData.handle;
                if ( handle ) {
                        handle.elem = null;
                }

                // removeData also checks for emptiness and clears the expando if empty
                // so use it instead of delete
                jQuery.removeData( elem, [ "events", "handle" ], true );
        }
},

// Events that are safe to short-circuit if no handlers are attached.
// Native DOM events should not be added, they may have inline handlers.
customEvent: {
        "getData": true,
        "setData": true,
        "changeData": true
},

trigger: function( event, data, elem, onlyHandlers ) {
        // Don't do events on text and comment nodes
        if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
                return;
        }

        // Event object or event type
        var type = event.type || event,
                namespaces = [],
                cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType;

        // focus/blur morphs to focusin/out; ensure we're not firing them right now
        if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
                return;
        }

        if ( type.indexOf( "!" ) >= 0 ) {
                // Exclusive events trigger only for the exact event (no namespaces)
                type = type.slice(0, -1);
                exclusive = true;
        }

        if ( type.indexOf( "." ) >= 0 ) {
                // Namespaced trigger; create a regexp to match event type in handle()
                namespaces = type.split(".");
                type = namespaces.shift();
                namespaces.sort();
        }

        if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
                // No jQuery handlers for this event type, and it can't have inline handlers
                return;
        }

        // Caller can pass in an Event, Object, or just an event type string
        event = typeof event === "object" ?
                // jQuery.Event object
                event[ jQuery.expando ] ? event :
                // Object literal
                new jQuery.Event( type, event ) :
                // Just the event type (string)
                new jQuery.Event( type );

        event.type = type;
        event.isTrigger = true;
        event.exclusive = exclusive;
        event.namespace = namespaces.join( "." );
        event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
        ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";

        // Handle a global trigger
        if ( !elem ) {

                // TODO: Stop taunting the data cache; remove global events and always attach to document
                cache = jQuery.cache;
                for ( i in cache ) {
                        if ( cache[ i ].events && cache[ i ].events[ type ] ) {
                                jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
                        }
                }
                return;
        }

        // Clean up the event in case it is being reused
        event.result = undefined;
        if ( !event.target ) {
                event.target = elem;
        }

        // Clone any incoming data and prepend the event, creating the handler arg list
        data = data != null ? jQuery.makeArray( data ) : [];
        data.unshift( event );

        // Allow special events to draw outside the lines
        special = jQuery.event.special[ type ] || {};
        if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
                return;
        }

        // Determine event propagation path in advance, per W3C events spec (#9951)
        // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
        eventPath = [[ elem, special.bindType || type ]];
        if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {

                bubbleType = special.delegateType || type;
                cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
                old = null;
                for ( ; cur; cur = cur.parentNode ) {
                        eventPath.push([ cur, bubbleType ]);
                        old = cur;
                }

                // Only add window if we got to document (e.g., not plain obj or detached DOM)
                if ( old && old === elem.ownerDocument ) {
                        eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
                }
        }

        // Fire handlers on the event path
        for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {

                cur = eventPath[i][0];
                event.type = eventPath[i][1];

                handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
                if ( handle ) {
                        handle.apply( cur, data );
                }
                // Note that this is a bare JS function and not a jQuery handler
                handle = ontype && cur[ ontype ];
                if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
                        event.preventDefault();
                }
        }
        event.type = type;

        // If nobody prevented the default action, do it now
        if ( !onlyHandlers && !event.isDefaultPrevented() ) {

                if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
                        !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {

                        // Call a native DOM method on the target with the same name name as the event.
                        // Can't use an .isFunction() check here because IE6/7 fails that test.
                        // Don't do default actions on window, that's where global variables be (#6170)
                        // IE<9 dies on focus/blur to hidden element (#1486)
                        if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {

                                // Don't re-trigger an onFOO event when we call its FOO() method
                                old = elem[ ontype ];

                                if ( old ) {
                                        elem[ ontype ] = null;
                                }

                                // Prevent re-triggering of the same event, since we already bubbled it above
                                jQuery.event.triggered = type;
                                elem[ type ]();
                                jQuery.event.triggered = undefined;

                                if ( old ) {
                                        elem[ ontype ] = old;
                                }
                        }
                }
        }

        return event.result;
},

dispatch: function( event ) {

        // Make a writable jQuery.Event from the native event object
        event = jQuery.event.fix( event || window.event );

        var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
                delegateCount = handlers.delegateCount,
                args = [].slice.call( arguments, 0 ),
                run_all = !event.exclusive && !event.namespace,
                special = jQuery.event.special[ event.type ] || {},
                handlerQueue = [],
                i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related;

        // Use the fix-ed jQuery.Event rather than the (read-only) native event
        args[0] = event;
        event.delegateTarget = this;

        // Call the preDispatch hook for the mapped type, and let it bail if desired
        if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
                return;
        }

        // Determine handlers that should run if there are delegated events
        // Avoid non-left-click bubbling in Firefox (#3861)
        if ( delegateCount && !(event.button && event.type === "click") ) {

                // Pregenerate a single jQuery object for reuse with .is()
                jqcur = jQuery(this);
                jqcur.context = this.ownerDocument || this;

                for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {

                        // Don't process events on disabled elements (#6911, #8165)
                        if ( cur.disabled !== true ) {
                                selMatch = {};
                                matches = [];
                                jqcur[0] = cur;
                                for ( i = 0; i < delegateCount; i++ ) {
                                        handleObj = handlers[ i ];
                                        sel = handleObj.selector;

                                        if ( selMatch[ sel ] === undefined ) {
                                                selMatch[ sel ] = (
                                                        handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel )
                                                );
                                        }
                                        if ( selMatch[ sel ] ) {
                                                matches.push( handleObj );
                                        }
                                }
                                if ( matches.length ) {
                                        handlerQueue.push({ elem: cur, matches: matches });
                                }
                        }
                }
        }

        // Add the remaining (directly-bound) handlers
        if ( handlers.length > delegateCount ) {
                handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
        }

        // Run delegates first; they may want to stop propagation beneath us
        for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
                matched = handlerQueue[ i ];
                event.currentTarget = matched.elem;

                for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
                        handleObj = matched.matches[ j ];

                        // Triggered event must either 1) be non-exclusive and have no namespace, or
                        // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
                        if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {

                                event.data = handleObj.data;
                                event.handleObj = handleObj;

                                ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
                                                .apply( matched.elem, args );

                                if ( ret !== undefined ) {
                                        event.result = ret;
                                        if ( ret === false ) {
                                                event.preventDefault();
                                                event.stopPropagation();
                                        }
                                }
                        }
                }
        }

        // Call the postDispatch hook for the mapped type
        if ( special.postDispatch ) {
                special.postDispatch.call( this, event );
        }

        return event.result;
},

// Includes some event props shared by KeyEvent and MouseEvent
// *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),

fixHooks: {},

keyHooks: {
        props: "char charCode key keyCode".split(" "),
        filter: function( event, original ) {

                // Add which for key events
                if ( event.which == null ) {
                        event.which = original.charCode != null ? original.charCode : original.keyCode;
                }

                return event;
        }
},

mouseHooks: {
        props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
        filter: function( event, original ) {
                var eventDoc, doc, body,
                        button = original.button,
                        fromElement = original.fromElement;

                // Calculate pageX/Y if missing and clientX/Y available
                if ( event.pageX == null && original.clientX != null ) {
                        eventDoc = event.target.ownerDocument || document;
                        doc = eventDoc.documentElement;
                        body = eventDoc.body;

                        event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
                        event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
                }

                // Add relatedTarget, if necessary
                if ( !event.relatedTarget && fromElement ) {
                        event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
                }

                // Add which for click: 1 === left; 2 === middle; 3 === right
                // Note: button is not normalized, so don't use it
                if ( !event.which && button !== undefined ) {
                        event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
                }

                return event;
        }
},

fix: function( event ) {
        if ( event[ jQuery.expando ] ) {
                return event;
        }

        // Create a writable copy of the event object and normalize some properties
        var i, prop,
                originalEvent = event,
                fixHook = jQuery.event.fixHooks[ event.type ] || {},
                copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;

        event = jQuery.Event( originalEvent );

        for ( i = copy.length; i; ) {
                prop = copy[ --i ];
                event[ prop ] = originalEvent[ prop ];
        }

        // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
        if ( !event.target ) {
                event.target = originalEvent.srcElement || document;
        }

        // Target should not be a text node (#504, Safari)
        if ( event.target.nodeType === 3 ) {
                event.target = event.target.parentNode;
        }

        // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8)
        if ( event.metaKey === undefined ) {
                event.metaKey = event.ctrlKey;
        }

        return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
},

special: {
        ready: {
                // Make sure the ready event is setup
                setup: jQuery.bindReady
        },

        load: {
                // Prevent triggered image.load events from bubbling to window.load
                noBubble: true
        },

        focus: {
                delegateType: "focusin"
        },
        blur: {
                delegateType: "focusout"
        },

        beforeunload: {
                setup: function( data, namespaces, eventHandle ) {
                        // We only want to do this special case on windows
                        if ( jQuery.isWindow( this ) ) {
                                this.onbeforeunload = eventHandle;
                        }
                },

                teardown: function( namespaces, eventHandle ) {
                        if ( this.onbeforeunload === eventHandle ) {
                                this.onbeforeunload = null;
                        }
                }
        }
},

simulate: function( type, elem, event, bubble ) {
        // Piggyback on a donor event to simulate a different one.
        // Fake originalEvent to avoid donor's stopPropagation, but if the
        // simulated event prevents default then we do the same on the donor.
        var e = jQuery.extend(
                new jQuery.Event(),
                event,
                { type: type,
                        isSimulated: true,
                        originalEvent: {}
                }
        );
        if ( bubble ) {
                jQuery.event.trigger( e, null, elem );
        } else {
                jQuery.event.dispatch.call( elem, e );
        }
        if ( e.isDefaultPrevented() ) {
                event.preventDefault();
        }
}

};

// Some plugins are using, but it's undocumented/deprecated and will be removed. // The 1.7 special event interface should provide all the hooks needed now. jQuery.event.handle = jQuery.event.dispatch;

jQuery.removeEvent = document.removeEventListener ?

function( elem, type, handle ) {
        if ( elem.removeEventListener ) {
                elem.removeEventListener( type, handle, false );
        }
} :
function( elem, type, handle ) {
        if ( elem.detachEvent ) {
                elem.detachEvent( "on" + type, handle );
        }
};

jQuery.Event = function( src, props ) {

// Allow instantiation without the 'new' keyword
if ( !(this instanceof jQuery.Event) ) {
        return new jQuery.Event( src, props );
}

// Event object
if ( src && src.type ) {
        this.originalEvent = src;
        this.type = src.type;

        // Events bubbling up the document may have been marked as prevented
        // by a handler lower down the tree; reflect the correct value.
        this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
                src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;

// Event type
} else {
        this.type = src;
}

// Put explicitly provided properties onto the event object
if ( props ) {
        jQuery.extend( this, props );
}

// Create a timestamp if incoming event doesn't have one
this.timeStamp = src && src.timeStamp || jQuery.now();

// Mark it as fixed
this[ jQuery.expando ] = true;

};

function returnFalse() {

return false;

} function returnTrue() {

return true;

}

// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding // www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html jQuery.Event.prototype = {

preventDefault: function() {
        this.isDefaultPrevented = returnTrue;

        var e = this.originalEvent;
        if ( !e ) {
                return;
        }

        // if preventDefault exists run it on the original event
        if ( e.preventDefault ) {
                e.preventDefault();

        // otherwise set the returnValue property of the original event to false (IE)
        } else {
                e.returnValue = false;
        }
},
stopPropagation: function() {
        this.isPropagationStopped = returnTrue;

        var e = this.originalEvent;
        if ( !e ) {
                return;
        }
        // if stopPropagation exists run it on the original event
        if ( e.stopPropagation ) {
                e.stopPropagation();
        }
        // otherwise set the cancelBubble property of the original event to true (IE)
        e.cancelBubble = true;
},
stopImmediatePropagation: function() {
        this.isImmediatePropagationStopped = returnTrue;
        this.stopPropagation();
},
isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse

};

// Create mouseenter/leave events using mouseover/out and event-time checks jQuery.each({

mouseenter: "mouseover",
mouseleave: "mouseout"

}, function( orig, fix ) {

jQuery.event.special[ orig ] = {
        delegateType: fix,
        bindType: fix,

        handle: function( event ) {
                var target = this,
                        related = event.relatedTarget,
                        handleObj = event.handleObj,
                        selector = handleObj.selector,
                        ret;

                // For mousenter/leave call the handler if related is outside the target.
                // NB: No relatedTarget if the mouse left/entered the browser window
                if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
                        event.type = handleObj.origType;
                        ret = handleObj.handler.apply( this, arguments );
                        event.type = fix;
                }
                return ret;
        }
};

});

// IE submit delegation if ( !jQuery.support.submitBubbles ) {

jQuery.event.special.submit = {
        setup: function() {
                // Only need this for delegated form submit events
                if ( jQuery.nodeName( this, "form" ) ) {
                        return false;
                }

                // Lazy-add a submit handler when a descendant form may potentially be submitted
                jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
                        // Node name check avoids a VML-related crash in IE (#9807)
                        var elem = e.target,
                                form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
                        if ( form && !form._submit_attached ) {
                                jQuery.event.add( form, "submit._submit", function( event ) {
                                        event._submit_bubble = true;
                                });
                                form._submit_attached = true;
                        }
                });
                // return undefined since we don't need an event listener
        },

        postDispatch: function( event ) {
                // If form was submitted by the user, bubble the event up the tree
                if ( event._submit_bubble ) {
                        delete event._submit_bubble;
                        if ( this.parentNode && !event.isTrigger ) {
                                jQuery.event.simulate( "submit", this.parentNode, event, true );
                        }
                }
        },

        teardown: function() {
                // Only need this for delegated form submit events
                if ( jQuery.nodeName( this, "form" ) ) {
                        return false;
                }

                // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
                jQuery.event.remove( this, "._submit" );
        }
};

}

// IE change delegation and checkbox/radio fix if ( !jQuery.support.changeBubbles ) {

jQuery.event.special.change = {

        setup: function() {

                if ( rformElems.test( this.nodeName ) ) {
                        // IE doesn't fire change on a check/radio until blur; trigger it on click
                        // after a propertychange. Eat the blur-change in special.change.handle.
                        // This still fires onchange a second time for check/radio after blur.
                        if ( this.type === "checkbox" || this.type === "radio" ) {
                                jQuery.event.add( this, "propertychange._change", function( event ) {
                                        if ( event.originalEvent.propertyName === "checked" ) {
                                                this._just_changed = true;
                                        }
                                });
                                jQuery.event.add( this, "click._change", function( event ) {
                                        if ( this._just_changed && !event.isTrigger ) {
                                                this._just_changed = false;
                                                jQuery.event.simulate( "change", this, event, true );
                                        }
                                });
                        }
                        return false;
                }
                // Delegated event; lazy-add a change handler on descendant inputs
                jQuery.event.add( this, "beforeactivate._change", function( e ) {
                        var elem = e.target;

                        if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) {
                                jQuery.event.add( elem, "change._change", function( event ) {
                                        if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
                                                jQuery.event.simulate( "change", this.parentNode, event, true );
                                        }
                                });
                                elem._change_attached = true;
                        }
                });
        },

        handle: function( event ) {
                var elem = event.target;

                // Swallow native change events from checkbox/radio, we already triggered them above
                if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
                        return event.handleObj.handler.apply( this, arguments );
                }
        },

        teardown: function() {
                jQuery.event.remove( this, "._change" );

                return rformElems.test( this.nodeName );
        }
};

}

// Create “bubbling” focus and blur events if ( !jQuery.support.focusinBubbles ) {

jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {

        // Attach a single capturing handler while someone wants focusin/focusout
        var attaches = 0,
                handler = function( event ) {
                        jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
                };

        jQuery.event.special[ fix ] = {
                setup: function() {
                        if ( attaches++ === 0 ) {
                                document.addEventListener( orig, handler, true );
                        }
                },
                teardown: function() {
                        if ( --attaches === 0 ) {
                                document.removeEventListener( orig, handler, true );
                        }
                }
        };
});

}

jQuery.fn.extend({

on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
        var origFn, type;

        // Types can be a map of types/handlers
        if ( typeof types === "object" ) {
                // ( types-Object, selector, data )
                if ( typeof selector !== "string" ) { // && selector != null
                        // ( types-Object, data )
                        data = data || selector;
                        selector = undefined;
                }
                for ( type in types ) {
                        this.on( type, selector, data, types[ type ], one );
                }
                return this;
        }

        if ( data == null && fn == null ) {
                // ( types, fn )
                fn = selector;
                data = selector = undefined;
        } else if ( fn == null ) {
                if ( typeof selector === "string" ) {
                        // ( types, selector, fn )
                        fn = data;
                        data = undefined;
                } else {
                        // ( types, data, fn )
                        fn = data;
                        data = selector;
                        selector = undefined;
                }
        }
        if ( fn === false ) {
                fn = returnFalse;
        } else if ( !fn ) {
                return this;
        }

        if ( one === 1 ) {
                origFn = fn;
                fn = function( event ) {
                        // Can use an empty set, since event contains the info
                        jQuery().off( event );
                        return origFn.apply( this, arguments );
                };
                // Use same guid so caller can remove using origFn
                fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
        }
        return this.each( function() {
                jQuery.event.add( this, types, fn, data, selector );
        });
},
one: function( types, selector, data, fn ) {
        return this.on( types, selector, data, fn, 1 );
},
off: function( types, selector, fn ) {
        if ( types && types.preventDefault && types.handleObj ) {
                // ( event )  dispatched jQuery.Event
                var handleObj = types.handleObj;
                jQuery( types.delegateTarget ).off(
                        handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
                        handleObj.selector,
                        handleObj.handler
                );
                return this;
        }
        if ( typeof types === "object" ) {
                // ( types-object [, selector] )
                for ( var type in types ) {
                        this.off( type, selector, types[ type ] );
                }
                return this;
        }
        if ( selector === false || typeof selector === "function" ) {
                // ( types [, fn] )
                fn = selector;
                selector = undefined;
        }
        if ( fn === false ) {
                fn = returnFalse;
        }
        return this.each(function() {
                jQuery.event.remove( this, types, fn, selector );
        });
},

bind: function( types, data, fn ) {
        return this.on( types, null, data, fn );
},
unbind: function( types, fn ) {
        return this.off( types, null, fn );
},

live: function( types, data, fn ) {
        jQuery( this.context ).on( types, this.selector, data, fn );
        return this;
},
die: function( types, fn ) {
        jQuery( this.context ).off( types, this.selector || "**", fn );
        return this;
},

delegate: function( selector, types, data, fn ) {
        return this.on( types, selector, data, fn );
},
undelegate: function( selector, types, fn ) {
        // ( namespace ) or ( selector, types [, fn] )
        return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn );
},

trigger: function( type, data ) {
        return this.each(function() {
                jQuery.event.trigger( type, data, this );
        });
},
triggerHandler: function( type, data ) {
        if ( this[0] ) {
                return jQuery.event.trigger( type, data, this[0], true );
        }
},

toggle: function( fn ) {
        // Save reference to arguments for access in closure
        var args = arguments,
                guid = fn.guid || jQuery.guid++,
                i = 0,
                toggler = function( event ) {
                        // Figure out which function to execute
                        var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
                        jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );

                        // Make sure that clicks stop
                        event.preventDefault();

                        // and execute the function
                        return args[ lastToggle ].apply( this, arguments ) || false;
                };

        // link all the functions, so any of them can unbind this click handler
        toggler.guid = guid;
        while ( i < args.length ) {
                args[ i++ ].guid = guid;
        }

        return this.click( toggler );
},

hover: function( fnOver, fnOut ) {
        return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
}

});

jQuery.each( (“blur focus focusin focusout load resize scroll unload click dblclick ” +

"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {

// Handle event binding
jQuery.fn[ name ] = function( data, fn ) {
        if ( fn == null ) {
                fn = data;
                data = null;
        }

        return arguments.length > 0 ?
                this.on( name, null, data, fn ) :
                this.trigger( name );
};

if ( jQuery.attrFn ) {
        jQuery.attrFn[ name ] = true;
}

if ( rkeyEvent.test( name ) ) {
        jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
}

if ( rmouseEvent.test( name ) ) {
        jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
}

});

/*!

* Sizzle CSS Selector Engine
*  Copyright 2011, The Dojo Foundation
*  Released under the MIT, BSD, and GPL Licenses.
*  More information: http://sizzlejs.com/
*/

(function(){

var chunker = /((?:((?:([^()]+)|[^()]+)+)|[(?:[[^[]]*]|['“][^'”]*['“]|[^[]'”]+)+]|\.|[^ >+~,([\]+)+|[>+~])(s*,s*)?((?:.|r|n)*)/g,

expando = "sizcache" + (Math.random() + '').replace('.', ''),
done = 0,
toString = Object.prototype.toString,
hasDuplicate = false,
baseHasDuplicate = true,
rBackslash = /\\/g,
rReturn = /\r\n/g,
rNonWord = /\W/;

// Here we check if the JavaScript engine is using some sort of // optimization where it does not always call our comparision // function. If that is the case, discard the hasDuplicate value. // Thus far that includes Google Chrome. [0, 0].sort(function() {

baseHasDuplicate = false;
return 0;

});

var Sizzle = function( selector, context, results, seed ) {

results = results || [];
context = context || document;

var origContext = context;

if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
        return [];
}

if ( !selector || typeof selector !== "string" ) {
        return results;
}

var m, set, checkSet, extra, ret, cur, pop, i,
        prune = true,
        contextXML = Sizzle.isXML( context ),
        parts = [],
        soFar = selector;

// Reset the position of the chunker regexp (start from head)
do {
        chunker.exec( "" );
        m = chunker.exec( soFar );

        if ( m ) {
                soFar = m[3];

                parts.push( m[1] );

                if ( m[2] ) {
                        extra = m[3];
                        break;
                }
        }
} while ( m );

if ( parts.length > 1 && origPOS.exec( selector ) ) {

        if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
                set = posProcess( parts[0] + parts[1], context, seed );

        } else {
                set = Expr.relative[ parts[0] ] ?
                        [ context ] :
                        Sizzle( parts.shift(), context );

                while ( parts.length ) {
                        selector = parts.shift();

                        if ( Expr.relative[ selector ] ) {
                                selector += parts.shift();
                        }

                        set = posProcess( selector, set, seed );
                }
        }

} else {
        // Take a shortcut and set the context if the root selector is an ID
        // (but not if it'll be faster if the inner selector is an ID)
        if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
                        Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {

                ret = Sizzle.find( parts.shift(), context, contextXML );
                context = ret.expr ?
                        Sizzle.filter( ret.expr, ret.set )[0] :
                        ret.set[0];
        }

        if ( context ) {
                ret = seed ?
                        { expr: parts.pop(), set: makeArray(seed) } :
                        Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );

                set = ret.expr ?
                        Sizzle.filter( ret.expr, ret.set ) :
                        ret.set;

                if ( parts.length > 0 ) {
                        checkSet = makeArray( set );

                } else {
                        prune = false;
                }

                while ( parts.length ) {
                        cur = parts.pop();
                        pop = cur;

                        if ( !Expr.relative[ cur ] ) {
                                cur = "";
                        } else {
                                pop = parts.pop();
                        }

                        if ( pop == null ) {
                                pop = context;
                        }

                        Expr.relative[ cur ]( checkSet, pop, contextXML );
                }

        } else {
                checkSet = parts = [];
        }
}

if ( !checkSet ) {
        checkSet = set;
}

if ( !checkSet ) {
        Sizzle.error( cur || selector );
}

if ( toString.call(checkSet) === "[object Array]" ) {
        if ( !prune ) {
                results.push.apply( results, checkSet );

        } else if ( context && context.nodeType === 1 ) {
                for ( i = 0; checkSet[i] != null; i++ ) {
                        if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
                                results.push( set[i] );
                        }
                }

        } else {
                for ( i = 0; checkSet[i] != null; i++ ) {
                        if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
                                results.push( set[i] );
                        }
                }
        }

} else {
        makeArray( checkSet, results );
}

if ( extra ) {
        Sizzle( extra, origContext, results, seed );
        Sizzle.uniqueSort( results );
}

return results;

};

Sizzle.uniqueSort = function( results ) {

if ( sortOrder ) {
        hasDuplicate = baseHasDuplicate;
        results.sort( sortOrder );

        if ( hasDuplicate ) {
                for ( var i = 1; i < results.length; i++ ) {
                        if ( results[i] === results[ i - 1 ] ) {
                                results.splice( i--, 1 );
                        }
                }
        }
}

return results;

};

Sizzle.matches = function( expr, set ) {

return Sizzle( expr, null, null, set );

};

Sizzle.matchesSelector = function( node, expr ) {

return Sizzle( expr, null, null, [node] ).length > 0;

};

Sizzle.find = function( expr, context, isXML ) {

var set, i, len, match, type, left;

if ( !expr ) {
        return [];
}

for ( i = 0, len = Expr.order.length; i < len; i++ ) {
        type = Expr.order[i];

        if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
                left = match[1];
                match.splice( 1, 1 );

                if ( left.substr( left.length - 1 ) !== "\\" ) {
                        match[1] = (match[1] || "").replace( rBackslash, "" );
                        set = Expr.find[ type ]( match, context, isXML );

                        if ( set != null ) {
                                expr = expr.replace( Expr.match[ type ], "" );
                                break;
                        }
                }
        }
}

if ( !set ) {
        set = typeof context.getElementsByTagName !== "undefined" ?
                context.getElementsByTagName( "*" ) :
                [];
}

return { set: set, expr: expr };

};

Sizzle.filter = function( expr, set, inplace, not ) {

var match, anyFound,
        type, found, item, filter, left,
        i, pass,
        old = expr,
        result = [],
        curLoop = set,
        isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );

while ( expr && set.length ) {
        for ( type in Expr.filter ) {
                if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
                        filter = Expr.filter[ type ];
                        left = match[1];

                        anyFound = false;

                        match.splice(1,1);

                        if ( left.substr( left.length - 1 ) === "\\" ) {
                                continue;
                        }

                        if ( curLoop === result ) {
                                result = [];
                        }

                        if ( Expr.preFilter[ type ] ) {
                                match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );

                                if ( !match ) {
                                        anyFound = found = true;

                                } else if ( match === true ) {
                                        continue;
                                }
                        }

                        if ( match ) {
                                for ( i = 0; (item = curLoop[i]) != null; i++ ) {
                                        if ( item ) {
                                                found = filter( item, match, i, curLoop );
                                                pass = not ^ found;

                                                if ( inplace && found != null ) {
                                                        if ( pass ) {
                                                                anyFound = true;

                                                        } else {
                                                                curLoop[i] = false;
                                                        }

                                                } else if ( pass ) {
                                                        result.push( item );
                                                        anyFound = true;
                                                }
                                        }
                                }
                        }

                        if ( found !== undefined ) {
                                if ( !inplace ) {
                                        curLoop = result;
                                }

                                expr = expr.replace( Expr.match[ type ], "" );

                                if ( !anyFound ) {
                                        return [];
                                }

                                break;
                        }
                }
        }

        // Improper expression
        if ( expr === old ) {
                if ( anyFound == null ) {
                        Sizzle.error( expr );

                } else {
                        break;
                }
        }

        old = expr;
}

return curLoop;

};

Sizzle.error = function( msg ) {

throw new Error( "Syntax error, unrecognized expression: " + msg );

};

/**

* Utility function for retreiving the text value of an array of DOM nodes
* @param {Array|Element} elem
*/

var getText = Sizzle.getText = function( elem ) {

var i, node,
            nodeType = elem.nodeType,
            ret = "";

    if ( nodeType ) {
            if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
                    // Use textContent || innerText for elements
                    if ( typeof elem.textContent === 'string' ) {
                            return elem.textContent;
                    } else if ( typeof elem.innerText === 'string' ) {
                            // Replace IE's carriage returns
                            return elem.innerText.replace( rReturn, '' );
                    } else {
                            // Traverse it's children
                            for ( elem = elem.firstChild; elem; elem = elem.nextSibling) {
                                    ret += getText( elem );
                            }
                    }
            } else if ( nodeType === 3 || nodeType === 4 ) {
                    return elem.nodeValue;
            }
    } else {

            // If no nodeType, this is expected to be an array
            for ( i = 0; (node = elem[i]); i++ ) {
                    // Do not traverse comment nodes
                    if ( node.nodeType !== 8 ) {
                            ret += getText( node );
                    }
            }
    }
    return ret;

};

var Expr = Sizzle.selectors = {

order: [ "ID", "NAME", "TAG" ],

match: {
        ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
        CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
        NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
        ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
        TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
        CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
        POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
        PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
},

leftMatch: {},

attrMap: {
        "class": "className",
        "for": "htmlFor"
},

attrHandle: {
        href: function( elem ) {
                return elem.getAttribute( "href" );
        },
        type: function( elem ) {
                return elem.getAttribute( "type" );
        }
},

relative: {
        "+": function(checkSet, part){
                var isPartStr = typeof part === "string",
                        isTag = isPartStr && !rNonWord.test( part ),
                        isPartStrNotTag = isPartStr && !isTag;

                if ( isTag ) {
                        part = part.toLowerCase();
                }

                for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
                        if ( (elem = checkSet[i]) ) {
                                while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}

                                checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
                                        elem || false :
                                        elem === part;
                        }
                }

                if ( isPartStrNotTag ) {
                        Sizzle.filter( part, checkSet, true );
                }
        },

        ">": function( checkSet, part ) {
                var elem,
                        isPartStr = typeof part === "string",
                        i = 0,
                        l = checkSet.length;

                if ( isPartStr && !rNonWord.test( part ) ) {
                        part = part.toLowerCase();

                        for ( ; i < l; i++ ) {
                                elem = checkSet[i];

                                if ( elem ) {
                                        var parent = elem.parentNode;
                                        checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
                                }
                        }

                } else {
                        for ( ; i < l; i++ ) {
                                elem = checkSet[i];

                                if ( elem ) {
                                        checkSet[i] = isPartStr ?
                                                elem.parentNode :
                                                elem.parentNode === part;
                                }
                        }

                        if ( isPartStr ) {
                                Sizzle.filter( part, checkSet, true );
                        }
                }
        },

        "": function(checkSet, part, isXML){
                var nodeCheck,
                        doneName = done++,
                        checkFn = dirCheck;

                if ( typeof part === "string" && !rNonWord.test( part ) ) {
                        part = part.toLowerCase();
                        nodeCheck = part;
                        checkFn = dirNodeCheck;
                }

                checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
        },

        "~": function( checkSet, part, isXML ) {
                var nodeCheck,
                        doneName = done++,
                        checkFn = dirCheck;

                if ( typeof part === "string" && !rNonWord.test( part ) ) {
                        part = part.toLowerCase();
                        nodeCheck = part;
                        checkFn = dirNodeCheck;
                }

                checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
        }
},

find: {
        ID: function( match, context, isXML ) {
                if ( typeof context.getElementById !== "undefined" && !isXML ) {
                        var m = context.getElementById(match[1]);
                        // Check parentNode to catch when Blackberry 4.6 returns
                        // nodes that are no longer in the document #6963
                        return m && m.parentNode ? [m] : [];
                }
        },

        NAME: function( match, context ) {
                if ( typeof context.getElementsByName !== "undefined" ) {
                        var ret = [],
                                results = context.getElementsByName( match[1] );

                        for ( var i = 0, l = results.length; i < l; i++ ) {
                                if ( results[i].getAttribute("name") === match[1] ) {
                                        ret.push( results[i] );
                                }
                        }

                        return ret.length === 0 ? null : ret;
                }
        },

        TAG: function( match, context ) {
                if ( typeof context.getElementsByTagName !== "undefined" ) {
                        return context.getElementsByTagName( match[1] );
                }
        }
},
preFilter: {
        CLASS: function( match, curLoop, inplace, result, not, isXML ) {
                match = " " + match[1].replace( rBackslash, "" ) + " ";

                if ( isXML ) {
                        return match;
                }

                for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
                        if ( elem ) {
                                if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
                                        if ( !inplace ) {
                                                result.push( elem );
                                        }

                                } else if ( inplace ) {
                                        curLoop[i] = false;
                                }
                        }
                }

                return false;
        },

        ID: function( match ) {
                return match[1].replace( rBackslash, "" );
        },

        TAG: function( match, curLoop ) {
                return match[1].replace( rBackslash, "" ).toLowerCase();
        },

        CHILD: function( match ) {
                if ( match[1] === "nth" ) {
                        if ( !match[2] ) {
                                Sizzle.error( match[0] );
                        }

                        match[2] = match[2].replace(/^\+|\s*/g, '');

                        // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
                        var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
                                match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
                                !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);

                        // calculate the numbers (first)n+(last) including if they are negative
                        match[2] = (test[1] + (test[2] || 1)) - 0;
                        match[3] = test[3] - 0;
                }
                else if ( match[2] ) {
                        Sizzle.error( match[0] );
                }

                // TODO: Move to normal caching system
                match[0] = done++;

                return match;
        },

        ATTR: function( match, curLoop, inplace, result, not, isXML ) {
                var name = match[1] = match[1].replace( rBackslash, "" );

                if ( !isXML && Expr.attrMap[name] ) {
                        match[1] = Expr.attrMap[name];
                }

                // Handle if an un-quoted value was used
                match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );

                if ( match[2] === "~=" ) {
                        match[4] = " " + match[4] + " ";
                }

                return match;
        },

        PSEUDO: function( match, curLoop, inplace, result, not ) {
                if ( match[1] === "not" ) {
                        // If we're dealing with a complex expression, or a simple one
                        if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
                                match[3] = Sizzle(match[3], null, null, curLoop);

                        } else {
                                var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);

                                if ( !inplace ) {
                                        result.push.apply( result, ret );
                                }

                                return false;
                        }

                } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
                        return true;
                }

                return match;
        },

        POS: function( match ) {
                match.unshift( true );

                return match;
        }
},

filters: {
        enabled: function( elem ) {
                return elem.disabled === false && elem.type !== "hidden";
        },

        disabled: function( elem ) {
                return elem.disabled === true;
        },

        checked: function( elem ) {
                return elem.checked === true;
        },

        selected: function( elem ) {
                // Accessing this property makes selected-by-default
                // options in Safari work properly
                if ( elem.parentNode ) {
                        elem.parentNode.selectedIndex;
                }

                return elem.selected === true;
        },

        parent: function( elem ) {
                return !!elem.firstChild;
        },

        empty: function( elem ) {
                return !elem.firstChild;
        },

        has: function( elem, i, match ) {
                return !!Sizzle( match[3], elem ).length;
        },

        header: function( elem ) {
                return (/h\d/i).test( elem.nodeName );
        },

        text: function( elem ) {
                var attr = elem.getAttribute( "type" ), type = elem.type;
                // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
                // use getAttribute instead to test this case
                return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
        },

        radio: function( elem ) {
                return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
        },

        checkbox: function( elem ) {
                return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
        },

        file: function( elem ) {
                return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
        },

        password: function( elem ) {
                return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
        },

        submit: function( elem ) {
                var name = elem.nodeName.toLowerCase();
                return (name === "input" || name === "button") && "submit" === elem.type;
        },

        image: function( elem ) {
                return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
        },

        reset: function( elem ) {
                var name = elem.nodeName.toLowerCase();
                return (name === "input" || name === "button") && "reset" === elem.type;
        },

        button: function( elem ) {
                var name = elem.nodeName.toLowerCase();
                return name === "input" && "button" === elem.type || name === "button";
        },

        input: function( elem ) {
                return (/input|select|textarea|button/i).test( elem.nodeName );
        },

        focus: function( elem ) {
                return elem === elem.ownerDocument.activeElement;
        }
},
setFilters: {
        first: function( elem, i ) {
                return i === 0;
        },

        last: function( elem, i, match, array ) {
                return i === array.length - 1;
        },

        even: function( elem, i ) {
                return i % 2 === 0;
        },

        odd: function( elem, i ) {
                return i % 2 === 1;
        },

        lt: function( elem, i, match ) {
                return i < match[3] - 0;
        },

        gt: function( elem, i, match ) {
                return i > match[3] - 0;
        },

        nth: function( elem, i, match ) {
                return match[3] - 0 === i;
        },

        eq: function( elem, i, match ) {
                return match[3] - 0 === i;
        }
},
filter: {
        PSEUDO: function( elem, match, i, array ) {
                var name = match[1],
                        filter = Expr.filters[ name ];

                if ( filter ) {
                        return filter( elem, i, match, array );

                } else if ( name === "contains" ) {
                        return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;

                } else if ( name === "not" ) {
                        var not = match[3];

                        for ( var j = 0, l = not.length; j < l; j++ ) {
                                if ( not[j] === elem ) {
                                        return false;
                                }
                        }

                        return true;

                } else {
                        Sizzle.error( name );
                }
        },

        CHILD: function( elem, match ) {
                var first, last,
                        doneName, parent, cache,
                        count, diff,
                        type = match[1],
                        node = elem;

                switch ( type ) {
                        case "only":
                        case "first":
                                while ( (node = node.previousSibling) ) {
                                        if ( node.nodeType === 1 ) {
                                                return false;
                                        }
                                }

                                if ( type === "first" ) {
                                        return true;
                                }

                                node = elem;

                                /* falls through */
                        case "last":
                                while ( (node = node.nextSibling) ) {
                                        if ( node.nodeType === 1 ) {
                                                return false;
                                        }
                                }

                                return true;

                        case "nth":
                                first = match[2];
                                last = match[3];

                                if ( first === 1 && last === 0 ) {
                                        return true;
                                }

                                doneName = match[0];
                                parent = elem.parentNode;

                                if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) {
                                        count = 0;

                                        for ( node = parent.firstChild; node; node = node.nextSibling ) {
                                                if ( node.nodeType === 1 ) {
                                                        node.nodeIndex = ++count;
                                                }
                                        }

                                        parent[ expando ] = doneName;
                                }

                                diff = elem.nodeIndex - last;

                                if ( first === 0 ) {
                                        return diff === 0;

                                } else {
                                        return ( diff % first === 0 && diff / first >= 0 );
                                }
                }
        },

        ID: function( elem, match ) {
                return elem.nodeType === 1 && elem.getAttribute("id") === match;
        },

        TAG: function( elem, match ) {
                return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match;
        },

        CLASS: function( elem, match ) {
                return (" " + (elem.className || elem.getAttribute("class")) + " ")
                        .indexOf( match ) > -1;
        },

        ATTR: function( elem, match ) {
                var name = match[1],
                        result = Sizzle.attr ?
                                Sizzle.attr( elem, name ) :
                                Expr.attrHandle[ name ] ?
                                Expr.attrHandle[ name ]( elem ) :
                                elem[ name ] != null ?
                                        elem[ name ] :
                                        elem.getAttribute( name ),
                        value = result + "",
                        type = match[2],
                        check = match[4];

                return result == null ?
                        type === "!=" :
                        !type && Sizzle.attr ?
                        result != null :
                        type === "=" ?
                        value === check :
                        type === "*=" ?
                        value.indexOf(check) >= 0 :
                        type === "~=" ?
                        (" " + value + " ").indexOf(check) >= 0 :
                        !check ?
                        value && result !== false :
                        type === "!=" ?
                        value !== check :
                        type === "^=" ?
                        value.indexOf(check) === 0 :
                        type === "$=" ?
                        value.substr(value.length - check.length) === check :
                        type === "|=" ?
                        value === check || value.substr(0, check.length + 1) === check + "-" :
                        false;
        },

        POS: function( elem, match, i, array ) {
                var name = match[2],
                        filter = Expr.setFilters[ name ];

                if ( filter ) {
                        return filter( elem, i, match, array );
                }
        }
}

};

var origPOS = Expr.match.POS,

fescape = function(all, num){
        return "\\" + (num - 0 + 1);
};

for ( var type in Expr.match ) {

Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );

} // Expose origPOS // “global” as in regardless of relation to brackets/parens Expr.match.globalPOS = origPOS;

var makeArray = function( array, results ) {

array = Array.prototype.slice.call( array, 0 );

if ( results ) {
        results.push.apply( results, array );
        return results;
}

return array;

};

// Perform a simple check to determine if the browser is capable of // converting a NodeList to an array using builtin methods. // Also verifies that the returned array holds DOM nodes // (which is not the case in the Blackberry browser) try {

Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;

// Provide a fallback method if it does not work } catch( e ) {

makeArray = function( array, results ) {
        var i = 0,
                ret = results || [];

        if ( toString.call(array) === "[object Array]" ) {
                Array.prototype.push.apply( ret, array );

        } else {
                if ( typeof array.length === "number" ) {
                        for ( var l = array.length; i < l; i++ ) {
                                ret.push( array[i] );
                        }

                } else {
                        for ( ; array[i]; i++ ) {
                                ret.push( array[i] );
                        }
                }
        }

        return ret;
};

}

var sortOrder, siblingCheck;

if ( document.documentElement.compareDocumentPosition ) {

sortOrder = function( a, b ) {
        if ( a === b ) {
                hasDuplicate = true;
                return 0;
        }

        if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
                return a.compareDocumentPosition ? -1 : 1;
        }

        return a.compareDocumentPosition(b) & 4 ? -1 : 1;
};

} else {

sortOrder = function( a, b ) {
        // The nodes are identical, we can exit early
        if ( a === b ) {
                hasDuplicate = true;
                return 0;

        // Fallback to using sourceIndex (in IE) if it's available on both nodes
        } else if ( a.sourceIndex && b.sourceIndex ) {
                return a.sourceIndex - b.sourceIndex;
        }

        var al, bl,
                ap = [],
                bp = [],
                aup = a.parentNode,
                bup = b.parentNode,
                cur = aup;

        // If the nodes are siblings (or identical) we can do a quick check
        if ( aup === bup ) {
                return siblingCheck( a, b );

        // If no parents were found then the nodes are disconnected
        } else if ( !aup ) {
                return -1;

        } else if ( !bup ) {
                return 1;
        }

        // Otherwise they're somewhere else in the tree so we need
        // to build up a full list of the parentNodes for comparison
        while ( cur ) {
                ap.unshift( cur );
                cur = cur.parentNode;
        }

        cur = bup;

        while ( cur ) {
                bp.unshift( cur );
                cur = cur.parentNode;
        }

        al = ap.length;
        bl = bp.length;

        // Start walking down the tree looking for a discrepancy
        for ( var i = 0; i < al && i < bl; i++ ) {
                if ( ap[i] !== bp[i] ) {
                        return siblingCheck( ap[i], bp[i] );
                }
        }

        // We ended someplace up the tree so do a sibling check
        return i === al ?
                siblingCheck( a, bp[i], -1 ) :
                siblingCheck( ap[i], b, 1 );
};

siblingCheck = function( a, b, ret ) {
        if ( a === b ) {
                return ret;
        }

        var cur = a.nextSibling;

        while ( cur ) {
                if ( cur === b ) {
                        return -1;
                }

                cur = cur.nextSibling;
        }

        return 1;
};

}

// Check to see if the browser returns elements by name when // querying by getElementById (and provide a workaround) (function(){

// We're going to inject a fake input element with a specified name
var form = document.createElement("div"),
        id = "script" + (new Date()).getTime(),
        root = document.documentElement;

form.innerHTML = "<a name='" + id + "'/>";

// Inject it into the root element, check its status, and remove it quickly
root.insertBefore( form, root.firstChild );

// The workaround has to do additional checks after a getElementById
// Which slows things down for other browsers (hence the branching)
if ( document.getElementById( id ) ) {
        Expr.find.ID = function( match, context, isXML ) {
                if ( typeof context.getElementById !== "undefined" && !isXML ) {
                        var m = context.getElementById(match[1]);

                        return m ?
                                m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
                                        [m] :
                                        undefined :
                                [];
                }
        };

        Expr.filter.ID = function( elem, match ) {
                var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");

                return elem.nodeType === 1 && node && node.nodeValue === match;
        };
}

root.removeChild( form );

// release memory in IE
root = form = null;

})();

(function(){

// Check to see if the browser returns only elements
// when doing getElementsByTagName("*")

// Create a fake element
var div = document.createElement("div");
div.appendChild( document.createComment("") );

// Make sure no comments are found
if ( div.getElementsByTagName("*").length > 0 ) {
        Expr.find.TAG = function( match, context ) {
                var results = context.getElementsByTagName( match[1] );

                // Filter out possible comments
                if ( match[1] === "*" ) {
                        var tmp = [];

                        for ( var i = 0; results[i]; i++ ) {
                                if ( results[i].nodeType === 1 ) {
                                        tmp.push( results[i] );
                                }
                        }

                        results = tmp;
                }

                return results;
        };
}

// Check to see if an attribute returns normalized href attributes
div.innerHTML = "<a href='#'></a>";

if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
                div.firstChild.getAttribute("href") !== "#" ) {

        Expr.attrHandle.href = function( elem ) {
                return elem.getAttribute( "href", 2 );
        };
}

// release memory in IE
div = null;

})();

if ( document.querySelectorAll ) {

(function(){
        var oldSizzle = Sizzle,
                div = document.createElement("div"),
                id = "__sizzle__";

        div.innerHTML = "<p class='TEST'></p>";

        // Safari can't handle uppercase or unicode characters when
        // in quirks mode.
        if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
                return;
        }

        Sizzle = function( query, context, extra, seed ) {
                context = context || document;

                // Only use querySelectorAll on non-XML documents
                // (ID selectors don't work in non-HTML documents)
                if ( !seed && !Sizzle.isXML(context) ) {
                        // See if we find a selector to speed up
                        var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );

                        if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
                                // Speed-up: Sizzle("TAG")
                                if ( match[1] ) {
                                        return makeArray( context.getElementsByTagName( query ), extra );

                                // Speed-up: Sizzle(".CLASS")
                                } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
                                        return makeArray( context.getElementsByClassName( match[2] ), extra );
                                }
                        }

                        if ( context.nodeType === 9 ) {
                                // Speed-up: Sizzle("body")
                                // The body element only exists once, optimize finding it
                                if ( query === "body" && context.body ) {
                                        return makeArray( [ context.body ], extra );

                                // Speed-up: Sizzle("#ID")
                                } else if ( match && match[3] ) {
                                        var elem = context.getElementById( match[3] );

                                        // Check parentNode to catch when Blackberry 4.6 returns
                                        // nodes that are no longer in the document #6963
                                        if ( elem && elem.parentNode ) {
                                                // Handle the case where IE and Opera return items
                                                // by name instead of ID
                                                if ( elem.id === match[3] ) {
                                                        return makeArray( [ elem ], extra );
                                                }

                                        } else {
                                                return makeArray( [], extra );
                                        }
                                }

                                try {
                                        return makeArray( context.querySelectorAll(query), extra );
                                } catch(qsaError) {}

                        // qSA works strangely on Element-rooted queries
                        // We can work around this by specifying an extra ID on the root
                        // and working up from there (Thanks to Andrew Dupont for the technique)
                        // IE 8 doesn't work on object elements
                        } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
                                var oldContext = context,
                                        old = context.getAttribute( "id" ),
                                        nid = old || id,
                                        hasParent = context.parentNode,
                                        relativeHierarchySelector = /^\s*[+~]/.test( query );

                                if ( !old ) {
                                        context.setAttribute( "id", nid );
                                } else {
                                        nid = nid.replace( /'/g, "\\$&" );
                                }
                                if ( relativeHierarchySelector && hasParent ) {
                                        context = context.parentNode;
                                }

                                try {
                                        if ( !relativeHierarchySelector || hasParent ) {
                                                return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
                                        }

                                } catch(pseudoError) {
                                } finally {
                                        if ( !old ) {
                                                oldContext.removeAttribute( "id" );
                                        }
                                }
                        }
                }

                return oldSizzle(query, context, extra, seed);
        };

        for ( var prop in oldSizzle ) {
                Sizzle[ prop ] = oldSizzle[ prop ];
        }

        // release memory in IE
        div = null;
})();

}

(function(){

var html = document.documentElement,
        matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;

if ( matches ) {
        // Check to see if it's possible to do matchesSelector
        // on a disconnected node (IE 9 fails this)
        var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
                pseudoWorks = false;

        try {
                // This should fail with an exception
                // Gecko does not error, returns false instead
                matches.call( document.documentElement, "[test!='']:sizzle" );

        } catch( pseudoError ) {
                pseudoWorks = true;
        }

        Sizzle.matchesSelector = function( node, expr ) {
                // Make sure that attribute selectors are quoted
                expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");

                if ( !Sizzle.isXML( node ) ) {
                        try {
                                if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
                                        var ret = matches.call( node, expr );

                                        // IE 9's matchesSelector returns false on disconnected nodes
                                        if ( ret || !disconnectedMatch ||
                                                        // As well, disconnected nodes are said to be in a document
                                                        // fragment in IE 9, so check for that
                                                        node.document && node.document.nodeType !== 11 ) {
                                                return ret;
                                        }
                                }
                        } catch(e) {}
                }

                return Sizzle(expr, null, null, [node]).length > 0;
        };
}

})();

(function(){

var div = document.createElement("div");

div.innerHTML = "<div class='test e'></div><div class='test'></div>";

// Opera can't find a second classname (in 9.6)
// Also, make sure that getElementsByClassName actually exists
if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
        return;
}

// Safari caches class attributes, doesn't catch changes (in 3.2)
div.lastChild.className = "e";

if ( div.getElementsByClassName("e").length === 1 ) {
        return;
}

Expr.order.splice(1, 0, "CLASS");
Expr.find.CLASS = function( match, context, isXML ) {
        if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
                return context.getElementsByClassName(match[1]);
        }
};

// release memory in IE
div = null;

})();

function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {

for ( var i = 0, l = checkSet.length; i < l; i++ ) {
        var elem = checkSet[i];

        if ( elem ) {
                var match = false;

                elem = elem[dir];

                while ( elem ) {
                        if ( elem[ expando ] === doneName ) {
                                match = checkSet[elem.sizset];
                                break;
                        }

                        if ( elem.nodeType === 1 && !isXML ){
                                elem[ expando ] = doneName;
                                elem.sizset = i;
                        }

                        if ( elem.nodeName.toLowerCase() === cur ) {
                                match = elem;
                                break;
                        }

                        elem = elem[dir];
                }

                checkSet[i] = match;
        }
}

}

function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {

for ( var i = 0, l = checkSet.length; i < l; i++ ) {
        var elem = checkSet[i];

        if ( elem ) {
                var match = false;

                elem = elem[dir];

                while ( elem ) {
                        if ( elem[ expando ] === doneName ) {
                                match = checkSet[elem.sizset];
                                break;
                        }

                        if ( elem.nodeType === 1 ) {
                                if ( !isXML ) {
                                        elem[ expando ] = doneName;
                                        elem.sizset = i;
                                }

                                if ( typeof cur !== "string" ) {
                                        if ( elem === cur ) {
                                                match = true;
                                                break;
                                        }

                                } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
                                        match = elem;
                                        break;
                                }
                        }

                        elem = elem[dir];
                }

                checkSet[i] = match;
        }
}

}

if ( document.documentElement.contains ) {

Sizzle.contains = function( a, b ) {
        return a !== b && (a.contains ? a.contains(b) : true);
};

} else if ( document.documentElement.compareDocumentPosition ) {

Sizzle.contains = function( a, b ) {
        return !!(a.compareDocumentPosition(b) & 16);
};

} else {

Sizzle.contains = function() {
        return false;
};

}

Sizzle.isXML = function( elem ) {

// documentElement is verified for cases where it doesn't yet exist
// (such as loading iframes in IE - #4833)
var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;

return documentElement ? documentElement.nodeName !== "HTML" : false;

};

var posProcess = function( selector, context, seed ) {

var match,
        tmpSet = [],
        later = "",
        root = context.nodeType ? [context] : context;

// Position selectors must be done after the filter
// And so must :not(positional) so we move all PSEUDOs to the end
while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
        later += match[0];
        selector = selector.replace( Expr.match.PSEUDO, "" );
}

selector = Expr.relative[selector] ? selector + "*" : selector;

for ( var i = 0, l = root.length; i < l; i++ ) {
        Sizzle( selector, root[i], tmpSet, seed );
}

return Sizzle.filter( later, tmpSet );

};

// EXPOSE // Override sizzle attribute retrieval Sizzle.attr = jQuery.attr; Sizzle.selectors.attrMap = {}; jQuery.find = Sizzle; jQuery.expr = Sizzle.selectors; jQuery.expr = jQuery.expr.filters; jQuery.unique = Sizzle.uniqueSort; jQuery.text = Sizzle.getText; jQuery.isXMLDoc = Sizzle.isXML; jQuery.contains = Sizzle.contains;

})();

var runtil = /Until$/,

rparentsprev = /^(?:parents|prevUntil|prevAll)/,
// Note: This RegExp should be improved, or likely pulled from Sizzle
rmultiselector = /,/,
isSimple = /^.[^:#\[\.,]*$/,
slice = Array.prototype.slice,
POS = jQuery.expr.match.globalPOS,
// methods guaranteed to produce a unique set when starting from a unique set
guaranteedUnique = {
        children: true,
        contents: true,
        next: true,
        prev: true
};

jQuery.fn.extend({

find: function( selector ) {
        var self = this,
                i, l;

        if ( typeof selector !== "string" ) {
                return jQuery( selector ).filter(function() {
                        for ( i = 0, l = self.length; i < l; i++ ) {
                                if ( jQuery.contains( self[ i ], this ) ) {
                                        return true;
                                }
                        }
                });
        }

        var ret = this.pushStack( "", "find", selector ),
                length, n, r;

        for ( i = 0, l = this.length; i < l; i++ ) {
                length = ret.length;
                jQuery.find( selector, this[i], ret );

                if ( i > 0 ) {
                        // Make sure that the results are unique
                        for ( n = length; n < ret.length; n++ ) {
                                for ( r = 0; r < length; r++ ) {
                                        if ( ret[r] === ret[n] ) {
                                                ret.splice(n--, 1);
                                                break;
                                        }
                                }
                        }
                }
        }

        return ret;
},

has: function( target ) {
        var targets = jQuery( target );
        return this.filter(function() {
                for ( var i = 0, l = targets.length; i < l; i++ ) {
                        if ( jQuery.contains( this, targets[i] ) ) {
                                return true;
                        }
                }
        });
},

not: function( selector ) {
        return this.pushStack( winnow(this, selector, false), "not", selector);
},

filter: function( selector ) {
        return this.pushStack( winnow(this, selector, true), "filter", selector );
},

is: function( selector ) {
        return !!selector && (
                typeof selector === "string" ?
                        // If this is a positional selector, check membership in the returned set
                        // so $("p:first").is("p:last") won't return true for a doc with two "p".
                        POS.test( selector ) ?
                                jQuery( selector, this.context ).index( this[0] ) >= 0 :
                                jQuery.filter( selector, this ).length > 0 :
                        this.filter( selector ).length > 0 );
},

closest: function( selectors, context ) {
        var ret = [], i, l, cur = this[0];

        // Array (deprecated as of jQuery 1.7)
        if ( jQuery.isArray( selectors ) ) {
                var level = 1;

                while ( cur && cur.ownerDocument && cur !== context ) {
                        for ( i = 0; i < selectors.length; i++ ) {

                                if ( jQuery( cur ).is( selectors[ i ] ) ) {
                                        ret.push({ selector: selectors[ i ], elem: cur, level: level });
                                }
                        }

                        cur = cur.parentNode;
                        level++;
                }

                return ret;
        }

        // String
        var pos = POS.test( selectors ) || typeof selectors !== "string" ?
                        jQuery( selectors, context || this.context ) :
                        0;

        for ( i = 0, l = this.length; i < l; i++ ) {
                cur = this[i];

                while ( cur ) {
                        if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
                                ret.push( cur );
                                break;

                        } else {
                                cur = cur.parentNode;
                                if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
                                        break;
                                }
                        }
                }
        }

        ret = ret.length > 1 ? jQuery.unique( ret ) : ret;

        return this.pushStack( ret, "closest", selectors );
},

// Determine the position of an element within
// the matched set of elements
index: function( elem ) {

        // No argument, return index in parent
        if ( !elem ) {
                return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
        }

        // index in selector
        if ( typeof elem === "string" ) {
                return jQuery.inArray( this[0], jQuery( elem ) );
        }

        // Locate the position of the desired element
        return jQuery.inArray(
                // If it receives a jQuery object, the first element is used
                elem.jquery ? elem[0] : elem, this );
},

add: function( selector, context ) {
        var set = typeof selector === "string" ?
                        jQuery( selector, context ) :
                        jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
                all = jQuery.merge( this.get(), set );

        return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
                all :
                jQuery.unique( all ) );
},

andSelf: function() {
        return this.add( this.prevObject );
}

});

// A painfully simple check to see if an element is disconnected // from a document (should be improved, where feasible). function isDisconnected( node ) {

return !node || !node.parentNode || node.parentNode.nodeType === 11;

}

jQuery.each({

parent: function( elem ) {
        var parent = elem.parentNode;
        return parent && parent.nodeType !== 11 ? parent : null;
},
parents: function( elem ) {
        return jQuery.dir( elem, "parentNode" );
},
parentsUntil: function( elem, i, until ) {
        return jQuery.dir( elem, "parentNode", until );
},
next: function( elem ) {
        return jQuery.nth( elem, 2, "nextSibling" );
},
prev: function( elem ) {
        return jQuery.nth( elem, 2, "previousSibling" );
},
nextAll: function( elem ) {
        return jQuery.dir( elem, "nextSibling" );
},
prevAll: function( elem ) {
        return jQuery.dir( elem, "previousSibling" );
},
nextUntil: function( elem, i, until ) {
        return jQuery.dir( elem, "nextSibling", until );
},
prevUntil: function( elem, i, until ) {
        return jQuery.dir( elem, "previousSibling", until );
},
siblings: function( elem ) {
        return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
},
children: function( elem ) {
        return jQuery.sibling( elem.firstChild );
},
contents: function( elem ) {
        return jQuery.nodeName( elem, "iframe" ) ?
                elem.contentDocument || elem.contentWindow.document :
                jQuery.makeArray( elem.childNodes );
}

}, function( name, fn ) {

jQuery.fn[ name ] = function( until, selector ) {
        var ret = jQuery.map( this, fn, until );

        if ( !runtil.test( name ) ) {
                selector = until;
        }

        if ( selector && typeof selector === "string" ) {
                ret = jQuery.filter( selector, ret );
        }

        ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;

        if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
                ret = ret.reverse();
        }

        return this.pushStack( ret, name, slice.call( arguments ).join(",") );
};

});

jQuery.extend({

filter: function( expr, elems, not ) {
        if ( not ) {
                expr = ":not(" + expr + ")";
        }

        return elems.length === 1 ?
                jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
                jQuery.find.matches(expr, elems);
},

dir: function( elem, dir, until ) {
        var matched = [],
                cur = elem[ dir ];

        while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
                if ( cur.nodeType === 1 ) {
                        matched.push( cur );
                }
                cur = cur[dir];
        }
        return matched;
},

nth: function( cur, result, dir, elem ) {
        result = result || 1;
        var num = 0;

        for ( ; cur; cur = cur[dir] ) {
                if ( cur.nodeType === 1 && ++num === result ) {
                        break;
                }
        }

        return cur;
},

sibling: function( n, elem ) {
        var r = [];

        for ( ; n; n = n.nextSibling ) {
                if ( n.nodeType === 1 && n !== elem ) {
                        r.push( n );
                }
        }

        return r;
}

});

// Implement the identical functionality for filter and not function winnow( elements, qualifier, keep ) {

// Can't pass null or undefined to indexOf in Firefox 4
// Set to 0 to skip string check
qualifier = qualifier || 0;

if ( jQuery.isFunction( qualifier ) ) {
        return jQuery.grep(elements, function( elem, i ) {
                var retVal = !!qualifier.call( elem, i, elem );
                return retVal === keep;
        });

} else if ( qualifier.nodeType ) {
        return jQuery.grep(elements, function( elem, i ) {
                return ( elem === qualifier ) === keep;
        });

} else if ( typeof qualifier === "string" ) {
        var filtered = jQuery.grep(elements, function( elem ) {
                return elem.nodeType === 1;
        });

        if ( isSimple.test( qualifier ) ) {
                return jQuery.filter(qualifier, filtered, !keep);
        } else {
                qualifier = jQuery.filter( qualifier, filtered );
        }
}

return jQuery.grep(elements, function( elem, i ) {
        return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
});

}

function createSafeFragment( document ) {

var list = nodeNames.split( "|" ),
safeFrag = document.createDocumentFragment();

if ( safeFrag.createElement ) {
        while ( list.length ) {
                safeFrag.createElement(
                        list.pop()
                );
        }
}
return safeFrag;

}

var nodeNames = “abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|” +

        "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
rleadingWhitespace = /^\s+/,
rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
rtagName = /<([\w:]+)/,
rtbody = /<tbody/i,
rhtml = /<|&#?\w+;/,
rnoInnerhtml = /<(?:script|style)/i,
rnocache = /<(?:script|object|embed|option|style)/i,
rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
// checked="checked" or checked
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
rscriptType = /\/(java|ecma)script/i,
rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
wrapMap = {
        option: [ 1, "<select multiple='multiple'>", "</select>" ],
        legend: [ 1, "<fieldset>", "</fieldset>" ],
        thead: [ 1, "<table>", "</table>" ],
        tr: [ 2, "<table><tbody>", "</tbody></table>" ],
        td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
        col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
        area: [ 1, "<map>", "</map>" ],
        _default: [ 0, "", "" ]
},
safeFragment = createSafeFragment( document );

wrapMap.optgroup = wrapMap.option; wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; wrapMap.th = wrapMap.td;

// IE can't serialize <link> and <script> tags normally if ( !jQuery.support.htmlSerialize ) {

wrapMap._default = [ 1, "div<div>", "</div>" ];

}

jQuery.fn.extend({

text: function( value ) {
        return jQuery.access( this, function( value ) {
                return value === undefined ?
                        jQuery.text( this ) :
                        this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
        }, null, value, arguments.length );
},

wrapAll: function( html ) {
        if ( jQuery.isFunction( html ) ) {
                return this.each(function(i) {
                        jQuery(this).wrapAll( html.call(this, i) );
                });
        }

        if ( this[0] ) {
                // The elements to wrap the target around
                var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);

                if ( this[0].parentNode ) {
                        wrap.insertBefore( this[0] );
                }

                wrap.map(function() {
                        var elem = this;

                        while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
                                elem = elem.firstChild;
                        }

                        return elem;
                }).append( this );
        }

        return this;
},

wrapInner: function( html ) {
        if ( jQuery.isFunction( html ) ) {
                return this.each(function(i) {
                        jQuery(this).wrapInner( html.call(this, i) );
                });
        }

        return this.each(function() {
                var self = jQuery( this ),
                        contents = self.contents();

                if ( contents.length ) {
                        contents.wrapAll( html );

                } else {
                        self.append( html );
                }
        });
},

wrap: function( html ) {
        var isFunction = jQuery.isFunction( html );

        return this.each(function(i) {
                jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
        });
},

unwrap: function() {
        return this.parent().each(function() {
                if ( !jQuery.nodeName( this, "body" ) ) {
                        jQuery( this ).replaceWith( this.childNodes );
                }
        }).end();
},

append: function() {
        return this.domManip(arguments, true, function( elem ) {
                if ( this.nodeType === 1 ) {
                        this.appendChild( elem );
                }
        });
},

prepend: function() {
        return this.domManip(arguments, true, function( elem ) {
                if ( this.nodeType === 1 ) {
                        this.insertBefore( elem, this.firstChild );
                }
        });
},

before: function() {
        if ( this[0] && this[0].parentNode ) {
                return this.domManip(arguments, false, function( elem ) {
                        this.parentNode.insertBefore( elem, this );
                });
        } else if ( arguments.length ) {
                var set = jQuery.clean( arguments );
                set.push.apply( set, this.toArray() );
                return this.pushStack( set, "before", arguments );
        }
},

after: function() {
        if ( this[0] && this[0].parentNode ) {
                return this.domManip(arguments, false, function( elem ) {
                        this.parentNode.insertBefore( elem, this.nextSibling );
                });
        } else if ( arguments.length ) {
                var set = this.pushStack( this, "after", arguments );
                set.push.apply( set, jQuery.clean(arguments) );
                return set;
        }
},

// keepData is for internal use only--do not document
remove: function( selector, keepData ) {
        for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
                if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
                        if ( !keepData && elem.nodeType === 1 ) {
                                jQuery.cleanData( elem.getElementsByTagName("*") );
                                jQuery.cleanData( [ elem ] );
                        }

                        if ( elem.parentNode ) {
                                elem.parentNode.removeChild( elem );
                        }
                }
        }

        return this;
},

empty: function() {
        for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
                // Remove element nodes and prevent memory leaks
                if ( elem.nodeType === 1 ) {
                        jQuery.cleanData( elem.getElementsByTagName("*") );
                }

                // Remove any remaining nodes
                while ( elem.firstChild ) {
                        elem.removeChild( elem.firstChild );
                }
        }

        return this;
},

clone: function( dataAndEvents, deepDataAndEvents ) {
        dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
        deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;

        return this.map( function () {
                return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
        });
},

html: function( value ) {
        return jQuery.access( this, function( value ) {
                var elem = this[0] || {},
                        i = 0,
                        l = this.length;

                if ( value === undefined ) {
                        return elem.nodeType === 1 ?
                                elem.innerHTML.replace( rinlinejQuery, "" ) :
                                null;
                }

                if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
                        ( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
                        !wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {

                        value = value.replace( rxhtmlTag, "<$1></$2>" );

                        try {
                                for (; i < l; i++ ) {
                                        // Remove element nodes and prevent memory leaks
                                        elem = this[i] || {};
                                        if ( elem.nodeType === 1 ) {
                                                jQuery.cleanData( elem.getElementsByTagName( "*" ) );
                                                elem.innerHTML = value;
                                        }
                                }

                                elem = 0;

                        // If using innerHTML throws an exception, use the fallback method
                        } catch(e) {}
                }

                if ( elem ) {
                        this.empty().append( value );
                }
        }, null, value, arguments.length );
},

replaceWith: function( value ) {
        if ( this[0] && this[0].parentNode ) {
                // Make sure that the elements are removed from the DOM before they are inserted
                // this can help fix replacing a parent with child elements
                if ( jQuery.isFunction( value ) ) {
                        return this.each(function(i) {
                                var self = jQuery(this), old = self.html();
                                self.replaceWith( value.call( this, i, old ) );
                        });
                }

                if ( typeof value !== "string" ) {
                        value = jQuery( value ).detach();
                }

                return this.each(function() {
                        var next = this.nextSibling,
                                parent = this.parentNode;

                        jQuery( this ).remove();

                        if ( next ) {
                                jQuery(next).before( value );
                        } else {
                                jQuery(parent).append( value );
                        }
                });
        } else {
                return this.length ?
                        this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
                        this;
        }
},

detach: function( selector ) {
        return this.remove( selector, true );
},

domManip: function( args, table, callback ) {
        var results, first, fragment, parent,
                value = args[0],
                scripts = [];

        // We can't cloneNode fragments that contain checked, in WebKit
        if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
                return this.each(function() {
                        jQuery(this).domManip( args, table, callback, true );
                });
        }

        if ( jQuery.isFunction(value) ) {
                return this.each(function(i) {
                        var self = jQuery(this);
                        args[0] = value.call(this, i, table ? self.html() : undefined);
                        self.domManip( args, table, callback );
                });
        }

        if ( this[0] ) {
                parent = value && value.parentNode;

                // If we're in a fragment, just use that instead of building a new one
                if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
                        results = { fragment: parent };

                } else {
                        results = jQuery.buildFragment( args, this, scripts );
                }

                fragment = results.fragment;

                if ( fragment.childNodes.length === 1 ) {
                        first = fragment = fragment.firstChild;
                } else {
                        first = fragment.firstChild;
                }

                if ( first ) {
                        table = table && jQuery.nodeName( first, "tr" );

                        for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
                                callback.call(
                                        table ?
                                                root(this[i], first) :
                                                this[i],
                                        // Make sure that we do not leak memory by inadvertently discarding
                                        // the original fragment (which might have attached data) instead of
                                        // using it; in addition, use the original fragment object for the last
                                        // item instead of first because it can end up being emptied incorrectly
                                        // in certain situations (Bug #8070).
                                        // Fragments from the fragment cache must always be cloned and never used
                                        // in place.
                                        results.cacheable || ( l > 1 && i < lastIndex ) ?
                                                jQuery.clone( fragment, true, true ) :
                                                fragment
                                );
                        }
                }

                if ( scripts.length ) {
                        jQuery.each( scripts, function( i, elem ) {
                                if ( elem.src ) {
                                        jQuery.ajax({
                                                type: "GET",
                                                global: false,
                                                url: elem.src,
                                                async: false,
                                                dataType: "script"
                                        });
                                } else {
                                        jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
                                }

                                if ( elem.parentNode ) {
                                        elem.parentNode.removeChild( elem );
                                }
                        });
                }
        }

        return this;
}

});

function root( elem, cur ) {

return jQuery.nodeName(elem, "table") ?
        (elem.getElementsByTagName("tbody")[0] ||
        elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
        elem;

}

function cloneCopyEvent( src, dest ) {

if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
        return;
}

var type, i, l,
        oldData = jQuery._data( src ),
        curData = jQuery._data( dest, oldData ),
        events = oldData.events;

if ( events ) {
        delete curData.handle;
        curData.events = {};

        for ( type in events ) {
                for ( i = 0, l = events[ type ].length; i < l; i++ ) {
                        jQuery.event.add( dest, type, events[ type ][ i ] );
                }
        }
}

// make the cloned public data object a copy from the original
if ( curData.data ) {
        curData.data = jQuery.extend( {}, curData.data );
}

}

function cloneFixAttributes( src, dest ) {

var nodeName;

// We do not need to do anything for non-Elements
if ( dest.nodeType !== 1 ) {
        return;
}

// clearAttributes removes the attributes, which we don't want,
// but also removes the attachEvent events, which we *do* want
if ( dest.clearAttributes ) {
        dest.clearAttributes();
}

// mergeAttributes, in contrast, only merges back on the
// original attributes, not the events
if ( dest.mergeAttributes ) {
        dest.mergeAttributes( src );
}

nodeName = dest.nodeName.toLowerCase();

// IE6-8 fail to clone children inside object elements that use
// the proprietary classid attribute value (rather than the type
// attribute) to identify the type of content to display
if ( nodeName === "object" ) {
        dest.outerHTML = src.outerHTML;

} else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
        // IE6-8 fails to persist the checked state of a cloned checkbox
        // or radio button. Worse, IE6-7 fail to give the cloned element
        // a checked appearance if the defaultChecked value isn't also set
        if ( src.checked ) {
                dest.defaultChecked = dest.checked = src.checked;
        }

        // IE6-7 get confused and end up setting the value of a cloned
        // checkbox/radio button to an empty string instead of "on"
        if ( dest.value !== src.value ) {
                dest.value = src.value;
        }

// IE6-8 fails to return the selected option to the default selected
// state when cloning options
} else if ( nodeName === "option" ) {
        dest.selected = src.defaultSelected;

// IE6-8 fails to set the defaultValue to the correct value when
// cloning other types of input fields
} else if ( nodeName === "input" || nodeName === "textarea" ) {
        dest.defaultValue = src.defaultValue;

// IE blanks contents when cloning scripts
} else if ( nodeName === "script" && dest.text !== src.text ) {
        dest.text = src.text;
}

// Event data gets referenced instead of copied if the expando
// gets copied too
dest.removeAttribute( jQuery.expando );

// Clear flags for bubbling special change/submit events, they must
// be reattached when the newly cloned events are first activated
dest.removeAttribute( "_submit_attached" );
dest.removeAttribute( "_change_attached" );

}

jQuery.buildFragment = function( args, nodes, scripts ) {

var fragment, cacheable, cacheresults, doc,
first = args[ 0 ];

// nodes may contain either an explicit document object,
// a jQuery collection or context object.
// If nodes[0] contains a valid object to assign to doc
if ( nodes && nodes[0] ) {
        doc = nodes[0].ownerDocument || nodes[0];
}

// Ensure that an attr object doesn't incorrectly stand in as a document object
// Chrome and Firefox seem to allow this to occur and will throw exception
// Fixes #8950
if ( !doc.createDocumentFragment ) {
        doc = document;
}

// Only cache "small" (1/2 KB) HTML strings that are associated with the main document
// Cloning options loses the selected state, so don't cache them
// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
// Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
if ( args.length === 1 && typeof first === "string" && first.length < 512 && doc === document &&
        first.charAt(0) === "<" && !rnocache.test( first ) &&
        (jQuery.support.checkClone || !rchecked.test( first )) &&
        (jQuery.support.html5Clone || !rnoshimcache.test( first )) ) {

        cacheable = true;

        cacheresults = jQuery.fragments[ first ];
        if ( cacheresults && cacheresults !== 1 ) {
                fragment = cacheresults;
        }
}

if ( !fragment ) {
        fragment = doc.createDocumentFragment();
        jQuery.clean( args, doc, fragment, scripts );
}

if ( cacheable ) {
        jQuery.fragments[ first ] = cacheresults ? fragment : 1;
}

return { fragment: fragment, cacheable: cacheable };

};

jQuery.fragments = {};

jQuery.each({

appendTo: "append",
prependTo: "prepend",
insertBefore: "before",
insertAfter: "after",
replaceAll: "replaceWith"

}, function( name, original ) {

jQuery.fn[ name ] = function( selector ) {
        var ret = [],
                insert = jQuery( selector ),
                parent = this.length === 1 && this[0].parentNode;

        if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
                insert[ original ]( this[0] );
                return this;

        } else {
                for ( var i = 0, l = insert.length; i < l; i++ ) {
                        var elems = ( i > 0 ? this.clone(true) : this ).get();
                        jQuery( insert[i] )[ original ]( elems );
                        ret = ret.concat( elems );
                }

                return this.pushStack( ret, name, insert.selector );
        }
};

});

function getAll( elem ) {

if ( typeof elem.getElementsByTagName !== "undefined" ) {
        return elem.getElementsByTagName( "*" );

} else if ( typeof elem.querySelectorAll !== "undefined" ) {
        return elem.querySelectorAll( "*" );

} else {
        return [];
}

}

// Used in clean, fixes the defaultChecked property function fixDefaultChecked( elem ) {

if ( elem.type === "checkbox" || elem.type === "radio" ) {
        elem.defaultChecked = elem.checked;
}

} // Finds all inputs and passes them to fixDefaultChecked function findInputs( elem ) {

var nodeName = ( elem.nodeName || "" ).toLowerCase();
if ( nodeName === "input" ) {
        fixDefaultChecked( elem );
// Skip scripts, get other children
} else if ( nodeName !== "script" && typeof elem.getElementsByTagName !== "undefined" ) {
        jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
}

}

// Derived From: www.iecss.com/shimprove/javascript/shimprove.1-0-1.js function shimCloneNode( elem ) {

var div = document.createElement( "div" );
safeFragment.appendChild( div );

div.innerHTML = elem.outerHTML;
return div.firstChild;

}

jQuery.extend({

clone: function( elem, dataAndEvents, deepDataAndEvents ) {
        var srcElements,
                destElements,
                i,
                // IE<=8 does not properly clone detached, unknown element nodes
                clone = jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ?
                        elem.cloneNode( true ) :
                        shimCloneNode( elem );

        if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
                        (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
                // IE copies events bound via attachEvent when using cloneNode.
                // Calling detachEvent on the clone will also remove the events
                // from the original. In order to get around this, we use some
                // proprietary methods to clear the events. Thanks to MooTools
                // guys for this hotness.

                cloneFixAttributes( elem, clone );

                // Using Sizzle here is crazy slow, so we use getElementsByTagName instead
                srcElements = getAll( elem );
                destElements = getAll( clone );

                // Weird iteration because IE will replace the length property
                // with an element if you are cloning the body and one of the
                // elements on the page has a name or id of "length"
                for ( i = 0; srcElements[i]; ++i ) {
                        // Ensure that the destination node is not null; Fixes #9587
                        if ( destElements[i] ) {
                                cloneFixAttributes( srcElements[i], destElements[i] );
                        }
                }
        }

        // Copy the events from the original to the clone
        if ( dataAndEvents ) {
                cloneCopyEvent( elem, clone );

                if ( deepDataAndEvents ) {
                        srcElements = getAll( elem );
                        destElements = getAll( clone );

                        for ( i = 0; srcElements[i]; ++i ) {
                                cloneCopyEvent( srcElements[i], destElements[i] );
                        }
                }
        }

        srcElements = destElements = null;

        // Return the cloned set
        return clone;
},

clean: function( elems, context, fragment, scripts ) {
        var checkScriptType, script, j,
                        ret = [];

        context = context || document;

        // !context.createElement fails in IE with an error but returns typeof 'object'
        if ( typeof context.createElement === "undefined" ) {
                context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
        }

        for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
                if ( typeof elem === "number" ) {
                        elem += "";
                }

                if ( !elem ) {
                        continue;
                }

                // Convert html string into DOM nodes
                if ( typeof elem === "string" ) {
                        if ( !rhtml.test( elem ) ) {
                                elem = context.createTextNode( elem );
                        } else {
                                // Fix "XHTML"-style tags in all browsers
                                elem = elem.replace(rxhtmlTag, "<$1></$2>");

                                // Trim whitespace, otherwise indexOf won't work as expected
                                var tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(),
                                        wrap = wrapMap[ tag ] || wrapMap._default,
                                        depth = wrap[0],
                                        div = context.createElement("div"),
                                        safeChildNodes = safeFragment.childNodes,
                                        remove;

                                // Append wrapper element to unknown element safe doc fragment
                                if ( context === document ) {
                                        // Use the fragment we've already created for this document
                                        safeFragment.appendChild( div );
                                } else {
                                        // Use a fragment created with the owner document
                                        createSafeFragment( context ).appendChild( div );
                                }

                                // Go to html and back, then peel off extra wrappers
                                div.innerHTML = wrap[1] + elem + wrap[2];

                                // Move to the right depth
                                while ( depth-- ) {
                                        div = div.lastChild;
                                }

                                // Remove IE's autoinserted <tbody> from table fragments
                                if ( !jQuery.support.tbody ) {

                                        // String was a <table>, *may* have spurious <tbody>
                                        var hasBody = rtbody.test(elem),
                                                tbody = tag === "table" && !hasBody ?
                                                        div.firstChild && div.firstChild.childNodes :

                                                        // String was a bare <thead> or <tfoot>
                                                        wrap[1] === "<table>" && !hasBody ?
                                                                div.childNodes :
                                                                [];

                                        for ( j = tbody.length - 1; j >= 0 ; --j ) {
                                                if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
                                                        tbody[ j ].parentNode.removeChild( tbody[ j ] );
                                                }
                                        }
                                }

                                // IE completely kills leading whitespace when innerHTML is used
                                if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
                                        div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
                                }

                                elem = div.childNodes;

                                // Clear elements from DocumentFragment (safeFragment or otherwise)
                                // to avoid hoarding elements. Fixes #11356
                                if ( div ) {
                                        div.parentNode.removeChild( div );

                                        // Guard against -1 index exceptions in FF3.6
                                        if ( safeChildNodes.length > 0 ) {
                                                remove = safeChildNodes[ safeChildNodes.length - 1 ];

                                                if ( remove && remove.parentNode ) {
                                                        remove.parentNode.removeChild( remove );
                                                }
                                        }
                                }
                        }
                }

                // Resets defaultChecked for any radios and checkboxes
                // about to be appended to the DOM in IE 6/7 (#8060)
                var len;
                if ( !jQuery.support.appendChecked ) {
                        if ( elem[0] && typeof (len = elem.length) === "number" ) {
                                for ( j = 0; j < len; j++ ) {
                                        findInputs( elem[j] );
                                }
                        } else {
                                findInputs( elem );
                        }
                }

                if ( elem.nodeType ) {
                        ret.push( elem );
                } else {
                        ret = jQuery.merge( ret, elem );
                }
        }

        if ( fragment ) {
                checkScriptType = function( elem ) {
                        return !elem.type || rscriptType.test( elem.type );
                };
                for ( i = 0; ret[i]; i++ ) {
                        script = ret[i];
                        if ( scripts && jQuery.nodeName( script, "script" ) && (!script.type || rscriptType.test( script.type )) ) {
                                scripts.push( script.parentNode ? script.parentNode.removeChild( script ) : script );

                        } else {
                                if ( script.nodeType === 1 ) {
                                        var jsTags = jQuery.grep( script.getElementsByTagName( "script" ), checkScriptType );

                                        ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
                                }
                                fragment.appendChild( script );
                        }
                }
        }

        return ret;
},

cleanData: function( elems ) {
        var data, id,
                cache = jQuery.cache,
                special = jQuery.event.special,
                deleteExpando = jQuery.support.deleteExpando;

        for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
                if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
                        continue;
                }

                id = elem[ jQuery.expando ];

                if ( id ) {
                        data = cache[ id ];

                        if ( data && data.events ) {
                                for ( var type in data.events ) {
                                        if ( special[ type ] ) {
                                                jQuery.event.remove( elem, type );

                                        // This is a shortcut to avoid jQuery.event.remove's overhead
                                        } else {
                                                jQuery.removeEvent( elem, type, data.handle );
                                        }
                                }

                                // Null the DOM reference to avoid IE6/7/8 leak (#7054)
                                if ( data.handle ) {
                                        data.handle.elem = null;
                                }
                        }

                        if ( deleteExpando ) {
                                delete elem[ jQuery.expando ];

                        } else if ( elem.removeAttribute ) {
                                elem.removeAttribute( jQuery.expando );
                        }

                        delete cache[ id ];
                }
        }
}

});

var ralpha = /alpha(*)/i,

ropacity = /opacity=([^)]*)/,
// fixed for IE9, see #8346
rupper = /([A-Z]|^ms)/g,
rnum = /^[\-+]?(?:\d*\.)?\d+$/i,
rnumnonpx = /^-?(?:\d*\.)?\d+(?!px)[^\d\s]+$/i,
rrelNum = /^([\-+])=([\-+.\de]+)/,
rmargin = /^margin/,

cssShow = { position: "absolute", visibility: "hidden", display: "block" },

// order is important!
cssExpand = [ "Top", "Right", "Bottom", "Left" ],

curCSS,

getComputedStyle,
currentStyle;

jQuery.fn.css = function( name, value ) {

return jQuery.access( this, function( elem, name, value ) {
        return value !== undefined ?
                jQuery.style( elem, name, value ) :
                jQuery.css( elem, name );
}, name, value, arguments.length > 1 );

};

jQuery.extend({

// Add in style property hooks for overriding the default
// behavior of getting and setting a style property
cssHooks: {
        opacity: {
                get: function( elem, computed ) {
                        if ( computed ) {
                                // We should always get a number back from opacity
                                var ret = curCSS( elem, "opacity" );
                                return ret === "" ? "1" : ret;

                        } else {
                                return elem.style.opacity;
                        }
                }
        }
},

// Exclude the following css properties to add px
cssNumber: {
        "fillOpacity": true,
        "fontWeight": true,
        "lineHeight": true,
        "opacity": true,
        "orphans": true,
        "widows": true,
        "zIndex": true,
        "zoom": true
},

// Add in properties whose names you wish to fix before
// setting or getting the value
cssProps: {
        // normalize float css property
        "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
},

// Get and set the style property on a DOM Node
style: function( elem, name, value, extra ) {
        // Don't set styles on text and comment nodes
        if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
                return;
        }

        // Make sure that we're working with the right name
        var ret, type, origName = jQuery.camelCase( name ),
                style = elem.style, hooks = jQuery.cssHooks[ origName ];

        name = jQuery.cssProps[ origName ] || origName;

        // Check if we're setting a value
        if ( value !== undefined ) {
                type = typeof value;

                // convert relative number strings (+= or -=) to relative numbers. #7345
                if ( type === "string" && (ret = rrelNum.exec( value )) ) {
                        value = ( +( ret[1] + 1) * +ret[2] ) + parseFloat( jQuery.css( elem, name ) );
                        // Fixes bug #9237
                        type = "number";
                }

                // Make sure that NaN and null values aren't set. See: #7116
                if ( value == null || type === "number" && isNaN( value ) ) {
                        return;
                }

                // If a number was passed in, add 'px' to the (except for certain CSS properties)
                if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
                        value += "px";
                }

                // If a hook was provided, use that value, otherwise just set the specified value
                if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
                        // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
                        // Fixes bug #5509
                        try {
                                style[ name ] = value;
                        } catch(e) {}
                }

        } else {
                // If a hook was provided get the non-computed value from there
                if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
                        return ret;
                }

                // Otherwise just get the value from the style object
                return style[ name ];
        }
},

css: function( elem, name, extra ) {
        var ret, hooks;

        // Make sure that we're working with the right name
        name = jQuery.camelCase( name );
        hooks = jQuery.cssHooks[ name ];
        name = jQuery.cssProps[ name ] || name;

        // cssFloat needs a special treatment
        if ( name === "cssFloat" ) {
                name = "float";
        }

        // If a hook was provided get the computed value from there
        if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
                return ret;

        // Otherwise, if a way to get the computed value exists, use that
        } else if ( curCSS ) {
                return curCSS( elem, name );
        }
},

// A method for quickly swapping in/out CSS properties to get correct calculations
swap: function( elem, options, callback ) {
        var old = {},
                ret, name;

        // Remember the old values, and insert the new ones
        for ( name in options ) {
                old[ name ] = elem.style[ name ];
                elem.style[ name ] = options[ name ];
        }

        ret = callback.call( elem );

        // Revert the old values
        for ( name in options ) {
                elem.style[ name ] = old[ name ];
        }

        return ret;
}

});

// DEPRECATED in 1.3, Use jQuery.css() instead jQuery.curCSS = jQuery.css;

if ( document.defaultView && document.defaultView.getComputedStyle ) {

getComputedStyle = function( elem, name ) {
        var ret, defaultView, computedStyle, width,
                style = elem.style;

        name = name.replace( rupper, "-$1" ).toLowerCase();

        if ( (defaultView = elem.ownerDocument.defaultView) &&
                        (computedStyle = defaultView.getComputedStyle( elem, null )) ) {

                ret = computedStyle.getPropertyValue( name );
                if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
                        ret = jQuery.style( elem, name );
                }
        }

        // A tribute to the "awesome hack by Dean Edwards"
        // WebKit uses "computed value (percentage if specified)" instead of "used value" for margins
        // which is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
        if ( !jQuery.support.pixelMargin && computedStyle && rmargin.test( name ) && rnumnonpx.test( ret ) ) {
                width = style.width;
                style.width = ret;
                ret = computedStyle.width;
                style.width = width;
        }

        return ret;
};

}

if ( document.documentElement.currentStyle ) {

currentStyle = function( elem, name ) {
        var left, rsLeft, uncomputed,
                ret = elem.currentStyle && elem.currentStyle[ name ],
                style = elem.style;

        // Avoid setting ret to empty string here
        // so we don't default to auto
        if ( ret == null && style && (uncomputed = style[ name ]) ) {
                ret = uncomputed;
        }

        // From the awesome hack by Dean Edwards
        // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291

        // If we're not dealing with a regular pixel number
        // but a number that has a weird ending, we need to convert it to pixels
        if ( rnumnonpx.test( ret ) ) {

                // Remember the original values
                left = style.left;
                rsLeft = elem.runtimeStyle && elem.runtimeStyle.left;

                // Put in the new values to get a computed value out
                if ( rsLeft ) {
                        elem.runtimeStyle.left = elem.currentStyle.left;
                }
                style.left = name === "fontSize" ? "1em" : ret;
                ret = style.pixelLeft + "px";

                // Revert the changed values
                style.left = left;
                if ( rsLeft ) {
                        elem.runtimeStyle.left = rsLeft;
                }
        }

        return ret === "" ? "auto" : ret;
};

}

curCSS = getComputedStyle || currentStyle;

function getWidthOrHeight( elem, name, extra ) {

// Start with offset property
var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
        i = name === "width" ? 1 : 0,
        len = 4;

if ( val > 0 ) {
        if ( extra !== "border" ) {
                for ( ; i < len; i += 2 ) {
                        if ( !extra ) {
                                val -= parseFloat( jQuery.css( elem, "padding" + cssExpand[ i ] ) ) || 0;
                        }
                        if ( extra === "margin" ) {
                                val += parseFloat( jQuery.css( elem, extra + cssExpand[ i ] ) ) || 0;
                        } else {
                                val -= parseFloat( jQuery.css( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0;
                        }
                }
        }

        return val + "px";
}

// Fall back to computed then uncomputed css if necessary
val = curCSS( elem, name );
if ( val < 0 || val == null ) {
        val = elem.style[ name ];
}

// Computed unit is not pixels. Stop here and return.
if ( rnumnonpx.test(val) ) {
        return val;
}

// Normalize "", auto, and prepare for extra
val = parseFloat( val ) || 0;

// Add padding, border, margin
if ( extra ) {
        for ( ; i < len; i += 2 ) {
                val += parseFloat( jQuery.css( elem, "padding" + cssExpand[ i ] ) ) || 0;
                if ( extra !== "padding" ) {
                        val += parseFloat( jQuery.css( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0;
                }
                if ( extra === "margin" ) {
                        val += parseFloat( jQuery.css( elem, extra + cssExpand[ i ]) ) || 0;
                }
        }
}

return val + "px";

}

jQuery.each([ “height”, “width” ], function( i, name ) {

jQuery.cssHooks[ name ] = {
        get: function( elem, computed, extra ) {
                if ( computed ) {
                        if ( elem.offsetWidth !== 0 ) {
                                return getWidthOrHeight( elem, name, extra );
                        } else {
                                return jQuery.swap( elem, cssShow, function() {
                                        return getWidthOrHeight( elem, name, extra );
                                });
                        }
                }
        },

        set: function( elem, value ) {
                return rnum.test( value ) ?
                        value + "px" :
                        value;
        }
};

});

if ( !jQuery.support.opacity ) {

jQuery.cssHooks.opacity = {
        get: function( elem, computed ) {
                // IE uses filters for opacity
                return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
                        ( parseFloat( RegExp.$1 ) / 100 ) + "" :
                        computed ? "1" : "";
        },

        set: function( elem, value ) {
                var style = elem.style,
                        currentStyle = elem.currentStyle,
                        opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
                        filter = currentStyle && currentStyle.filter || style.filter || "";

                // IE has trouble with opacity if it does not have layout
                // Force it by setting the zoom level
                style.zoom = 1;

                // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
                if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" ) {

                        // Setting style.filter to null, "" & " " still leave "filter:" in the cssText
                        // if "filter:" is present at all, clearType is disabled, we want to avoid this
                        // style.removeAttribute is IE Only, but so apparently is this code path...
                        style.removeAttribute( "filter" );

                        // if there there is no filter style applied in a css rule, we are done
                        if ( currentStyle && !currentStyle.filter ) {
                                return;
                        }
                }

                // otherwise, set new filter values
                style.filter = ralpha.test( filter ) ?
                        filter.replace( ralpha, opacity ) :
                        filter + " " + opacity;
        }
};

}

jQuery(function() {

// This hook cannot be added until DOM ready because the support test
// for it is not run until after DOM ready
if ( !jQuery.support.reliableMarginRight ) {
        jQuery.cssHooks.marginRight = {
                get: function( elem, computed ) {
                        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
                        // Work around by temporarily setting element display to inline-block
                        return jQuery.swap( elem, { "display": "inline-block" }, function() {
                                if ( computed ) {
                                        return curCSS( elem, "margin-right" );
                                } else {
                                        return elem.style.marginRight;
                                }
                        });
                }
        };
}

});

if ( jQuery.expr && jQuery.expr.filters ) {

jQuery.expr.filters.hidden = function( elem ) {
        var width = elem.offsetWidth,
                height = elem.offsetHeight;

        return ( width === 0 && height === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");
};

jQuery.expr.filters.visible = function( elem ) {
        return !jQuery.expr.filters.hidden( elem );
};

}

// These hooks are used by animate to expand properties jQuery.each({

margin: "",
padding: "",
border: "Width"

}, function( prefix, suffix ) {

jQuery.cssHooks[ prefix + suffix ] = {
        expand: function( value ) {
                var i,

                        // assumes a single number if not a string
                        parts = typeof value === "string" ? value.split(" ") : [ value ],
                        expanded = {};

                for ( i = 0; i < 4; i++ ) {
                        expanded[ prefix + cssExpand[ i ] + suffix ] =
                                parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
                }

                return expanded;
        }
};

});

var r20 = /%20/g,

rbracket = /\[\]$/,
rCRLF = /\r?\n/g,
rhash = /#.*$/,
rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
// #7653, #8125, #8152: local protocol detection
rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
rnoContent = /^(?:GET|HEAD)$/,
rprotocol = /^\/\//,
rquery = /\?/,
rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
rselectTextarea = /^(?:select|textarea)/i,
rspacesAjax = /\s+/,
rts = /([?&])_=[^&]*/,
rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,

// Keep a copy of the old load method
_load = jQuery.fn.load,

/* Prefilters
 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
 * 2) These are called:
 *    - BEFORE asking for a transport
 *    - AFTER param serialization (s.data is a string if s.processData is true)
 * 3) key is the dataType
 * 4) the catchall symbol "*" can be used
 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
 */
prefilters = {},

/* Transports bindings
 * 1) key is the dataType
 * 2) the catchall symbol "*" can be used
 * 3) selection will start with transport dataType and THEN go to "*" if needed
 */
transports = {},

// Document location
ajaxLocation,

// Document location segments
ajaxLocParts,

// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
allTypes = ["*/"] + ["*"];

// #8138, IE may throw an exception when accessing // a field from window.location if document.domain has been set try {

ajaxLocation = location.href;

} catch( e ) {

// Use the href attribute of an A element
// since IE will modify it given document.location
ajaxLocation = document.createElement( "a" );
ajaxLocation.href = "";
ajaxLocation = ajaxLocation.href;

}

// Segment location into parts ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];

// Base “constructor” for jQuery.ajaxPrefilter and jQuery.ajaxTransport function addToPrefiltersOrTransports( structure ) {

// dataTypeExpression is optional and defaults to "*"
return function( dataTypeExpression, func ) {

        if ( typeof dataTypeExpression !== "string" ) {
                func = dataTypeExpression;
                dataTypeExpression = "*";
        }

        if ( jQuery.isFunction( func ) ) {
                var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
                        i = 0,
                        length = dataTypes.length,
                        dataType,
                        list,
                        placeBefore;

                // For each dataType in the dataTypeExpression
                for ( ; i < length; i++ ) {
                        dataType = dataTypes[ i ];
                        // We control if we're asked to add before
                        // any existing element
                        placeBefore = /^\+/.test( dataType );
                        if ( placeBefore ) {
                                dataType = dataType.substr( 1 ) || "*";
                        }
                        list = structure[ dataType ] = structure[ dataType ] || [];
                        // then we add to the structure accordingly
                        list[ placeBefore ? "unshift" : "push" ]( func );
                }
        }
};

}

// Base inspection function for prefilters and transports function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,

        dataType /* internal */, inspected /* internal */ ) {

dataType = dataType || options.dataTypes[ 0 ];
inspected = inspected || {};

inspected[ dataType ] = true;

var list = structure[ dataType ],
        i = 0,
        length = list ? list.length : 0,
        executeOnly = ( structure === prefilters ),
        selection;

for ( ; i < length && ( executeOnly || !selection ); i++ ) {
        selection = list[ i ]( options, originalOptions, jqXHR );
        // If we got redirected to another dataType
        // we try there if executing only and not done already
        if ( typeof selection === "string" ) {
                if ( !executeOnly || inspected[ selection ] ) {
                        selection = undefined;
                } else {
                        options.dataTypes.unshift( selection );
                        selection = inspectPrefiltersOrTransports(
                                        structure, options, originalOptions, jqXHR, selection, inspected );
                }
        }
}
// If we're only executing or nothing was selected
// we try the catchall dataType if not done already
if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
        selection = inspectPrefiltersOrTransports(
                        structure, options, originalOptions, jqXHR, "*", inspected );
}
// unnecessary when only executing (prefilters)
// but it'll be ignored by the caller in that case
return selection;

}

// A special extend for ajax options // that takes “flat” options (not to be deep extended) // Fixes #9887 function ajaxExtend( target, src ) {

var key, deep,
        flatOptions = jQuery.ajaxSettings.flatOptions || {};
for ( key in src ) {
        if ( src[ key ] !== undefined ) {
                ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
        }
}
if ( deep ) {
        jQuery.extend( true, target, deep );
}

}

jQuery.fn.extend({

load: function( url, params, callback ) {
        if ( typeof url !== "string" && _load ) {
                return _load.apply( this, arguments );

        // Don't do a request if no elements are being requested
        } else if ( !this.length ) {
                return this;
        }

        var off = url.indexOf( " " );
        if ( off >= 0 ) {
                var selector = url.slice( off, url.length );
                url = url.slice( 0, off );
        }

        // Default to a GET request
        var type = "GET";

        // If the second parameter was provided
        if ( params ) {
                // If it's a function
                if ( jQuery.isFunction( params ) ) {
                        // We assume that it's the callback
                        callback = params;
                        params = undefined;

                // Otherwise, build a param string
                } else if ( typeof params === "object" ) {
                        params = jQuery.param( params, jQuery.ajaxSettings.traditional );
                        type = "POST";
                }
        }

        var self = this;

        // Request the remote document
        jQuery.ajax({
                url: url,
                type: type,
                dataType: "html",
                data: params,
                // Complete callback (responseText is used internally)
                complete: function( jqXHR, status, responseText ) {
                        // Store the response as specified by the jqXHR object
                        responseText = jqXHR.responseText;
                        // If successful, inject the HTML into all the matched elements
                        if ( jqXHR.isResolved() ) {
                                // #4825: Get the actual response in case
                                // a dataFilter is present in ajaxSettings
                                jqXHR.done(function( r ) {
                                        responseText = r;
                                });
                                // See if a selector was specified
                                self.html( selector ?
                                        // Create a dummy div to hold the results
                                        jQuery("<div>")
                                                // inject the contents of the document in, removing the scripts
                                                // to avoid any 'Permission Denied' errors in IE
                                                .append(responseText.replace(rscript, ""))

                                                // Locate the specified elements
                                                .find(selector) :

                                        // If not, just inject the full result
                                        responseText );
                        }

                        if ( callback ) {
                                self.each( callback, [ responseText, status, jqXHR ] );
                        }
                }
        });

        return this;
},

serialize: function() {
        return jQuery.param( this.serializeArray() );
},

serializeArray: function() {
        return this.map(function(){
                return this.elements ? jQuery.makeArray( this.elements ) : this;
        })
        .filter(function(){
                return this.name && !this.disabled &&
                        ( this.checked || rselectTextarea.test( this.nodeName ) ||
                                rinput.test( this.type ) );
        })
        .map(function( i, elem ){
                var val = jQuery( this ).val();

                return val == null ?
                        null :
                        jQuery.isArray( val ) ?
                                jQuery.map( val, function( val, i ){
                                        return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
                                }) :
                                { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
        }).get();
}

});

// Attach a bunch of functions for handling common AJAX events jQuery.each( “ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend”.split( “ ” ), function( i, o ){

jQuery.fn[ o ] = function( f ){
        return this.on( o, f );
};

});

jQuery.each( [ “get”, “post” ], function( i, method ) {

jQuery[ method ] = function( url, data, callback, type ) {
        // shift arguments if data argument was omitted
        if ( jQuery.isFunction( data ) ) {
                type = type || callback;
                callback = data;
                data = undefined;
        }

        return jQuery.ajax({
                type: method,
                url: url,
                data: data,
                success: callback,
                dataType: type
        });
};

});

jQuery.extend({

getScript: function( url, callback ) {
        return jQuery.get( url, undefined, callback, "script" );
},

getJSON: function( url, data, callback ) {
        return jQuery.get( url, data, callback, "json" );
},

// Creates a full fledged settings object into target
// with both ajaxSettings and settings fields.
// If target is omitted, writes into ajaxSettings.
ajaxSetup: function( target, settings ) {
        if ( settings ) {
                // Building a settings object
                ajaxExtend( target, jQuery.ajaxSettings );
        } else {
                // Extending ajaxSettings
                settings = target;
                target = jQuery.ajaxSettings;
        }
        ajaxExtend( target, settings );
        return target;
},

ajaxSettings: {
        url: ajaxLocation,
        isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
        global: true,
        type: "GET",
        contentType: "application/x-www-form-urlencoded; charset=UTF-8",
        processData: true,
        async: true,
        /*
        timeout: 0,
        data: null,
        dataType: null,
        username: null,
        password: null,
        cache: null,
        traditional: false,
        headers: {},
        */

        accepts: {
                xml: "application/xml, text/xml",
                html: "text/html",
                text: "text/plain",
                json: "application/json, text/javascript",
                "*": allTypes
        },

        contents: {
                xml: /xml/,
                html: /html/,
                json: /json/
        },

        responseFields: {
                xml: "responseXML",
                text: "responseText"
        },

        // List of data converters
        // 1) key format is "source_type destination_type" (a single space in-between)
        // 2) the catchall symbol "*" can be used for source_type
        converters: {

                // Convert anything to text
                "* text": window.String,

                // Text to html (true = no transformation)
                "text html": true,

                // Evaluate text as a json expression
                "text json": jQuery.parseJSON,

                // Parse text as xml
                "text xml": jQuery.parseXML
        },

        // For options that shouldn't be deep extended:
        // you can add your own custom options here if
        // and when you create one that shouldn't be
        // deep extended (see ajaxExtend)
        flatOptions: {
                context: true,
                url: true
        }
},

ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
ajaxTransport: addToPrefiltersOrTransports( transports ),

// Main method
ajax: function( url, options ) {

        // If url is an object, simulate pre-1.5 signature
        if ( typeof url === "object" ) {
                options = url;
                url = undefined;
        }

        // Force options to be an object
        options = options || {};

        var // Create the final options object
                s = jQuery.ajaxSetup( {}, options ),
                // Callbacks context
                callbackContext = s.context || s,
                // Context for global events
                // It's the callbackContext if one was provided in the options
                // and if it's a DOM node or a jQuery collection
                globalEventContext = callbackContext !== s &&
                        ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
                                        jQuery( callbackContext ) : jQuery.event,
                // Deferreds
                deferred = jQuery.Deferred(),
                completeDeferred = jQuery.Callbacks( "once memory" ),
                // Status-dependent callbacks
                statusCode = s.statusCode || {},
                // ifModified key
                ifModifiedKey,
                // Headers (they are sent all at once)
                requestHeaders = {},
                requestHeadersNames = {},
                // Response headers
                responseHeadersString,
                responseHeaders,
                // transport
                transport,
                // timeout handle
                timeoutTimer,
                // Cross-domain detection vars
                parts,
                // The jqXHR state
                state = 0,
                // To know if global events are to be dispatched
                fireGlobals,
                // Loop variable
                i,
                // Fake xhr
                jqXHR = {

                        readyState: 0,

                        // Caches the header
                        setRequestHeader: function( name, value ) {
                                if ( !state ) {
                                        var lname = name.toLowerCase();
                                        name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
                                        requestHeaders[ name ] = value;
                                }
                                return this;
                        },

                        // Raw string
                        getAllResponseHeaders: function() {
                                return state === 2 ? responseHeadersString : null;
                        },

                        // Builds headers hashtable if needed
                        getResponseHeader: function( key ) {
                                var match;
                                if ( state === 2 ) {
                                        if ( !responseHeaders ) {
                                                responseHeaders = {};
                                                while( ( match = rheaders.exec( responseHeadersString ) ) ) {
                                                        responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
                                                }
                                        }
                                        match = responseHeaders[ key.toLowerCase() ];
                                }
                                return match === undefined ? null : match;
                        },

                        // Overrides response content-type header
                        overrideMimeType: function( type ) {
                                if ( !state ) {
                                        s.mimeType = type;
                                }
                                return this;
                        },

                        // Cancel the request
                        abort: function( statusText ) {
                                statusText = statusText || "abort";
                                if ( transport ) {
                                        transport.abort( statusText );
                                }
                                done( 0, statusText );
                                return this;
                        }
                };

        // Callback for when everything is done
        // It is defined here because jslint complains if it is declared
        // at the end of the function (which would be more logical and readable)
        function done( status, nativeStatusText, responses, headers ) {

                // Called once
                if ( state === 2 ) {
                        return;
                }

                // State is "done" now
                state = 2;

                // Clear timeout if it exists
                if ( timeoutTimer ) {
                        clearTimeout( timeoutTimer );
                }

                // Dereference transport for early garbage collection
                // (no matter how long the jqXHR object will be used)
                transport = undefined;

                // Cache response headers
                responseHeadersString = headers || "";

                // Set readyState
                jqXHR.readyState = status > 0 ? 4 : 0;

                var isSuccess,
                        success,
                        error,
                        statusText = nativeStatusText,
                        response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
                        lastModified,
                        etag;

                // If successful, handle type chaining
                if ( status >= 200 && status < 300 || status === 304 ) {

                        // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
                        if ( s.ifModified ) {

                                if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
                                        jQuery.lastModified[ ifModifiedKey ] = lastModified;
                                }
                                if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
                                        jQuery.etag[ ifModifiedKey ] = etag;
                                }
                        }

                        // If not modified
                        if ( status === 304 ) {

                                statusText = "notmodified";
                                isSuccess = true;

                        // If we have data
                        } else {

                                try {
                                        success = ajaxConvert( s, response );
                                        statusText = "success";
                                        isSuccess = true;
                                } catch(e) {
                                        // We have a parsererror
                                        statusText = "parsererror";
                                        error = e;
                                }
                        }
                } else {
                        // We extract error from statusText
                        // then normalize statusText and status for non-aborts
                        error = statusText;
                        if ( !statusText || status ) {
                                statusText = "error";
                                if ( status < 0 ) {
                                        status = 0;
                                }
                        }
                }

                // Set data for the fake xhr object
                jqXHR.status = status;
                jqXHR.statusText = "" + ( nativeStatusText || statusText );

                // Success/Error
                if ( isSuccess ) {
                        deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
                } else {
                        deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
                }

                // Status-dependent callbacks
                jqXHR.statusCode( statusCode );
                statusCode = undefined;

                if ( fireGlobals ) {
                        globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
                                        [ jqXHR, s, isSuccess ? success : error ] );
                }

                // Complete
                completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );

                if ( fireGlobals ) {
                        globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
                        // Handle the global AJAX counter
                        if ( !( --jQuery.active ) ) {
                                jQuery.event.trigger( "ajaxStop" );
                        }
                }
        }

        // Attach deferreds
        deferred.promise( jqXHR );
        jqXHR.success = jqXHR.done;
        jqXHR.error = jqXHR.fail;
        jqXHR.complete = completeDeferred.add;

        // Status-dependent callbacks
        jqXHR.statusCode = function( map ) {
                if ( map ) {
                        var tmp;
                        if ( state < 2 ) {
                                for ( tmp in map ) {
                                        statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
                                }
                        } else {
                                tmp = map[ jqXHR.status ];
                                jqXHR.then( tmp, tmp );
                        }
                }
                return this;
        };

        // Remove hash character (#7531: and string promotion)
        // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
        // We also use the url parameter if available
        s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );

        // Extract dataTypes list
        s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );

        // Determine if a cross-domain request is in order
        if ( s.crossDomain == null ) {
                parts = rurl.exec( s.url.toLowerCase() );
                s.crossDomain = !!( parts &&
                        ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
                                ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
                                        ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
                );
        }

        // Convert data if not already a string
        if ( s.data && s.processData && typeof s.data !== "string" ) {
                s.data = jQuery.param( s.data, s.traditional );
        }

        // Apply prefilters
        inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );

        // If request was aborted inside a prefilter, stop there
        if ( state === 2 ) {
                return false;
        }

        // We can fire global events as of now if asked to
        fireGlobals = s.global;

        // Uppercase the type
        s.type = s.type.toUpperCase();

        // Determine if request has content
        s.hasContent = !rnoContent.test( s.type );

        // Watch for a new set of requests
        if ( fireGlobals && jQuery.active++ === 0 ) {
                jQuery.event.trigger( "ajaxStart" );
        }

        // More options handling for requests with no content
        if ( !s.hasContent ) {

                // If data is available, append data to url
                if ( s.data ) {
                        s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
                        // #9682: remove data so that it's not used in an eventual retry
                        delete s.data;
                }

                // Get ifModifiedKey before adding the anti-cache parameter
                ifModifiedKey = s.url;

                // Add anti-cache in url if needed
                if ( s.cache === false ) {

                        var ts = jQuery.now(),
                                // try replacing _= if it is there
                                ret = s.url.replace( rts, "$1_=" + ts );

                        // if nothing was replaced, add timestamp to the end
                        s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
                }
        }

        // Set the correct header, if data is being sent
        if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
                jqXHR.setRequestHeader( "Content-Type", s.contentType );
        }

        // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
        if ( s.ifModified ) {
                ifModifiedKey = ifModifiedKey || s.url;
                if ( jQuery.lastModified[ ifModifiedKey ] ) {
                        jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
                }
                if ( jQuery.etag[ ifModifiedKey ] ) {
                        jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
                }
        }

        // Set the Accepts header for the server, depending on the dataType
        jqXHR.setRequestHeader(
                "Accept",
                s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
                        s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
                        s.accepts[ "*" ]
        );

        // Check for headers option
        for ( i in s.headers ) {
                jqXHR.setRequestHeader( i, s.headers[ i ] );
        }

        // Allow custom headers/mimetypes and early abort
        if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
                        // Abort if not done already
                        jqXHR.abort();
                        return false;

        }

        // Install callbacks on deferreds
        for ( i in { success: 1, error: 1, complete: 1 } ) {
                jqXHR[ i ]( s[ i ] );
        }

        // Get transport
        transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );

        // If no transport, we auto-abort
        if ( !transport ) {
                done( -1, "No Transport" );
        } else {
                jqXHR.readyState = 1;
                // Send global event
                if ( fireGlobals ) {
                        globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
                }
                // Timeout
                if ( s.async && s.timeout > 0 ) {
                        timeoutTimer = setTimeout( function(){
                                jqXHR.abort( "timeout" );
                        }, s.timeout );
                }

                try {
                        state = 1;
                        transport.send( requestHeaders, done );
                } catch (e) {
                        // Propagate exception as error if not done
                        if ( state < 2 ) {
                                done( -1, e );
                        // Simply rethrow otherwise
                        } else {
                                throw e;
                        }
                }
        }

        return jqXHR;
},

// Serialize an array of form elements or a set of
// key/values into a query string
param: function( a, traditional ) {
        var s = [],
                add = function( key, value ) {
                        // If value is a function, invoke it and return its value
                        value = jQuery.isFunction( value ) ? value() : value;
                        s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
                };

        // Set traditional to true for jQuery <= 1.3.2 behavior.
        if ( traditional === undefined ) {
                traditional = jQuery.ajaxSettings.traditional;
        }

        // If an array was passed in, assume that it is an array of form elements.
        if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
                // Serialize the form elements
                jQuery.each( a, function() {
                        add( this.name, this.value );
                });

        } else {
                // If traditional, encode the "old" way (the way 1.3.2 or older
                // did it), otherwise encode params recursively.
                for ( var prefix in a ) {
                        buildParams( prefix, a[ prefix ], traditional, add );
                }
        }

        // Return the resulting serialization
        return s.join( "&" ).replace( r20, "+" );
}

});

function buildParams( prefix, obj, traditional, add ) {

if ( jQuery.isArray( obj ) ) {
        // Serialize array item.
        jQuery.each( obj, function( i, v ) {
                if ( traditional || rbracket.test( prefix ) ) {
                        // Treat each array item as a scalar.
                        add( prefix, v );

                } else {
                        // If array item is non-scalar (array or object), encode its
                        // numeric index to resolve deserialization ambiguity issues.
                        // Note that rack (as of 1.0.0) can't currently deserialize
                        // nested arrays properly, and attempting to do so may cause
                        // a server error. Possible fixes are to modify rack's
                        // deserialization algorithm or to provide an option or flag
                        // to force array serialization to be shallow.
                        buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add );
                }
        });

} else if ( !traditional && jQuery.type( obj ) === "object" ) {
        // Serialize object item.
        for ( var name in obj ) {
                buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
        }

} else {
        // Serialize scalar item.
        add( prefix, obj );
}

}

// This is still on the jQuery object… for now // Want to move this to jQuery.ajax some day jQuery.extend({

// Counter for holding the number of active queries
active: 0,

// Last-Modified header cache for next request
lastModified: {},
etag: {}

});

/* Handles responses to an ajax request:

* - sets all responseXXX fields accordingly
* - finds the right dataType (mediates between content-type and expected dataType)
* - returns the corresponding response
*/

function ajaxHandleResponses( s, jqXHR, responses ) {

var contents = s.contents,
        dataTypes = s.dataTypes,
        responseFields = s.responseFields,
        ct,
        type,
        finalDataType,
        firstDataType;

// Fill responseXXX fields
for ( type in responseFields ) {
        if ( type in responses ) {
                jqXHR[ responseFields[type] ] = responses[ type ];
        }
}

// Remove auto dataType and get content-type in the process
while( dataTypes[ 0 ] === "*" ) {
        dataTypes.shift();
        if ( ct === undefined ) {
                ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
        }
}

// Check if we're dealing with a known content-type
if ( ct ) {
        for ( type in contents ) {
                if ( contents[ type ] && contents[ type ].test( ct ) ) {
                        dataTypes.unshift( type );
                        break;
                }
        }
}

// Check to see if we have a response for the expected dataType
if ( dataTypes[ 0 ] in responses ) {
        finalDataType = dataTypes[ 0 ];
} else {
        // Try convertible dataTypes
        for ( type in responses ) {
                if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
                        finalDataType = type;
                        break;
                }
                if ( !firstDataType ) {
                        firstDataType = type;
                }
        }
        // Or just use first one
        finalDataType = finalDataType || firstDataType;
}

// If we found a dataType
// We add the dataType to the list if needed
// and return the corresponding response
if ( finalDataType ) {
        if ( finalDataType !== dataTypes[ 0 ] ) {
                dataTypes.unshift( finalDataType );
        }
        return responses[ finalDataType ];
}

}

// Chain conversions given the request and the original response function ajaxConvert( s, response ) {

// Apply the dataFilter if provided
if ( s.dataFilter ) {
        response = s.dataFilter( response, s.dataType );
}

var dataTypes = s.dataTypes,
        converters = {},
        i,
        key,
        length = dataTypes.length,
        tmp,
        // Current and previous dataTypes
        current = dataTypes[ 0 ],
        prev,
        // Conversion expression
        conversion,
        // Conversion function
        conv,
        // Conversion functions (transitive conversion)
        conv1,
        conv2;

// For each dataType in the chain
for ( i = 1; i < length; i++ ) {

        // Create converters map
        // with lowercased keys
        if ( i === 1 ) {
                for ( key in s.converters ) {
                        if ( typeof key === "string" ) {
                                converters[ key.toLowerCase() ] = s.converters[ key ];
                        }
                }
        }

        // Get the dataTypes
        prev = current;
        current = dataTypes[ i ];

        // If current is auto dataType, update it to prev
        if ( current === "*" ) {
                current = prev;
        // If no auto and dataTypes are actually different
        } else if ( prev !== "*" && prev !== current ) {

                // Get the converter
                conversion = prev + " " + current;
                conv = converters[ conversion ] || converters[ "* " + current ];

                // If there is no direct converter, search transitively
                if ( !conv ) {
                        conv2 = undefined;
                        for ( conv1 in converters ) {
                                tmp = conv1.split( " " );
                                if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
                                        conv2 = converters[ tmp[1] + " " + current ];
                                        if ( conv2 ) {
                                                conv1 = converters[ conv1 ];
                                                if ( conv1 === true ) {
                                                        conv = conv2;
                                                } else if ( conv2 === true ) {
                                                        conv = conv1;
                                                }
                                                break;
                                        }
                                }
                        }
                }
                // If we found no converter, dispatch an error
                if ( !( conv || conv2 ) ) {
                        jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
                }
                // If found converter is not an equivalence
                if ( conv !== true ) {
                        // Convert with 1 or 2 converters accordingly
                        response = conv ? conv( response ) : conv2( conv1(response) );
                }
        }
}
return response;

}

var jsc = jQuery.now(),

jsre = /(\=)\?(&|$)|\?\?/i;

// Default jsonp settings jQuery.ajaxSetup({

jsonp: "callback",
jsonpCallback: function() {
        return jQuery.expando + "_" + ( jsc++ );
}

});

// Detect, normalize options and install callbacks for jsonp requests jQuery.ajaxPrefilter( “json jsonp”, function( s, originalSettings, jqXHR ) {

var inspectData = ( typeof s.data === "string" ) && /^application\/x\-www\-form\-urlencoded/.test( s.contentType );

if ( s.dataTypes[ 0 ] === "jsonp" ||
        s.jsonp !== false && ( jsre.test( s.url ) ||
                        inspectData && jsre.test( s.data ) ) ) {

        var responseContainer,
                jsonpCallback = s.jsonpCallback =
                        jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
                previous = window[ jsonpCallback ],
                url = s.url,
                data = s.data,
                replace = "$1" + jsonpCallback + "$2";

        if ( s.jsonp !== false ) {
                url = url.replace( jsre, replace );
                if ( s.url === url ) {
                        if ( inspectData ) {
                                data = data.replace( jsre, replace );
                        }
                        if ( s.data === data ) {
                                // Add callback manually
                                url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
                        }
                }
        }

        s.url = url;
        s.data = data;

        // Install callback
        window[ jsonpCallback ] = function( response ) {
                responseContainer = [ response ];
        };

        // Clean-up function
        jqXHR.always(function() {
                // Set callback back to previous value
                window[ jsonpCallback ] = previous;
                // Call if it was a function and we have a response
                if ( responseContainer && jQuery.isFunction( previous ) ) {
                        window[ jsonpCallback ]( responseContainer[ 0 ] );
                }
        });

        // Use data converter to retrieve json after script execution
        s.converters["script json"] = function() {
                if ( !responseContainer ) {
                        jQuery.error( jsonpCallback + " was not called" );
                }
                return responseContainer[ 0 ];
        };

        // force json dataType
        s.dataTypes[ 0 ] = "json";

        // Delegate to script
        return "script";
}

});

// Install script dataType jQuery.ajaxSetup({

accepts: {
        script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
},
contents: {
        script: /javascript|ecmascript/
},
converters: {
        "text script": function( text ) {
                jQuery.globalEval( text );
                return text;
        }
}

});

// Handle cache's special case and global jQuery.ajaxPrefilter( “script”, function( s ) {

if ( s.cache === undefined ) {
        s.cache = false;
}
if ( s.crossDomain ) {
        s.type = "GET";
        s.global = false;
}

});

// Bind script tag hack transport jQuery.ajaxTransport( “script”, function(s) {

// This transport only deals with cross domain requests
if ( s.crossDomain ) {

        var script,
                head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;

        return {

                send: function( _, callback ) {

                        script = document.createElement( "script" );

                        script.async = "async";

                        if ( s.scriptCharset ) {
                                script.charset = s.scriptCharset;
                        }

                        script.src = s.url;

                        // Attach handlers for all browsers
                        script.onload = script.onreadystatechange = function( _, isAbort ) {

                                if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {

                                        // Handle memory leak in IE
                                        script.onload = script.onreadystatechange = null;

                                        // Remove the script
                                        if ( head && script.parentNode ) {
                                                head.removeChild( script );
                                        }

                                        // Dereference the script
                                        script = undefined;

                                        // Callback if not abort
                                        if ( !isAbort ) {
                                                callback( 200, "success" );
                                        }
                                }
                        };
                        // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
                        // This arises when a base node is used (#2709 and #4378).
                        head.insertBefore( script, head.firstChild );
                },

                abort: function() {
                        if ( script ) {
                                script.onload( 0, 1 );
                        }
                }
        };
}

});

var // #5280: Internet Explorer will keep connections alive if we don't abort on unload

xhrOnUnloadAbort = window.ActiveXObject ? function() {
        // Abort all pending requests
        for ( var key in xhrCallbacks ) {
                xhrCallbacks[ key ]( 0, 1 );
        }
} : false,
xhrId = 0,
xhrCallbacks;

// Functions to create xhrs function createStandardXHR() {

try {
        return new window.XMLHttpRequest();
} catch( e ) {}

}

function createActiveXHR() {

try {
        return new window.ActiveXObject( "Microsoft.XMLHTTP" );
} catch( e ) {}

}

// Create the request object // (This is still attached to ajaxSettings for backward compatibility) jQuery.ajaxSettings.xhr = window.ActiveXObject ?

/* Microsoft failed to properly
 * implement the XMLHttpRequest in IE7 (can't request local files),
 * so we use the ActiveXObject when it is available
 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
 * we need a fallback.
 */
function() {
        return !this.isLocal && createStandardXHR() || createActiveXHR();
} :
// For all other browsers, use the standard XMLHttpRequest object
createStandardXHR;

// Determine support properties (function( xhr ) {

jQuery.extend( jQuery.support, {
        ajax: !!xhr,
        cors: !!xhr && ( "withCredentials" in xhr )
});

})( jQuery.ajaxSettings.xhr() );

// Create transport if the browser can provide an xhr if ( jQuery.support.ajax ) {

jQuery.ajaxTransport(function( s ) {
        // Cross domain only allowed if supported through XMLHttpRequest
        if ( !s.crossDomain || jQuery.support.cors ) {

                var callback;

                return {
                        send: function( headers, complete ) {

                                // Get a new xhr
                                var xhr = s.xhr(),
                                        handle,
                                        i;

                                // Open the socket
                                // Passing null username, generates a login popup on Opera (#2865)
                                if ( s.username ) {
                                        xhr.open( s.type, s.url, s.async, s.username, s.password );
                                } else {
                                        xhr.open( s.type, s.url, s.async );
                                }

                                // Apply custom fields if provided
                                if ( s.xhrFields ) {
                                        for ( i in s.xhrFields ) {
                                                xhr[ i ] = s.xhrFields[ i ];
                                        }
                                }

                                // Override mime type if needed
                                if ( s.mimeType && xhr.overrideMimeType ) {
                                        xhr.overrideMimeType( s.mimeType );
                                }

                                // X-Requested-With header
                                // For cross-domain requests, seeing as conditions for a preflight are
                                // akin to a jigsaw puzzle, we simply never set it to be sure.
                                // (it can always be set on a per-request basis or even using ajaxSetup)
                                // For same-domain requests, won't change header if already provided.
                                if ( !s.crossDomain && !headers["X-Requested-With"] ) {
                                        headers[ "X-Requested-With" ] = "XMLHttpRequest";
                                }

                                // Need an extra try/catch for cross domain requests in Firefox 3
                                try {
                                        for ( i in headers ) {
                                                xhr.setRequestHeader( i, headers[ i ] );
                                        }
                                } catch( _ ) {}

                                // Do send the request
                                // This may raise an exception which is actually
                                // handled in jQuery.ajax (so no try/catch here)
                                xhr.send( ( s.hasContent && s.data ) || null );

                                // Listener
                                callback = function( _, isAbort ) {

                                        var status,
                                                statusText,
                                                responseHeaders,
                                                responses,
                                                xml;

                                        // Firefox throws exceptions when accessing properties
                                        // of an xhr when a network error occured
                                        // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
                                        try {

                                                // Was never called and is aborted or complete
                                                if ( callback && ( isAbort || xhr.readyState === 4 ) ) {

                                                        // Only called once
                                                        callback = undefined;

                                                        // Do not keep as active anymore
                                                        if ( handle ) {
                                                                xhr.onreadystatechange = jQuery.noop;
                                                                if ( xhrOnUnloadAbort ) {
                                                                        delete xhrCallbacks[ handle ];
                                                                }
                                                        }

                                                        // If it's an abort
                                                        if ( isAbort ) {
                                                                // Abort it manually if needed
                                                                if ( xhr.readyState !== 4 ) {
                                                                        xhr.abort();
                                                                }
                                                        } else {
                                                                status = xhr.status;
                                                                responseHeaders = xhr.getAllResponseHeaders();
                                                                responses = {};
                                                                xml = xhr.responseXML;

                                                                // Construct response list
                                                                if ( xml && xml.documentElement /* #4958 */ ) {
                                                                        responses.xml = xml;
                                                                }

                                                                // When requesting binary data, IE6-9 will throw an exception
                                                                // on any attempt to access responseText (#11426)
                                                                try {
                                                                        responses.text = xhr.responseText;
                                                                } catch( _ ) {
                                                                }

                                                                // Firefox throws an exception when accessing
                                                                // statusText for faulty cross-domain requests
                                                                try {
                                                                        statusText = xhr.statusText;
                                                                } catch( e ) {
                                                                        // We normalize with Webkit giving an empty statusText
                                                                        statusText = "";
                                                                }

                                                                // Filter status for non standard behaviors

                                                                // If the request is local and we have data: assume a success
                                                                // (success with no data won't get notified, that's the best we
                                                                // can do given current implementations)
                                                                if ( !status && s.isLocal && !s.crossDomain ) {
                                                                        status = responses.text ? 200 : 404;
                                                                // IE - #1450: sometimes returns 1223 when it should be 204
                                                                } else if ( status === 1223 ) {
                                                                        status = 204;
                                                                }
                                                        }
                                                }
                                        } catch( firefoxAccessException ) {
                                                if ( !isAbort ) {
                                                        complete( -1, firefoxAccessException );
                                                }
                                        }

                                        // Call complete if needed
                                        if ( responses ) {
                                                complete( status, statusText, responses, responseHeaders );
                                        }
                                };

                                // if we're in sync mode or it's in cache
                                // and has been retrieved directly (IE6 & IE7)
                                // we need to manually fire the callback
                                if ( !s.async || xhr.readyState === 4 ) {
                                        callback();
                                } else {
                                        handle = ++xhrId;
                                        if ( xhrOnUnloadAbort ) {
                                                // Create the active xhrs callbacks list if needed
                                                // and attach the unload handler
                                                if ( !xhrCallbacks ) {
                                                        xhrCallbacks = {};
                                                        jQuery( window ).unload( xhrOnUnloadAbort );
                                                }
                                                // Add to list of active xhrs callbacks
                                                xhrCallbacks[ handle ] = callback;
                                        }
                                        xhr.onreadystatechange = callback;
                                }
                        },

                        abort: function() {
                                if ( callback ) {
                                        callback(0,1);
                                }
                        }
                };
        }
});

}

var elemdisplay = {},

iframe, iframeDoc,
rfxtypes = /^(?:toggle|show|hide)$/,
rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
timerId,
fxAttrs = [
        // height animations
        [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
        // width animations
        [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
        // opacity animations
        [ "opacity" ]
],
fxNow;

jQuery.fn.extend({

show: function( speed, easing, callback ) {
        var elem, display;

        if ( speed || speed === 0 ) {
                return this.animate( genFx("show", 3), speed, easing, callback );

        } else {
                for ( var i = 0, j = this.length; i < j; i++ ) {
                        elem = this[ i ];

                        if ( elem.style ) {
                                display = elem.style.display;

                                // Reset the inline display of this element to learn if it is
                                // being hidden by cascaded rules or not
                                if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
                                        display = elem.style.display = "";
                                }

                                // Set elements which have been overridden with display: none
                                // in a stylesheet to whatever the default browser style is
                                // for such an element
                                if ( (display === "" && jQuery.css(elem, "display") === "none") ||
                                        !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
                                        jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) );
                                }
                        }
                }

                // Set the display of most of the elements in a second loop
                // to avoid the constant reflow
                for ( i = 0; i < j; i++ ) {
                        elem = this[ i ];

                        if ( elem.style ) {
                                display = elem.style.display;

                                if ( display === "" || display === "none" ) {
                                        elem.style.display = jQuery._data( elem, "olddisplay" ) || "";
                                }
                        }
                }

                return this;
        }
},

hide: function( speed, easing, callback ) {
        if ( speed || speed === 0 ) {
                return this.animate( genFx("hide", 3), speed, easing, callback);

        } else {
                var elem, display,
                        i = 0,
                        j = this.length;

                for ( ; i < j; i++ ) {
                        elem = this[i];
                        if ( elem.style ) {
                                display = jQuery.css( elem, "display" );

                                if ( display !== "none" && !jQuery._data( elem, "olddisplay" ) ) {
                                        jQuery._data( elem, "olddisplay", display );
                                }
                        }
                }

                // Set the display of the elements in a second loop
                // to avoid the constant reflow
                for ( i = 0; i < j; i++ ) {
                        if ( this[i].style ) {
                                this[i].style.display = "none";
                        }
                }

                return this;
        }
},

// Save the old toggle function
_toggle: jQuery.fn.toggle,

toggle: function( fn, fn2, callback ) {
        var bool = typeof fn === "boolean";

        if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
                this._toggle.apply( this, arguments );

        } else if ( fn == null || bool ) {
                this.each(function() {
                        var state = bool ? fn : jQuery(this).is(":hidden");
                        jQuery(this)[ state ? "show" : "hide" ]();
                });

        } else {
                this.animate(genFx("toggle", 3), fn, fn2, callback);
        }

        return this;
},

fadeTo: function( speed, to, easing, callback ) {
        return this.filter(":hidden").css("opacity", 0).show().end()
                                .animate({opacity: to}, speed, easing, callback);
},

animate: function( prop, speed, easing, callback ) {
        var optall = jQuery.speed( speed, easing, callback );

        if ( jQuery.isEmptyObject( prop ) ) {
                return this.each( optall.complete, [ false ] );
        }

        // Do not change referenced properties as per-property easing will be lost
        prop = jQuery.extend( {}, prop );

        function doAnimation() {
                // XXX 'this' does not always have a nodeName when running the
                // test suite

                if ( optall.queue === false ) {
                        jQuery._mark( this );
                }

                var opt = jQuery.extend( {}, optall ),
                        isElement = this.nodeType === 1,
                        hidden = isElement && jQuery(this).is(":hidden"),
                        name, val, p, e, hooks, replace,
                        parts, start, end, unit,
                        method;

                // will store per property easing and be used to determine when an animation is complete
                opt.animatedProperties = {};

                // first pass over propertys to expand / normalize
                for ( p in prop ) {
                        name = jQuery.camelCase( p );
                        if ( p !== name ) {
                                prop[ name ] = prop[ p ];
                                delete prop[ p ];
                        }

                        if ( ( hooks = jQuery.cssHooks[ name ] ) && "expand" in hooks ) {
                                replace = hooks.expand( prop[ name ] );
                                delete prop[ name ];

                                // not quite $.extend, this wont overwrite keys already present.
                                // also - reusing 'p' from above because we have the correct "name"
                                for ( p in replace ) {
                                        if ( ! ( p in prop ) ) {
                                                prop[ p ] = replace[ p ];
                                        }
                                }
                        }
                }

                for ( name in prop ) {
                        val = prop[ name ];
                        // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
                        if ( jQuery.isArray( val ) ) {
                                opt.animatedProperties[ name ] = val[ 1 ];
                                val = prop[ name ] = val[ 0 ];
                        } else {
                                opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
                        }

                        if ( val === "hide" && hidden || val === "show" && !hidden ) {
                                return opt.complete.call( this );
                        }

                        if ( isElement && ( name === "height" || name === "width" ) ) {
                                // Make sure that nothing sneaks out
                                // Record all 3 overflow attributes because IE does not
                                // change the overflow attribute when overflowX and
                                // overflowY are set to the same value
                                opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];

                                // Set display property to inline-block for height/width
                                // animations on inline elements that are having width/height animated
                                if ( jQuery.css( this, "display" ) === "inline" &&
                                                jQuery.css( this, "float" ) === "none" ) {

                                        // inline-level elements accept inline-block;
                                        // block-level elements need to be inline with layout
                                        if ( !jQuery.support.inlineBlockNeedsLayout || defaultDisplay( this.nodeName ) === "inline" ) {
                                                this.style.display = "inline-block";

                                        } else {
                                                this.style.zoom = 1;
                                        }
                                }
                        }
                }

                if ( opt.overflow != null ) {
                        this.style.overflow = "hidden";
                }

                for ( p in prop ) {
                        e = new jQuery.fx( this, opt, p );
                        val = prop[ p ];

                        if ( rfxtypes.test( val ) ) {

                                // Tracks whether to show or hide based on private
                                // data attached to the element
                                method = jQuery._data( this, "toggle" + p ) || ( val === "toggle" ? hidden ? "show" : "hide" : 0 );
                                if ( method ) {
                                        jQuery._data( this, "toggle" + p, method === "show" ? "hide" : "show" );
                                        e[ method ]();
                                } else {
                                        e[ val ]();
                                }

                        } else {
                                parts = rfxnum.exec( val );
                                start = e.cur();

                                if ( parts ) {
                                        end = parseFloat( parts[2] );
                                        unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );

                                        // We need to compute starting value
                                        if ( unit !== "px" ) {
                                                jQuery.style( this, p, (end || 1) + unit);
                                                start = ( (end || 1) / e.cur() ) * start;
                                                jQuery.style( this, p, start + unit);
                                        }

                                        // If a +=/-= token was provided, we're doing a relative animation
                                        if ( parts[1] ) {
                                                end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
                                        }

                                        e.custom( start, end, unit );

                                } else {
                                        e.custom( start, val, "" );
                                }
                        }
                }

                // For JS strict compliance
                return true;
        }

        return optall.queue === false ?
                this.each( doAnimation ) :
                this.queue( optall.queue, doAnimation );
},

stop: function( type, clearQueue, gotoEnd ) {
        if ( typeof type !== "string" ) {
                gotoEnd = clearQueue;
                clearQueue = type;
                type = undefined;
        }
        if ( clearQueue && type !== false ) {
                this.queue( type || "fx", [] );
        }

        return this.each(function() {
                var index,
                        hadTimers = false,
                        timers = jQuery.timers,
                        data = jQuery._data( this );

                // clear marker counters if we know they won't be
                if ( !gotoEnd ) {
                        jQuery._unmark( true, this );
                }

                function stopQueue( elem, data, index ) {
                        var hooks = data[ index ];
                        jQuery.removeData( elem, index, true );
                        hooks.stop( gotoEnd );
                }

                if ( type == null ) {
                        for ( index in data ) {
                                if ( data[ index ] && data[ index ].stop && index.indexOf(".run") === index.length - 4 ) {
                                        stopQueue( this, data, index );
                                }
                        }
                } else if ( data[ index = type + ".run" ] && data[ index ].stop ){
                        stopQueue( this, data, index );
                }

                for ( index = timers.length; index--; ) {
                        if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
                                if ( gotoEnd ) {

                                        // force the next step to be the last
                                        timers[ index ]( true );
                                } else {
                                        timers[ index ].saveState();
                                }
                                hadTimers = true;
                                timers.splice( index, 1 );
                        }
                }

                // start the next in the queue if the last step wasn't forced
                // timers currently will call their complete callbacks, which will dequeue
                // but only if they were gotoEnd
                if ( !( gotoEnd && hadTimers ) ) {
                        jQuery.dequeue( this, type );
                }
        });
}

});

// Animations created synchronously will run synchronously function createFxNow() {

setTimeout( clearFxNow, 0 );
return ( fxNow = jQuery.now() );

}

function clearFxNow() {

fxNow = undefined;

}

// Generate parameters to create a standard animation function genFx( type, num ) {

var obj = {};

jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice( 0, num )), function() {
        obj[ this ] = type;
});

return obj;

}

// Generate shortcuts for custom animations jQuery.each({

slideDown: genFx( "show", 1 ),
slideUp: genFx( "hide", 1 ),
slideToggle: genFx( "toggle", 1 ),
fadeIn: { opacity: "show" },
fadeOut: { opacity: "hide" },
fadeToggle: { opacity: "toggle" }

}, function( name, props ) {

jQuery.fn[ name ] = function( speed, easing, callback ) {
        return this.animate( props, speed, easing, callback );
};

});

jQuery.extend({

speed: function( speed, easing, fn ) {
        var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
                complete: fn || !fn && easing ||
                        jQuery.isFunction( speed ) && speed,
                duration: speed,
                easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
        };

        opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
                opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;

        // normalize opt.queue - true/undefined/null -> "fx"
        if ( opt.queue == null || opt.queue === true ) {
                opt.queue = "fx";
        }

        // Queueing
        opt.old = opt.complete;

        opt.complete = function( noUnmark ) {
                if ( jQuery.isFunction( opt.old ) ) {
                        opt.old.call( this );
                }

                if ( opt.queue ) {
                        jQuery.dequeue( this, opt.queue );
                } else if ( noUnmark !== false ) {
                        jQuery._unmark( this );
                }
        };

        return opt;
},

easing: {
        linear: function( p ) {
                return p;
        },
        swing: function( p ) {
                return ( -Math.cos( p*Math.PI ) / 2 ) + 0.5;
        }
},

timers: [],

fx: function( elem, options, prop ) {
        this.options = options;
        this.elem = elem;
        this.prop = prop;

        options.orig = options.orig || {};
}

});

jQuery.fx.prototype = {

// Simple function for setting a style value
update: function() {
        if ( this.options.step ) {
                this.options.step.call( this.elem, this.now, this );
        }

        ( jQuery.fx.step[ this.prop ] || jQuery.fx.step._default )( this );
},

// Get the current size
cur: function() {
        if ( this.elem[ this.prop ] != null && (!this.elem.style || this.elem.style[ this.prop ] == null) ) {
                return this.elem[ this.prop ];
        }

        var parsed,
                r = jQuery.css( this.elem, this.prop );
        // Empty strings, null, undefined and "auto" are converted to 0,
        // complex values such as "rotate(1rad)" are returned as is,
        // simple values such as "10px" are parsed to Float.
        return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
},

// Start an animation from one number to another
custom: function( from, to, unit ) {
        var self = this,
                fx = jQuery.fx;

        this.startTime = fxNow || createFxNow();
        this.end = to;
        this.now = this.start = from;
        this.pos = this.state = 0;
        this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );

        function t( gotoEnd ) {
                return self.step( gotoEnd );
        }

        t.queue = this.options.queue;
        t.elem = this.elem;
        t.saveState = function() {
                if ( jQuery._data( self.elem, "fxshow" + self.prop ) === undefined ) {
                        if ( self.options.hide ) {
                                jQuery._data( self.elem, "fxshow" + self.prop, self.start );
                        } else if ( self.options.show ) {
                                jQuery._data( self.elem, "fxshow" + self.prop, self.end );
                        }
                }
        };

        if ( t() && jQuery.timers.push(t) && !timerId ) {
                timerId = setInterval( fx.tick, fx.interval );
        }
},

// Simple 'show' function
show: function() {
        var dataShow = jQuery._data( this.elem, "fxshow" + this.prop );

        // Remember where we started, so that we can go back to it later
        this.options.orig[ this.prop ] = dataShow || jQuery.style( this.elem, this.prop );
        this.options.show = true;

        // Begin the animation
        // Make sure that we start at a small width/height to avoid any flash of content
        if ( dataShow !== undefined ) {
                // This show is picking up where a previous hide or show left off
                this.custom( this.cur(), dataShow );
        } else {
                this.custom( this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur() );
        }

        // Start by showing the element
        jQuery( this.elem ).show();
},

// Simple 'hide' function
hide: function() {
        // Remember where we started, so that we can go back to it later
        this.options.orig[ this.prop ] = jQuery._data( this.elem, "fxshow" + this.prop ) || jQuery.style( this.elem, this.prop );
        this.options.hide = true;

        // Begin the animation
        this.custom( this.cur(), 0 );
},

// Each step of an animation
step: function( gotoEnd ) {
        var p, n, complete,
                t = fxNow || createFxNow(),
                done = true,
                elem = this.elem,
                options = this.options;

        if ( gotoEnd || t >= options.duration + this.startTime ) {
                this.now = this.end;
                this.pos = this.state = 1;
                this.update();

                options.animatedProperties[ this.prop ] = true;

                for ( p in options.animatedProperties ) {
                        if ( options.animatedProperties[ p ] !== true ) {
                                done = false;
                        }
                }

                if ( done ) {
                        // Reset the overflow
                        if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {

                                jQuery.each( [ "", "X", "Y" ], function( index, value ) {
                                        elem.style[ "overflow" + value ] = options.overflow[ index ];
                                });
                        }

                        // Hide the element if the "hide" operation was done
                        if ( options.hide ) {
                                jQuery( elem ).hide();
                        }

                        // Reset the properties, if the item has been hidden or shown
                        if ( options.hide || options.show ) {
                                for ( p in options.animatedProperties ) {
                                        jQuery.style( elem, p, options.orig[ p ] );
                                        jQuery.removeData( elem, "fxshow" + p, true );
                                        // Toggle data is no longer needed
                                        jQuery.removeData( elem, "toggle" + p, true );
                                }
                        }

                        // Execute the complete function
                        // in the event that the complete function throws an exception
                        // we must ensure it won't be called twice. #5684

                        complete = options.complete;
                        if ( complete ) {

                                options.complete = false;
                                complete.call( elem );
                        }
                }

                return false;

        } else {
                // classical easing cannot be used with an Infinity duration
                if ( options.duration == Infinity ) {
                        this.now = t;
                } else {
                        n = t - this.startTime;
                        this.state = n / options.duration;

                        // Perform the easing function, defaults to swing
                        this.pos = jQuery.easing[ options.animatedProperties[this.prop] ]( this.state, n, 0, 1, options.duration );
                        this.now = this.start + ( (this.end - this.start) * this.pos );
                }
                // Perform the next step of the animation
                this.update();
        }

        return true;
}

};

jQuery.extend( jQuery.fx, {

tick: function() {
        var timer,
                timers = jQuery.timers,
                i = 0;

        for ( ; i < timers.length; i++ ) {
                timer = timers[ i ];
                // Checks the timer has not already been removed
                if ( !timer() && timers[ i ] === timer ) {
                        timers.splice( i--, 1 );
                }
        }

        if ( !timers.length ) {
                jQuery.fx.stop();
        }
},

interval: 13,

stop: function() {
        clearInterval( timerId );
        timerId = null;
},

speeds: {
        slow: 600,
        fast: 200,
        // Default speed
        _default: 400
},

step: {
        opacity: function( fx ) {
                jQuery.style( fx.elem, "opacity", fx.now );
        },

        _default: function( fx ) {
                if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
                        fx.elem.style[ fx.prop ] = fx.now + fx.unit;
                } else {
                        fx.elem[ fx.prop ] = fx.now;
                }
        }
}

});

// Ensure props that can't be negative don't go there on undershoot easing jQuery.each( fxAttrs.concat.apply( [], fxAttrs ), function( i, prop ) {

// exclude marginTop, marginLeft, marginBottom and marginRight from this list
if ( prop.indexOf( "margin" ) ) {
        jQuery.fx.step[ prop ] = function( fx ) {
                jQuery.style( fx.elem, prop, Math.max(0, fx.now) + fx.unit );
        };
}

});

if ( jQuery.expr && jQuery.expr.filters ) {

jQuery.expr.filters.animated = function( elem ) {
        return jQuery.grep(jQuery.timers, function( fn ) {
                return elem === fn.elem;
        }).length;
};

}

// Try to restore the default display value of an element function defaultDisplay( nodeName ) {

if ( !elemdisplay[ nodeName ] ) {

        var body = document.body,
                elem = jQuery( "<" + nodeName + ">" ).appendTo( body ),
                display = elem.css( "display" );
        elem.remove();

        // If the simple way fails,
        // get element's real default display by attaching it to a temp iframe
        if ( display === "none" || display === "" ) {
                // No iframe to use yet, so create it
                if ( !iframe ) {
                        iframe = document.createElement( "iframe" );
                        iframe.frameBorder = iframe.width = iframe.height = 0;
                }

                body.appendChild( iframe );

                // Create a cacheable copy of the iframe document on first call.
                // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
                // document to it; WebKit & Firefox won't allow reusing the iframe document.
                if ( !iframeDoc || !iframe.createElement ) {
                        iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
                        iframeDoc.write( ( jQuery.support.boxModel ? "<!doctype html>" : "" ) + "<html><body>" );
                        iframeDoc.close();
                }

                elem = iframeDoc.createElement( nodeName );

                iframeDoc.body.appendChild( elem );

                display = jQuery.css( elem, "display" );
                body.removeChild( iframe );
        }

        // Store the correct default display
        elemdisplay[ nodeName ] = display;
}

return elemdisplay[ nodeName ];

}

var getOffset,

rtable = /^t(?:able|d|h)$/i,
rroot = /^(?:body|html)$/i;

if ( “getBoundingClientRect” in document.documentElement ) {

getOffset = function( elem, doc, docElem, box ) {
        try {
                box = elem.getBoundingClientRect();
        } catch(e) {}

        // Make sure we're not dealing with a disconnected DOM node
        if ( !box || !jQuery.contains( docElem, elem ) ) {
                return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
        }

        var body = doc.body,
                win = getWindow( doc ),
                clientTop  = docElem.clientTop  || body.clientTop  || 0,
                clientLeft = docElem.clientLeft || body.clientLeft || 0,
                scrollTop  = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop,
                scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
                top  = box.top  + scrollTop  - clientTop,
                left = box.left + scrollLeft - clientLeft;

        return { top: top, left: left };
};

} else {

getOffset = function( elem, doc, docElem ) {
        var computedStyle,
                offsetParent = elem.offsetParent,
                prevOffsetParent = elem,
                body = doc.body,
                defaultView = doc.defaultView,
                prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
                top = elem.offsetTop,
                left = elem.offsetLeft;

        while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
                if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
                        break;
                }

                computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
                top  -= elem.scrollTop;
                left -= elem.scrollLeft;

                if ( elem === offsetParent ) {
                        top  += elem.offsetTop;
                        left += elem.offsetLeft;

                        if ( jQuery.support.doesNotAddBorder && !(jQuery.support.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
                                top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
                                left += parseFloat( computedStyle.borderLeftWidth ) || 0;
                        }

                        prevOffsetParent = offsetParent;
                        offsetParent = elem.offsetParent;
                }

                if ( jQuery.support.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
                        top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
                        left += parseFloat( computedStyle.borderLeftWidth ) || 0;
                }

                prevComputedStyle = computedStyle;
        }

        if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
                top  += body.offsetTop;
                left += body.offsetLeft;
        }

        if ( jQuery.support.fixedPosition && prevComputedStyle.position === "fixed" ) {
                top  += Math.max( docElem.scrollTop, body.scrollTop );
                left += Math.max( docElem.scrollLeft, body.scrollLeft );
        }

        return { top: top, left: left };
};

}

jQuery.fn.offset = function( options ) {

if ( arguments.length ) {
        return options === undefined ?
                this :
                this.each(function( i ) {
                        jQuery.offset.setOffset( this, options, i );
                });
}

var elem = this[0],
        doc = elem && elem.ownerDocument;

if ( !doc ) {
        return null;
}

if ( elem === doc.body ) {
        return jQuery.offset.bodyOffset( elem );
}

return getOffset( elem, doc, doc.documentElement );

};

jQuery.offset = {

bodyOffset: function( body ) {
        var top = body.offsetTop,
                left = body.offsetLeft;

        if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) {
                top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
                left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
        }

        return { top: top, left: left };
},

setOffset: function( elem, options, i ) {
        var position = jQuery.css( elem, "position" );

        // set position first, in-case top/left are set even on static elem
        if ( position === "static" ) {
                elem.style.position = "relative";
        }

        var curElem = jQuery( elem ),
                curOffset = curElem.offset(),
                curCSSTop = jQuery.css( elem, "top" ),
                curCSSLeft = jQuery.css( elem, "left" ),
                calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
                props = {}, curPosition = {}, curTop, curLeft;

        // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
        if ( calculatePosition ) {
                curPosition = curElem.position();
                curTop = curPosition.top;
                curLeft = curPosition.left;
        } else {
                curTop = parseFloat( curCSSTop ) || 0;
                curLeft = parseFloat( curCSSLeft ) || 0;
        }

        if ( jQuery.isFunction( options ) ) {
                options = options.call( elem, i, curOffset );
        }

        if ( options.top != null ) {
                props.top = ( options.top - curOffset.top ) + curTop;
        }
        if ( options.left != null ) {
                props.left = ( options.left - curOffset.left ) + curLeft;
        }

        if ( "using" in options ) {
                options.using.call( elem, props );
        } else {
                curElem.css( props );
        }
}

};

jQuery.fn.extend({

position: function() {
        if ( !this[0] ) {
                return null;
        }

        var elem = this[0],

        // Get *real* offsetParent
        offsetParent = this.offsetParent(),

        // Get correct offsets
        offset       = this.offset(),
        parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();

        // Subtract element margins
        // note: when an element has margin: auto the offsetLeft and marginLeft
        // are the same in Safari causing offset.left to incorrectly be 0
        offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
        offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;

        // Add offsetParent borders
        parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
        parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;

        // Subtract the two offsets
        return {
                top:  offset.top  - parentOffset.top,
                left: offset.left - parentOffset.left
        };
},

offsetParent: function() {
        return this.map(function() {
                var offsetParent = this.offsetParent || document.body;
                while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
                        offsetParent = offsetParent.offsetParent;
                }
                return offsetParent;
        });
}

});

// Create scrollLeft and scrollTop methods jQuery.each( {scrollLeft: “pageXOffset”, scrollTop: “pageYOffset”}, function( method, prop ) {

var top = /Y/.test( prop );

jQuery.fn[ method ] = function( val ) {
        return jQuery.access( this, function( elem, method, val ) {
                var win = getWindow( elem );

                if ( val === undefined ) {
                        return win ? (prop in win) ? win[ prop ] :
                                jQuery.support.boxModel && win.document.documentElement[ method ] ||
                                        win.document.body[ method ] :
                                elem[ method ];
                }

                if ( win ) {
                        win.scrollTo(
                                !top ? val : jQuery( win ).scrollLeft(),
                                 top ? val : jQuery( win ).scrollTop()
                        );

                } else {
                        elem[ method ] = val;
                }
        }, method, val, arguments.length, null );
};

});

function getWindow( elem ) {

return jQuery.isWindow( elem ) ?
        elem :
        elem.nodeType === 9 ?
                elem.defaultView || elem.parentWindow :
                false;

}

// Create width, height, innerHeight, innerWidth, outerHeight and outerWidth methods jQuery.each( { Height: “height”, Width: “width” }, function( name, type ) {

var clientProp = "client" + name,
        scrollProp = "scroll" + name,
        offsetProp = "offset" + name;

// innerHeight and innerWidth
jQuery.fn[ "inner" + name ] = function() {
        var elem = this[0];
        return elem ?
                elem.style ?
                parseFloat( jQuery.css( elem, type, "padding" ) ) :
                this[ type ]() :
                null;
};

// outerHeight and outerWidth
jQuery.fn[ "outer" + name ] = function( margin ) {
        var elem = this[0];
        return elem ?
                elem.style ?
                parseFloat( jQuery.css( elem, type, margin ? "margin" : "border" ) ) :
                this[ type ]() :
                null;
};

jQuery.fn[ type ] = function( value ) {
        return jQuery.access( this, function( elem, type, value ) {
                var doc, docElemProp, orig, ret;

                if ( jQuery.isWindow( elem ) ) {
                        // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
                        doc = elem.document;
                        docElemProp = doc.documentElement[ clientProp ];
                        return jQuery.support.boxModel && docElemProp ||
                                doc.body && doc.body[ clientProp ] || docElemProp;
                }

                // Get document width or height
                if ( elem.nodeType === 9 ) {
                        // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
                        doc = elem.documentElement;

                        // when a window > document, IE6 reports a offset[Width/Height] > client[Width/Height]
                        // so we can't use max, as it'll choose the incorrect offset[Width/Height]
                        // instead we use the correct client[Width/Height]
                        // support:IE6
                        if ( doc[ clientProp ] >= doc[ scrollProp ] ) {
                                return doc[ clientProp ];
                        }

                        return Math.max(
                                elem.body[ scrollProp ], doc[ scrollProp ],
                                elem.body[ offsetProp ], doc[ offsetProp ]
                        );
                }

                // Get width or height on the element
                if ( value === undefined ) {
                        orig = jQuery.css( elem, type );
                        ret = parseFloat( orig );
                        return jQuery.isNumeric( ret ) ? ret : orig;
                }

                // Set the width or height on the element
                jQuery( elem ).css( type, value );
        }, type, value, arguments.length, null );
};

});

// Expose jQuery to the global object window.jQuery = window.$ = jQuery;

// Expose jQuery as an AMD module, but only for AMD loaders that // understand the issues with loading multiple versions of jQuery // in a page that all might call define(). The loader will indicate // they have special allowances for multiple jQuery versions by // specifying define.amd.jQuery = true. Register as a named module, // since jQuery can be concatenated with other files that may use define, // but not use a proper concatenation script that understands anonymous // AMD modules. A named AMD is safest and most robust way to register. // Lowercase jquery is used because AMD module names are derived from // file names, and jQuery is normally delivered in a lowercase file name. // Do this after creating the global so that if an AMD module wants to call // noConflict to hide this version of jQuery, it will work. if ( typeof define === “function” && define.amd && define.amd.jQuery ) {

define( "jquery", [], function () { return jQuery; } );

}

})( window );

/**

* @license AngularJS v1.0.6
* (c) 2010-2012 Google, Inc. http://angularjs.org
* License: MIT
*/

(function(window, document){

var _jQuery = window.jQuery.noConflict(true);

////////////////////////////////////

/**

* @ngdoc function
* @name angular.lowercase
* @function
*
* @description Converts the specified string to lowercase.
* @param {string} string String to be converted to lowercase.
* @returns {string} Lowercased string.
*/

var lowercase = function(string){return isString(string) ? string.toLowerCase() : string;};

/**

* @ngdoc function
* @name angular.uppercase
* @function
*
* @description Converts the specified string to uppercase.
* @param {string} string String to be converted to uppercase.
* @returns {string} Uppercased string.
*/

var uppercase = function(string){return isString(string) ? string.toUpperCase() : string;};

var manualLowercase = function(s) {

return isString(s)
    ? s.replace(/[A-Z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) | 32);})
    : s;

}; var manualUppercase = function(s) {

return isString(s)
    ? s.replace(/[a-z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) & ~32);})
    : s;

};

// String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish // locale, for this reason we need to detect this case and redefine lowercase/uppercase methods // with correct but slower alternatives. if ('i' !== 'I'.toLowerCase()) {

lowercase = manualLowercase;
uppercase = manualUppercase;

}

var /** holds major version number for IE or NaN for real browsers */

msie              = int((/msie (\d+)/.exec(lowercase(navigator.userAgent)) || [])[1]),
jqLite,           // delay binding since jQuery could be loaded after us.
jQuery,           // delay binding
slice             = [].slice,
push              = [].push,
toString          = Object.prototype.toString,

/** @name angular */
angular           = window.angular || (window.angular = {}),
angularModule,
nodeName_,
uid               = ['0', '0', '0'];

/**

* @ngdoc function
* @name angular.forEach
* @function
*
* @description
* Invokes the `iterator` function once for each item in `obj` collection, which can be either an
* object or an array. The `iterator` function is invoked with `iterator(value, key)`, where `value`
* is the value of an object property or an array element and `key` is the object property key or
* array element index. Specifying a `context` for the function is optional.
*
* Note: this function was previously known as `angular.foreach`.
*
  <pre>
    var values = {name: 'misko', gender: 'male'};
    var log = [];
    angular.forEach(values, function(value, key){
      this.push(key + ': ' + value);
    }, log);
    expect(log).toEqual(['name: misko', 'gender:male']);
  </pre>
*
* @param {Object|Array} obj Object to iterate over.
* @param {Function} iterator Iterator function.
* @param {Object=} context Object to become context (`this`) for the iterator function.
* @returns {Object|Array} Reference to `obj`.
*/

/**

* @private
* @param {*} obj
* @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments, ...)
*/

function isArrayLike(obj) {

if (!obj || (typeof obj.length !== 'number')) return false;

// We have on object which has length property. Should we treat it as array?
if (typeof obj.hasOwnProperty != 'function' &&
    typeof obj.constructor != 'function') {
  // This is here for IE8: it is a bogus object treat it as array;
  return true;
} else  {
  return obj instanceof JQLite ||                      // JQLite
         (jQuery && obj instanceof jQuery) ||          // jQuery
         toString.call(obj) !== '[object Object]' ||   // some browser native object
         typeof obj.callee === 'function';              // arguments (on IE8 looks like regular obj)
}

}

function forEach(obj, iterator, context) {

var key;
if (obj) {
  if (isFunction(obj)){
    for (key in obj) {
      if (key != 'prototype' && key != 'length' && key != 'name' && obj.hasOwnProperty(key)) {
        iterator.call(context, obj[key], key);
      }
    }
  } else if (obj.forEach && obj.forEach !== forEach) {
    obj.forEach(iterator, context);
  } else if (isArrayLike(obj)) {
    for (key = 0; key < obj.length; key++)
      iterator.call(context, obj[key], key);
  } else {
    for (key in obj) {
      if (obj.hasOwnProperty(key)) {
        iterator.call(context, obj[key], key);
      }
    }
  }
}
return obj;

}

function sortedKeys(obj) {

var keys = [];
for (var key in obj) {
  if (obj.hasOwnProperty(key)) {
    keys.push(key);
  }
}
return keys.sort();

}

function forEachSorted(obj, iterator, context) {

var keys = sortedKeys(obj);
for ( var i = 0; i < keys.length; i++) {
  iterator.call(context, obj[keys[i]], keys[i]);
}
return keys;

}

/**

* when using forEach the params are value, key, but it is often useful to have key, value.
* @param {function(string, *)} iteratorFn
* @returns {function(*, string)}
*/

function reverseParams(iteratorFn) {

return function(value, key) { iteratorFn(key, value) };

}

/**

* A consistent way of creating unique IDs in angular. The ID is a sequence of alpha numeric
* characters such as '012ABC'. The reason why we are not using simply a number counter is that
* the number string gets longer over time, and it can also overflow, where as the nextId
* will grow much slower, it is a string, and it will never overflow.
*
* @returns an unique alpha-numeric string
*/

function nextUid() {

var index = uid.length;
var digit;

while(index) {
  index--;
  digit = uid[index].charCodeAt(0);
  if (digit == 57 /*'9'*/) {
    uid[index] = 'A';
    return uid.join('');
  }
  if (digit == 90  /*'Z'*/) {
    uid[index] = '0';
  } else {
    uid[index] = String.fromCharCode(digit + 1);
    return uid.join('');
  }
}
uid.unshift('0');
return uid.join('');

}

/**

* @ngdoc function
* @name angular.extend
* @function
*
* @description
* Extends the destination object `dst` by copying all of the properties from the `src` object(s)
* to `dst`. You can specify multiple `src` objects.
*
* @param {Object} dst Destination object.
* @param {...Object} src Source object(s).
*/

function extend(dst) {

forEach(arguments, function(obj){
  if (obj !== dst) {
    forEach(obj, function(value, key){
      dst[key] = value;
    });
  }
});
return dst;

}

function int(str) {

return parseInt(str, 10);

}

function inherit(parent, extra) {

return extend(new (extend(function() {}, {prototype:parent}))(), extra);

}

/**

* @ngdoc function
* @name angular.noop
* @function
*
* @description
* A function that performs no operations. This function can be useful when writing code in the
* functional style.
  <pre>
    function foo(callback) {
      var result = calculateResult();
      (callback || angular.noop)(result);
    }
  </pre>
*/

function noop() {} noop.$inject = [];

/**

* @ngdoc function
* @name angular.identity
* @function
*
* @description
* A function that returns its first argument. This function is useful when writing code in the
* functional style.
*
  <pre>
    function transformer(transformationFn, value) {
      return (transformationFn || identity)(value);
    };
  </pre>
*/

function identity($) {return $;} identity.$inject = [];

function valueFn(value) {return function() {return value;};}

/**

* @ngdoc function
* @name angular.isUndefined
* @function
*
* @description
* Determines if a reference is undefined.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is undefined.
*/

function isUndefined(value){return typeof value == 'undefined';}

/**

* @ngdoc function
* @name angular.isDefined
* @function
*
* @description
* Determines if a reference is defined.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is defined.
*/

function isDefined(value){return typeof value != 'undefined';}

/**

* @ngdoc function
* @name angular.isObject
* @function
*
* @description
* Determines if a reference is an `Object`. Unlike `typeof` in JavaScript, `null`s are not
* considered to be objects.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is an `Object` but not `null`.
*/

function isObject(value){return value != null && typeof value == 'object';}

/**

* @ngdoc function
* @name angular.isString
* @function
*
* @description
* Determines if a reference is a `String`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `String`.
*/

function isString(value){return typeof value == 'string';}

/**

* @ngdoc function
* @name angular.isNumber
* @function
*
* @description
* Determines if a reference is a `Number`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Number`.
*/

function isNumber(value){return typeof value == 'number';}

/**

* @ngdoc function
* @name angular.isDate
* @function
*
* @description
* Determines if a value is a date.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Date`.
*/

function isDate(value){

return toString.apply(value) == '[object Date]';

}

/**

* @ngdoc function
* @name angular.isArray
* @function
*
* @description
* Determines if a reference is an `Array`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is an `Array`.
*/

function isArray(value) {

return toString.apply(value) == '[object Array]';

}

/**

* @ngdoc function
* @name angular.isFunction
* @function
*
* @description
* Determines if a reference is a `Function`.
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a `Function`.
*/

function isFunction(value){return typeof value == 'function';}

/**

* Checks if `obj` is a window object.
*
* @private
* @param {*} obj Object to check
* @returns {boolean} True if `obj` is a window obj.
*/

function isWindow(obj) {

return obj && obj.document && obj.location && obj.alert && obj.setInterval;

}

function isScope(obj) {

return obj && obj.$evalAsync && obj.$watch;

}

function isFile(obj) {

return toString.apply(obj) === '[object File]';

}

function isBoolean(value) {

return typeof value == 'boolean';

}

function trim(value) {

return isString(value) ? value.replace(/^\s*/, '').replace(/\s*$/, '') : value;

}

/**

* @ngdoc function
* @name angular.isElement
* @function
*
* @description
* Determines if a reference is a DOM element (or wrapped jQuery element).
*
* @param {*} value Reference to check.
* @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
*/

function isElement(node) {

return node &&
  (node.nodeName  // we are a direct element
  || (node.bind && node.find));  // we have a bind and find method part of jQuery API

}

/**

* @param str 'key1,key2,...'
* @returns {object} in the form of {key1:true, key2:true, ...}
*/

function makeMap(str){

var obj = {}, items = str.split(","), i;
for ( i = 0; i < items.length; i++ )
  obj[ items[i] ] = true;
return obj;

}

if (msie < 9) {

nodeName_ = function(element) {
  element = element.nodeName ? element : element[0];
  return (element.scopeName && element.scopeName != 'HTML')
    ? uppercase(element.scopeName + ':' + element.nodeName) : element.nodeName;
};

} else {

nodeName_ = function(element) {
  return element.nodeName ? element.nodeName : element[0].nodeName;
};

}

function map(obj, iterator, context) {

var results = [];
forEach(obj, function(value, index, list) {
  results.push(iterator.call(context, value, index, list));
});
return results;

}

/**

* @description
* Determines the number of elements in an array, the number of properties an object has, or
* the length of a string.
*
* Note: This function is used to augment the Object type in Angular expressions. See
* {@link angular.Object} for more information about Angular arrays.
*
* @param {Object|Array|string} obj Object, array, or string to inspect.
* @param {boolean} [ownPropsOnly=false] Count only "own" properties in an object
* @returns {number} The size of `obj` or `0` if `obj` is neither an object nor an array.
*/

function size(obj, ownPropsOnly) {

var size = 0, key;

if (isArray(obj) || isString(obj)) {
  return obj.length;
} else if (isObject(obj)){
  for (key in obj)
    if (!ownPropsOnly || obj.hasOwnProperty(key))
      size++;
}

return size;

}

function includes(array, obj) {

return indexOf(array, obj) != -1;

}

function indexOf(array, obj) {

if (array.indexOf) return array.indexOf(obj);

for ( var i = 0; i < array.length; i++) {
  if (obj === array[i]) return i;
}
return -1;

}

function arrayRemove(array, value) {

var index = indexOf(array, value);
if (index >=0)
  array.splice(index, 1);
return value;

}

function isLeafNode (node) {

if (node) {
  switch (node.nodeName) {
  case "OPTION":
  case "PRE":
  case "TITLE":
    return true;
  }
}
return false;

}

/**

* @ngdoc function
* @name angular.copy
* @function
*
* @description
* Creates a deep copy of `source`, which should be an object or an array.
*
* * If no destination is supplied, a copy of the object or array is created.
* * If a destination is provided, all of its elements (for array) or properties (for objects)
*   are deleted and then all elements/properties from the source are copied to it.
* * If  `source` is not an object or array, `source` is returned.
*
* Note: this function is used to augment the Object type in Angular expressions. See
* {@link ng.$filter} for more information about Angular arrays.
*
* @param {*} source The source that will be used to make a copy.
*                   Can be any type, including primitives, `null`, and `undefined`.
* @param {(Object|Array)=} destination Destination into which the source is copied. If
*     provided, must be of the same type as `source`.
* @returns {*} The copy or updated `destination`, if `destination` was specified.
*/

function copy(source, destination){

if (isWindow(source) || isScope(source)) throw Error("Can't copy Window or Scope");
if (!destination) {
  destination = source;
  if (source) {
    if (isArray(source)) {
      destination = copy(source, []);
    } else if (isDate(source)) {
      destination = new Date(source.getTime());
    } else if (isObject(source)) {
      destination = copy(source, {});
    }
  }
} else {
  if (source === destination) throw Error("Can't copy equivalent objects or arrays");
  if (isArray(source)) {
    destination.length = 0;
    for ( var i = 0; i < source.length; i++) {
      destination.push(copy(source[i]));
    }
  } else {
    forEach(destination, function(value, key){
      delete destination[key];
    });
    for ( var key in source) {
      destination[key] = copy(source[key]);
    }
  }
}
return destination;

}

/**

* Create a shallow copy of an object
*/

function shallowCopy(src, dst) {

dst = dst || {};

for(var key in src) {
  if (src.hasOwnProperty(key) && key.substr(0, 2) !== '$$') {
    dst[key] = src[key];
  }
}

return dst;

}

/**

* @ngdoc function
* @name angular.equals
* @function
*
* @description
* Determines if two objects or two values are equivalent. Supports value types, arrays and
* objects.
*
* Two objects or values are considered equivalent if at least one of the following is true:
*
* * Both objects or values pass `===` comparison.
* * Both objects or values are of the same type and all of their properties pass `===` comparison.
* * Both values are NaN. (In JavasScript, NaN == NaN => false. But we consider two NaN as equal)
*
* During a property comparision, properties of `function` type and properties with names
* that begin with `$` are ignored.
*
* Scope and DOMWindow objects are being compared only be identify (`===`).
*
* @param {*} o1 Object or value to compare.
* @param {*} o2 Object or value to compare.
* @returns {boolean} True if arguments are equal.
*/

function equals(o1, o2) {

if (o1 === o2) return true;
if (o1 === null || o2 === null) return false;
if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
if (t1 == t2) {
  if (t1 == 'object') {
    if (isArray(o1)) {
      if ((length = o1.length) == o2.length) {
        for(key=0; key<length; key++) {
          if (!equals(o1[key], o2[key])) return false;
        }
        return true;
      }
    } else if (isDate(o1)) {
      return isDate(o2) && o1.getTime() == o2.getTime();
    } else {
      if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2)) return false;
      keySet = {};
      for(key in o1) {
        if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
        if (!equals(o1[key], o2[key])) return false;
        keySet[key] = true;
      }
      for(key in o2) {
        if (!keySet[key] &&
            key.charAt(0) !== '$' &&
            o2[key] !== undefined &&
            !isFunction(o2[key])) return false;
      }
      return true;
    }
  }
}
return false;

}

function concat(array1, array2, index) {

return array1.concat(slice.call(array2, index));

}

function sliceArgs(args, startIndex) {

return slice.call(args, startIndex || 0);

}

/**

* @ngdoc function
* @name angular.bind
* @function
*
* @description
* Returns a function which calls function `fn` bound to `self` (`self` becomes the `this` for
* `fn`). You can supply optional `args` that are are prebound to the function. This feature is also
* known as [function currying](http://en.wikipedia.org/wiki/Currying).
*
* @param {Object} self Context which `fn` should be evaluated in.
* @param {function()} fn Function to be bound.
* @param {...*} args Optional arguments to be prebound to the `fn` function call.
* @returns {function()} Function that wraps the `fn` with all the specified bindings.
*/

function bind(self, fn) {

var curryArgs = arguments.length > 2 ? sliceArgs(arguments, 2) : [];
if (isFunction(fn) && !(fn instanceof RegExp)) {
  return curryArgs.length
    ? function() {
        return arguments.length
          ? fn.apply(self, curryArgs.concat(slice.call(arguments, 0)))
          : fn.apply(self, curryArgs);
      }
    : function() {
        return arguments.length
          ? fn.apply(self, arguments)
          : fn.call(self);
      };
} else {
  // in IE, native methods are not functions so they cannot be bound (note: they don't need to be)
  return fn;
}

}

function toJsonReplacer(key, value) {

var val = value;

if (/^\$+/.test(key)) {
  val = undefined;
} else if (isWindow(value)) {
  val = '$WINDOW';
} else if (value &&  document === value) {
  val = '$DOCUMENT';
} else if (isScope(value)) {
  val = '$SCOPE';
}

return val;

}

/**

* @ngdoc function
* @name angular.toJson
* @function
*
* @description
* Serializes input into a JSON-formatted string.
*
* @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
* @param {boolean=} pretty If set to true, the JSON output will contain newlines and whitespace.
* @returns {string} Jsonified string representing `obj`.
*/

function toJson(obj, pretty) {

return JSON.stringify(obj, toJsonReplacer, pretty ? '  ' : null);

}

/**

* @ngdoc function
* @name angular.fromJson
* @function
*
* @description
* Deserializes a JSON string.
*
* @param {string} json JSON string to deserialize.
* @returns {Object|Array|Date|string|number} Deserialized thingy.
*/

function fromJson(json) {

return isString(json)
    ? JSON.parse(json)
    : json;

}

function toBoolean(value) {

if (value && value.length !== 0) {
  var v = lowercase("" + value);
  value = !(v == 'f' || v == '0' || v == 'false' || v == 'no' || v == 'n' || v == '[]');
} else {
  value = false;
}
return value;

}

/**

* @returns {string} Returns the string representation of the element.
*/

function startingTag(element) {

element = jqLite(element).clone();
try {
  // turns out IE does not let you set .html() on elements which
  // are not allowed to have children. So we just ignore it.
  element.html('');
} catch(e) {}
// As Per DOM Standards
var TEXT_NODE = 3;
var elemHtml = jqLite('<div>').append(element).html();
try {
  return element[0].nodeType === TEXT_NODE ? lowercase(elemHtml) :
      elemHtml.
        match(/^(<[^>]+>)/)[1].
        replace(/^<([\w\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });
} catch(e) {
  return lowercase(elemHtml);
}

}

/////////////////////////////////////////////////

/**

* Parses an escaped url query string into key-value pairs.
* @returns Object.<(string|boolean)>
*/

function parseKeyValue(/*string/keyValue) {

var obj = {}, key_value, key;
forEach((keyValue || "").split('&'), function(keyValue){
  if (keyValue) {
    key_value = keyValue.split('=');
    key = decodeURIComponent(key_value[0]);
    obj[key] = isDefined(key_value[1]) ? decodeURIComponent(key_value[1]) : true;
  }
});
return obj;

}

function toKeyValue(obj) {

var parts = [];
forEach(obj, function(value, key) {
  parts.push(encodeUriQuery(key, true) + (value === true ? '' : '=' + encodeUriQuery(value, true)));
});
return parts.length ? parts.join('&') : '';

}

/**

* We need our custom method because encodeURIComponent is too agressive and doesn't follow
* http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
* segments:
*    segment       = *pchar
*    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
*    pct-encoded   = "%" HEXDIG HEXDIG
*    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
*    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
*                     / "*" / "+" / "," / ";" / "="
*/

function encodeUriSegment(val) {

return encodeUriQuery(val, true).
           replace(/%26/gi, '&').
           replace(/%3D/gi, '=').
           replace(/%2B/gi, '+');

}

/**

* This method is intended for encoding *key* or *value* parts of query component. We need a custom
* method becuase encodeURIComponent is too agressive and encodes stuff that doesn't have to be
* encoded per http://tools.ietf.org/html/rfc3986:
*    query       = *( pchar / "/" / "?" )
*    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
*    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
*    pct-encoded   = "%" HEXDIG HEXDIG
*    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
*                     / "*" / "+" / "," / ";" / "="
*/

function encodeUriQuery(val, pctEncodeSpaces) {

return encodeURIComponent(val).
           replace(/%40/gi, '@').
           replace(/%3A/gi, ':').
           replace(/%24/g, '$').
           replace(/%2C/gi, ',').
           replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));

}

/**

* @ngdoc directive
* @name ng.directive:ngApp
*
* @element ANY
* @param {angular.Module} ngApp an optional application
*   {@link angular.module module} name to load.
*
* @description
*
* Use this directive to auto-bootstrap on application. Only
* one directive can be used per HTML document. The directive
* designates the root of the application and is typically placed
* at the root of the page.
*
* In the example below if the `ngApp` directive would not be placed
* on the `html` element then the document would not be compiled
* and the `{{ 1+2 }}` would not be resolved to `3`.
*
* `ngApp` is the easiest way to bootstrap an application.
*
<doc:example>
  <doc:source>
   I can add: 1 + 2 =  {{ 1+2 }}
  </doc:source>
</doc:example>
*
*/

function angularInit(element, bootstrap) {

var elements = [element],
    appElement,
    module,
    names = ['ng:app', 'ng-app', 'x-ng-app', 'data-ng-app'],
    NG_APP_CLASS_REGEXP = /\sng[:\-]app(:\s*([\w\d_]+);?)?\s/;

function append(element) {
  element && elements.push(element);
}

forEach(names, function(name) {
  names[name] = true;
  append(document.getElementById(name));
  name = name.replace(':', '\\:');
  if (element.querySelectorAll) {
    forEach(element.querySelectorAll('.' + name), append);
    forEach(element.querySelectorAll('.' + name + '\\:'), append);
    forEach(element.querySelectorAll('[' + name + ']'), append);
  }
});

forEach(elements, function(element) {
  if (!appElement) {
    var className = ' ' + element.className + ' ';
    var match = NG_APP_CLASS_REGEXP.exec(className);
    if (match) {
      appElement = element;
      module = (match[2] || '').replace(/\s+/g, ',');
    } else {
      forEach(element.attributes, function(attr) {
        if (!appElement && names[attr.name]) {
          appElement = element;
          module = attr.value;
        }
      });
    }
  }
});
if (appElement) {
  bootstrap(appElement, module ? [module] : []);
}

}

/**

* @ngdoc function
* @name angular.bootstrap
* @description
* Use this function to manually start up angular application.
*
* See: {@link guide/bootstrap Bootstrap}
*
* @param {Element} element DOM element which is the root of angular application.
* @param {Array<String|Function>=} modules an array of module declarations. See: {@link angular.module modules}
* @returns {AUTO.$injector} Returns the newly created injector for this app.
*/

function bootstrap(element, modules) {

var resumeBootstrapInternal = function() {
  element = jqLite(element);
  modules = modules || [];
  modules.unshift(['$provide', function($provide) {
    $provide.value('$rootElement', element);
  }]);
  modules.unshift('ng');
  var injector = createInjector(modules);
  injector.invoke(['$rootScope', '$rootElement', '$compile', '$injector',
     function(scope, element, compile, injector) {
      scope.$apply(function() {
        element.data('$injector', injector);
        compile(element)(scope);
      });
    }]
  );
  return injector;
};

var NG_DEFER_BOOTSTRAP = /^NG_DEFER_BOOTSTRAP!/;

if (window && !NG_DEFER_BOOTSTRAP.test(window.name)) {
  return resumeBootstrapInternal();
}

window.name = window.name.replace(NG_DEFER_BOOTSTRAP, '');
angular.resumeBootstrap = function(extraModules) {
  forEach(extraModules, function(module) {
    modules.push(module);
  });
  resumeBootstrapInternal();
};

}

var SNAKE_CASE_REGEXP = /[A-Z]/g; function snake_case(name, separator){

separator = separator || '_';
return name.replace(SNAKE_CASE_REGEXP, function(letter, pos) {
  return (pos ? separator : '') + letter.toLowerCase();
});

}

function bindJQuery() {

// bind to jQuery if present;
jQuery = window.jQuery;
// reset to jQuery or default to us.
if (jQuery) {
  jqLite = jQuery;
  extend(jQuery.fn, {
    scope: JQLitePrototype.scope,
    controller: JQLitePrototype.controller,
    injector: JQLitePrototype.injector,
    inheritedData: JQLitePrototype.inheritedData
  });
  JQLitePatchJQueryRemove('remove', true);
  JQLitePatchJQueryRemove('empty');
  JQLitePatchJQueryRemove('html');
} else {
  jqLite = JQLite;
}
angular.element = jqLite;

}

/**

* throw error of the argument is falsy.
*/

function assertArg(arg, name, reason) {

if (!arg) {
  throw new Error("Argument '" + (name || '?') + "' is " + (reason || "required"));
}
return arg;

}

function assertArgFn(arg, name, acceptArrayAnnotation) {

if (acceptArrayAnnotation && isArray(arg)) {
    arg = arg[arg.length - 1];
}

assertArg(isFunction(arg), name, 'not a function, got ' +
    (arg && typeof arg == 'object' ? arg.constructor.name || 'Object' : typeof arg));
return arg;

}

/**

* @ngdoc interface
* @name angular.Module
* @description
*
* Interface for configuring angular {@link angular.module modules}.
*/

function setupModuleLoader(window) {

function ensure(obj, name, factory) {
  return obj[name] || (obj[name] = factory());
}

return ensure(ensure(window, 'angular', Object), 'module', function() {
  /** @type {Object.<string, angular.Module>} */
  var modules = {};

  /**
   * @ngdoc function
   * @name angular.module
   * @description
   *
   * The `angular.module` is a global place for creating and registering Angular modules. All
   * modules (angular core or 3rd party) that should be available to an application must be
   * registered using this mechanism.
   *
   *
   * # Module
   *
   * A module is a collocation of services, directives, filters, and configuration information. Module
   * is used to configure the {@link AUTO.$injector $injector}.
   *
   * <pre>
   * // Create a new module
   * var myModule = angular.module('myModule', []);
   *
   * // register a new service
   * myModule.value('appName', 'MyCoolApp');
   *
   * // configure existing services inside initialization blocks.
   * myModule.config(function($locationProvider) {
   *   // Configure existing providers
   *   $locationProvider.hashPrefix('!');
   * });
   * </pre>
   *
   * Then you can create an injector and load your modules like this:
   *
   * <pre>
   * var injector = angular.injector(['ng', 'MyModule'])
   * </pre>
   *
   * However it's more likely that you'll just use
   * {@link ng.directive:ngApp ngApp} or
   * {@link angular.bootstrap} to simplify this process for you.
   *
   * @param {!string} name The name of the module to create or retrieve.
   * @param {Array.<string>=} requires If specified then new module is being created. If unspecified then the
   *        the module is being retrieved for further configuration.
   * @param {Function} configFn Optional configuration function for the module. Same as
   *        {@link angular.Module#config Module#config()}.
   * @returns {module} new module with the {@link angular.Module} api.
   */
  return function module(name, requires, configFn) {
    if (requires && modules.hasOwnProperty(name)) {
      modules[name] = null;
    }
    return ensure(modules, name, function() {
      if (!requires) {
        throw Error('No module: ' + name);
      }

      /** @type {!Array.<Array.<*>>} */
      var invokeQueue = [];

      /** @type {!Array.<Function>} */
      var runBlocks = [];

      var config = invokeLater('$injector', 'invoke');

      /** @type {angular.Module} */
      var moduleInstance = {
        // Private state
        _invokeQueue: invokeQueue,
        _runBlocks: runBlocks,

        /**
         * @ngdoc property
         * @name angular.Module#requires
         * @propertyOf angular.Module
         * @returns {Array.<string>} List of module names which must be loaded before this module.
         * @description
         * Holds the list of modules which the injector will load before the current module is loaded.
         */
        requires: requires,

        /**
         * @ngdoc property
         * @name angular.Module#name
         * @propertyOf angular.Module
         * @returns {string} Name of the module.
         * @description
         */
        name: name,

        /**
         * @ngdoc method
         * @name angular.Module#provider
         * @methodOf angular.Module
         * @param {string} name service name
         * @param {Function} providerType Construction function for creating new instance of the service.
         * @description
         * See {@link AUTO.$provide#provider $provide.provider()}.
         */
        provider: invokeLater('$provide', 'provider'),

        /**
         * @ngdoc method
         * @name angular.Module#factory
         * @methodOf angular.Module
         * @param {string} name service name
         * @param {Function} providerFunction Function for creating new instance of the service.
         * @description
         * See {@link AUTO.$provide#factory $provide.factory()}.
         */
        factory: invokeLater('$provide', 'factory'),

        /**
         * @ngdoc method
         * @name angular.Module#service
         * @methodOf angular.Module
         * @param {string} name service name
         * @param {Function} constructor A constructor function that will be instantiated.
         * @description
         * See {@link AUTO.$provide#service $provide.service()}.
         */
        service: invokeLater('$provide', 'service'),

        /**
         * @ngdoc method
         * @name angular.Module#value
         * @methodOf angular.Module
         * @param {string} name service name
         * @param {*} object Service instance object.
         * @description
         * See {@link AUTO.$provide#value $provide.value()}.
         */
        value: invokeLater('$provide', 'value'),

        /**
         * @ngdoc method
         * @name angular.Module#constant
         * @methodOf angular.Module
         * @param {string} name constant name
         * @param {*} object Constant value.
         * @description
         * Because the constant are fixed, they get applied before other provide methods.
         * See {@link AUTO.$provide#constant $provide.constant()}.
         */
        constant: invokeLater('$provide', 'constant', 'unshift'),

        /**
         * @ngdoc method
         * @name angular.Module#filter
         * @methodOf angular.Module
         * @param {string} name Filter name.
         * @param {Function} filterFactory Factory function for creating new instance of filter.
         * @description
         * See {@link ng.$filterProvider#register $filterProvider.register()}.
         */
        filter: invokeLater('$filterProvider', 'register'),

        /**
         * @ngdoc method
         * @name angular.Module#controller
         * @methodOf angular.Module
         * @param {string} name Controller name.
         * @param {Function} constructor Controller constructor function.
         * @description
         * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
         */
        controller: invokeLater('$controllerProvider', 'register'),

        /**
         * @ngdoc method
         * @name angular.Module#directive
         * @methodOf angular.Module
         * @param {string} name directive name
         * @param {Function} directiveFactory Factory function for creating new instance of
         * directives.
         * @description
         * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
         */
        directive: invokeLater('$compileProvider', 'directive'),

        /**
         * @ngdoc method
         * @name angular.Module#config
         * @methodOf angular.Module
         * @param {Function} configFn Execute this function on module load. Useful for service
         *    configuration.
         * @description
         * Use this method to register work which needs to be performed on module loading.
         */
        config: config,

        /**
         * @ngdoc method
         * @name angular.Module#run
         * @methodOf angular.Module
         * @param {Function} initializationFn Execute this function after injector creation.
         *    Useful for application initialization.
         * @description
         * Use this method to register work which should be performed when the injector is done
         * loading all modules.
         */
        run: function(block) {
          runBlocks.push(block);
          return this;
        }
      };

      if (configFn) {
        config(configFn);
      }

      return  moduleInstance;

      /**
       * @param {string} provider
       * @param {string} method
       * @param {String=} insertMethod
       * @returns {angular.Module}
       */
      function invokeLater(provider, method, insertMethod) {
        return function() {
          invokeQueue[insertMethod || 'push']([provider, method, arguments]);
          return moduleInstance;
        }
      }
    });
  };
});

}

/**

* @ngdoc property
* @name angular.version
* @description
* An object that contains information about the current AngularJS version. This object has the
* following properties:
*
* - `full` – `{string}` – Full version string, such as "0.9.18".
* - `major` – `{number}` – Major version number, such as "0".
* - `minor` – `{number}` – Minor version number, such as "9".
* - `dot` – `{number}` – Dot version number, such as "18".
* - `codeName` – `{string}` – Code name of the release, such as "jiggling-armfat".
*/

var version = {

full: '1.0.6',    // all of these placeholder strings will be replaced by grunt's
major: 1,    // package task
minor: 0,
dot: 6,
codeName: 'universal-irreversibility'

};

function publishExternalAPI(angular){

extend(angular, {
  'bootstrap': bootstrap,
  'copy': copy,
  'extend': extend,
  'equals': equals,
  'element': jqLite,
  'forEach': forEach,
  'injector': createInjector,
  'noop':noop,
  'bind':bind,
  'toJson': toJson,
  'fromJson': fromJson,
  'identity':identity,
  'isUndefined': isUndefined,
  'isDefined': isDefined,
  'isString': isString,
  'isFunction': isFunction,
  'isObject': isObject,
  'isNumber': isNumber,
  'isElement': isElement,
  'isArray': isArray,
  'version': version,
  'isDate': isDate,
  'lowercase': lowercase,
  'uppercase': uppercase,
  'callbacks': {counter: 0}
});

angularModule = setupModuleLoader(window);
try {
  angularModule('ngLocale');
} catch (e) {
  angularModule('ngLocale', []).provider('$locale', $LocaleProvider);
}

angularModule('ng', ['ngLocale'], ['$provide',
  function ngModule($provide) {
    $provide.provider('$compile', $CompileProvider).
      directive({
          a: htmlAnchorDirective,
          input: inputDirective,
          textarea: inputDirective,
          form: formDirective,
          script: scriptDirective,
          select: selectDirective,
          style: styleDirective,
          option: optionDirective,
          ngBind: ngBindDirective,
          ngBindHtmlUnsafe: ngBindHtmlUnsafeDirective,
          ngBindTemplate: ngBindTemplateDirective,
          ngClass: ngClassDirective,
          ngClassEven: ngClassEvenDirective,
          ngClassOdd: ngClassOddDirective,
          ngCsp: ngCspDirective,
          ngCloak: ngCloakDirective,
          ngController: ngControllerDirective,
          ngForm: ngFormDirective,
          ngHide: ngHideDirective,
          ngInclude: ngIncludeDirective,
          ngInit: ngInitDirective,
          ngNonBindable: ngNonBindableDirective,
          ngPluralize: ngPluralizeDirective,
          ngRepeat: ngRepeatDirective,
          ngShow: ngShowDirective,
          ngSubmit: ngSubmitDirective,
          ngStyle: ngStyleDirective,
          ngSwitch: ngSwitchDirective,
          ngSwitchWhen: ngSwitchWhenDirective,
          ngSwitchDefault: ngSwitchDefaultDirective,
          ngOptions: ngOptionsDirective,
          ngView: ngViewDirective,
          ngTransclude: ngTranscludeDirective,
          ngModel: ngModelDirective,
          ngList: ngListDirective,
          ngChange: ngChangeDirective,
          required: requiredDirective,
          ngRequired: requiredDirective,
          ngValue: ngValueDirective
      }).
      directive(ngAttributeAliasDirectives).
      directive(ngEventDirectives);
    $provide.provider({
      $anchorScroll: $AnchorScrollProvider,
      $browser: $BrowserProvider,
      $cacheFactory: $CacheFactoryProvider,
      $controller: $ControllerProvider,
      $document: $DocumentProvider,
      $exceptionHandler: $ExceptionHandlerProvider,
      $filter: $FilterProvider,
      $interpolate: $InterpolateProvider,
      $http: $HttpProvider,
      $httpBackend: $HttpBackendProvider,
      $location: $LocationProvider,
      $log: $LogProvider,
      $parse: $ParseProvider,
      $route: $RouteProvider,
      $routeParams: $RouteParamsProvider,
      $rootScope: $RootScopeProvider,
      $q: $QProvider,
      $sniffer: $SnifferProvider,
      $templateCache: $TemplateCacheProvider,
      $timeout: $TimeoutProvider,
      $window: $WindowProvider
    });
  }
]);

}

////////////////////////////////// //JQLite //////////////////////////////////

/**

* @ngdoc function
* @name angular.element
* @function
*
* @description
* Wraps a raw DOM element or HTML string as a [jQuery](http://jquery.com) element.
* `angular.element` can be either an alias for [jQuery](http://api.jquery.com/jQuery/) function, if
* jQuery is available, or a function that wraps the element or string in Angular's jQuery lite
* implementation (commonly referred to as jqLite).
*
* Real jQuery always takes precedence over jqLite, provided it was loaded before `DOMContentLoaded`
* event fired.
*
* jqLite is a tiny, API-compatible subset of jQuery that allows
* Angular to manipulate the DOM. jqLite implements only the most commonly needed functionality
* within a very small footprint, so only a subset of the jQuery API - methods, arguments and
* invocation styles - are supported.
*
* Note: All element references in Angular are always wrapped with jQuery or jqLite; they are never
* raw DOM references.
*
* ## Angular's jQuery lite provides the following methods:
*
* - [addClass()](http://api.jquery.com/addClass/)
* - [after()](http://api.jquery.com/after/)
* - [append()](http://api.jquery.com/append/)
* - [attr()](http://api.jquery.com/attr/)
* - [bind()](http://api.jquery.com/bind/)
* - [children()](http://api.jquery.com/children/)
* - [clone()](http://api.jquery.com/clone/)
* - [contents()](http://api.jquery.com/contents/)
* - [css()](http://api.jquery.com/css/)
* - [data()](http://api.jquery.com/data/)
* - [eq()](http://api.jquery.com/eq/)
* - [find()](http://api.jquery.com/find/) - Limited to lookups by tag name.
* - [hasClass()](http://api.jquery.com/hasClass/)
* - [html()](http://api.jquery.com/html/)
* - [next()](http://api.jquery.com/next/)
* - [parent()](http://api.jquery.com/parent/)
* - [prepend()](http://api.jquery.com/prepend/)
* - [prop()](http://api.jquery.com/prop/)
* - [ready()](http://api.jquery.com/ready/)
* - [remove()](http://api.jquery.com/remove/)
* - [removeAttr()](http://api.jquery.com/removeAttr/)
* - [removeClass()](http://api.jquery.com/removeClass/)
* - [removeData()](http://api.jquery.com/removeData/)
* - [replaceWith()](http://api.jquery.com/replaceWith/)
* - [text()](http://api.jquery.com/text/)
* - [toggleClass()](http://api.jquery.com/toggleClass/)
* - [triggerHandler()](http://api.jquery.com/triggerHandler/) - Doesn't pass native event objects to handlers.
* - [unbind()](http://api.jquery.com/unbind/)
* - [val()](http://api.jquery.com/val/)
* - [wrap()](http://api.jquery.com/wrap/)
*
* ## In addtion to the above, Angular provides additional methods to both jQuery and jQuery lite:
*
* - `controller(name)` - retrieves the controller of the current element or its parent. By default
*   retrieves controller associated with the `ngController` directive. If `name` is provided as
*   camelCase directive name, then the controller for this directive will be retrieved (e.g.
*   `'ngModel'`).
* - `injector()` - retrieves the injector of the current element or its parent.
* - `scope()` - retrieves the {@link api/ng.$rootScope.Scope scope} of the current
*   element or its parent.
* - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
*   parent element is reached.
*
* @param {string|DOMElement} element HTML string or DOMElement to be wrapped into jQuery.
* @returns {Object} jQuery object.
*/

var jqCache = JQLite.cache = {},

jqName = JQLite.expando = 'ng-' + new Date().getTime(),
jqId = 1,
addEventListenerFn = (window.document.addEventListener
  ? function(element, type, fn) {element.addEventListener(type, fn, false);}
  : function(element, type, fn) {element.attachEvent('on' + type, fn);}),
removeEventListenerFn = (window.document.removeEventListener
  ? function(element, type, fn) {element.removeEventListener(type, fn, false); }
  : function(element, type, fn) {element.detachEvent('on' + type, fn); });

function jqNextId() { return ++jqId; }

var SPECIAL_CHARS_REGEXP = /([:-_]+(.))/g; var MOZ_HACK_REGEXP = /^moz()/;

/**

* Converts snake_case to camelCase.
* Also there is special case for Moz prefix starting with upper case letter.
* @param name Name to normalize
*/

function camelCase(name) {

return name.
  replace(SPECIAL_CHARS_REGEXP, function(_, separator, letter, offset) {
    return offset ? letter.toUpperCase() : letter;
  }).
  replace(MOZ_HACK_REGEXP, 'Moz$1');

}

///////////////////////////////////////////// // jQuery mutation patch // // In conjunction with bindJQuery intercepts all jQuery's DOM destruction apis and fires a // $destroy event on all DOM nodes being removed. // /////////////////////////////////////////////

function JQLitePatchJQueryRemove(name, dispatchThis) {

var originalJqFn = jQuery.fn[name];
originalJqFn = originalJqFn.$original || originalJqFn;
removePatch.$original = originalJqFn;
jQuery.fn[name] = removePatch;

function removePatch() {
  var list = [this],
      fireEvent = dispatchThis,
      set, setIndex, setLength,
      element, childIndex, childLength, children,
      fns, events;

  while(list.length) {
    set = list.shift();
    for(setIndex = 0, setLength = set.length; setIndex < setLength; setIndex++) {
      element = jqLite(set[setIndex]);
      if (fireEvent) {
        element.triggerHandler('$destroy');
      } else {
        fireEvent = !fireEvent;
      }
      for(childIndex = 0, childLength = (children = element.children()).length;
          childIndex < childLength;
          childIndex++) {
        list.push(jQuery(children[childIndex]));
      }
    }
  }
  return originalJqFn.apply(this, arguments);
}

}

///////////////////////////////////////////// function JQLite(element) {

if (element instanceof JQLite) {
  return element;
}
if (!(this instanceof JQLite)) {
  if (isString(element) && element.charAt(0) != '<') {
    throw Error('selectors not implemented');
  }
  return new JQLite(element);
}

if (isString(element)) {
  var div = document.createElement('div');
  // Read about the NoScope elements here:
  // http://msdn.microsoft.com/en-us/library/ms533897(VS.85).aspx
  div.innerHTML = '<div>&#160;</div>' + element; // IE insanity to make NoScope elements work!
  div.removeChild(div.firstChild); // remove the superfluous div
  JQLiteAddNodes(this, div.childNodes);
  this.remove(); // detach the elements from the temporary DOM div.
} else {
  JQLiteAddNodes(this, element);
}

}

function JQLiteClone(element) {

return element.cloneNode(true);

}

function JQLiteDealoc(element){

JQLiteRemoveData(element);
for ( var i = 0, children = element.childNodes || []; i < children.length; i++) {
  JQLiteDealoc(children[i]);
}

}

function JQLiteUnbind(element, type, fn) {

var events = JQLiteExpandoStore(element, 'events'),
    handle = JQLiteExpandoStore(element, 'handle');

if (!handle) return; //no listeners registered

if (isUndefined(type)) {
  forEach(events, function(eventHandler, type) {
    removeEventListenerFn(element, type, eventHandler);
    delete events[type];
  });
} else {
  if (isUndefined(fn)) {
    removeEventListenerFn(element, type, events[type]);
    delete events[type];
  } else {
    arrayRemove(events[type], fn);
  }
}

}

function JQLiteRemoveData(element) {

var expandoId = element[jqName],
    expandoStore = jqCache[expandoId];

if (expandoStore) {
  if (expandoStore.handle) {
    expandoStore.events.$destroy && expandoStore.handle({}, '$destroy');
    JQLiteUnbind(element);
  }
  delete jqCache[expandoId];
  element[jqName] = undefined; // ie does not allow deletion of attributes on elements.
}

}

function JQLiteExpandoStore(element, key, value) {

var expandoId = element[jqName],
    expandoStore = jqCache[expandoId || -1];

if (isDefined(value)) {
  if (!expandoStore) {
    element[jqName] = expandoId = jqNextId();
    expandoStore = jqCache[expandoId] = {};
  }
  expandoStore[key] = value;
} else {
  return expandoStore && expandoStore[key];
}

}

function JQLiteData(element, key, value) {

var data = JQLiteExpandoStore(element, 'data'),
    isSetter = isDefined(value),
    keyDefined = !isSetter && isDefined(key),
    isSimpleGetter = keyDefined && !isObject(key);

if (!data && !isSimpleGetter) {
  JQLiteExpandoStore(element, 'data', data = {});
}

if (isSetter) {
  data[key] = value;
} else {
  if (keyDefined) {
    if (isSimpleGetter) {
      // don't create data in this case.
      return data && data[key];
    } else {
      extend(data, key);
    }
  } else {
    return data;
  }
}

}

function JQLiteHasClass(element, selector) {

return ((" " + element.className + " ").replace(/[\n\t]/g, " ").
    indexOf( " " + selector + " " ) > -1);

}

function JQLiteRemoveClass(element, cssClasses) {

if (cssClasses) {
  forEach(cssClasses.split(' '), function(cssClass) {
    element.className = trim(
        (" " + element.className + " ")
        .replace(/[\n\t]/g, " ")
        .replace(" " + trim(cssClass) + " ", " ")
    );
  });
}

}

function JQLiteAddClass(element, cssClasses) {

if (cssClasses) {
  forEach(cssClasses.split(' '), function(cssClass) {
    if (!JQLiteHasClass(element, cssClass)) {
      element.className = trim(element.className + ' ' + trim(cssClass));
    }
  });
}

}

function JQLiteAddNodes(root, elements) {

if (elements) {
  elements = (!elements.nodeName && isDefined(elements.length) && !isWindow(elements))
    ? elements
    : [ elements ];
  for(var i=0; i < elements.length; i++) {
    root.push(elements[i]);
  }
}

}

function JQLiteController(element, name) {

return JQLiteInheritedData(element, '$' + (name || 'ngController' ) + 'Controller');

}

function JQLiteInheritedData(element, name, value) {

element = jqLite(element);

// if element is the document object work with the html element instead
// this makes $(document).scope() possible
if(element[0].nodeType == 9) {
  element = element.find('html');
}

while (element.length) {
  if (value = element.data(name)) return value;
  element = element.parent();
}

}

////////////////////////////////////////// // Functions which are declared directly. ////////////////////////////////////////// var JQLitePrototype = JQLite.prototype = {

ready: function(fn) {
  var fired = false;

  function trigger() {
    if (fired) return;
    fired = true;
    fn();
  }

  this.bind('DOMContentLoaded', trigger); // works for modern browsers and IE9
  // we can not use jqLite since we are not done loading and jQuery could be loaded later.
  JQLite(window).bind('load', trigger); // fallback to window.onload for others
},
toString: function() {
  var value = [];
  forEach(this, function(e){ value.push('' + e);});
  return '[' + value.join(', ') + ']';
},

eq: function(index) {
    return (index >= 0) ? jqLite(this[index]) : jqLite(this[this.length + index]);
},

length: 0,
push: push,
sort: [].sort,
splice: [].splice

};

////////////////////////////////////////// // Functions iterating getter/setters. // these functions return self on setter and // value on get. ////////////////////////////////////////// var BOOLEAN_ATTR = {}; forEach('multiple,selected,checked,disabled,readOnly,required'.split(','), function(value) {

BOOLEAN_ATTR[lowercase(value)] = value;

}); var BOOLEAN_ELEMENTS = {}; forEach('input,select,option,textarea,button,form'.split(','), function(value) {

BOOLEAN_ELEMENTS[uppercase(value)] = true;

});

function getBooleanAttrName(element, name) {

// check dom last since we will most likely fail on name
var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];

// booleanAttr is here twice to minimize DOM access
return booleanAttr && BOOLEAN_ELEMENTS[element.nodeName] && booleanAttr;

}

forEach({

data: JQLiteData,
inheritedData: JQLiteInheritedData,

scope: function(element) {
  return JQLiteInheritedData(element, '$scope');
},

controller: JQLiteController ,

injector: function(element) {
  return JQLiteInheritedData(element, '$injector');
},

removeAttr: function(element,name) {
  element.removeAttribute(name);
},

hasClass: JQLiteHasClass,

css: function(element, name, value) {
  name = camelCase(name);

  if (isDefined(value)) {
    element.style[name] = value;
  } else {
    var val;

    if (msie <= 8) {
      // this is some IE specific weirdness that jQuery 1.6.4 does not sure why
      val = element.currentStyle && element.currentStyle[name];
      if (val === '') val = 'auto';
    }

    val = val || element.style[name];

    if (msie <= 8) {
      // jquery weirdness :-/
      val = (val === '') ? undefined : val;
    }

    return  val;
  }
},

attr: function(element, name, value){
  var lowercasedName = lowercase(name);
  if (BOOLEAN_ATTR[lowercasedName]) {
    if (isDefined(value)) {
      if (!!value) {
        element[name] = true;
        element.setAttribute(name, lowercasedName);
      } else {
        element[name] = false;
        element.removeAttribute(lowercasedName);
      }
    } else {
      return (element[name] ||
               (element.attributes.getNamedItem(name)|| noop).specified)
             ? lowercasedName
             : undefined;
    }
  } else if (isDefined(value)) {
    element.setAttribute(name, value);
  } else if (element.getAttribute) {
    // the extra argument "2" is to get the right thing for a.href in IE, see jQuery code
    // some elements (e.g. Document) don't have get attribute, so return undefined
    var ret = element.getAttribute(name, 2);
    // normalize non-existing attributes to undefined (as jQuery)
    return ret === null ? undefined : ret;
  }
},

prop: function(element, name, value) {
  if (isDefined(value)) {
    element[name] = value;
  } else {
    return element[name];
  }
},

text: extend((msie < 9)
    ? function(element, value) {
      if (element.nodeType == 1 /** Element */) {
        if (isUndefined(value))
          return element.innerText;
        element.innerText = value;
      } else {
        if (isUndefined(value))
          return element.nodeValue;
        element.nodeValue = value;
      }
    }
    : function(element, value) {
      if (isUndefined(value)) {
        return element.textContent;
      }
      element.textContent = value;
    }, {$dv:''}),

val: function(element, value) {
  if (isUndefined(value)) {
    return element.value;
  }
  element.value = value;
},

html: function(element, value) {
  if (isUndefined(value)) {
    return element.innerHTML;
  }
  for (var i = 0, childNodes = element.childNodes; i < childNodes.length; i++) {
    JQLiteDealoc(childNodes[i]);
  }
  element.innerHTML = value;
}

}, function(fn, name){

/**
 * Properties: writes return selection, reads return first value
 */
JQLite.prototype[name] = function(arg1, arg2) {
  var i, key;

  // JQLiteHasClass has only two arguments, but is a getter-only fn, so we need to special-case it
  // in a way that survives minification.
  if (((fn.length == 2 && (fn !== JQLiteHasClass && fn !== JQLiteController)) ? arg1 : arg2) === undefined) {
    if (isObject(arg1)) {

      // we are a write, but the object properties are the key/values
      for(i=0; i < this.length; i++) {
        if (fn === JQLiteData) {
          // data() takes the whole object in jQuery
          fn(this[i], arg1);
        } else {
          for (key in arg1) {
            fn(this[i], key, arg1[key]);
          }
        }
      }
      // return self for chaining
      return this;
    } else {
      // we are a read, so read the first child.
      if (this.length)
        return fn(this[0], arg1, arg2);
    }
  } else {
    // we are a write, so apply to all children
    for(i=0; i < this.length; i++) {
      fn(this[i], arg1, arg2);
    }
    // return self for chaining
    return this;
  }
  return fn.$dv;
};

});

function createEventHandler(element, events) {

var eventHandler = function (event, type) {
  if (!event.preventDefault) {
    event.preventDefault = function() {
      event.returnValue = false; //ie
    };
  }

  if (!event.stopPropagation) {
    event.stopPropagation = function() {
      event.cancelBubble = true; //ie
    };
  }

  if (!event.target) {
    event.target = event.srcElement || document;
  }

  if (isUndefined(event.defaultPrevented)) {
    var prevent = event.preventDefault;
    event.preventDefault = function() {
      event.defaultPrevented = true;
      prevent.call(event);
    };
    event.defaultPrevented = false;
  }

  event.isDefaultPrevented = function() {
    return event.defaultPrevented;
  };

  forEach(events[type || event.type], function(fn) {
    fn.call(element, event);
  });

  // Remove monkey-patched methods (IE),
  // as they would cause memory leaks in IE8.
  if (msie <= 8) {
    // IE7/8 does not allow to delete property on native object
    event.preventDefault = null;
    event.stopPropagation = null;
    event.isDefaultPrevented = null;
  } else {
    // It shouldn't affect normal browsers (native methods are defined on prototype).
    delete event.preventDefault;
    delete event.stopPropagation;
    delete event.isDefaultPrevented;
  }
};
eventHandler.elem = element;
return eventHandler;

}

////////////////////////////////////////// // Functions iterating traversal. // These functions chain results into a single // selector. ////////////////////////////////////////// forEach({

removeData: JQLiteRemoveData,

dealoc: JQLiteDealoc,

bind: function bindFn(element, type, fn){
  var events = JQLiteExpandoStore(element, 'events'),
      handle = JQLiteExpandoStore(element, 'handle');

  if (!events) JQLiteExpandoStore(element, 'events', events = {});
  if (!handle) JQLiteExpandoStore(element, 'handle', handle = createEventHandler(element, events));

  forEach(type.split(' '), function(type){
    var eventFns = events[type];

    if (!eventFns) {
      if (type == 'mouseenter' || type == 'mouseleave') {
        var counter = 0;

        events.mouseenter = [];
        events.mouseleave = [];

        bindFn(element, 'mouseover', function(event) {
          counter++;
          if (counter == 1) {
            handle(event, 'mouseenter');
          }
        });
        bindFn(element, 'mouseout', function(event) {
          counter --;
          if (counter == 0) {
            handle(event, 'mouseleave');
          }
        });
      } else {
        addEventListenerFn(element, type, handle);
        events[type] = [];
      }
      eventFns = events[type]
    }
    eventFns.push(fn);
  });
},

unbind: JQLiteUnbind,

replaceWith: function(element, replaceNode) {
  var index, parent = element.parentNode;
  JQLiteDealoc(element);
  forEach(new JQLite(replaceNode), function(node){
    if (index) {
      parent.insertBefore(node, index.nextSibling);
    } else {
      parent.replaceChild(node, element);
    }
    index = node;
  });
},

children: function(element) {
  var children = [];
  forEach(element.childNodes, function(element){
    if (element.nodeType === 1)
      children.push(element);
  });
  return children;
},

contents: function(element) {
  return element.childNodes || [];
},

append: function(element, node) {
  forEach(new JQLite(node), function(child){
    if (element.nodeType === 1)
      element.appendChild(child);
  });
},

prepend: function(element, node) {
  if (element.nodeType === 1) {
    var index = element.firstChild;
    forEach(new JQLite(node), function(child){
      if (index) {
        element.insertBefore(child, index);
      } else {
        element.appendChild(child);
        index = child;
      }
    });
  }
},

wrap: function(element, wrapNode) {
  wrapNode = jqLite(wrapNode)[0];
  var parent = element.parentNode;
  if (parent) {
    parent.replaceChild(wrapNode, element);
  }
  wrapNode.appendChild(element);
},

remove: function(element) {
  JQLiteDealoc(element);
  var parent = element.parentNode;
  if (parent) parent.removeChild(element);
},

after: function(element, newElement) {
  var index = element, parent = element.parentNode;
  forEach(new JQLite(newElement), function(node){
    parent.insertBefore(node, index.nextSibling);
    index = node;
  });
},

addClass: JQLiteAddClass,
removeClass: JQLiteRemoveClass,

toggleClass: function(element, selector, condition) {
  if (isUndefined(condition)) {
    condition = !JQLiteHasClass(element, selector);
  }
  (condition ? JQLiteAddClass : JQLiteRemoveClass)(element, selector);
},

parent: function(element) {
  var parent = element.parentNode;
  return parent && parent.nodeType !== 11 ? parent : null;
},

next: function(element) {
  if (element.nextElementSibling) {
    return element.nextElementSibling;
  }

  // IE8 doesn't have nextElementSibling
  var elm = element.nextSibling;
  while (elm != null && elm.nodeType !== 1) {
    elm = elm.nextSibling;
  }
  return elm;
},

find: function(element, selector) {
  return element.getElementsByTagName(selector);
},

clone: JQLiteClone,

triggerHandler: function(element, eventName) {
  var eventFns = (JQLiteExpandoStore(element, 'events') || {})[eventName];

  forEach(eventFns, function(fn) {
    fn.call(element, null);
  });
}

}, function(fn, name){

/**
 * chaining functions
 */
JQLite.prototype[name] = function(arg1, arg2) {
  var value;
  for(var i=0; i < this.length; i++) {
    if (value == undefined) {
      value = fn(this[i], arg1, arg2);
      if (value !== undefined) {
        // any function which returns a value needs to be wrapped
        value = jqLite(value);
      }
    } else {
      JQLiteAddNodes(value, fn(this[i], arg1, arg2));
    }
  }
  return value == undefined ? this : value;
};

});

/**

* Computes a hash of an 'obj'.
* Hash of a:
*  string is string
*  number is number as string
*  object is either result of calling $$hashKey function on the object or uniquely generated id,
*         that is also assigned to the $$hashKey property of the object.
*
* @param obj
* @returns {string} hash string such that the same input will have the same hash string.
*         The resulting string key is in 'type:hashKey' format.
*/

function hashKey(obj) {

var objType = typeof obj,
    key;

if (objType == 'object' && obj !== null) {
  if (typeof (key = obj.$$hashKey) == 'function') {
    // must invoke on object to keep the right this
    key = obj.$$hashKey();
  } else if (key === undefined) {
    key = obj.$$hashKey = nextUid();
  }
} else {
  key = obj;
}

return objType + ':' + key;

}

/**

* HashMap which can use objects as keys
*/

function HashMap(array){

forEach(array, this.put, this);

} HashMap.prototype = {

/**
 * Store key value pair
 * @param key key to store can be any type
 * @param value value to store can be any type
 */
put: function(key, value) {
  this[hashKey(key)] = value;
},

/**
 * @param key
 * @returns the value for the key
 */
get: function(key) {
  return this[hashKey(key)];
},

/**
 * Remove the key/value pair
 * @param key
 */
remove: function(key) {
  var value = this[key = hashKey(key)];
  delete this[key];
  return value;
}

};

/**

* A map where multiple values can be added to the same key such that they form a queue.
* @returns {HashQueueMap}
*/

function HashQueueMap() {} HashQueueMap.prototype = {

/**
 * Same as array push, but using an array as the value for the hash
 */
push: function(key, value) {
  var array = this[key = hashKey(key)];
  if (!array) {
    this[key] = [value];
  } else {
    array.push(value);
  }
},

/**
 * Same as array shift, but using an array as the value for the hash
 */
shift: function(key) {
  var array = this[key = hashKey(key)];
  if (array) {
    if (array.length == 1) {
      delete this[key];
      return array[0];
    } else {
      return array.shift();
    }
  }
},

/**
 * return the first item without deleting it
 */
peek: function(key) {
  var array = this[hashKey(key)];
  if (array) {
  return array[0];
  }
}

};

/**

* @ngdoc function
* @name angular.injector
* @function
*
* @description
* Creates an injector function that can be used for retrieving services as well as for
* dependency injection (see {@link guide/di dependency injection}).
*

* @param {Array.<string|Function>} modules A list of module functions or their aliases. See
*        {@link angular.module}. The `ng` module must be explicitly added.
* @returns {function()} Injector function. See {@link AUTO.$injector $injector}.
*
* @example
* Typical usage
* <pre>
*   // create an injector
*   var $injector = angular.injector(['ng']);
*
*   // use the injector to kick off your application
*   // use the type inference to auto inject arguments, or use implicit injection
*   $injector.invoke(function($rootScope, $compile, $document){
*     $compile($document)($rootScope);
*     $rootScope.$digest();
*   });
* </pre>
*/

/**

* @ngdoc overview
* @name AUTO
* @description
*
* Implicit module which gets automatically added to each {@link AUTO.$injector $injector}.
*/

var FN_ARGS = /^functions**(s*([^)]*))/m; var FN_ARG_SPLIT = /,/; var FN_ARG = /^s*(_?)(S+?)1s*$/; var STRIP_COMMENTS = /((//.*$)|(/*[sS]*?*/))/mg; function annotate(fn) {

var $inject,
    fnText,
    argDecl,
    last;

if (typeof fn == 'function') {
  if (!($inject = fn.$inject)) {
    $inject = [];
    fnText = fn.toString().replace(STRIP_COMMENTS, '');
    argDecl = fnText.match(FN_ARGS);
    forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg){
      arg.replace(FN_ARG, function(all, underscore, name){
        $inject.push(name);
      });
    });
    fn.$inject = $inject;
  }
} else if (isArray(fn)) {
  last = fn.length - 1;
  assertArgFn(fn[last], 'fn')
  $inject = fn.slice(0, last);
} else {
  assertArgFn(fn, 'fn', true);
}
return $inject;

}

///////////////////////////////////////

/**

* @ngdoc object
* @name AUTO.$injector
* @function
*
* @description
*
* `$injector` is used to retrieve object instances as defined by
* {@link AUTO.$provide provider}, instantiate types, invoke methods,
* and load modules.
*
* The following always holds true:
*
* <pre>
*   var $injector = angular.injector();
*   expect($injector.get('$injector')).toBe($injector);
*   expect($injector.invoke(function($injector){
*     return $injector;
*   }).toBe($injector);
* </pre>
*
* # Injection Function Annotation
*
* JavaScript does not have annotations, and annotations are needed for dependency injection. The
* following ways are all valid way of annotating function with injection arguments and are equivalent.
*
* <pre>
*   // inferred (only works if code not minified/obfuscated)
*   $injector.invoke(function(serviceA){});
*
*   // annotated
*   function explicit(serviceA) {};
*   explicit.$inject = ['serviceA'];
*   $injector.invoke(explicit);
*
*   // inline
*   $injector.invoke(['serviceA', function(serviceA){}]);
* </pre>
*
* ## Inference
*
* In JavaScript calling `toString()` on a function returns the function definition. The definition can then be
* parsed and the function arguments can be extracted. *NOTE:* This does not work with minification, and obfuscation
* tools since these tools change the argument names.
*
* ## `$inject` Annotation
* By adding a `$inject` property onto a function the injection parameters can be specified.
*
* ## Inline
* As an array of injection names, where the last item in the array is the function to call.
*/

/**

* @ngdoc method
* @name AUTO.$injector#get
* @methodOf AUTO.$injector
*
* @description
* Return an instance of the service.
*
* @param {string} name The name of the instance to retrieve.
* @return {*} The instance.
*/

/**

* @ngdoc method
* @name AUTO.$injector#invoke
* @methodOf AUTO.$injector
*
* @description
* Invoke the method and supply the method arguments from the `$injector`.
*
* @param {!function} fn The function to invoke. The function arguments come form the function annotation.
* @param {Object=} self The `this` for the invoked method.
* @param {Object=} locals Optional object. If preset then any argument names are read from this object first, before
*   the `$injector` is consulted.
* @returns {*} the value returned by the invoked `fn` function.
*/

/**

* @ngdoc method
* @name AUTO.$injector#instantiate
* @methodOf AUTO.$injector
* @description
* Create a new instance of JS type. The method takes a constructor function invokes the new operator and supplies
* all of the arguments to the constructor function as specified by the constructor annotation.
*
* @param {function} Type Annotated constructor function.
* @param {Object=} locals Optional object. If preset then any argument names are read from this object first, before
*   the `$injector` is consulted.
* @returns {Object} new instance of `Type`.
*/

/**

* @ngdoc method
* @name AUTO.$injector#annotate
* @methodOf AUTO.$injector
*
* @description
* Returns an array of service names which the function is requesting for injection. This API is used by the injector
* to determine which services need to be injected into the function when the function is invoked. There are three
* ways in which the function can be annotated with the needed dependencies.
*
* # Argument names
*
* The simplest form is to extract the dependencies from the arguments of the function. This is done by converting
* the function into a string using `toString()` method and extracting the argument names.
* <pre>
*   // Given
*   function MyController($scope, $route) {
*     // ...
*   }
*
*   // Then
*   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
* </pre>
*
* This method does not work with code minfication / obfuscation. For this reason the following annotation strategies
* are supported.
*
* # The `$inject` property
*
* If a function has an `$inject` property and its value is an array of strings, then the strings represent names of
* services to be injected into the function.
* <pre>
*   // Given
*   var MyController = function(obfuscatedScope, obfuscatedRoute) {
*     // ...
*   }
*   // Define function dependencies
*   MyController.$inject = ['$scope', '$route'];
*
*   // Then
*   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
* </pre>
*
* # The array notation
*
* It is often desirable to inline Injected functions and that's when setting the `$inject` property is very
* inconvenient. In these situations using the array notation to specify the dependencies in a way that survives
* minification is a better choice:
*
* <pre>
*   // We wish to write this (not minification / obfuscation safe)
*   injector.invoke(function($compile, $rootScope) {
*     // ...
*   });
*
*   // We are forced to write break inlining
*   var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {
*     // ...
*   };
*   tmpFn.$inject = ['$compile', '$rootScope'];
*   injector.invoke(tempFn);
*
*   // To better support inline function the inline annotation is supported
*   injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {
*     // ...
*   }]);
*
*   // Therefore
*   expect(injector.annotate(
*      ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
*    ).toEqual(['$compile', '$rootScope']);
* </pre>
*
* @param {function|Array.<string|Function>} fn Function for which dependent service names need to be retrieved as described
*   above.
*
* @returns {Array.<string>} The names of the services which the function requires.
*/

/**

* @ngdoc object
* @name AUTO.$provide
*
* @description
*
* Use `$provide` to register new providers with the `$injector`. The providers are the factories for the instance.
* The providers share the same name as the instance they create with `Provider` suffixed to them.
*
* A provider is an object with a `$get()` method. The injector calls the `$get` method to create a new instance of
* a service. The Provider can have additional methods which would allow for configuration of the provider.
*
* <pre>
*   function GreetProvider() {
*     var salutation = 'Hello';
*
*     this.salutation = function(text) {
*       salutation = text;
*     };
*
*     this.$get = function() {
*       return function (name) {
*         return salutation + ' ' + name + '!';
*       };
*     };
*   }
*
*   describe('Greeter', function(){
*
*     beforeEach(module(function($provide) {
*       $provide.provider('greet', GreetProvider);
*     });
*
*     it('should greet', inject(function(greet) {
*       expect(greet('angular')).toEqual('Hello angular!');
*     }));
*
*     it('should allow configuration of salutation', function() {
*       module(function(greetProvider) {
*         greetProvider.salutation('Ahoj');
*       });
*       inject(function(greet) {
*         expect(greet('angular')).toEqual('Ahoj angular!');
*       });
*     )};
*
*   });
* </pre>
*/

/**

* @ngdoc method
* @name AUTO.$provide#provider
* @methodOf AUTO.$provide
* @description
*
* Register a provider for a service. The providers can be retrieved and can have additional configuration methods.
*
* @param {string} name The name of the instance. NOTE: the provider will be available under `name + 'Provider'` key.
* @param {(Object|function())} provider If the provider is:
*
*   - `Object`: then it should have a `$get` method. The `$get` method will be invoked using
*               {@link AUTO.$injector#invoke $injector.invoke()} when an instance needs to be created.
*   - `Constructor`: a new instance of the provider will be created using
*               {@link AUTO.$injector#instantiate $injector.instantiate()}, then treated as `object`.
*
* @returns {Object} registered provider instance
*/

/**

* @ngdoc method
* @name AUTO.$provide#factory
* @methodOf AUTO.$provide
* @description
*
* A short hand for configuring services if only `$get` method is required.
*
* @param {string} name The name of the instance.
* @param {function()} $getFn The $getFn for the instance creation. Internally this is a short hand for
* `$provide.provider(name, {$get: $getFn})`.
* @returns {Object} registered provider instance
*/

/**

* @ngdoc method
* @name AUTO.$provide#service
* @methodOf AUTO.$provide
* @description
*
* A short hand for registering service of given class.
*
* @param {string} name The name of the instance.
* @param {Function} constructor A class (constructor function) that will be instantiated.
* @returns {Object} registered provider instance
*/

/**

* @ngdoc method
* @name AUTO.$provide#value
* @methodOf AUTO.$provide
* @description
*
* A short hand for configuring services if the `$get` method is a constant.
*
* @param {string} name The name of the instance.
* @param {*} value The value.
* @returns {Object} registered provider instance
*/

/**

* @ngdoc method
* @name AUTO.$provide#constant
* @methodOf AUTO.$provide
* @description
*
* A constant value, but unlike {@link AUTO.$provide#value value} it can be injected
* into configuration function (other modules) and it is not interceptable by
* {@link AUTO.$provide#decorator decorator}.
*
* @param {string} name The name of the constant.
* @param {*} value The constant value.
* @returns {Object} registered instance
*/

/**

* @ngdoc method
* @name AUTO.$provide#decorator
* @methodOf AUTO.$provide
* @description
*
* Decoration of service, allows the decorator to intercept the service instance creation. The
* returned instance may be the original instance, or a new instance which delegates to the
* original instance.
*
* @param {string} name The name of the service to decorate.
* @param {function()} decorator This function will be invoked when the service needs to be
*    instanciated. The function is called using the {@link AUTO.$injector#invoke
*    injector.invoke} method and is therefore fully injectable. Local injection arguments:
*
*    * `$delegate` - The original service instance, which can be monkey patched, configured,
*      decorated or delegated to.
*/

function createInjector(modulesToLoad) {

var INSTANTIATING = {},
    providerSuffix = 'Provider',
    path = [],
    loadedModules = new HashMap(),
    providerCache = {
      $provide: {
          provider: supportObject(provider),
          factory: supportObject(factory),
          service: supportObject(service),
          value: supportObject(value),
          constant: supportObject(constant),
          decorator: decorator
        }
    },
    providerInjector = createInternalInjector(providerCache, function() {
      throw Error("Unknown provider: " + path.join(' <- '));
    }),
    instanceCache = {},
    instanceInjector = (instanceCache.$injector =
        createInternalInjector(instanceCache, function(servicename) {
          var provider = providerInjector.get(servicename + providerSuffix);
          return instanceInjector.invoke(provider.$get, provider);
        }));

forEach(loadModules(modulesToLoad), function(fn) { instanceInjector.invoke(fn || noop); });

return instanceInjector;

////////////////////////////////////
// $provider
////////////////////////////////////

function supportObject(delegate) {
  return function(key, value) {
    if (isObject(key)) {
      forEach(key, reverseParams(delegate));
    } else {
      return delegate(key, value);
    }
  }
}

function provider(name, provider_) {
  if (isFunction(provider_) || isArray(provider_)) {
    provider_ = providerInjector.instantiate(provider_);
  }
  if (!provider_.$get) {
    throw Error('Provider ' + name + ' must define $get factory method.');
  }
  return providerCache[name + providerSuffix] = provider_;
}

function factory(name, factoryFn) { return provider(name, { $get: factoryFn }); }

function service(name, constructor) {
  return factory(name, ['$injector', function($injector) {
    return $injector.instantiate(constructor);
  }]);
}

function value(name, value) { return factory(name, valueFn(value)); }

function constant(name, value) {
  providerCache[name] = value;
  instanceCache[name] = value;
}

function decorator(serviceName, decorFn) {
  var origProvider = providerInjector.get(serviceName + providerSuffix),
      orig$get = origProvider.$get;

  origProvider.$get = function() {
    var origInstance = instanceInjector.invoke(orig$get, origProvider);
    return instanceInjector.invoke(decorFn, null, {$delegate: origInstance});
  };
}

////////////////////////////////////
// Module Loading
////////////////////////////////////
function loadModules(modulesToLoad){
  var runBlocks = [];
  forEach(modulesToLoad, function(module) {
    if (loadedModules.get(module)) return;
    loadedModules.put(module, true);
    if (isString(module)) {
      var moduleFn = angularModule(module);
      runBlocks = runBlocks.concat(loadModules(moduleFn.requires)).concat(moduleFn._runBlocks);

      try {
        for(var invokeQueue = moduleFn._invokeQueue, i = 0, ii = invokeQueue.length; i < ii; i++) {
          var invokeArgs = invokeQueue[i],
              provider = invokeArgs[0] == '$injector'
                  ? providerInjector
                  : providerInjector.get(invokeArgs[0]);

          provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
        }
      } catch (e) {
        if (e.message) e.message += ' from ' + module;
        throw e;
      }
    } else if (isFunction(module)) {
      try {
        runBlocks.push(providerInjector.invoke(module));
      } catch (e) {
        if (e.message) e.message += ' from ' + module;
        throw e;
      }
    } else if (isArray(module)) {
      try {
        runBlocks.push(providerInjector.invoke(module));
      } catch (e) {
        if (e.message) e.message += ' from ' + String(module[module.length - 1]);
        throw e;
      }
    } else {
      assertArgFn(module, 'module');
    }
  });
  return runBlocks;
}

////////////////////////////////////
// internal Injector
////////////////////////////////////

function createInternalInjector(cache, factory) {

  function getService(serviceName) {
    if (typeof serviceName !== 'string') {
      throw Error('Service name expected');
    }
    if (cache.hasOwnProperty(serviceName)) {
      if (cache[serviceName] === INSTANTIATING) {
        throw Error('Circular dependency: ' + path.join(' <- '));
      }
      return cache[serviceName];
    } else {
      try {
        path.unshift(serviceName);
        cache[serviceName] = INSTANTIATING;
        return cache[serviceName] = factory(serviceName);
      } finally {
        path.shift();
      }
    }
  }

  function invoke(fn, self, locals){
    var args = [],
        $inject = annotate(fn),
        length, i,
        key;

    for(i = 0, length = $inject.length; i < length; i++) {
      key = $inject[i];
      args.push(
        locals && locals.hasOwnProperty(key)
        ? locals[key]
        : getService(key)
      );
    }
    if (!fn.$inject) {
      // this means that we must be an array.
      fn = fn[length];
    }

    // Performance optimization: http://jsperf.com/apply-vs-call-vs-invoke
    switch (self ? -1 : args.length) {
      case  0: return fn();
      case  1: return fn(args[0]);
      case  2: return fn(args[0], args[1]);
      case  3: return fn(args[0], args[1], args[2]);
      case  4: return fn(args[0], args[1], args[2], args[3]);
      case  5: return fn(args[0], args[1], args[2], args[3], args[4]);
      case  6: return fn(args[0], args[1], args[2], args[3], args[4], args[5]);
      case  7: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
      case  8: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
      case  9: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
      case 10: return fn(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8], args[9]);
      default: return fn.apply(self, args);
    }
  }

  function instantiate(Type, locals) {
    var Constructor = function() {},
        instance, returnedValue;

    Constructor.prototype = (isArray(Type) ? Type[Type.length - 1] : Type).prototype;
    instance = new Constructor();
    returnedValue = invoke(Type, instance, locals);

    return isObject(returnedValue) ? returnedValue : instance;
  }

  return {
    invoke: invoke,
    instantiate: instantiate,
    get: getService,
    annotate: annotate
  };
}

}

/**

* @ngdoc function
* @name ng.$anchorScroll
* @requires $window
* @requires $location
* @requires $rootScope
*
* @description
* When called, it checks current value of `$location.hash()` and scroll to related element,
* according to rules specified in
* {@link http://dev.w3.org/html5/spec/Overview.html#the-indicated-part-of-the-document Html5 spec}.
*
* It also watches the `$location.hash()` and scroll whenever it changes to match any anchor.
* This can be disabled by calling `$anchorScrollProvider.disableAutoScrolling()`.
*/

function $AnchorScrollProvider() {

var autoScrollingEnabled = true;

this.disableAutoScrolling = function() {
  autoScrollingEnabled = false;
};

this.$get = ['$window', '$location', '$rootScope', function($window, $location, $rootScope) {
  var document = $window.document;

  // helper function to get first anchor from a NodeList
  // can't use filter.filter, as it accepts only instances of Array
  // and IE can't convert NodeList to an array using [].slice
  // TODO(vojta): use filter if we change it to accept lists as well
  function getFirstAnchor(list) {
    var result = null;
    forEach(list, function(element) {
      if (!result && lowercase(element.nodeName) === 'a') result = element;
    });
    return result;
  }

  function scroll() {
    var hash = $location.hash(), elm;

    // empty hash, scroll to the top of the page
    if (!hash) $window.scrollTo(0, 0);

    // element with given id
    else if ((elm = document.getElementById(hash))) elm.scrollIntoView();

    // first anchor with given name :-D
    else if ((elm = getFirstAnchor(document.getElementsByName(hash)))) elm.scrollIntoView();

    // no element and hash == 'top', scroll to the top of the page
    else if (hash === 'top') $window.scrollTo(0, 0);
  }

  // does not scroll when user clicks on anchor link that is currently on
  // (no url change, no $location.hash() change), browser native does scroll
  if (autoScrollingEnabled) {
    $rootScope.$watch(function autoScrollWatch() {return $location.hash();},
      function autoScrollWatchAction() {
        $rootScope.$evalAsync(scroll);
      });
  }

  return scroll;
}];

}

/**

* ! This is a private undocumented service !
*
* @name ng.$browser
* @requires $log
* @description
* This object has two goals:
*
* - hide all the global state in the browser caused by the window object
* - abstract away all the browser specific features and inconsistencies
*
* For tests we provide {@link ngMock.$browser mock implementation} of the `$browser`
* service, which can be used for convenient testing of the application without the interaction with
* the real browser apis.
*/

/**

* @param {object} window The global window object.
* @param {object} document jQuery wrapped document.
* @param {function()} XHR XMLHttpRequest constructor.
* @param {object} $log console.log or an object with the same interface.
* @param {object} $sniffer $sniffer service
*/

function Browser(window, document, $log, $sniffer) {

var self = this,
    rawDocument = document[0],
    location = window.location,
    history = window.history,
    setTimeout = window.setTimeout,
    clearTimeout = window.clearTimeout,
    pendingDeferIds = {};

self.isMock = false;

var outstandingRequestCount = 0;
var outstandingRequestCallbacks = [];

// TODO(vojta): remove this temporary api
self.$$completeOutstandingRequest = completeOutstandingRequest;
self.$$incOutstandingRequestCount = function() { outstandingRequestCount++; };

/**
 * Executes the `fn` function(supports currying) and decrements the `outstandingRequestCallbacks`
 * counter. If the counter reaches 0, all the `outstandingRequestCallbacks` are executed.
 */
function completeOutstandingRequest(fn) {
  try {
    fn.apply(null, sliceArgs(arguments, 1));
  } finally {
    outstandingRequestCount--;
    if (outstandingRequestCount === 0) {
      while(outstandingRequestCallbacks.length) {
        try {
          outstandingRequestCallbacks.pop()();
        } catch (e) {
          $log.error(e);
        }
      }
    }
  }
}

/**
 * @private
 * Note: this method is used only by scenario runner
 * TODO(vojta): prefix this method with $$ ?
 * @param {function()} callback Function that will be called when no outstanding request
 */
self.notifyWhenNoOutstandingRequests = function(callback) {
  // force browser to execute all pollFns - this is needed so that cookies and other pollers fire
  // at some deterministic time in respect to the test runner's actions. Leaving things up to the
  // regular poller would result in flaky tests.
  forEach(pollFns, function(pollFn){ pollFn(); });

  if (outstandingRequestCount === 0) {
    callback();
  } else {
    outstandingRequestCallbacks.push(callback);
  }
};

//////////////////////////////////////////////////////////////
// Poll Watcher API
//////////////////////////////////////////////////////////////
var pollFns = [],
    pollTimeout;

/**
 * @name ng.$browser#addPollFn
 * @methodOf ng.$browser
 *
 * @param {function()} fn Poll function to add
 *
 * @description
 * Adds a function to the list of functions that poller periodically executes,
 * and starts polling if not started yet.
 *
 * @returns {function()} the added function
 */
self.addPollFn = function(fn) {
  if (isUndefined(pollTimeout)) startPoller(100, setTimeout);
  pollFns.push(fn);
  return fn;
};

/**
 * @param {number} interval How often should browser call poll functions (ms)
 * @param {function()} setTimeout Reference to a real or fake `setTimeout` function.
 *
 * @description
 * Configures the poller to run in the specified intervals, using the specified
 * setTimeout fn and kicks it off.
 */
function startPoller(interval, setTimeout) {
  (function check() {
    forEach(pollFns, function(pollFn){ pollFn(); });
    pollTimeout = setTimeout(check, interval);
  })();
}

//////////////////////////////////////////////////////////////
// URL API
//////////////////////////////////////////////////////////////

var lastBrowserUrl = location.href,
    baseElement = document.find('base');

/**
 * @name ng.$browser#url
 * @methodOf ng.$browser
 *
 * @description
 * GETTER:
 * Without any argument, this method just returns current value of location.href.
 *
 * SETTER:
 * With at least one argument, this method sets url to new value.
 * If html5 history api supported, pushState/replaceState is used, otherwise
 * location.href/location.replace is used.
 * Returns its own instance to allow chaining
 *
 * NOTE: this api is intended for use only by the $location service. Please use the
 * {@link ng.$location $location service} to change url.
 *
 * @param {string} url New url (when used as setter)
 * @param {boolean=} replace Should new url replace current history record ?
 */
self.url = function(url, replace) {
  // setter
  if (url) {
    if (lastBrowserUrl == url) return;
    lastBrowserUrl = url;
    if ($sniffer.history) {
      if (replace) history.replaceState(null, '', url);
      else {
        history.pushState(null, '', url);
        // Crazy Opera Bug: http://my.opera.com/community/forums/topic.dml?id=1185462
        baseElement.attr('href', baseElement.attr('href'));
      }
    } else {
      if (replace) location.replace(url);
      else location.href = url;
    }
    return self;
  // getter
  } else {
    // the replacement is a workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=407172
    return location.href.replace(/%27/g,"'");
  }
};

var urlChangeListeners = [],
    urlChangeInit = false;

function fireUrlChange() {
  if (lastBrowserUrl == self.url()) return;

  lastBrowserUrl = self.url();
  forEach(urlChangeListeners, function(listener) {
    listener(self.url());
  });
}

/**
 * @name ng.$browser#onUrlChange
 * @methodOf ng.$browser
 * @TODO(vojta): refactor to use node's syntax for events
 *
 * @description
 * Register callback function that will be called, when url changes.
 *
 * It's only called when the url is changed by outside of angular:
 * - user types different url into address bar
 * - user clicks on history (forward/back) button
 * - user clicks on a link
 *
 * It's not called when url is changed by $browser.url() method
 *
 * The listener gets called with new url as parameter.
 *
 * NOTE: this api is intended for use only by the $location service. Please use the
 * {@link ng.$location $location service} to monitor url changes in angular apps.
 *
 * @param {function(string)} listener Listener function to be called when url changes.
 * @return {function(string)} Returns the registered listener fn - handy if the fn is anonymous.
 */
self.onUrlChange = function(callback) {
  if (!urlChangeInit) {
    // We listen on both (hashchange/popstate) when available, as some browsers (e.g. Opera)
    // don't fire popstate when user change the address bar and don't fire hashchange when url
    // changed by push/replaceState

    // html5 history api - popstate event
    if ($sniffer.history) jqLite(window).bind('popstate', fireUrlChange);
    // hashchange event
    if ($sniffer.hashchange) jqLite(window).bind('hashchange', fireUrlChange);
    // polling
    else self.addPollFn(fireUrlChange);

    urlChangeInit = true;
  }

  urlChangeListeners.push(callback);
  return callback;
};

//////////////////////////////////////////////////////////////
// Misc API
//////////////////////////////////////////////////////////////

/**
 * Returns current <base href>
 * (always relative - without domain)
 *
 * @returns {string=}
 */
self.baseHref = function() {
  var href = baseElement.attr('href');
  return href ? href.replace(/^https?\:\/\/[^\/]*/, '') : '';
};

//////////////////////////////////////////////////////////////
// Cookies API
//////////////////////////////////////////////////////////////
var lastCookies = {};
var lastCookieString = '';
var cookiePath = self.baseHref();

/**
 * @name ng.$browser#cookies
 * @methodOf ng.$browser
 *
 * @param {string=} name Cookie name
 * @param {string=} value Cokkie value
 *
 * @description
 * The cookies method provides a 'private' low level access to browser cookies.
 * It is not meant to be used directly, use the $cookie service instead.
 *
 * The return values vary depending on the arguments that the method was called with as follows:
 * <ul>
 *   <li>cookies() -> hash of all cookies, this is NOT a copy of the internal state, so do not modify it</li>
 *   <li>cookies(name, value) -> set name to value, if value is undefined delete the cookie</li>
 *   <li>cookies(name) -> the same as (name, undefined) == DELETES (no one calls it right now that way)</li>
 * </ul>
 *
 * @returns {Object} Hash of all cookies (if called without any parameter)
 */
self.cookies = function(name, value) {
  var cookieLength, cookieArray, cookie, i, index;

  if (name) {
    if (value === undefined) {
      rawDocument.cookie = escape(name) + "=;path=" + cookiePath + ";expires=Thu, 01 Jan 1970 00:00:00 GMT";
    } else {
      if (isString(value)) {
        cookieLength = (rawDocument.cookie = escape(name) + '=' + escape(value) + ';path=' + cookiePath).length + 1;

        // per http://www.ietf.org/rfc/rfc2109.txt browser must allow at minimum:
        // - 300 cookies
        // - 20 cookies per unique domain
        // - 4096 bytes per cookie
        if (cookieLength > 4096) {
          $log.warn("Cookie '"+ name +"' possibly not set or overflowed because it was too large ("+
            cookieLength + " > 4096 bytes)!");
        }
      }
    }
  } else {
    if (rawDocument.cookie !== lastCookieString) {
      lastCookieString = rawDocument.cookie;
      cookieArray = lastCookieString.split("; ");
      lastCookies = {};

      for (i = 0; i < cookieArray.length; i++) {
        cookie = cookieArray[i];
        index = cookie.indexOf('=');
        if (index > 0) { //ignore nameless cookies
          lastCookies[unescape(cookie.substring(0, index))] = unescape(cookie.substring(index + 1));
        }
      }
    }
    return lastCookies;
  }
};

/**
 * @name ng.$browser#defer
 * @methodOf ng.$browser
 * @param {function()} fn A function, who's execution should be defered.
 * @param {number=} [delay=0] of milliseconds to defer the function execution.
 * @returns {*} DeferId that can be used to cancel the task via `$browser.defer.cancel()`.
 *
 * @description
 * Executes a fn asynchroniously via `setTimeout(fn, delay)`.
 *
 * Unlike when calling `setTimeout` directly, in test this function is mocked and instead of using
 * `setTimeout` in tests, the fns are queued in an array, which can be programmatically flushed
 * via `$browser.defer.flush()`.
 *
 */
self.defer = function(fn, delay) {
  var timeoutId;
  outstandingRequestCount++;
  timeoutId = setTimeout(function() {
    delete pendingDeferIds[timeoutId];
    completeOutstandingRequest(fn);
  }, delay || 0);
  pendingDeferIds[timeoutId] = true;
  return timeoutId;
};

/**
 * @name ng.$browser#defer.cancel
 * @methodOf ng.$browser.defer
 *
 * @description
 * Cancels a defered task identified with `deferId`.
 *
 * @param {*} deferId Token returned by the `$browser.defer` function.
 * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfuly canceled.
 */
self.defer.cancel = function(deferId) {
  if (pendingDeferIds[deferId]) {
    delete pendingDeferIds[deferId];
    clearTimeout(deferId);
    completeOutstandingRequest(noop);
    return true;
  }
  return false;
};

}

function $BrowserProvider(){

this.$get = ['$window', '$log', '$sniffer', '$document',
    function( $window,   $log,   $sniffer,   $document){
      return new Browser($window, $document, $log, $sniffer);
    }];

}

/**

* @ngdoc object
* @name ng.$cacheFactory
*
* @description
* Factory that constructs cache objects.
*
*
* @param {string} cacheId Name or id of the newly created cache.
* @param {object=} options Options object that specifies the cache behavior. Properties:
*
*   - `{number=}` `capacity` — turns the cache into LRU cache.
*
* @returns {object} Newly created cache object with the following set of methods:
*
* - `{object}` `info()` — Returns id, size, and options of cache.
* - `{void}` `put({string} key, {*} value)` — Puts a new key-value pair into the cache.
* - `{{*}}` `get({string} key)` — Returns cached value for `key` or undefined for cache miss.
* - `{void}` `remove({string} key)` — Removes a key-value pair from the cache.
* - `{void}` `removeAll()` — Removes all cached values.
* - `{void}` `destroy()` — Removes references to this cache from $cacheFactory.
*
*/

function $CacheFactoryProvider() {

this.$get = function() {
  var caches = {};

  function cacheFactory(cacheId, options) {
    if (cacheId in caches) {
      throw Error('cacheId ' + cacheId + ' taken');
    }

    var size = 0,
        stats = extend({}, options, {id: cacheId}),
        data = {},
        capacity = (options && options.capacity) || Number.MAX_VALUE,
        lruHash = {},
        freshEnd = null,
        staleEnd = null;

    return caches[cacheId] = {

      put: function(key, value) {
        var lruEntry = lruHash[key] || (lruHash[key] = {key: key});

        refresh(lruEntry);

        if (isUndefined(value)) return;
        if (!(key in data)) size++;
        data[key] = value;

        if (size > capacity) {
          this.remove(staleEnd.key);
        }
      },

      get: function(key) {
        var lruEntry = lruHash[key];

        if (!lruEntry) return;

        refresh(lruEntry);

        return data[key];
      },

      remove: function(key) {
        var lruEntry = lruHash[key];

        if (!lruEntry) return;

        if (lruEntry == freshEnd) freshEnd = lruEntry.p;
        if (lruEntry == staleEnd) staleEnd = lruEntry.n;
        link(lruEntry.n,lruEntry.p);

        delete lruHash[key];
        delete data[key];
        size--;
      },

      removeAll: function() {
        data = {};
        size = 0;
        lruHash = {};
        freshEnd = staleEnd = null;
      },

      destroy: function() {
        data = null;
        stats = null;
        lruHash = null;
        delete caches[cacheId];
      },

      info: function() {
        return extend({}, stats, {size: size});
      }
    };

    /**
     * makes the `entry` the freshEnd of the LRU linked list
     */
    function refresh(entry) {
      if (entry != freshEnd) {
        if (!staleEnd) {
          staleEnd = entry;
        } else if (staleEnd == entry) {
          staleEnd = entry.n;
        }

        link(entry.n, entry.p);
        link(entry, freshEnd);
        freshEnd = entry;
        freshEnd.n = null;
      }
    }

    /**
     * bidirectionally links two entries of the LRU linked list
     */
    function link(nextEntry, prevEntry) {
      if (nextEntry != prevEntry) {
        if (nextEntry) nextEntry.p = prevEntry; //p stands for previous, 'prev' didn't minify
        if (prevEntry) prevEntry.n = nextEntry; //n stands for next, 'next' didn't minify
      }
    }
  }

  cacheFactory.info = function() {
    var info = {};
    forEach(caches, function(cache, cacheId) {
      info[cacheId] = cache.info();
    });
    return info;
  };

  cacheFactory.get = function(cacheId) {
    return caches[cacheId];
  };

  return cacheFactory;
};

}

/**

* @ngdoc object
* @name ng.$templateCache
*
* @description
* Cache used for storing html templates.
*
* See {@link ng.$cacheFactory $cacheFactory}.
*
*/

function $TemplateCacheProvider() {

this.$get = ['$cacheFactory', function($cacheFactory) {
  return $cacheFactory('templates');
}];

}

/* ! VARIABLE/FUNCTION NAMING CONVENTIONS THAT APPLY TO THIS FILE!

*
* DOM-related variables:
*
* - "node" - DOM Node
* - "element" - DOM Element or Node
* - "$node" or "$element" - jqLite-wrapped node or element
*
*
* Compiler related stuff:
*
* - "linkFn" - linking fn of a single directive
* - "nodeLinkFn" - function that aggregates all linking fns for a particular node
* - "childLinkFn" -  function that aggregates all linking fns for child nodes of a particular node
* - "compositeLinkFn" - function that aggregates all linking fns for a compilation root (nodeList)
*/

var NON_ASSIGNABLE_MODEL_EXPRESSION = 'Non-assignable model expression: ';

/**

* @ngdoc function
* @name ng.$compile
* @function
*
* @description
* Compiles a piece of HTML string or DOM into a template and produces a template function, which
* can then be used to link {@link ng.$rootScope.Scope scope} and the template together.
*
* The compilation is a process of walking the DOM tree and trying to match DOM elements to
* {@link ng.$compileProvider#directive directives}. For each match it
* executes corresponding template function and collects the
* instance functions into a single template function which is then returned.
*
* The template function can then be used once to produce the view or as it is the case with
* {@link ng.directive:ngRepeat repeater} many-times, in which
* case each call results in a view that is a DOM clone of the original template.
*
<doc:example module="compile">
  <doc:source>
   <script>
     // declare a new module, and inject the $compileProvider
     angular.module('compile', [], function($compileProvider) {
       // configure new 'compile' directive by passing a directive
       // factory function. The factory function injects the '$compile'
       $compileProvider.directive('compile', function($compile) {
         // directive factory creates a link function
         return function(scope, element, attrs) {
           scope.$watch(
             function(scope) {
                // watch the 'compile' expression for changes
               return scope.$eval(attrs.compile);
             },
             function(value) {
               // when the 'compile' expression changes
               // assign it into the current DOM
               element.html(value);

               // compile the new DOM and link it to the current
               // scope.
               // NOTE: we only compile .childNodes so that
               // we don't get into infinite loop compiling ourselves
               $compile(element.contents())(scope);
             }
           );
         };
       })
     });

     function Ctrl($scope) {
       $scope.name = 'Angular';
       $scope.html = 'Hello {{name}}';
     }
   </script>
   <div ng-controller="Ctrl">
     <input ng-model="name"> <br>
     <textarea ng-model="html"></textarea> <br>
     <div compile="html"></div>
   </div>
  </doc:source>
  <doc:scenario>
    it('should auto compile', function() {
      expect(element('div[compile]').text()).toBe('Hello Angular');
      input('html').enter('{{name}}!');
      expect(element('div[compile]').text()).toBe('Angular!');
    });
  </doc:scenario>
</doc:example>

*
*
* @param {string|DOMElement} element Element or HTML string to compile into a template function.
* @param {function(angular.Scope[, cloneAttachFn]} transclude function available to directives.
* @param {number} maxPriority only apply directives lower then given priority (Only effects the
*                 root element(s), not their children)
* @returns {function(scope[, cloneAttachFn])} a link function which is used to bind template
* (a DOM element/tree) to a scope. Where:
*
*  * `scope` - A {@link ng.$rootScope.Scope Scope} to bind to.
*  * `cloneAttachFn` - If `cloneAttachFn` is provided, then the link function will clone the
*               `template` and call the `cloneAttachFn` function allowing the caller to attach the
*               cloned elements to the DOM document at the appropriate place. The `cloneAttachFn` is
*               called as: <br> `cloneAttachFn(clonedElement, scope)` where:
*
*      * `clonedElement` - is a clone of the original `element` passed into the compiler.
*      * `scope` - is the current scope with which the linking function is working with.
*
* Calling the linking function returns the element of the template. It is either the original element
* passed in, or the clone of the element if the `cloneAttachFn` is provided.
*
* After linking the view is not updated until after a call to $digest which typically is done by
* Angular automatically.
*
* If you need access to the bound view, there are two ways to do it:
*
* - If you are not asking the linking function to clone the template, create the DOM element(s)
*   before you send them to the compiler and keep this reference around.
*   <pre>
*     var element = $compile('<p>{{total}}</p>')(scope);
*   </pre>
*
* - if on the other hand, you need the element to be cloned, the view reference from the original
*   example would not point to the clone, but rather to the original template that was cloned. In
*   this case, you can access the clone via the cloneAttachFn:
*   <pre>
*     var templateHTML = angular.element('<p>{{total}}</p>'),
*         scope = ....;
*
*     var clonedElement = $compile(templateHTML)(scope, function(clonedElement, scope) {
*       //attach the clone to DOM document at the right place
*     });
*
*     //now we have reference to the cloned DOM via `clone`
*   </pre>
*
*
* For information on how the compiler works, see the
* {@link guide/compiler Angular HTML Compiler} section of the Developer Guide.
*/

/**

* @ngdoc service
* @name ng.$compileProvider
* @function
*
* @description
*/

$CompileProvider.$inject = ['$provide']; function $CompileProvider($provide) {

var hasDirectives = {},
    Suffix = 'Directive',
    COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\d\w\-_]+)\s+(.*)$/,
    CLASS_DIRECTIVE_REGEXP = /(([\d\w\-_]+)(?:\:([^;]+))?;?)/,
    MULTI_ROOT_TEMPLATE_ERROR = 'Template must have exactly one root element. was: ',
    urlSanitizationWhitelist = /^\s*(https?|ftp|mailto|file):/;

/**
 * @ngdoc function
 * @name ng.$compileProvider#directive
 * @methodOf ng.$compileProvider
 * @function
 *
 * @description
 * Register a new directives with the compiler.
 *
 * @param {string} name Name of the directive in camel-case. (ie <code>ngBind</code> which will match as
 *                <code>ng-bind</code>).
 * @param {function} directiveFactory An injectable directive factroy function. See {@link guide/directive} for more
 *                info.
 * @returns {ng.$compileProvider} Self for chaining.
 */
 this.directive = function registerDirective(name, directiveFactory) {
  if (isString(name)) {
    assertArg(directiveFactory, 'directive');
    if (!hasDirectives.hasOwnProperty(name)) {
      hasDirectives[name] = [];
      $provide.factory(name + Suffix, ['$injector', '$exceptionHandler',
        function($injector, $exceptionHandler) {
          var directives = [];
          forEach(hasDirectives[name], function(directiveFactory) {
            try {
              var directive = $injector.invoke(directiveFactory);
              if (isFunction(directive)) {
                directive = { compile: valueFn(directive) };
              } else if (!directive.compile && directive.link) {
                directive.compile = valueFn(directive.link);
              }
              directive.priority = directive.priority || 0;
              directive.name = directive.name || name;
              directive.require = directive.require || (directive.controller && directive.name);
              directive.restrict = directive.restrict || 'A';
              directives.push(directive);
            } catch (e) {
              $exceptionHandler(e);
            }
          });
          return directives;
        }]);
    }
    hasDirectives[name].push(directiveFactory);
  } else {
    forEach(name, reverseParams(registerDirective));
  }
  return this;
};

/**
 * @ngdoc function
 * @name ng.$compileProvider#urlSanitizationWhitelist
 * @methodOf ng.$compileProvider
 * @function
 *
 * @description
 * Retrieves or overrides the default regular expression that is used for whitelisting of safe
 * urls during a[href] sanitization.
 *
 * The sanitization is a security measure aimed at prevent XSS attacks via html links.
 *
 * Any url about to be assigned to a[href] via data-binding is first normalized and turned into an
 * absolute url. Afterwards the url is matched against the `urlSanitizationWhitelist` regular
 * expression. If a match is found the original url is written into the dom. Otherwise the
 * absolute url is prefixed with `'unsafe:'` string and only then it is written into the DOM.
 *
 * @param {RegExp=} regexp New regexp to whitelist urls with.
 * @returns {RegExp|ng.$compileProvider} Current RegExp if called without value or self for
 *    chaining otherwise.
 */
this.urlSanitizationWhitelist = function(regexp) {
  if (isDefined(regexp)) {
    urlSanitizationWhitelist = regexp;
    return this;
  }
  return urlSanitizationWhitelist;
};

this.$get = [
          '$injector', '$interpolate', '$exceptionHandler', '$http', '$templateCache', '$parse',
          '$controller', '$rootScope', '$document',
  function($injector,   $interpolate,   $exceptionHandler,   $http,   $templateCache,   $parse,
           $controller,   $rootScope,   $document) {

  var Attributes = function(element, attr) {
    this.$$element = element;
    this.$attr = attr || {};
  };

  Attributes.prototype = {
    $normalize: directiveNormalize,

    /**
     * Set a normalized attribute on the element in a way such that all directives
     * can share the attribute. This function properly handles boolean attributes.
     * @param {string} key Normalized key. (ie ngAttribute)
     * @param {string|boolean} value The value to set. If `null` attribute will be deleted.
     * @param {boolean=} writeAttr If false, does not write the value to DOM element attribute.
     *     Defaults to true.
     * @param {string=} attrName Optional none normalized name. Defaults to key.
     */
    $set: function(key, value, writeAttr, attrName) {
      var booleanKey = getBooleanAttrName(this.$$element[0], key),
          $$observers = this.$$observers,
          normalizedVal;

      if (booleanKey) {
        this.$$element.prop(key, value);
        attrName = booleanKey;
      }

      this[key] = value;

      // translate normalized key to actual key
      if (attrName) {
        this.$attr[key] = attrName;
      } else {
        attrName = this.$attr[key];
        if (!attrName) {
          this.$attr[key] = attrName = snake_case(key, '-');
        }
      }

      // sanitize a[href] values
      if (nodeName_(this.$$element[0]) === 'A' && key === 'href') {
        urlSanitizationNode.setAttribute('href', value);

        // href property always returns normalized absolute url, so we can match against that
        normalizedVal = urlSanitizationNode.href;
        if (!normalizedVal.match(urlSanitizationWhitelist)) {
          this[key] = value = 'unsafe:' + normalizedVal;
        }
      }

      if (writeAttr !== false) {
        if (value === null || value === undefined) {
          this.$$element.removeAttr(attrName);
        } else {
          this.$$element.attr(attrName, value);
        }
      }

      // fire observers
      $$observers && forEach($$observers[key], function(fn) {
        try {
          fn(value);
        } catch (e) {
          $exceptionHandler(e);
        }
      });
    },

    /**
     * Observe an interpolated attribute.
     * The observer will never be called, if given attribute is not interpolated.
     *
     * @param {string} key Normalized key. (ie ngAttribute) .
     * @param {function(*)} fn Function that will be called whenever the attribute value changes.
     * @returns {function(*)} the `fn` Function passed in.
     */
    $observe: function(key, fn) {
      var attrs = this,
          $$observers = (attrs.$$observers || (attrs.$$observers = {})),
          listeners = ($$observers[key] || ($$observers[key] = []));

      listeners.push(fn);
      $rootScope.$evalAsync(function() {
        if (!listeners.$$inter) {
          // no one registered attribute interpolation function, so lets call it manually
          fn(attrs[key]);
        }
      });
      return fn;
    }
  };

  var urlSanitizationNode = $document[0].createElement('a'),
      startSymbol = $interpolate.startSymbol(),
      endSymbol = $interpolate.endSymbol(),
      denormalizeTemplate = (startSymbol == '{{' || endSymbol  == '}}')
          ? identity
          : function denormalizeTemplate(template) {
            return template.replace(/\{\{/g, startSymbol).replace(/}}/g, endSymbol);
          };

  return compile;

  //================================

  function compile($compileNodes, transcludeFn, maxPriority) {
    if (!($compileNodes instanceof jqLite)) {
      // jquery always rewraps, whereas we need to preserve the original selector so that we can modify it.
      $compileNodes = jqLite($compileNodes);
    }
    // We can not compile top level text elements since text nodes can be merged and we will
    // not be able to attach scope data to them, so we will wrap them in <span>
    forEach($compileNodes, function(node, index){
      if (node.nodeType == 3 /* text node */ && node.nodeValue.match(/\S+/) /* non-empty */ ) {
        $compileNodes[index] = jqLite(node).wrap('<span></span>').parent()[0];
      }
    });
    var compositeLinkFn = compileNodes($compileNodes, transcludeFn, $compileNodes, maxPriority);
    return function publicLinkFn(scope, cloneConnectFn){
      assertArg(scope, 'scope');
      // important!!: we must call our jqLite.clone() since the jQuery one is trying to be smart
      // and sometimes changes the structure of the DOM.
      var $linkNode = cloneConnectFn
        ? JQLitePrototype.clone.call($compileNodes) // IMPORTANT!!!
        : $compileNodes;

      // Attach scope only to non-text nodes.
      for(var i = 0, ii = $linkNode.length; i<ii; i++) {
        var node = $linkNode[i];
        if (node.nodeType == 1 /* element */ || node.nodeType == 9 /* document */) {
          $linkNode.eq(i).data('$scope', scope);
        }
      }
      safeAddClass($linkNode, 'ng-scope');
      if (cloneConnectFn) cloneConnectFn($linkNode, scope);
      if (compositeLinkFn) compositeLinkFn(scope, $linkNode, $linkNode);
      return $linkNode;
    };
  }

  function wrongMode(localName, mode) {
    throw Error("Unsupported '" + mode + "' for '" + localName + "'.");
  }

  function safeAddClass($element, className) {
    try {
      $element.addClass(className);
    } catch(e) {
      // ignore, since it means that we are trying to set class on
      // SVG element, where class name is read-only.
    }
  }

  /**
   * Compile function matches each node in nodeList against the directives. Once all directives
   * for a particular node are collected their compile functions are executed. The compile
   * functions return values - the linking functions - are combined into a composite linking
   * function, which is the a linking function for the node.
   *
   * @param {NodeList} nodeList an array of nodes or NodeList to compile
   * @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the
   *        scope argument is auto-generated to the new child of the transcluded parent scope.
   * @param {DOMElement=} $rootElement If the nodeList is the root of the compilation tree then the
   *        rootElement must be set the jqLite collection of the compile root. This is
   *        needed so that the jqLite collection items can be replaced with widgets.
   * @param {number=} max directive priority
   * @returns {?function} A composite linking function of all of the matched directives or null.
   */
  function compileNodes(nodeList, transcludeFn, $rootElement, maxPriority) {
    var linkFns = [],
        nodeLinkFn, childLinkFn, directives, attrs, linkFnFound;

    for(var i = 0; i < nodeList.length; i++) {
      attrs = new Attributes();

      // we must always refer to nodeList[i] since the nodes can be replaced underneath us.
      directives = collectDirectives(nodeList[i], [], attrs, maxPriority);

      nodeLinkFn = (directives.length)
          ? applyDirectivesToNode(directives, nodeList[i], attrs, transcludeFn, $rootElement)
          : null;

      childLinkFn = (nodeLinkFn && nodeLinkFn.terminal || !nodeList[i].childNodes || !nodeList[i].childNodes.length)
          ? null
          : compileNodes(nodeList[i].childNodes,
               nodeLinkFn ? nodeLinkFn.transclude : transcludeFn);

      linkFns.push(nodeLinkFn);
      linkFns.push(childLinkFn);
      linkFnFound = (linkFnFound || nodeLinkFn || childLinkFn);
    }

    // return a linking function if we have found anything, null otherwise
    return linkFnFound ? compositeLinkFn : null;

    function compositeLinkFn(scope, nodeList, $rootElement, boundTranscludeFn) {
      var nodeLinkFn, childLinkFn, node, childScope, childTranscludeFn, i, ii, n;

      // copy nodeList so that linking doesn't break due to live list updates.
      var stableNodeList = [];
      for (i = 0, ii = nodeList.length; i < ii; i++) {
        stableNodeList.push(nodeList[i]);
      }

      for(i = 0, n = 0, ii = linkFns.length; i < ii; n++) {
        node = stableNodeList[n];
        nodeLinkFn = linkFns[i++];
        childLinkFn = linkFns[i++];

        if (nodeLinkFn) {
          if (nodeLinkFn.scope) {
            childScope = scope.$new(isObject(nodeLinkFn.scope));
            jqLite(node).data('$scope', childScope);
          } else {
            childScope = scope;
          }
          childTranscludeFn = nodeLinkFn.transclude;
          if (childTranscludeFn || (!boundTranscludeFn && transcludeFn)) {
            nodeLinkFn(childLinkFn, childScope, node, $rootElement,
                (function(transcludeFn) {
                  return function(cloneFn) {
                    var transcludeScope = scope.$new();
                    transcludeScope.$$transcluded = true;

                    return transcludeFn(transcludeScope, cloneFn).
                        bind('$destroy', bind(transcludeScope, transcludeScope.$destroy));
                  };
                })(childTranscludeFn || transcludeFn)
            );
          } else {
            nodeLinkFn(childLinkFn, childScope, node, undefined, boundTranscludeFn);
          }
        } else if (childLinkFn) {
          childLinkFn(scope, node.childNodes, undefined, boundTranscludeFn);
        }
      }
    }
  }

  /**
   * Looks for directives on the given node and adds them to the directive collection which is
   * sorted.
   *
   * @param node Node to search.
   * @param directives An array to which the directives are added to. This array is sorted before
   *        the function returns.
   * @param attrs The shared attrs object which is used to populate the normalized attributes.
   * @param {number=} maxPriority Max directive priority.
   */
  function collectDirectives(node, directives, attrs, maxPriority) {
    var nodeType = node.nodeType,
        attrsMap = attrs.$attr,
        match,
        className;

    switch(nodeType) {
      case 1: /* Element */
        // use the node name: <directive>
        addDirective(directives,
            directiveNormalize(nodeName_(node).toLowerCase()), 'E', maxPriority);

        // iterate over the attributes
        for (var attr, name, nName, value, nAttrs = node.attributes,
                 j = 0, jj = nAttrs && nAttrs.length; j < jj; j++) {
          attr = nAttrs[j];
          if (attr.specified) {
            name = attr.name;
            nName = directiveNormalize(name.toLowerCase());
            attrsMap[nName] = name;
            attrs[nName] = value = trim((msie && name == 'href')
              ? decodeURIComponent(node.getAttribute(name, 2))
              : attr.value);
            if (getBooleanAttrName(node, nName)) {
              attrs[nName] = true; // presence means true
            }
            addAttrInterpolateDirective(node, directives, value, nName);
            addDirective(directives, nName, 'A', maxPriority);
          }
        }

        // use class as directive
        className = node.className;
        if (isString(className) && className !== '') {
          while (match = CLASS_DIRECTIVE_REGEXP.exec(className)) {
            nName = directiveNormalize(match[2]);
            if (addDirective(directives, nName, 'C', maxPriority)) {
              attrs[nName] = trim(match[3]);
            }
            className = className.substr(match.index + match[0].length);
          }
        }
        break;
      case 3: /* Text Node */
        addTextInterpolateDirective(directives, node.nodeValue);
        break;
      case 8: /* Comment */
        try {
          match = COMMENT_DIRECTIVE_REGEXP.exec(node.nodeValue);
          if (match) {
            nName = directiveNormalize(match[1]);
            if (addDirective(directives, nName, 'M', maxPriority)) {
              attrs[nName] = trim(match[2]);
            }
          }
        } catch (e) {
          // turns out that under some circumstances IE9 throws errors when one attempts to read comment's node value.
          // Just ignore it and continue. (Can't seem to reproduce in test case.)
        }
        break;
    }

    directives.sort(byPriority);
    return directives;
  }

  /**
   * Once the directives have been collected their compile functions is executed. This method
   * is responsible for inlining directive templates as well as terminating the application
   * of the directives if the terminal directive has been reached..
   *
   * @param {Array} directives Array of collected directives to execute their compile function.
   *        this needs to be pre-sorted by priority order.
   * @param {Node} compileNode The raw DOM node to apply the compile functions to
   * @param {Object} templateAttrs The shared attribute function
   * @param {function(angular.Scope[, cloneAttachFn]} transcludeFn A linking function, where the
   *        scope argument is auto-generated to the new child of the transcluded parent scope.
   * @param {DOMElement} $rootElement If we are working on the root of the compile tree then this
   *        argument has the root jqLite array so that we can replace widgets on it.
   * @returns linkFn
   */
  function applyDirectivesToNode(directives, compileNode, templateAttrs, transcludeFn, $rootElement) {
    var terminalPriority = -Number.MAX_VALUE,
        preLinkFns = [],
        postLinkFns = [],
        newScopeDirective = null,
        newIsolateScopeDirective = null,
        templateDirective = null,
        $compileNode = templateAttrs.$$element = jqLite(compileNode),
        directive,
        directiveName,
        $template,
        transcludeDirective,
        childTranscludeFn = transcludeFn,
        controllerDirectives,
        linkFn,
        directiveValue;

    // executes all directives on the current element
    for(var i = 0, ii = directives.length; i < ii; i++) {
      directive = directives[i];
      $template = undefined;

      if (terminalPriority > directive.priority) {
        break; // prevent further processing of directives
      }

      if (directiveValue = directive.scope) {
        assertNoDuplicate('isolated scope', newIsolateScopeDirective, directive, $compileNode);
        if (isObject(directiveValue)) {
          safeAddClass($compileNode, 'ng-isolate-scope');
          newIsolateScopeDirective = directive;
        }
        safeAddClass($compileNode, 'ng-scope');
        newScopeDirective = newScopeDirective || directive;
      }

      directiveName = directive.name;

      if (directiveValue = directive.controller) {
        controllerDirectives = controllerDirectives || {};
        assertNoDuplicate("'" + directiveName + "' controller",
            controllerDirectives[directiveName], directive, $compileNode);
        controllerDirectives[directiveName] = directive;
      }

      if (directiveValue = directive.transclude) {
        assertNoDuplicate('transclusion', transcludeDirective, directive, $compileNode);
        transcludeDirective = directive;
        terminalPriority = directive.priority;
        if (directiveValue == 'element') {
          $template = jqLite(compileNode);
          $compileNode = templateAttrs.$$element =
              jqLite(document.createComment(' ' + directiveName + ': ' + templateAttrs[directiveName] + ' '));
          compileNode = $compileNode[0];
          replaceWith($rootElement, jqLite($template[0]), compileNode);
          childTranscludeFn = compile($template, transcludeFn, terminalPriority);
        } else {
          $template = jqLite(JQLiteClone(compileNode)).contents();
          $compileNode.html(''); // clear contents
          childTranscludeFn = compile($template, transcludeFn);
        }
      }

      if ((directiveValue = directive.template)) {
        assertNoDuplicate('template', templateDirective, directive, $compileNode);
        templateDirective = directive;
        directiveValue = denormalizeTemplate(directiveValue);

        if (directive.replace) {
          $template = jqLite('<div>' +
                               trim(directiveValue) +
                             '</div>').contents();
          compileNode = $template[0];

          if ($template.length != 1 || compileNode.nodeType !== 1) {
            throw new Error(MULTI_ROOT_TEMPLATE_ERROR + directiveValue);
          }

          replaceWith($rootElement, $compileNode, compileNode);

          var newTemplateAttrs = {$attr: {}};

          // combine directives from the original node and from the template:
          // - take the array of directives for this element
          // - split it into two parts, those that were already applied and those that weren't
          // - collect directives from the template, add them to the second group and sort them
          // - append the second group with new directives to the first group
          directives = directives.concat(
              collectDirectives(
                  compileNode,
                  directives.splice(i + 1, directives.length - (i + 1)),
                  newTemplateAttrs
              )
          );
          mergeTemplateAttributes(templateAttrs, newTemplateAttrs);

          ii = directives.length;
        } else {
          $compileNode.html(directiveValue);
        }
      }

      if (directive.templateUrl) {
        assertNoDuplicate('template', templateDirective, directive, $compileNode);
        templateDirective = directive;
        nodeLinkFn = compileTemplateUrl(directives.splice(i, directives.length - i),
            nodeLinkFn, $compileNode, templateAttrs, $rootElement, directive.replace,
            childTranscludeFn);
        ii = directives.length;
      } else if (directive.compile) {
        try {
          linkFn = directive.compile($compileNode, templateAttrs, childTranscludeFn);
          if (isFunction(linkFn)) {
            addLinkFns(null, linkFn);
          } else if (linkFn) {
            addLinkFns(linkFn.pre, linkFn.post);
          }
        } catch (e) {
          $exceptionHandler(e, startingTag($compileNode));
        }
      }

      if (directive.terminal) {
        nodeLinkFn.terminal = true;
        terminalPriority = Math.max(terminalPriority, directive.priority);
      }

    }

    nodeLinkFn.scope = newScopeDirective && newScopeDirective.scope;
    nodeLinkFn.transclude = transcludeDirective && childTranscludeFn;

    // might be normal or delayed nodeLinkFn depending on if templateUrl is present
    return nodeLinkFn;

    ////////////////////

    function addLinkFns(pre, post) {
      if (pre) {
        pre.require = directive.require;
        preLinkFns.push(pre);
      }
      if (post) {
        post.require = directive.require;
        postLinkFns.push(post);
      }
    }

    function getControllers(require, $element) {
      var value, retrievalMethod = 'data', optional = false;
      if (isString(require)) {
        while((value = require.charAt(0)) == '^' || value == '?') {
          require = require.substr(1);
          if (value == '^') {
            retrievalMethod = 'inheritedData';
          }
          optional = optional || value == '?';
        }
        value = $element[retrievalMethod]('$' + require + 'Controller');
        if (!value && !optional) {
          throw Error("No controller: " + require);
        }
        return value;
      } else if (isArray(require)) {
        value = [];
        forEach(require, function(require) {
          value.push(getControllers(require, $element));
        });
      }
      return value;
    }

    function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn) {
      var attrs, $element, i, ii, linkFn, controller;

      if (compileNode === linkNode) {
        attrs = templateAttrs;
      } else {
        attrs = shallowCopy(templateAttrs, new Attributes(jqLite(linkNode), templateAttrs.$attr));
      }
      $element = attrs.$$element;

      if (newIsolateScopeDirective) {
        var LOCAL_REGEXP = /^\s*([@=&])\s*(\w*)\s*$/;

        var parentScope = scope.$parent || scope;

        forEach(newIsolateScopeDirective.scope, function(definiton, scopeName) {
          var match = definiton.match(LOCAL_REGEXP) || [],
              attrName = match[2]|| scopeName,
              mode = match[1], // @, =, or &
              lastValue,
              parentGet, parentSet;

          scope.$$isolateBindings[scopeName] = mode + attrName;

          switch (mode) {

            case '@': {
              attrs.$observe(attrName, function(value) {
                scope[scopeName] = value;
              });
              attrs.$$observers[attrName].$$scope = parentScope;
              break;
            }

            case '=': {
              parentGet = $parse(attrs[attrName]);
              parentSet = parentGet.assign || function() {
                // reset the change, or we will throw this exception on every $digest
                lastValue = scope[scopeName] = parentGet(parentScope);
                throw Error(NON_ASSIGNABLE_MODEL_EXPRESSION + attrs[attrName] +
                    ' (directive: ' + newIsolateScopeDirective.name + ')');
              };
              lastValue = scope[scopeName] = parentGet(parentScope);
              scope.$watch(function parentValueWatch() {
                var parentValue = parentGet(parentScope);

                if (parentValue !== scope[scopeName]) {
                  // we are out of sync and need to copy
                  if (parentValue !== lastValue) {
                    // parent changed and it has precedence
                    lastValue = scope[scopeName] = parentValue;
                  } else {
                    // if the parent can be assigned then do so
                    parentSet(parentScope, parentValue = lastValue = scope[scopeName]);
                  }
                }
                return parentValue;
              });
              break;
            }

            case '&': {
              parentGet = $parse(attrs[attrName]);
              scope[scopeName] = function(locals) {
                return parentGet(parentScope, locals);
              }
              break;
            }

            default: {
              throw Error('Invalid isolate scope definition for directive ' +
                  newIsolateScopeDirective.name + ': ' + definiton);
            }
          }
        });
      }

      if (controllerDirectives) {
        forEach(controllerDirectives, function(directive) {
          var locals = {
            $scope: scope,
            $element: $element,
            $attrs: attrs,
            $transclude: boundTranscludeFn
          };

          controller = directive.controller;
          if (controller == '@') {
            controller = attrs[directive.name];
          }

          $element.data(
              '$' + directive.name + 'Controller',
              $controller(controller, locals));
        });
      }

      // PRELINKING
      for(i = 0, ii = preLinkFns.length; i < ii; i++) {
        try {
          linkFn = preLinkFns[i];
          linkFn(scope, $element, attrs,
              linkFn.require && getControllers(linkFn.require, $element));
        } catch (e) {
          $exceptionHandler(e, startingTag($element));
        }
      }

      // RECURSION
      childLinkFn && childLinkFn(scope, linkNode.childNodes, undefined, boundTranscludeFn);

      // POSTLINKING
      for(i = 0, ii = postLinkFns.length; i < ii; i++) {
        try {
          linkFn = postLinkFns[i];
          linkFn(scope, $element, attrs,
              linkFn.require && getControllers(linkFn.require, $element));
        } catch (e) {
          $exceptionHandler(e, startingTag($element));
        }
      }
    }
  }

  /**
   * looks up the directive and decorates it with exception handling and proper parameters. We
   * call this the boundDirective.
   *
   * @param {string} name name of the directive to look up.
   * @param {string} location The directive must be found in specific format.
   *   String containing any of theses characters:
   *
   *   * `E`: element name
   *   * `A': attribute
   *   * `C`: class
   *   * `M`: comment
   * @returns true if directive was added.
   */
  function addDirective(tDirectives, name, location, maxPriority) {
    var match = false;
    if (hasDirectives.hasOwnProperty(name)) {
      for(var directive, directives = $injector.get(name + Suffix),
          i = 0, ii = directives.length; i<ii; i++) {
        try {
          directive = directives[i];
          if ( (maxPriority === undefined || maxPriority > directive.priority) &&
               directive.restrict.indexOf(location) != -1) {
            tDirectives.push(directive);
            match = true;
          }
        } catch(e) { $exceptionHandler(e); }
      }
    }
    return match;
  }

  /**
   * When the element is replaced with HTML template then the new attributes
   * on the template need to be merged with the existing attributes in the DOM.
   * The desired effect is to have both of the attributes present.
   *
   * @param {object} dst destination attributes (original DOM)
   * @param {object} src source attributes (from the directive template)
   */
  function mergeTemplateAttributes(dst, src) {
    var srcAttr = src.$attr,
        dstAttr = dst.$attr,
        $element = dst.$$element;

    // reapply the old attributes to the new element
    forEach(dst, function(value, key) {
      if (key.charAt(0) != '$') {
        if (src[key]) {
          value += (key === 'style' ? ';' : ' ') + src[key];
        }
        dst.$set(key, value, true, srcAttr[key]);
      }
    });

    // copy the new attributes on the old attrs object
    forEach(src, function(value, key) {
      if (key == 'class') {
        safeAddClass($element, value);
        dst['class'] = (dst['class'] ? dst['class'] + ' ' : '') + value;
      } else if (key == 'style') {
        $element.attr('style', $element.attr('style') + ';' + value);
      } else if (key.charAt(0) != '$' && !dst.hasOwnProperty(key)) {
        dst[key] = value;
        dstAttr[key] = srcAttr[key];
      }
    });
  }

  function compileTemplateUrl(directives, beforeTemplateNodeLinkFn, $compileNode, tAttrs,
      $rootElement, replace, childTranscludeFn) {
    var linkQueue = [],
        afterTemplateNodeLinkFn,
        afterTemplateChildLinkFn,
        beforeTemplateCompileNode = $compileNode[0],
        origAsyncDirective = directives.shift(),
        // The fact that we have to copy and patch the directive seems wrong!
        derivedSyncDirective = extend({}, origAsyncDirective, {
          controller: null, templateUrl: null, transclude: null, scope: null
        });

    $compileNode.html('');

    $http.get(origAsyncDirective.templateUrl, {cache: $templateCache}).
      success(function(content) {
        var compileNode, tempTemplateAttrs, $template;

        content = denormalizeTemplate(content);

        if (replace) {
          $template = jqLite('<div>' + trim(content) + '</div>').contents();
          compileNode = $template[0];

          if ($template.length != 1 || compileNode.nodeType !== 1) {
            throw new Error(MULTI_ROOT_TEMPLATE_ERROR + content);
          }

          tempTemplateAttrs = {$attr: {}};
          replaceWith($rootElement, $compileNode, compileNode);
          collectDirectives(compileNode, directives, tempTemplateAttrs);
          mergeTemplateAttributes(tAttrs, tempTemplateAttrs);
        } else {
          compileNode = beforeTemplateCompileNode;
          $compileNode.html(content);
        }

        directives.unshift(derivedSyncDirective);
        afterTemplateNodeLinkFn = applyDirectivesToNode(directives, compileNode, tAttrs, childTranscludeFn);
        afterTemplateChildLinkFn = compileNodes($compileNode[0].childNodes, childTranscludeFn);

        while(linkQueue.length) {
          var controller = linkQueue.pop(),
              linkRootElement = linkQueue.pop(),
              beforeTemplateLinkNode = linkQueue.pop(),
              scope = linkQueue.pop(),
              linkNode = compileNode;

          if (beforeTemplateLinkNode !== beforeTemplateCompileNode) {
            // it was cloned therefore we have to clone as well.
            linkNode = JQLiteClone(compileNode);
            replaceWith(linkRootElement, jqLite(beforeTemplateLinkNode), linkNode);
          }

          afterTemplateNodeLinkFn(function() {
            beforeTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, linkNode, $rootElement, controller);
          }, scope, linkNode, $rootElement, controller);
        }
        linkQueue = null;
      }).
      error(function(response, code, headers, config) {
        throw Error('Failed to load template: ' + config.url);
      });

    return function delayedNodeLinkFn(ignoreChildLinkFn, scope, node, rootElement, controller) {
      if (linkQueue) {
        linkQueue.push(scope);
        linkQueue.push(node);
        linkQueue.push(rootElement);
        linkQueue.push(controller);
      } else {
        afterTemplateNodeLinkFn(function() {
          beforeTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, node, rootElement, controller);
        }, scope, node, rootElement, controller);
      }
    };
  }

  /**
   * Sorting function for bound directives.
   */
  function byPriority(a, b) {
    return b.priority - a.priority;
  }

  function assertNoDuplicate(what, previousDirective, directive, element) {
    if (previousDirective) {
      throw Error('Multiple directives [' + previousDirective.name + ', ' +
        directive.name + '] asking for ' + what + ' on: ' +  startingTag(element));
    }
  }

  function addTextInterpolateDirective(directives, text) {
    var interpolateFn = $interpolate(text, true);
    if (interpolateFn) {
      directives.push({
        priority: 0,
        compile: valueFn(function textInterpolateLinkFn(scope, node) {
          var parent = node.parent(),
              bindings = parent.data('$binding') || [];
          bindings.push(interpolateFn);
          safeAddClass(parent.data('$binding', bindings), 'ng-binding');
          scope.$watch(interpolateFn, function interpolateFnWatchAction(value) {
            node[0].nodeValue = value;
          });
        })
      });
    }
  }

  function addAttrInterpolateDirective(node, directives, value, name) {
    var interpolateFn = $interpolate(value, true);

    // no interpolation found -> ignore
    if (!interpolateFn) return;

    directives.push({
      priority: 100,
      compile: valueFn(function attrInterpolateLinkFn(scope, element, attr) {
        var $$observers = (attr.$$observers || (attr.$$observers = {}));

        if (name === 'class') {
          // we need to interpolate classes again, in the case the element was replaced
          // and therefore the two class attrs got merged - we want to interpolate the result
          interpolateFn = $interpolate(attr[name], true);
        }

        attr[name] = undefined;
        ($$observers[name] || ($$observers[name] = [])).$$inter = true;
        (attr.$$observers && attr.$$observers[name].$$scope || scope).
          $watch(interpolateFn, function interpolateFnWatchAction(value) {
            attr.$set(name, value);
          });
      })
    });
  }

  /**
   * This is a special jqLite.replaceWith, which can replace items which
   * have no parents, provided that the containing jqLite collection is provided.
   *
   * @param {JqLite=} $rootElement The root of the compile tree. Used so that we can replace nodes
   *    in the root of the tree.
   * @param {JqLite} $element The jqLite element which we are going to replace. We keep the shell,
   *    but replace its DOM node reference.
   * @param {Node} newNode The new DOM node.
   */
  function replaceWith($rootElement, $element, newNode) {
    var oldNode = $element[0],
        parent = oldNode.parentNode,
        i, ii;

    if ($rootElement) {
      for(i = 0, ii = $rootElement.length; i < ii; i++) {
        if ($rootElement[i] == oldNode) {
          $rootElement[i] = newNode;
          break;
        }
      }
    }

    if (parent) {
      parent.replaceChild(newNode, oldNode);
    }

    newNode[jqLite.expando] = oldNode[jqLite.expando];
    $element[0] = newNode;
  }
}];

}

var PREFIX_REGEXP = /^(x|data)/i; /**

* Converts all accepted directives format into proper directive name.
* All of these will become 'myDirective':
*   my:DiRective
*   my-directive
*   x-my-directive
*   data-my:directive
*
* Also there is special case for Moz prefix starting with upper case letter.
* @param name Name to normalize
*/

function directiveNormalize(name) {

return camelCase(name.replace(PREFIX_REGEXP, ''));

}

/**

* @ngdoc object
* @name ng.$compile.directive.Attributes
* @description
*
* A shared object between directive compile / linking functions which contains normalized DOM element
* attributes. The the values reflect current binding state `{{ }}`. The normalization is needed
* since all of these are treated as equivalent in Angular:
*
*          <span ng:bind="a" ng-bind="a" data-ng-bind="a" x-ng-bind="a">
*/

/**

* @ngdoc property
* @name ng.$compile.directive.Attributes#$attr
* @propertyOf ng.$compile.directive.Attributes
* @returns {object} A map of DOM element attribute names to the normalized name. This is
*          needed to do reverse lookup from normalized name back to actual name.
*/

/**

* @ngdoc function
* @name ng.$compile.directive.Attributes#$set
* @methodOf ng.$compile.directive.Attributes
* @function
*
* @description
* Set DOM element attribute value.
*
*
* @param {string} name Normalized element attribute name of the property to modify. The name is
*          revers translated using the {@link ng.$compile.directive.Attributes#$attr $attr}
*          property to the original name.
* @param {string} value Value to set the attribute to.
*/

/**

* Closure compiler type information
*/

function nodesetLinkingFn(

/* angular.Scope */ scope,
/* NodeList */ nodeList,
/* Element */ rootElement,
/* function(Function) */ boundTranscludeFn

){}

function directiveLinkingFn(

/* nodesetLinkingFn */ nodesetLinkingFn,
/* angular.Scope */ scope,
/* Node */ node,
/* Element */ rootElement,
/* function(Function) */ boundTranscludeFn

){}

/**

* @ngdoc object
* @name ng.$controllerProvider
* @description
* The {@link ng.$controller $controller service} is used by Angular to create new
* controllers.
*
* This provider allows controller registration via the
* {@link ng.$controllerProvider#register register} method.
*/

function $ControllerProvider() {

var controllers = {};

/**
 * @ngdoc function
 * @name ng.$controllerProvider#register
 * @methodOf ng.$controllerProvider
 * @param {string} name Controller name
 * @param {Function|Array} constructor Controller constructor fn (optionally decorated with DI
 *    annotations in the array notation).
 */
this.register = function(name, constructor) {
  if (isObject(name)) {
    extend(controllers, name)
  } else {
    controllers[name] = constructor;
  }
};

this.$get = ['$injector', '$window', function($injector, $window) {

  /**
   * @ngdoc function
   * @name ng.$controller
   * @requires $injector
   *
   * @param {Function|string} constructor If called with a function then it's considered to be the
   *    controller constructor function. Otherwise it's considered to be a string which is used
   *    to retrieve the controller constructor using the following steps:
   *
   *    * check if a controller with given name is registered via `$controllerProvider`
   *    * check if evaluating the string on the current scope returns a constructor
   *    * check `window[constructor]` on the global `window` object
   *
   * @param {Object} locals Injection locals for Controller.
   * @return {Object} Instance of given controller.
   *
   * @description
   * `$controller` service is responsible for instantiating controllers.
   *
   * It's just a simple call to {@link AUTO.$injector $injector}, but extracted into
   * a service, so that one can override this service with {@link https://gist.github.com/1649788
   * BC version}.
   */
  return function(constructor, locals) {
    if(isString(constructor)) {
      var name = constructor;
      constructor = controllers.hasOwnProperty(name)
          ? controllers[name]
          : getter(locals.$scope, name, true) || getter($window, name, true);

      assertArgFn(constructor, name, true);
    }

    return $injector.instantiate(constructor, locals);
  };
}];

}

/**

* @ngdoc object
* @name ng.$document
* @requires $window
*
* @description
* A {@link angular.element jQuery (lite)}-wrapped reference to the browser's `window.document`
* element.
*/

function $DocumentProvider(){

this.$get = ['$window', function(window){
  return jqLite(window.document);
}];

}

/**

* @ngdoc function
* @name ng.$exceptionHandler
* @requires $log
*
* @description
* Any uncaught exception in angular expressions is delegated to this service.
* The default implementation simply delegates to `$log.error` which logs it into
* the browser console.
*
* In unit tests, if `angular-mocks.js` is loaded, this service is overridden by
* {@link ngMock.$exceptionHandler mock $exceptionHandler} which aids in testing.
*
* @param {Error} exception Exception associated with the error.
* @param {string=} cause optional information about the context in which
*       the error was thrown.
*
*/

function $ExceptionHandlerProvider() {

this.$get = ['$log', function($log){
  return function(exception, cause) {
    $log.error.apply($log, arguments);
  };
}];

}

/**

* @ngdoc object
* @name ng.$interpolateProvider
* @function
*
* @description
*
* Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
*/

function $InterpolateProvider() {

var startSymbol = '{{';
var endSymbol = '}}';

/**
 * @ngdoc method
 * @name ng.$interpolateProvider#startSymbol
 * @methodOf ng.$interpolateProvider
 * @description
 * Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
 *
 * @param {string=} value new value to set the starting symbol to.
 * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
 */
this.startSymbol = function(value){
  if (value) {
    startSymbol = value;
    return this;
  } else {
    return startSymbol;
  }
};

/**
 * @ngdoc method
 * @name ng.$interpolateProvider#endSymbol
 * @methodOf ng.$interpolateProvider
 * @description
 * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
 *
 * @param {string=} value new value to set the ending symbol to.
 * @returns {string|self} Returns the symbol when used as getter and self if used as setter.
 */
this.endSymbol = function(value){
  if (value) {
    endSymbol = value;
    return this;
  } else {
    return endSymbol;
  }
};

this.$get = ['$parse', function($parse) {
  var startSymbolLength = startSymbol.length,
      endSymbolLength = endSymbol.length;

  /**
   * @ngdoc function
   * @name ng.$interpolate
   * @function
   *
   * @requires $parse
   *
   * @description
   *
   * Compiles a string with markup into an interpolation function. This service is used by the
   * HTML {@link ng.$compile $compile} service for data binding. See
   * {@link ng.$interpolateProvider $interpolateProvider} for configuring the
   * interpolation markup.
   *
   *
     <pre>
       var $interpolate = ...; // injected
       var exp = $interpolate('Hello {{name}}!');
       expect(exp({name:'Angular'}).toEqual('Hello Angular!');
     </pre>
   *
   *
   * @param {string} text The text with markup to interpolate.
   * @param {boolean=} mustHaveExpression if set to true then the interpolation string must have
   *    embedded expression in order to return an interpolation function. Strings with no
   *    embedded expression will return null for the interpolation function.
   * @returns {function(context)} an interpolation function which is used to compute the interpolated
   *    string. The function has these parameters:
   *
   *    * `context`: an object against which any expressions embedded in the strings are evaluated
   *      against.
   *
   */
  function $interpolate(text, mustHaveExpression) {
    var startIndex,
        endIndex,
        index = 0,
        parts = [],
        length = text.length,
        hasInterpolation = false,
        fn,
        exp,
        concat = [];

    while(index < length) {
      if ( ((startIndex = text.indexOf(startSymbol, index)) != -1) &&
           ((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) != -1) ) {
        (index != startIndex) && parts.push(text.substring(index, startIndex));
        parts.push(fn = $parse(exp = text.substring(startIndex + startSymbolLength, endIndex)));
        fn.exp = exp;
        index = endIndex + endSymbolLength;
        hasInterpolation = true;
      } else {
        // we did not find anything, so we have to add the remainder to the parts array
        (index != length) && parts.push(text.substring(index));
        index = length;
      }
    }

    if (!(length = parts.length)) {
      // we added, nothing, must have been an empty string.
      parts.push('');
      length = 1;
    }

    if (!mustHaveExpression  || hasInterpolation) {
      concat.length = length;
      fn = function(context) {
        for(var i = 0, ii = length, part; i<ii; i++) {
          if (typeof (part = parts[i]) == 'function') {
            part = part(context);
            if (part == null || part == undefined) {
              part = '';
            } else if (typeof part != 'string') {
              part = toJson(part);
            }
          }
          concat[i] = part;
        }
        return concat.join('');
      };
      fn.exp = text;
      fn.parts = parts;
      return fn;
    }
  }

  /**
   * @ngdoc method
   * @name ng.$interpolate#startSymbol
   * @methodOf ng.$interpolate
   * @description
   * Symbol to denote the start of expression in the interpolated string. Defaults to `{{`.
   *
   * Use {@link ng.$interpolateProvider#startSymbol $interpolateProvider#startSymbol} to change
   * the symbol.
   *
   * @returns {string} start symbol.
   */
  $interpolate.startSymbol = function() {
    return startSymbol;
  }

  /**
   * @ngdoc method
   * @name ng.$interpolate#endSymbol
   * @methodOf ng.$interpolate
   * @description
   * Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
   *
   * Use {@link ng.$interpolateProvider#endSymbol $interpolateProvider#endSymbol} to change
   * the symbol.
   *
   * @returns {string} start symbol.
   */
  $interpolate.endSymbol = function() {
    return endSymbol;
  }

  return $interpolate;
}];

}

var URL_MATCH = /^([^:]+)://(w+:{0,1}w*@)?({?[w.-]*}?)(:([0-9]+))?(/*)?(?([^#]*))?(#(.*))?$/,

PATH_MATCH = /^([^\?#]*)?(\?([^#]*))?(#(.*))?$/,
HASH_MATCH = PATH_MATCH,
DEFAULT_PORTS = {'http': 80, 'https': 443, 'ftp': 21};

/**

* Encode path using encodeUriSegment, ignoring forward slashes
*
* @param {string} path Path to encode
* @returns {string}
*/

function encodePath(path) {

var segments = path.split('/'),
    i = segments.length;

while (i--) {
  segments[i] = encodeUriSegment(segments[i]);
}

return segments.join('/');

}

function stripHash(url) {

return url.split('#')[0];

}

function matchUrl(url, obj) {

var match = URL_MATCH.exec(url);

match = {
    protocol: match[1],
    host: match[3],
    port: int(match[5]) || DEFAULT_PORTS[match[1]] || null,
    path: match[6] || '/',
    search: match[8],
    hash: match[10]
  };

if (obj) {
  obj.$$protocol = match.protocol;
  obj.$$host = match.host;
  obj.$$port = match.port;
}

return match;

}

function composeProtocolHostPort(protocol, host, port) {

return protocol + '://' + host + (port == DEFAULT_PORTS[protocol] ? '' : ':' + port);

}

function pathPrefixFromBase(basePath) {

return basePath.substr(0, basePath.lastIndexOf('/'));

}

function convertToHtml5Url(url, basePath, hashPrefix) {

var match = matchUrl(url);

// already html5 url
if (decodeURIComponent(match.path) != basePath || isUndefined(match.hash) ||
    match.hash.indexOf(hashPrefix) !== 0) {
  return url;
// convert hashbang url -> html5 url
} else {
  return composeProtocolHostPort(match.protocol, match.host, match.port) +
         pathPrefixFromBase(basePath) + match.hash.substr(hashPrefix.length);
}

}

function convertToHashbangUrl(url, basePath, hashPrefix) {

var match = matchUrl(url);

// already hashbang url
if (decodeURIComponent(match.path) == basePath && !isUndefined(match.hash) &&
    match.hash.indexOf(hashPrefix) === 0) {
  return url;
// convert html5 url -> hashbang url
} else {
  var search = match.search && '?' + match.search || '',
      hash = match.hash && '#' + match.hash || '',
      pathPrefix = pathPrefixFromBase(basePath),
      path = match.path.substr(pathPrefix.length);

  if (match.path.indexOf(pathPrefix) !== 0) {
    throw Error('Invalid url "' + url + '", missing path prefix "' + pathPrefix + '" !');
  }

  return composeProtocolHostPort(match.protocol, match.host, match.port) + basePath +
         '#' + hashPrefix + path + search + hash;
}

}

/**

* LocationUrl represents an url
* This object is exposed as $location service when HTML5 mode is enabled and supported
*
* @constructor
* @param {string} url HTML5 url
* @param {string} pathPrefix
*/

function LocationUrl(url, pathPrefix, appBaseUrl) {

pathPrefix = pathPrefix || '';

/**
 * Parse given html5 (regular) url string into properties
 * @param {string} newAbsoluteUrl HTML5 url
 * @private
 */
this.$$parse = function(newAbsoluteUrl) {
  var match = matchUrl(newAbsoluteUrl, this);

  if (match.path.indexOf(pathPrefix) !== 0) {
    throw Error('Invalid url "' + newAbsoluteUrl + '", missing path prefix "' + pathPrefix + '" !');
  }

  this.$$path = decodeURIComponent(match.path.substr(pathPrefix.length));
  this.$$search = parseKeyValue(match.search);
  this.$$hash = match.hash && decodeURIComponent(match.hash) || '';

  this.$$compose();
};

/**
 * Compose url and update `absUrl` property
 * @private
 */
this.$$compose = function() {
  var search = toKeyValue(this.$$search),
      hash = this.$$hash ? '#' + encodeUriSegment(this.$$hash) : '';

  this.$$url = encodePath(this.$$path) + (search ? '?' + search : '') + hash;
  this.$$absUrl = composeProtocolHostPort(this.$$protocol, this.$$host, this.$$port) +
                  pathPrefix + this.$$url;
};

this.$$rewriteAppUrl = function(absoluteLinkUrl) {
  if(absoluteLinkUrl.indexOf(appBaseUrl) == 0) {
    return absoluteLinkUrl;
  }
}

this.$$parse(url);

}

/**

* LocationHashbangUrl represents url
* This object is exposed as $location service when html5 history api is disabled or not supported
*
* @constructor
* @param {string} url Legacy url
* @param {string} hashPrefix Prefix for hash part (containing path and search)
*/

function LocationHashbangUrl(url, hashPrefix, appBaseUrl) {

var basePath;

/**
 * Parse given hashbang url into properties
 * @param {string} url Hashbang url
 * @private
 */
this.$$parse = function(url) {
  var match = matchUrl(url, this);

  if (match.hash && match.hash.indexOf(hashPrefix) !== 0) {
    throw Error('Invalid url "' + url + '", missing hash prefix "' + hashPrefix + '" !');
  }

  basePath = match.path + (match.search ? '?' + match.search : '');
  match = HASH_MATCH.exec((match.hash || '').substr(hashPrefix.length));
  if (match[1]) {
    this.$$path = (match[1].charAt(0) == '/' ? '' : '/') + decodeURIComponent(match[1]);
  } else {
    this.$$path = '';
  }

  this.$$search = parseKeyValue(match[3]);
  this.$$hash = match[5] && decodeURIComponent(match[5]) || '';

  this.$$compose();
};

/**
 * Compose hashbang url and update `absUrl` property
 * @private
 */
this.$$compose = function() {
  var search = toKeyValue(this.$$search),
      hash = this.$$hash ? '#' + encodeUriSegment(this.$$hash) : '';

  this.$$url = encodePath(this.$$path) + (search ? '?' + search : '') + hash;
  this.$$absUrl = composeProtocolHostPort(this.$$protocol, this.$$host, this.$$port) +
                  basePath + (this.$$url ? '#' + hashPrefix + this.$$url : '');
};

this.$$rewriteAppUrl = function(absoluteLinkUrl) {
  if(absoluteLinkUrl.indexOf(appBaseUrl) == 0) {
    return absoluteLinkUrl;
  }
}

this.$$parse(url);

}

LocationUrl.prototype = {

/**
 * Has any change been replacing ?
 * @private
 */
$$replace: false,

/**
 * @ngdoc method
 * @name ng.$location#absUrl
 * @methodOf ng.$location
 *
 * @description
 * This method is getter only.
 *
 * Return full url representation with all segments encoded according to rules specified in
 * {@link http://www.ietf.org/rfc/rfc3986.txt RFC 3986}.
 *
 * @return {string} full url
 */
absUrl: locationGetter('$$absUrl'),

/**
 * @ngdoc method
 * @name ng.$location#url
 * @methodOf ng.$location
 *
 * @description
 * This method is getter / setter.
 *
 * Return url (e.g. `/path?a=b#hash`) when called without any parameter.
 *
 * Change path, search and hash, when called with parameter and return `$location`.
 *
 * @param {string=} url New url without base prefix (e.g. `/path?a=b#hash`)
 * @return {string} url
 */
url: function(url, replace) {
  if (isUndefined(url))
    return this.$$url;

  var match = PATH_MATCH.exec(url);
  if (match[1]) this.path(decodeURIComponent(match[1]));
  if (match[2] || match[1]) this.search(match[3] || '');
  this.hash(match[5] || '', replace);

  return this;
},

/**
 * @ngdoc method
 * @name ng.$location#protocol
 * @methodOf ng.$location
 *
 * @description
 * This method is getter only.
 *
 * Return protocol of current url.
 *
 * @return {string} protocol of current url
 */
protocol: locationGetter('$$protocol'),

/**
 * @ngdoc method
 * @name ng.$location#host
 * @methodOf ng.$location
 *
 * @description
 * This method is getter only.
 *
 * Return host of current url.
 *
 * @return {string} host of current url.
 */
host: locationGetter('$$host'),

/**
 * @ngdoc method
 * @name ng.$location#port
 * @methodOf ng.$location
 *
 * @description
 * This method is getter only.
 *
 * Return port of current url.
 *
 * @return {Number} port
 */
port: locationGetter('$$port'),

/**
 * @ngdoc method
 * @name ng.$location#path
 * @methodOf ng.$location
 *
 * @description
 * This method is getter / setter.
 *
 * Return path of current url when called without any parameter.
 *
 * Change path when called with parameter and return `$location`.
 *
 * Note: Path should always begin with forward slash (/), this method will add the forward slash
 * if it is missing.
 *
 * @param {string=} path New path
 * @return {string} path
 */
path: locationGetterSetter('$$path', function(path) {
  return path.charAt(0) == '/' ? path : '/' + path;
}),

/**
 * @ngdoc method
 * @name ng.$location#search
 * @methodOf ng.$location
 *
 * @description
 * This method is getter / setter.
 *
 * Return search part (as object) of current url when called without any parameter.
 *
 * Change search part when called with parameter and return `$location`.
 *
 * @param {string|object<string,string>=} search New search params - string or hash object
 * @param {string=} paramValue If `search` is a string, then `paramValue` will override only a
 *    single search parameter. If the value is `null`, the parameter will be deleted.
 *
 * @return {string} search
 */
search: function(search, paramValue) {
  if (isUndefined(search))
    return this.$$search;

  if (isDefined(paramValue)) {
    if (paramValue === null) {
      delete this.$$search[search];
    } else {
      this.$$search[search] = paramValue;
    }
  } else {
    this.$$search = isString(search) ? parseKeyValue(search) : search;
  }

  this.$$compose();
  return this;
},

/**
 * @ngdoc method
 * @name ng.$location#hash
 * @methodOf ng.$location
 *
 * @description
 * This method is getter / setter.
 *
 * Return hash fragment when called without any parameter.
 *
 * Change hash fragment when called with parameter and return `$location`.
 *
 * @param {string=} hash New hash fragment
 * @return {string} hash
 */
hash: locationGetterSetter('$$hash', identity),

/**
 * @ngdoc method
 * @name ng.$location#replace
 * @methodOf ng.$location
 *
 * @description
 * If called, all changes to $location during current `$digest` will be replacing current history
 * record, instead of adding new one.
 */
replace: function() {
  this.$$replace = true;
  return this;
}

};

LocationHashbangUrl.prototype = inherit(LocationUrl.prototype);

function LocationHashbangInHtml5Url(url, hashPrefix, appBaseUrl, baseExtra) {

LocationHashbangUrl.apply(this, arguments);

this.$$rewriteAppUrl = function(absoluteLinkUrl) {
  if (absoluteLinkUrl.indexOf(appBaseUrl) == 0) {
    return appBaseUrl + baseExtra + '#' + hashPrefix  + absoluteLinkUrl.substr(appBaseUrl.length);
  }
}

}

LocationHashbangInHtml5Url.prototype = inherit(LocationHashbangUrl.prototype);

function locationGetter(property) {

return function() {
  return this[property];
};

}

function locationGetterSetter(property, preprocess) {

return function(value) {
  if (isUndefined(value))
    return this[property];

  this[property] = preprocess(value);
  this.$$compose();

  return this;
};

}

/**

* @ngdoc object
* @name ng.$location
*
* @requires $browser
* @requires $sniffer
* @requires $rootElement
*
* @description
* The $location service parses the URL in the browser address bar (based on the
* {@link https://developer.mozilla.org/en/window.location window.location}) and makes the URL
* available to your application. Changes to the URL in the address bar are reflected into
* $location service and changes to $location are reflected into the browser address bar.
*
* **The $location service:**
*
* - Exposes the current URL in the browser address bar, so you can
*   - Watch and observe the URL.
*   - Change the URL.
* - Synchronizes the URL with the browser when the user
*   - Changes the address bar.
*   - Clicks the back or forward button (or clicks a History link).
*   - Clicks on a link.
* - Represents the URL object as a set of methods (protocol, host, port, path, search, hash).
*
* For more information see {@link guide/dev_guide.services.$location Developer Guide: Angular
* Services: Using $location}
*/

/**

* @ngdoc object
* @name ng.$locationProvider
* @description
* Use the `$locationProvider` to configure how the application deep linking paths are stored.
*/

function $LocationProvider(){

var hashPrefix = '',
    html5Mode = false;

/**
 * @ngdoc property
 * @name ng.$locationProvider#hashPrefix
 * @methodOf ng.$locationProvider
 * @description
 * @param {string=} prefix Prefix for hash part (containing path and search)
 * @returns {*} current value if used as getter or itself (chaining) if used as setter
 */
this.hashPrefix = function(prefix) {
  if (isDefined(prefix)) {
    hashPrefix = prefix;
    return this;
  } else {
    return hashPrefix;
  }
};

/**
 * @ngdoc property
 * @name ng.$locationProvider#html5Mode
 * @methodOf ng.$locationProvider
 * @description
 * @param {string=} mode Use HTML5 strategy if available.
 * @returns {*} current value if used as getter or itself (chaining) if used as setter
 */
this.html5Mode = function(mode) {
  if (isDefined(mode)) {
    html5Mode = mode;
    return this;
  } else {
    return html5Mode;
  }
};

this.$get = ['$rootScope', '$browser', '$sniffer', '$rootElement',
    function( $rootScope,   $browser,   $sniffer,   $rootElement) {
  var $location,
      basePath,
      pathPrefix,
      initUrl = $browser.url(),
      initUrlParts = matchUrl(initUrl),
      appBaseUrl;

  if (html5Mode) {
    basePath = $browser.baseHref() || '/';
    pathPrefix = pathPrefixFromBase(basePath);
    appBaseUrl =
        composeProtocolHostPort(initUrlParts.protocol, initUrlParts.host, initUrlParts.port) +
        pathPrefix + '/';

    if ($sniffer.history) {
      $location = new LocationUrl(
        convertToHtml5Url(initUrl, basePath, hashPrefix),
        pathPrefix, appBaseUrl);
    } else {
      $location = new LocationHashbangInHtml5Url(
        convertToHashbangUrl(initUrl, basePath, hashPrefix),
        hashPrefix, appBaseUrl, basePath.substr(pathPrefix.length + 1));
    }
  } else {
    appBaseUrl =
        composeProtocolHostPort(initUrlParts.protocol, initUrlParts.host, initUrlParts.port) +
        (initUrlParts.path || '') +
        (initUrlParts.search ? ('?' + initUrlParts.search) : '') +
        '#' + hashPrefix + '/';

    $location = new LocationHashbangUrl(initUrl, hashPrefix, appBaseUrl);
  }

  $rootElement.bind('click', function(event) {
    // TODO(vojta): rewrite link when opening in new tab/window (in legacy browser)
    // currently we open nice url link and redirect then

    if (event.ctrlKey || event.metaKey || event.which == 2) return;

    var elm = jqLite(event.target);

    // traverse the DOM up to find first A tag
    while (lowercase(elm[0].nodeName) !== 'a') {
      // ignore rewriting if no A tag (reached root element, or no parent - removed from document)
      if (elm[0] === $rootElement[0] || !(elm = elm.parent())[0]) return;
    }

    var absHref = elm.prop('href'),
        rewrittenUrl = $location.$$rewriteAppUrl(absHref);

    if (absHref && !elm.attr('target') && rewrittenUrl) {
      // update location manually
      $location.$$parse(rewrittenUrl);
      $rootScope.$apply();
      event.preventDefault();
      // hack to work around FF6 bug 684208 when scenario runner clicks on links
      window.angular['ff-684208-preventDefault'] = true;
    }
  });

  // rewrite hashbang url <> html5 url
  if ($location.absUrl() != initUrl) {
    $browser.url($location.absUrl(), true);
  }

  // update $location when $browser url changes
  $browser.onUrlChange(function(newUrl) {
    if ($location.absUrl() != newUrl) {
      $rootScope.$evalAsync(function() {
        var oldUrl = $location.absUrl();

        $location.$$parse(newUrl);
        afterLocationChange(oldUrl);
      });
      if (!$rootScope.$$phase) $rootScope.$digest();
    }
  });

  // update browser
  var changeCounter = 0;
  $rootScope.$watch(function $locationWatch() {
    var oldUrl = $browser.url();
    var currentReplace = $location.$$replace;

    if (!changeCounter || oldUrl != $location.absUrl()) {
      changeCounter++;
      $rootScope.$evalAsync(function() {
        if ($rootScope.$broadcast('$locationChangeStart', $location.absUrl(), oldUrl).
            defaultPrevented) {
          $location.$$parse(oldUrl);
        } else {
          $browser.url($location.absUrl(), currentReplace);
          afterLocationChange(oldUrl);
        }
      });
    }
    $location.$$replace = false;

    return changeCounter;
  });

  return $location;

  function afterLocationChange(oldUrl) {
    $rootScope.$broadcast('$locationChangeSuccess', $location.absUrl(), oldUrl);
  }

}]; }

/**

* @ngdoc object
* @name ng.$log
* @requires $window
*
* @description
* Simple service for logging. Default implementation writes the message
* into the browser's console (if present).
*
* The main purpose of this service is to simplify debugging and troubleshooting.
*
* @example
  <example>
    <file name="script.js">
      function LogCtrl($scope, $log) {
        $scope.$log = $log;
        $scope.message = 'Hello World!';
      }
    </file>
    <file name="index.html">
      <div ng-controller="LogCtrl">
        <p>Reload this page with open console, enter text and hit the log button...</p>
        Message:
        <input type="text" ng-model="message"/>
        <button ng-click="$log.log(message)">log</button>
        <button ng-click="$log.warn(message)">warn</button>
        <button ng-click="$log.info(message)">info</button>
        <button ng-click="$log.error(message)">error</button>
      </div>
    </file>
  </example>
*/

function $LogProvider(){

this.$get = ['$window', function($window){
  return {
    /**
     * @ngdoc method
     * @name ng.$log#log
     * @methodOf ng.$log
     *
     * @description
     * Write a log message
     */
    log: consoleLog('log'),

    /**
     * @ngdoc method
     * @name ng.$log#warn
     * @methodOf ng.$log
     *
     * @description
     * Write a warning message
     */
    warn: consoleLog('warn'),

    /**
     * @ngdoc method
     * @name ng.$log#info
     * @methodOf ng.$log
     *
     * @description
     * Write an information message
     */
    info: consoleLog('info'),

    /**
     * @ngdoc method
     * @name ng.$log#error
     * @methodOf ng.$log
     *
     * @description
     * Write an error message
     */
    error: consoleLog('error')
  };

  function formatError(arg) {
    if (arg instanceof Error) {
      if (arg.stack) {
        arg = (arg.message && arg.stack.indexOf(arg.message) === -1)
            ? 'Error: ' + arg.message + '\n' + arg.stack
            : arg.stack;
      } else if (arg.sourceURL) {
        arg = arg.message + '\n' + arg.sourceURL + ':' + arg.line;
      }
    }
    return arg;
  }

  function consoleLog(type) {
    var console = $window.console || {},
        logFn = console[type] || console.log || noop;

    if (logFn.apply) {
      return function() {
        var args = [];
        forEach(arguments, function(arg) {
          args.push(formatError(arg));
        });
        return logFn.apply(console, args);
      };
    }

    // we are IE which either doesn't have window.console => this is noop and we do nothing,
    // or we are IE where console.log doesn't have apply so we log at least first 2 args
    return function(arg1, arg2) {
      logFn(arg1, arg2);
    }
  }
}];

}

var OPERATORS = {

'null':function(){return null;},
'true':function(){return true;},
'false':function(){return false;},
undefined:noop,
'+':function(self, locals, a,b){
  a=a(self, locals); b=b(self, locals);
  if (isDefined(a)) {
    if (isDefined(b)) {
      return a + b;
    }
    return a;
  }
  return isDefined(b)?b:undefined;},
'-':function(self, locals, a,b){a=a(self, locals); b=b(self, locals); return (isDefined(a)?a:0)-(isDefined(b)?b:0);},
'*':function(self, locals, a,b){return a(self, locals)*b(self, locals);},
'/':function(self, locals, a,b){return a(self, locals)/b(self, locals);},
'%':function(self, locals, a,b){return a(self, locals)%b(self, locals);},
'^':function(self, locals, a,b){return a(self, locals)^b(self, locals);},
'=':noop,
'==':function(self, locals, a,b){return a(self, locals)==b(self, locals);},
'!=':function(self, locals, a,b){return a(self, locals)!=b(self, locals);},
'<':function(self, locals, a,b){return a(self, locals)<b(self, locals);},
'>':function(self, locals, a,b){return a(self, locals)>b(self, locals);},
'<=':function(self, locals, a,b){return a(self, locals)<=b(self, locals);},
'>=':function(self, locals, a,b){return a(self, locals)>=b(self, locals);},
'&&':function(self, locals, a,b){return a(self, locals)&&b(self, locals);},
'||':function(self, locals, a,b){return a(self, locals)||b(self, locals);},
'&':function(self, locals, a,b){return a(self, locals)&b(self, locals);},

// '|':function(self, locals, a,b){return a|b;},

'|':function(self, locals, a,b){return b(self, locals)(self, locals, a(self, locals));},
'!':function(self, locals, a){return !a(self, locals);}

}; var ESCAPE = {“n”:“n”, “f”:“f”, “r”:“r”, “t”:“t”, “v”:“v”, “'”:“'”, '“':'”'};

function lex(text, csp){

var tokens = [],
    token,
    index = 0,
    json = [],
    ch,
    lastCh = ':'; // can start regexp

while (index < text.length) {
  ch = text.charAt(index);
  if (is('"\'')) {
    readString(ch);
  } else if (isNumber(ch) || is('.') && isNumber(peek())) {
    readNumber();
  } else if (isIdent(ch)) {
    readIdent();
    // identifiers can only be if the preceding char was a { or ,
    if (was('{,') && json[0]=='{' &&
       (token=tokens[tokens.length-1])) {
      token.json = token.text.indexOf('.') == -1;
    }
  } else if (is('(){}[].,;:')) {
    tokens.push({
      index:index,
      text:ch,
      json:(was(':[,') && is('{[')) || is('}]:,')
    });
    if (is('{[')) json.unshift(ch);
    if (is('}]')) json.shift();
    index++;
  } else if (isWhitespace(ch)) {
    index++;
    continue;
  } else {
    var ch2 = ch + peek(),
        fn = OPERATORS[ch],
        fn2 = OPERATORS[ch2];
    if (fn2) {
      tokens.push({index:index, text:ch2, fn:fn2});
      index += 2;
    } else if (fn) {
      tokens.push({index:index, text:ch, fn:fn, json: was('[,:') && is('+-')});
      index += 1;
    } else {
      throwError("Unexpected next character ", index, index+1);
    }
  }
  lastCh = ch;
}
return tokens;

function is(chars) {
  return chars.indexOf(ch) != -1;
}

function was(chars) {
  return chars.indexOf(lastCh) != -1;
}

function peek() {
  return index + 1 < text.length ? text.charAt(index + 1) : false;
}
function isNumber(ch) {
  return '0' <= ch && ch <= '9';
}
function isWhitespace(ch) {
  return ch == ' ' || ch == '\r' || ch == '\t' ||
         ch == '\n' || ch == '\v' || ch == '\u00A0'; // IE treats non-breaking space as \u00A0
}
function isIdent(ch) {
  return 'a' <= ch && ch <= 'z' ||
         'A' <= ch && ch <= 'Z' ||
         '_' == ch || ch == '$';
}
function isExpOperator(ch) {
  return ch == '-' || ch == '+' || isNumber(ch);
}

function throwError(error, start, end) {
  end = end || index;
  throw Error("Lexer Error: " + error + " at column" +
      (isDefined(start)
          ? "s " + start +  "-" + index + " [" + text.substring(start, end) + "]"
          : " " + end) +
      " in expression [" + text + "].");
}

function readNumber() {
  var number = "";
  var start = index;
  while (index < text.length) {
    var ch = lowercase(text.charAt(index));
    if (ch == '.' || isNumber(ch)) {
      number += ch;
    } else {
      var peekCh = peek();
      if (ch == 'e' && isExpOperator(peekCh)) {
        number += ch;
      } else if (isExpOperator(ch) &&
          peekCh && isNumber(peekCh) &&
          number.charAt(number.length - 1) == 'e') {
        number += ch;
      } else if (isExpOperator(ch) &&
          (!peekCh || !isNumber(peekCh)) &&
          number.charAt(number.length - 1) == 'e') {
        throwError('Invalid exponent');
      } else {
        break;
      }
    }
    index++;
  }
  number = 1 * number;
  tokens.push({index:start, text:number, json:true,
    fn:function() {return number;}});
}
function readIdent() {
  var ident = "",
      start = index,
      lastDot, peekIndex, methodName;

  while (index < text.length) {
    var ch = text.charAt(index);
    if (ch == '.' || isIdent(ch) || isNumber(ch)) {
      if (ch == '.') lastDot = index;
      ident += ch;
    } else {
      break;
    }
    index++;
  }

  //check if this is not a method invocation and if it is back out to last dot
  if (lastDot) {
    peekIndex = index;
    while(peekIndex < text.length) {
      var ch = text.charAt(peekIndex);
      if (ch == '(') {
        methodName = ident.substr(lastDot - start + 1);
        ident = ident.substr(0, lastDot - start);
        index = peekIndex;
        break;
      }
      if(isWhitespace(ch)) {
        peekIndex++;
      } else {
        break;
      }
    }
  }

  var token = {
    index:start,
    text:ident
  };

  if (OPERATORS.hasOwnProperty(ident)) {
    token.fn = token.json = OPERATORS[ident];
  } else {
    var getter = getterFn(ident, csp);
    token.fn = extend(function(self, locals) {
      return (getter(self, locals));
    }, {
      assign: function(self, value) {
        return setter(self, ident, value);
      }
    });
  }

  tokens.push(token);

  if (methodName) {
    tokens.push({
      index:lastDot,
      text: '.',
      json: false
    });
    tokens.push({
      index: lastDot + 1,
      text: methodName,
      json: false
    });
  }
}

function readString(quote) {
  var start = index;
  index++;
  var string = "";
  var rawString = quote;
  var escape = false;
  while (index < text.length) {
    var ch = text.charAt(index);
    rawString += ch;
    if (escape) {
      if (ch == 'u') {
        var hex = text.substring(index + 1, index + 5);
        if (!hex.match(/[\da-f]{4}/i))
          throwError( "Invalid unicode escape [\\u" + hex + "]");
        index += 4;
        string += String.fromCharCode(parseInt(hex, 16));
      } else {
        var rep = ESCAPE[ch];
        if (rep) {
          string += rep;
        } else {
          string += ch;
        }
      }
      escape = false;
    } else if (ch == '\\') {
      escape = true;
    } else if (ch == quote) {
      index++;
      tokens.push({
        index:start,
        text:rawString,
        string:string,
        json:true,
        fn:function() { return string; }
      });
      return;
    } else {
      string += ch;
    }
    index++;
  }
  throwError("Unterminated quote", start);
}

}

/////////////////////////////////////////

function parser(text, json, $filter, csp){

var ZERO = valueFn(0),
    value,
    tokens = lex(text, csp),
    assignment = _assignment,
    functionCall = _functionCall,
    fieldAccess = _fieldAccess,
    objectIndex = _objectIndex,
    filterChain = _filterChain;

if(json){
  // The extra level of aliasing is here, just in case the lexer misses something, so that
  // we prevent any accidental execution in JSON.
  assignment = logicalOR;
  functionCall =
    fieldAccess =
    objectIndex =
    filterChain =
      function() { throwError("is not valid json", {text:text, index:0}); };
  value = primary();
} else {
  value = statements();
}
if (tokens.length !== 0) {
  throwError("is an unexpected token", tokens[0]);
}
return value;

///////////////////////////////////
function throwError(msg, token) {
  throw Error("Syntax Error: Token '" + token.text +
    "' " + msg + " at column " +
    (token.index + 1) + " of the expression [" +
    text + "] starting at [" + text.substring(token.index) + "].");
}

function peekToken() {
  if (tokens.length === 0)
    throw Error("Unexpected end of expression: " + text);
  return tokens[0];
}

function peek(e1, e2, e3, e4) {
  if (tokens.length > 0) {
    var token = tokens[0];
    var t = token.text;
    if (t==e1 || t==e2 || t==e3 || t==e4 ||
        (!e1 && !e2 && !e3 && !e4)) {
      return token;
    }
  }
  return false;
}

function expect(e1, e2, e3, e4){
  var token = peek(e1, e2, e3, e4);
  if (token) {
    if (json && !token.json) {
      throwError("is not valid json", token);
    }
    tokens.shift();
    return token;
  }
  return false;
}

function consume(e1){
  if (!expect(e1)) {
    throwError("is unexpected, expecting [" + e1 + "]", peek());
  }
}

function unaryFn(fn, right) {
  return function(self, locals) {
    return fn(self, locals, right);
  };
}

function binaryFn(left, fn, right) {
  return function(self, locals) {
    return fn(self, locals, left, right);
  };
}

function statements() {
  var statements = [];
  while(true) {
    if (tokens.length > 0 && !peek('}', ')', ';', ']'))
      statements.push(filterChain());
    if (!expect(';')) {
      // optimize for the common case where there is only one statement.
      // TODO(size): maybe we should not support multiple statements?
      return statements.length == 1
        ? statements[0]
        : function(self, locals){
          var value;
          for ( var i = 0; i < statements.length; i++) {
            var statement = statements[i];
            if (statement)
              value = statement(self, locals);
          }
          return value;
        };
    }
  }
}

function _filterChain() {
  var left = expression();
  var token;
  while(true) {
    if ((token = expect('|'))) {
      left = binaryFn(left, token.fn, filter());
    } else {
      return left;
    }
  }
}

function filter() {
  var token = expect();
  var fn = $filter(token.text);
  var argsFn = [];
  while(true) {
    if ((token = expect(':'))) {
      argsFn.push(expression());
    } else {
      var fnInvoke = function(self, locals, input){
        var args = [input];
        for ( var i = 0; i < argsFn.length; i++) {
          args.push(argsFn[i](self, locals));
        }
        return fn.apply(self, args);
      };
      return function() {
        return fnInvoke;
      };
    }
  }
}

function expression() {
  return assignment();
}

function _assignment() {
  var left = logicalOR();
  var right;
  var token;
  if ((token = expect('='))) {
    if (!left.assign) {
      throwError("implies assignment but [" +
        text.substring(0, token.index) + "] can not be assigned to", token);
    }
    right = logicalOR();
    return function(self, locals){
      return left.assign(self, right(self, locals), locals);
    };
  } else {
    return left;
  }
}

function logicalOR() {
  var left = logicalAND();
  var token;
  while(true) {
    if ((token = expect('||'))) {
      left = binaryFn(left, token.fn, logicalAND());
    } else {
      return left;
    }
  }
}

function logicalAND() {
  var left = equality();
  var token;
  if ((token = expect('&&'))) {
    left = binaryFn(left, token.fn, logicalAND());
  }
  return left;
}

function equality() {
  var left = relational();
  var token;
  if ((token = expect('==','!='))) {
    left = binaryFn(left, token.fn, equality());
  }
  return left;
}

function relational() {
  var left = additive();
  var token;
  if ((token = expect('<', '>', '<=', '>='))) {
    left = binaryFn(left, token.fn, relational());
  }
  return left;
}

function additive() {
  var left = multiplicative();
  var token;
  while ((token = expect('+','-'))) {
    left = binaryFn(left, token.fn, multiplicative());
  }
  return left;
}

function multiplicative() {
  var left = unary();
  var token;
  while ((token = expect('*','/','%'))) {
    left = binaryFn(left, token.fn, unary());
  }
  return left;
}

function unary() {
  var token;
  if (expect('+')) {
    return primary();
  } else if ((token = expect('-'))) {
    return binaryFn(ZERO, token.fn, unary());
  } else if ((token = expect('!'))) {
    return unaryFn(token.fn, unary());
  } else {
    return primary();
  }
}

function primary() {
  var primary;
  if (expect('(')) {
    primary = filterChain();
    consume(')');
  } else if (expect('[')) {
    primary = arrayDeclaration();
  } else if (expect('{')) {
    primary = object();
  } else {
    var token = expect();
    primary = token.fn;
    if (!primary) {
      throwError("not a primary expression", token);
    }
  }

  var next, context;
  while ((next = expect('(', '[', '.'))) {
    if (next.text === '(') {
      primary = functionCall(primary, context);
      context = null;
    } else if (next.text === '[') {
      context = primary;
      primary = objectIndex(primary);
    } else if (next.text === '.') {
      context = primary;
      primary = fieldAccess(primary);
    } else {
      throwError("IMPOSSIBLE");
    }
  }
  return primary;
}

function _fieldAccess(object) {
  var field = expect().text;
  var getter = getterFn(field, csp);
  return extend(
      function(self, locals) {
        return getter(object(self, locals), locals);
      },
      {
        assign:function(self, value, locals) {
          return setter(object(self, locals), field, value);
        }
      }
  );
}

function _objectIndex(obj) {
  var indexFn = expression();
  consume(']');
  return extend(
    function(self, locals){
      var o = obj(self, locals),
          i = indexFn(self, locals),
          v, p;

      if (!o) return undefined;
      v = o[i];
      if (v && v.then) {
        p = v;
        if (!('$$v' in v)) {
          p.$$v = undefined;
          p.then(function(val) { p.$$v = val; });
        }
        v = v.$$v;
      }
      return v;
    }, {
      assign:function(self, value, locals){
        return obj(self, locals)[indexFn(self, locals)] = value;
      }
    });
}

function _functionCall(fn, contextGetter) {
  var argsFn = [];
  if (peekToken().text != ')') {
    do {
      argsFn.push(expression());
    } while (expect(','));
  }
  consume(')');
  return function(self, locals){
    var args = [],
        context = contextGetter ? contextGetter(self, locals) : self;

    for ( var i = 0; i < argsFn.length; i++) {
      args.push(argsFn[i](self, locals));
    }
    var fnPtr = fn(self, locals) || noop;
    // IE stupidity!
    return fnPtr.apply
        ? fnPtr.apply(context, args)
        : fnPtr(args[0], args[1], args[2], args[3], args[4]);
  };
}

// This is used with json array declaration
function arrayDeclaration () {
  var elementFns = [];
  if (peekToken().text != ']') {
    do {
      elementFns.push(expression());
    } while (expect(','));
  }
  consume(']');
  return function(self, locals){
    var array = [];
    for ( var i = 0; i < elementFns.length; i++) {
      array.push(elementFns[i](self, locals));
    }
    return array;
  };
}

function object () {
  var keyValues = [];
  if (peekToken().text != '}') {
    do {
      var token = expect(),
      key = token.string || token.text;
      consume(":");
      var value = expression();
      keyValues.push({key:key, value:value});
    } while (expect(','));
  }
  consume('}');
  return function(self, locals){
    var object = {};
    for ( var i = 0; i < keyValues.length; i++) {
      var keyValue = keyValues[i];
      var value = keyValue.value(self, locals);
      object[keyValue.key] = value;
    }
    return object;
  };
}

}

////////////////////////////////////////////////// // Parser helper functions //////////////////////////////////////////////////

function setter(obj, path, setValue) {

var element = path.split('.');
for (var i = 0; element.length > 1; i++) {
  var key = element.shift();
  var propertyObj = obj[key];
  if (!propertyObj) {
    propertyObj = {};
    obj[key] = propertyObj;
  }
  obj = propertyObj;
}
obj[element.shift()] = setValue;
return setValue;

}

/**

* Return the value accesible from the object by path. Any undefined traversals are ignored
* @param {Object} obj starting object
* @param {string} path path to traverse
* @param {boolean=true} bindFnToScope
* @returns value as accesbile by path
*/

//TODO(misko): this function needs to be removed function getter(obj, path, bindFnToScope) {

if (!path) return obj;
var keys = path.split('.');
var key;
var lastInstance = obj;
var len = keys.length;

for (var i = 0; i < len; i++) {
  key = keys[i];
  if (obj) {
    obj = (lastInstance = obj)[key];
  }
}
if (!bindFnToScope && isFunction(obj)) {
  return bind(lastInstance, obj);
}
return obj;

}

var getterFnCache = {};

/**

* Implementation of the "Black Hole" variant from:
* - http://jsperf.com/angularjs-parse-getter/4
* - http://jsperf.com/path-evaluation-simplified/7
*/

function cspSafeGetterFn(key0, key1, key2, key3, key4) {

return function(scope, locals) {
  var pathVal = (locals && locals.hasOwnProperty(key0)) ? locals : scope,
      promise;

  if (pathVal === null || pathVal === undefined) return pathVal;

  pathVal = pathVal[key0];
  if (pathVal && pathVal.then) {
    if (!("$$v" in pathVal)) {
      promise = pathVal;
      promise.$$v = undefined;
      promise.then(function(val) { promise.$$v = val; });
    }
    pathVal = pathVal.$$v;
  }
  if (!key1 || pathVal === null || pathVal === undefined) return pathVal;

  pathVal = pathVal[key1];
  if (pathVal && pathVal.then) {
    if (!("$$v" in pathVal)) {
      promise = pathVal;
      promise.$$v = undefined;
      promise.then(function(val) { promise.$$v = val; });
    }
    pathVal = pathVal.$$v;
  }
  if (!key2 || pathVal === null || pathVal === undefined) return pathVal;

  pathVal = pathVal[key2];
  if (pathVal && pathVal.then) {
    if (!("$$v" in pathVal)) {
      promise = pathVal;
      promise.$$v = undefined;
      promise.then(function(val) { promise.$$v = val; });
    }
    pathVal = pathVal.$$v;
  }
  if (!key3 || pathVal === null || pathVal === undefined) return pathVal;

  pathVal = pathVal[key3];
  if (pathVal && pathVal.then) {
    if (!("$$v" in pathVal)) {
      promise = pathVal;
      promise.$$v = undefined;
      promise.then(function(val) { promise.$$v = val; });
    }
    pathVal = pathVal.$$v;
  }
  if (!key4 || pathVal === null || pathVal === undefined) return pathVal;

  pathVal = pathVal[key4];
  if (pathVal && pathVal.then) {
    if (!("$$v" in pathVal)) {
      promise = pathVal;
      promise.$$v = undefined;
      promise.then(function(val) { promise.$$v = val; });
    }
    pathVal = pathVal.$$v;
  }
  return pathVal;
};

};

function getterFn(path, csp) {

if (getterFnCache.hasOwnProperty(path)) {
  return getterFnCache[path];
}

var pathKeys = path.split('.'),
    pathKeysLength = pathKeys.length,
    fn;

if (csp) {
  fn = (pathKeysLength < 6)
      ? cspSafeGetterFn(pathKeys[0], pathKeys[1], pathKeys[2], pathKeys[3], pathKeys[4])
      : function(scope, locals) {
        var i = 0, val
        do {
          val = cspSafeGetterFn(
                  pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++]
                )(scope, locals);

          locals = undefined; // clear after first iteration
          scope = val;
        } while (i < pathKeysLength);
        return val;
      }
} else {
  var code = 'var l, fn, p;\n';
  forEach(pathKeys, function(key, index) {
    code += 'if(s === null || s === undefined) return s;\n' +
            'l=s;\n' +
            's='+ (index
                    // we simply dereference 's' on any .dot notation
                    ? 's'
                    // but if we are first then we check locals first, and if so read it first
                    : '((k&&k.hasOwnProperty("' + key + '"))?k:s)') + '["' + key + '"]' + ';\n' +
            'if (s && s.then) {\n' +
              ' if (!("$$v" in s)) {\n' +
                ' p=s;\n' +
                ' p.$$v = undefined;\n' +
                ' p.then(function(v) {p.$$v=v;});\n' +
                '}\n' +
              ' s=s.$$v\n' +
            '}\n';
  });
  code += 'return s;';
  fn = Function('s', 'k', code); // s=scope, k=locals
  fn.toString = function() { return code; };
}

return getterFnCache[path] = fn;

}

///////////////////////////////////

/**

* @ngdoc function
* @name ng.$parse
* @function
*
* @description
*
* Converts Angular {@link guide/expression expression} into a function.
*
* <pre>
*   var getter = $parse('user.name');
*   var setter = getter.assign;
*   var context = {user:{name:'angular'}};
*   var locals = {user:{name:'local'}};
*
*   expect(getter(context)).toEqual('angular');
*   setter(context, 'newValue');
*   expect(context.user.name).toEqual('newValue');
*   expect(getter(context, locals)).toEqual('local');
* </pre>
*
*
* @param {string} expression String expression to compile.
* @returns {function(context, locals)} a function which represents the compiled expression:
*
*    * `context` – `{object}` – an object against which any expressions embedded in the strings
*      are evaluated against (tipically a scope object).
*    * `locals` – `{object=}` – local variables context object, useful for overriding values in
*      `context`.
*
*    The return function also has an `assign` property, if the expression is assignable, which
*    allows one to set values to expressions.
*
*/

function $ParseProvider() {

var cache = {};
this.$get = ['$filter', '$sniffer', function($filter, $sniffer) {
  return function(exp) {
    switch(typeof exp) {
      case 'string':
        return cache.hasOwnProperty(exp)
          ? cache[exp]
          : cache[exp] =  parser(exp, false, $filter, $sniffer.csp);
      case 'function':
        return exp;
      default:
        return noop;
    }
  };
}];

}

/**

* @ngdoc service
* @name ng.$q
* @requires $rootScope
*
* @description
* A promise/deferred implementation inspired by [Kris Kowal's Q](https://github.com/kriskowal/q).
*
* [The CommonJS Promise proposal](http://wiki.commonjs.org/wiki/Promises) describes a promise as an
* interface for interacting with an object that represents the result of an action that is
* performed asynchronously, and may or may not be finished at any given point in time.
*
* From the perspective of dealing with error handling, deferred and promise APIs are to
* asynchronous programming what `try`, `catch` and `throw` keywords are to synchronous programming.
*
* <pre>
*   // for the purpose of this example let's assume that variables `$q` and `scope` are
*   // available in the current lexical scope (they could have been injected or passed in).
*
*   function asyncGreet(name) {
*     var deferred = $q.defer();
*
*     setTimeout(function() {
*       // since this fn executes async in a future turn of the event loop, we need to wrap
*       // our code into an $apply call so that the model changes are properly observed.
*       scope.$apply(function() {
*         if (okToGreet(name)) {
*           deferred.resolve('Hello, ' + name + '!');
*         } else {
*           deferred.reject('Greeting ' + name + ' is not allowed.');
*         }
*       });
*     }, 1000);
*
*     return deferred.promise;
*   }
*
*   var promise = asyncGreet('Robin Hood');
*   promise.then(function(greeting) {
*     alert('Success: ' + greeting);
*   }, function(reason) {
*     alert('Failed: ' + reason);
*   });
* </pre>
*
* At first it might not be obvious why this extra complexity is worth the trouble. The payoff
* comes in the way of
* [guarantees that promise and deferred APIs make](https://github.com/kriskowal/uncommonjs/blob/master/promises/specification.md).
*
* Additionally the promise api allows for composition that is very hard to do with the
* traditional callback ([CPS](http://en.wikipedia.org/wiki/Continuation-passing_style)) approach.
* For more on this please see the [Q documentation](https://github.com/kriskowal/q) especially the
* section on serial or parallel joining of promises.
*
*
* # The Deferred API
*
* A new instance of deferred is constructed by calling `$q.defer()`.
*
* The purpose of the deferred object is to expose the associated Promise instance as well as APIs
* that can be used for signaling the successful or unsuccessful completion of the task.
*
* **Methods**
*
* - `resolve(value)` – resolves the derived promise with the `value`. If the value is a rejection
*   constructed via `$q.reject`, the promise will be rejected instead.
* - `reject(reason)` – rejects the derived promise with the `reason`. This is equivalent to
*   resolving it with a rejection constructed via `$q.reject`.
*
* **Properties**
*
* - promise – `{Promise}` – promise object associated with this deferred.
*
*
* # The Promise API
*
* A new promise instance is created when a deferred instance is created and can be retrieved by
* calling `deferred.promise`.
*
* The purpose of the promise object is to allow for interested parties to get access to the result
* of the deferred task when it completes.
*
* **Methods**
*
* - `then(successCallback, errorCallback)` – regardless of when the promise was or will be resolved
*   or rejected calls one of the success or error callbacks asynchronously as soon as the result
*   is available. The callbacks are called with a single argument the result or rejection reason.
*
*   This method *returns a new promise* which is resolved or rejected via the return value of the
*   `successCallback` or `errorCallback`.
*
*
* # Chaining promises
*
* Because calling `then` api of a promise returns a new derived promise, it is easily possible
* to create a chain of promises:
*
* <pre>
*   promiseB = promiseA.then(function(result) {
*     return result + 1;
*   });
*
*   // promiseB will be resolved immediately after promiseA is resolved and its value will be
*   // the result of promiseA incremented by 1
* </pre>
*
* It is possible to create chains of any length and since a promise can be resolved with another
* promise (which will defer its resolution further), it is possible to pause/defer resolution of
* the promises at any point in the chain. This makes it possible to implement powerful apis like
* $http's response interceptors.
*
*
* # Differences between Kris Kowal's Q and $q
*
*  There are three main differences:
*
* - $q is integrated with the {@link ng.$rootScope.Scope} Scope model observation
*   mechanism in angular, which means faster propagation of resolution or rejection into your
*   models and avoiding unnecessary browser repaints, which would result in flickering UI.
* - $q promises are recognized by the templating engine in angular, which means that in templates
*   you can treat promises attached to a scope as if they were the resulting values.
* - Q has many more features that $q, but that comes at a cost of bytes. $q is tiny, but contains
*   all the important functionality needed for common async tasks.
* 
*  # Testing
* 
*  <pre>
*    it('should simulate promise', inject(function($q, $rootScope) {
*      var deferred = $q.defer();
*      var promise = deferred.promise;
*      var resolvedValue;
* 
*      promise.then(function(value) { resolvedValue = value; });
*      expect(resolvedValue).toBeUndefined();
* 
*      // Simulate resolving of promise
*      deferred.resolve(123);
*      // Note that the 'then' function does not get called synchronously.
*      // This is because we want the promise API to always be async, whether or not
*      // it got called synchronously or asynchronously.
*      expect(resolvedValue).toBeUndefined();
* 
*      // Propagate promise resolution to 'then' functions using $apply().
*      $rootScope.$apply();
*      expect(resolvedValue).toEqual(123);
*    });
*  </pre>
*/

function $QProvider() {

this.$get = ['$rootScope', '$exceptionHandler', function($rootScope, $exceptionHandler) {
  return qFactory(function(callback) {
    $rootScope.$evalAsync(callback);
  }, $exceptionHandler);
}];

}

/**

* Constructs a promise manager.
*
* @param {function(function)} nextTick Function for executing functions in the next turn.
* @param {function(...*)} exceptionHandler Function into which unexpected exceptions are passed for
*     debugging purposes.
* @returns {object} Promise manager.
*/

function qFactory(nextTick, exceptionHandler) {

/**
 * @ngdoc
 * @name ng.$q#defer
 * @methodOf ng.$q
 * @description
 * Creates a `Deferred` object which represents a task which will finish in the future.
 *
 * @returns {Deferred} Returns a new instance of deferred.
 */
var defer = function() {
  var pending = [],
      value, deferred;

  deferred = {

    resolve: function(val) {
      if (pending) {
        var callbacks = pending;
        pending = undefined;
        value = ref(val);

        if (callbacks.length) {
          nextTick(function() {
            var callback;
            for (var i = 0, ii = callbacks.length; i < ii; i++) {
              callback = callbacks[i];
              value.then(callback[0], callback[1]);
            }
          });
        }
      }
    },

    reject: function(reason) {
      deferred.resolve(reject(reason));
    },

    promise: {
      then: function(callback, errback) {
        var result = defer();

        var wrappedCallback = function(value) {
          try {
            result.resolve((callback || defaultCallback)(value));
          } catch(e) {
            exceptionHandler(e);
            result.reject(e);
          }
        };

        var wrappedErrback = function(reason) {
          try {
            result.resolve((errback || defaultErrback)(reason));
          } catch(e) {
            exceptionHandler(e);
            result.reject(e);
          }
        };

        if (pending) {
          pending.push([wrappedCallback, wrappedErrback]);
        } else {
          value.then(wrappedCallback, wrappedErrback);
        }

        return result.promise;
      }
    }
  };

  return deferred;
};

var ref = function(value) {
  if (value && value.then) return value;
  return {
    then: function(callback) {
      var result = defer();
      nextTick(function() {
        result.resolve(callback(value));
      });
      return result.promise;
    }
  };
};

/**
 * @ngdoc
 * @name ng.$q#reject
 * @methodOf ng.$q
 * @description
 * Creates a promise that is resolved as rejected with the specified `reason`. This api should be
 * used to forward rejection in a chain of promises. If you are dealing with the last promise in
 * a promise chain, you don't need to worry about it.
 *
 * When comparing deferreds/promises to the familiar behavior of try/catch/throw, think of
 * `reject` as the `throw` keyword in JavaScript. This also means that if you "catch" an error via
 * a promise error callback and you want to forward the error to the promise derived from the
 * current promise, you have to "rethrow" the error by returning a rejection constructed via
 * `reject`.
 *
 * <pre>
 *   promiseB = promiseA.then(function(result) {
 *     // success: do something and resolve promiseB
 *     //          with the old or a new result
 *     return result;
 *   }, function(reason) {
 *     // error: handle the error if possible and
 *     //        resolve promiseB with newPromiseOrValue,
 *     //        otherwise forward the rejection to promiseB
 *     if (canHandle(reason)) {
 *      // handle the error and recover
 *      return newPromiseOrValue;
 *     }
 *     return $q.reject(reason);
 *   });
 * </pre>
 *
 * @param {*} reason Constant, message, exception or an object representing the rejection reason.
 * @returns {Promise} Returns a promise that was already resolved as rejected with the `reason`.
 */
var reject = function(reason) {
  return {
    then: function(callback, errback) {
      var result = defer();
      nextTick(function() {
        result.resolve((errback || defaultErrback)(reason));
      });
      return result.promise;
    }
  };
};

/**
 * @ngdoc
 * @name ng.$q#when
 * @methodOf ng.$q
 * @description
 * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise.
 * This is useful when you are dealing with an object that might or might not be a promise, or if
 * the promise comes from a source that can't be trusted.
 *
 * @param {*} value Value or a promise
 * @returns {Promise} Returns a single promise that will be resolved with an array of values,
 *   each value corresponding to the promise at the same index in the `promises` array. If any of
 *   the promises is resolved with a rejection, this resulting promise will be resolved with the
 *   same rejection.
 */
var when = function(value, callback, errback) {
  var result = defer(),
      done;

  var wrappedCallback = function(value) {
    try {
      return (callback || defaultCallback)(value);
    } catch (e) {
      exceptionHandler(e);
      return reject(e);
    }
  };

  var wrappedErrback = function(reason) {
    try {
      return (errback || defaultErrback)(reason);
    } catch (e) {
      exceptionHandler(e);
      return reject(e);
    }
  };

  nextTick(function() {
    ref(value).then(function(value) {
      if (done) return;
      done = true;
      result.resolve(ref(value).then(wrappedCallback, wrappedErrback));
    }, function(reason) {
      if (done) return;
      done = true;
      result.resolve(wrappedErrback(reason));
    });
  });

  return result.promise;
};

function defaultCallback(value) {
  return value;
}

function defaultErrback(reason) {
  return reject(reason);
}

/**
 * @ngdoc
 * @name ng.$q#all
 * @methodOf ng.$q
 * @description
 * Combines multiple promises into a single promise that is resolved when all of the input
 * promises are resolved.
 *
 * @param {Array.<Promise>} promises An array of promises.
 * @returns {Promise} Returns a single promise that will be resolved with an array of values,
 *   each value corresponding to the promise at the same index in the `promises` array. If any of
 *   the promises is resolved with a rejection, this resulting promise will be resolved with the
 *   same rejection.
 */
function all(promises) {
  var deferred = defer(),
      counter = promises.length,
      results = [];

  if (counter) {
    forEach(promises, function(promise, index) {
      ref(promise).then(function(value) {
        if (index in results) return;
        results[index] = value;
        if (!(--counter)) deferred.resolve(results);
      }, function(reason) {
        if (index in results) return;
        deferred.reject(reason);
      });
    });
  } else {
    deferred.resolve(results);
  }

  return deferred.promise;
}

return {
  defer: defer,
  reject: reject,
  when: when,
  all: all
};

}

/**

* @ngdoc object
* @name ng.$routeProvider
* @function
*
* @description
*
* Used for configuring routes. See {@link ng.$route $route} for an example.
*/

function $RouteProvider(){

var routes = {};

/**
 * @ngdoc method
 * @name ng.$routeProvider#when
 * @methodOf ng.$routeProvider
 *
 * @param {string} path Route path (matched against `$location.path`). If `$location.path`
 *    contains redundant trailing slash or is missing one, the route will still match and the
 *    `$location.path` will be updated to add or drop the trailing slash to exactly match the
 *    route definition.
 *
 *    `path` can contain named groups starting with a colon (`:name`). All characters up to the
 *    next slash are matched and stored in `$routeParams` under the given `name` when the route
 *    matches.
 *
 * @param {Object} route Mapping information to be assigned to `$route.current` on route
 *    match.
 *
 *    Object properties:
 *
 *    - `controller` – `{(string|function()=}` – Controller fn that should be associated with newly
 *      created scope or the name of a {@link angular.Module#controller registered controller}
 *      if passed as a string.
 *    - `template` – `{string=}` –  html template as a string that should be used by
 *      {@link ng.directive:ngView ngView} or
 *      {@link ng.directive:ngInclude ngInclude} directives.
 *      this property takes precedence over `templateUrl`.
 *    - `templateUrl` – `{string=}` – path to an html template that should be used by
 *      {@link ng.directive:ngView ngView}.
 *    - `resolve` - `{Object.<string, function>=}` - An optional map of dependencies which should
 *      be injected into the controller. If any of these dependencies are promises, they will be
 *      resolved and converted to a value before the controller is instantiated and the
 *      `$routeChangeSuccess` event is fired. The map object is:
 *
 *      - `key` – `{string}`: a name of a dependency to be injected into the controller.
 *      - `factory` - `{string|function}`: If `string` then it is an alias for a service.
 *        Otherwise if function, then it is {@link api/AUTO.$injector#invoke injected}
 *        and the return value is treated as the dependency. If the result is a promise, it is resolved
 *        before its value is injected into the controller.
 *
 *    - `redirectTo` – {(string|function())=} – value to update
 *      {@link ng.$location $location} path with and trigger route redirection.
 *
 *      If `redirectTo` is a function, it will be called with the following parameters:
 *
 *      - `{Object.<string>}` - route parameters extracted from the current
 *        `$location.path()` by applying the current route templateUrl.
 *      - `{string}` - current `$location.path()`
 *      - `{Object}` - current `$location.search()`
 *
 *      The custom `redirectTo` function is expected to return a string which will be used
 *      to update `$location.path()` and `$location.search()`.
 *
 *    - `[reloadOnSearch=true]` - {boolean=} - reload route when only $location.search()
 *    changes.
 *
 *      If the option is set to `false` and url in the browser changes, then
 *      `$routeUpdate` event is broadcasted on the root scope.
 *
 * @returns {Object} self
 *
 * @description
 * Adds a new route definition to the `$route` service.
 */
this.when = function(path, route) {
  routes[path] = extend({reloadOnSearch: true}, route);

  // create redirection for trailing slashes
  if (path) {
    var redirectPath = (path[path.length-1] == '/')
        ? path.substr(0, path.length-1)
        : path +'/';

    routes[redirectPath] = {redirectTo: path};
  }

  return this;
};

/**
 * @ngdoc method
 * @name ng.$routeProvider#otherwise
 * @methodOf ng.$routeProvider
 *
 * @description
 * Sets route definition that will be used on route change when no other route definition
 * is matched.
 *
 * @param {Object} params Mapping information to be assigned to `$route.current`.
 * @returns {Object} self
 */
this.otherwise = function(params) {
  this.when(null, params);
  return this;
};

this.$get = ['$rootScope', '$location', '$routeParams', '$q', '$injector', '$http', '$templateCache',
    function( $rootScope,   $location,   $routeParams,   $q,   $injector,   $http,   $templateCache) {

  /**
   * @ngdoc object
   * @name ng.$route
   * @requires $location
   * @requires $routeParams
   *
   * @property {Object} current Reference to the current route definition.
   * The route definition contains:
   *
   *   - `controller`: The controller constructor as define in route definition.
   *   - `locals`: A map of locals which is used by {@link ng.$controller $controller} service for
   *     controller instantiation. The `locals` contain
   *     the resolved values of the `resolve` map. Additionally the `locals` also contain:
   *
   *     - `$scope` - The current route scope.
   *     - `$template` - The current route template HTML.
   *
   * @property {Array.<Object>} routes Array of all configured routes.
   *
   * @description
   * Is used for deep-linking URLs to controllers and views (HTML partials).
   * It watches `$location.url()` and tries to map the path to an existing route definition.
   *
   * You can define routes through {@link ng.$routeProvider $routeProvider}'s API.
   *
   * The `$route` service is typically used in conjunction with {@link ng.directive:ngView ngView}
   * directive and the {@link ng.$routeParams $routeParams} service.
   *
   * @example
     This example shows how changing the URL hash causes the `$route` to match a route against the
     URL, and the `ngView` pulls in the partial.

     Note that this example is using {@link ng.directive:script inlined templates}
     to get it working on jsfiddle as well.

   <example module="ngView">
     <file name="index.html">
       <div ng-controller="MainCntl">
         Choose:
         <a href="Book/Moby">Moby</a> |
         <a href="Book/Moby/ch/1">Moby: Ch1</a> |
         <a href="Book/Gatsby">Gatsby</a> |
         <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> |
         <a href="Book/Scarlet">Scarlet Letter</a><br/>

         <div ng-view></div>
         <hr />

         <pre>$location.path() = {{$location.path()}}</pre>
         <pre>$route.current.templateUrl = {{$route.current.templateUrl}}</pre>
         <pre>$route.current.params = {{$route.current.params}}</pre>
         <pre>$route.current.scope.name = {{$route.current.scope.name}}</pre>
         <pre>$routeParams = {{$routeParams}}</pre>
       </div>
     </file>

     <file name="book.html">
       controller: {{name}}<br />
       Book Id: {{params.bookId}}<br />
     </file>

     <file name="chapter.html">
       controller: {{name}}<br />
       Book Id: {{params.bookId}}<br />
       Chapter Id: {{params.chapterId}}
     </file>

     <file name="script.js">
       angular.module('ngView', [], function($routeProvider, $locationProvider) {
         $routeProvider.when('/Book/:bookId', {
           templateUrl: 'book.html',
           controller: BookCntl,
           resolve: {
             // I will cause a 1 second delay
             delay: function($q, $timeout) {
               var delay = $q.defer();
               $timeout(delay.resolve, 1000);
               return delay.promise;
             }
           }
         });
         $routeProvider.when('/Book/:bookId/ch/:chapterId', {
           templateUrl: 'chapter.html',
           controller: ChapterCntl
         });

         // configure html5 to get links working on jsfiddle
         $locationProvider.html5Mode(true);
       });

       function MainCntl($scope, $route, $routeParams, $location) {
         $scope.$route = $route;
         $scope.$location = $location;
         $scope.$routeParams = $routeParams;
       }

       function BookCntl($scope, $routeParams) {
         $scope.name = "BookCntl";
         $scope.params = $routeParams;
       }

       function ChapterCntl($scope, $routeParams) {
         $scope.name = "ChapterCntl";
         $scope.params = $routeParams;
       }
     </file>

     <file name="scenario.js">
       it('should load and compile correct template', function() {
         element('a:contains("Moby: Ch1")').click();
         var content = element('.doc-example-live [ng-view]').text();
         expect(content).toMatch(/controller\: ChapterCntl/);
         expect(content).toMatch(/Book Id\: Moby/);
         expect(content).toMatch(/Chapter Id\: 1/);

         element('a:contains("Scarlet")').click();
         sleep(2); // promises are not part of scenario waiting
         content = element('.doc-example-live [ng-view]').text();
         expect(content).toMatch(/controller\: BookCntl/);
         expect(content).toMatch(/Book Id\: Scarlet/);
       });
     </file>
   </example>
   */

  /**
   * @ngdoc event
   * @name ng.$route#$routeChangeStart
   * @eventOf ng.$route
   * @eventType broadcast on root scope
   * @description
   * Broadcasted before a route change. At this  point the route services starts
   * resolving all of the dependencies needed for the route change to occurs.
   * Typically this involves fetching the view template as well as any dependencies
   * defined in `resolve` route property. Once  all of the dependencies are resolved
   * `$routeChangeSuccess` is fired.
   *
   * @param {Route} next Future route information.
   * @param {Route} current Current route information.
   */

  /**
   * @ngdoc event
   * @name ng.$route#$routeChangeSuccess
   * @eventOf ng.$route
   * @eventType broadcast on root scope
   * @description
   * Broadcasted after a route dependencies are resolved.
   * {@link ng.directive:ngView ngView} listens for the directive
   * to instantiate the controller and render the view.
   *
   * @param {Object} angularEvent Synthetic event object.
   * @param {Route} current Current route information.
   * @param {Route|Undefined} previous Previous route information, or undefined if current is first route entered.
   */

  /**
   * @ngdoc event
   * @name ng.$route#$routeChangeError
   * @eventOf ng.$route
   * @eventType broadcast on root scope
   * @description
   * Broadcasted if any of the resolve promises are rejected.
   *
   * @param {Route} current Current route information.
   * @param {Route} previous Previous route information.
   * @param {Route} rejection Rejection of the promise. Usually the error of the failed promise.
   */

  /**
   * @ngdoc event
   * @name ng.$route#$routeUpdate
   * @eventOf ng.$route
   * @eventType broadcast on root scope
   * @description
   *
   * The `reloadOnSearch` property has been set to false, and we are reusing the same
   * instance of the Controller.
   */

  var forceReload = false,
      $route = {
        routes: routes,

        /**
         * @ngdoc method
         * @name ng.$route#reload
         * @methodOf ng.$route
         *
         * @description
         * Causes `$route` service to reload the current route even if
         * {@link ng.$location $location} hasn't changed.
         *
         * As a result of that, {@link ng.directive:ngView ngView}
         * creates new scope, reinstantiates the controller.
         */
        reload: function() {
          forceReload = true;
          $rootScope.$evalAsync(updateRoute);
        }
      };

  $rootScope.$on('$locationChangeSuccess', updateRoute);

  return $route;

  /////////////////////////////////////////////////////

  /**
   * @param on {string} current url
   * @param when {string} route when template to match the url against
   * @return {?Object}
   */
  function switchRouteMatcher(on, when) {
    // TODO(i): this code is convoluted and inefficient, we should construct the route matching
    //   regex only once and then reuse it

    // Escape regexp special characters.
    when = '^' + when.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&") + '$';
    var regex = '',
        params = [],
        dst = {};

    var re = /:(\w+)/g,
        paramMatch,
        lastMatchedIndex = 0;

    while ((paramMatch = re.exec(when)) !== null) {
      // Find each :param in `when` and replace it with a capturing group.
      // Append all other sections of when unchanged.
      regex += when.slice(lastMatchedIndex, paramMatch.index);
      regex += '([^\\/]*)';
      params.push(paramMatch[1]);
      lastMatchedIndex = re.lastIndex;
    }
    // Append trailing path part.
    regex += when.substr(lastMatchedIndex);

    var match = on.match(new RegExp(regex));
    if (match) {
      forEach(params, function(name, index) {
        dst[name] = match[index + 1];
      });
    }
    return match ? dst : null;
  }

  function updateRoute() {
    var next = parseRoute(),
        last = $route.current;

    if (next && last && next.$$route === last.$$route
        && equals(next.pathParams, last.pathParams) && !next.reloadOnSearch && !forceReload) {
      last.params = next.params;
      copy(last.params, $routeParams);
      $rootScope.$broadcast('$routeUpdate', last);
    } else if (next || last) {
      forceReload = false;
      $rootScope.$broadcast('$routeChangeStart', next, last);
      $route.current = next;
      if (next) {
        if (next.redirectTo) {
          if (isString(next.redirectTo)) {
            $location.path(interpolate(next.redirectTo, next.params)).search(next.params)
                     .replace();
          } else {
            $location.url(next.redirectTo(next.pathParams, $location.path(), $location.search()))
                     .replace();
          }
        }
      }

      $q.when(next).
        then(function() {
          if (next) {
            var keys = [],
                values = [],
                template;

            forEach(next.resolve || {}, function(value, key) {
              keys.push(key);
              values.push(isString(value) ? $injector.get(value) : $injector.invoke(value));
            });
            if (isDefined(template = next.template)) {
            } else if (isDefined(template = next.templateUrl)) {
              template = $http.get(template, {cache: $templateCache}).
                  then(function(response) { return response.data; });
            }
            if (isDefined(template)) {
              keys.push('$template');
              values.push(template);
            }
            return $q.all(values).then(function(values) {
              var locals = {};
              forEach(values, function(value, index) {
                locals[keys[index]] = value;
              });
              return locals;
            });
          }
        }).
        // after route change
        then(function(locals) {
          if (next == $route.current) {
            if (next) {
              next.locals = locals;
              copy(next.params, $routeParams);
            }
            $rootScope.$broadcast('$routeChangeSuccess', next, last);
          }
        }, function(error) {
          if (next == $route.current) {
            $rootScope.$broadcast('$routeChangeError', next, last, error);
          }
        });
    }
  }

  /**
   * @returns the current active route, by matching it against the URL
   */
  function parseRoute() {
    // Match a route
    var params, match;
    forEach(routes, function(route, path) {
      if (!match && (params = switchRouteMatcher($location.path(), path))) {
        match = inherit(route, {
          params: extend({}, $location.search(), params),
          pathParams: params});
        match.$$route = route;
      }
    });
    // No route matched; fallback to "otherwise" route
    return match || routes[null] && inherit(routes[null], {params: {}, pathParams:{}});
  }

  /**
   * @returns interpolation of the redirect path with the parametrs
   */
  function interpolate(string, params) {
    var result = [];
    forEach((string||'').split(':'), function(segment, i) {
      if (i == 0) {
        result.push(segment);
      } else {
        var segmentMatch = segment.match(/(\w+)(.*)/);
        var key = segmentMatch[1];
        result.push(params[key]);
        result.push(segmentMatch[2] || '');
        delete params[key];
      }
    });
    return result.join('');
  }
}];

}

/**

* @ngdoc object
* @name ng.$routeParams
* @requires $route
*
* @description
* Current set of route parameters. The route parameters are a combination of the
* {@link ng.$location $location} `search()`, and `path()`. The `path` parameters
* are extracted when the {@link ng.$route $route} path is matched.
*
* In case of parameter name collision, `path` params take precedence over `search` params.
*
* The service guarantees that the identity of the `$routeParams` object will remain unchanged
* (but its properties will likely change) even when a route change occurs.
*
* @example
* <pre>
*  // Given:
*  // URL: http://server.com/index.html#/Chapter/1/Section/2?search=moby
*  // Route: /Chapter/:chapterId/Section/:sectionId
*  //
*  // Then
*  $routeParams ==> {chapterId:1, sectionId:2, search:'moby'}
* </pre>
*/

function $RouteParamsProvider() {

this.$get = valueFn({});

}

/**

* DESIGN NOTES
*
* The design decisions behind the scope ware heavily favored for speed and memory consumption.
*
* The typical use of scope is to watch the expressions, which most of the time return the same
* value as last time so we optimize the operation.
*
* Closures construction is expensive from speed as well as memory:
*   - no closures, instead ups prototypical inheritance for API
*   - Internal state needs to be stored on scope directly, which means that private state is
*     exposed as $$____ properties
*
* Loop operations are optimized by using while(count--) { ... }
*   - this means that in order to keep the same order of execution as addition we have to add
*     items to the array at the begging (shift) instead of at the end (push)
*
* Child scopes are created and removed often
*   - Using array would be slow since inserts in meddle are expensive so we use linked list
*
* There are few watches then a lot of observers. This is why you don't want the observer to be
* implemented in the same way as watch. Watch requires return of initialization function which
* are expensive to construct.
*/

/**

* @ngdoc object
* @name ng.$rootScopeProvider
* @description
*
* Provider for the $rootScope service.
*/

/**

* @ngdoc function
* @name ng.$rootScopeProvider#digestTtl
* @methodOf ng.$rootScopeProvider
* @description
*
* Sets the number of digest iteration the scope should attempt to execute before giving up and
* assuming that the model is unstable.
*
* The current default is 10 iterations.
*
* @param {number} limit The number of digest iterations.
*/

/**

* @ngdoc object
* @name ng.$rootScope
* @description
*
* Every application has a single root {@link ng.$rootScope.Scope scope}.
* All other scopes are child scopes of the root scope. Scopes provide mechanism for watching the model and provide
* event processing life-cycle. See {@link guide/scope developer guide on scopes}.
*/

function $RootScopeProvider(){

var TTL = 10;

this.digestTtl = function(value) {
  if (arguments.length) {
    TTL = value;
  }
  return TTL;
};

this.$get = ['$injector', '$exceptionHandler', '$parse',
    function( $injector,   $exceptionHandler,   $parse) {

  /**
   * @ngdoc function
   * @name ng.$rootScope.Scope
   *
   * @description
   * A root scope can be retrieved using the {@link ng.$rootScope $rootScope} key from the
   * {@link AUTO.$injector $injector}. Child scopes are created using the
   * {@link ng.$rootScope.Scope#$new $new()} method. (Most scopes are created automatically when
   * compiled HTML template is executed.)
   *
   * Here is a simple scope snippet to show how you can interact with the scope.
   * <pre>
      angular.injector(['ng']).invoke(function($rootScope) {
         var scope = $rootScope.$new();
         scope.salutation = 'Hello';
         scope.name = 'World';

         expect(scope.greeting).toEqual(undefined);

         scope.$watch('name', function() {
           scope.greeting = scope.salutation + ' ' + scope.name + '!';
         }); // initialize the watch

         expect(scope.greeting).toEqual(undefined);
         scope.name = 'Misko';
         // still old value, since watches have not been called yet
         expect(scope.greeting).toEqual(undefined);

         scope.$digest(); // fire all  the watches
         expect(scope.greeting).toEqual('Hello Misko!');
      });
   * </pre>
   *
   * # Inheritance
   * A scope can inherit from a parent scope, as in this example:
   * <pre>
       var parent = $rootScope;
       var child = parent.$new();

       parent.salutation = "Hello";
       child.name = "World";
       expect(child.salutation).toEqual('Hello');

       child.salutation = "Welcome";
       expect(child.salutation).toEqual('Welcome');
       expect(parent.salutation).toEqual('Hello');
   * </pre>
   *
   *
   * @param {Object.<string, function()>=} providers Map of service factory which need to be provided
   *     for the current scope. Defaults to {@link ng}.
   * @param {Object.<string, *>=} instanceCache Provides pre-instantiated services which should
   *     append/override services provided by `providers`. This is handy when unit-testing and having
   *     the need to override a default service.
   * @returns {Object} Newly created scope.
   *
   */
  function Scope() {
    this.$id = nextUid();
    this.$$phase = this.$parent = this.$$watchers =
                   this.$$nextSibling = this.$$prevSibling =
                   this.$$childHead = this.$$childTail = null;
    this['this'] = this.$root =  this;
    this.$$destroyed = false;
    this.$$asyncQueue = [];
    this.$$listeners = {};
    this.$$isolateBindings = {};
  }

  /**
   * @ngdoc property
   * @name ng.$rootScope.Scope#$id
   * @propertyOf ng.$rootScope.Scope
   * @returns {number} Unique scope ID (monotonically increasing alphanumeric sequence) useful for
   *   debugging.
   */

  Scope.prototype = {
    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$new
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * Creates a new child {@link ng.$rootScope.Scope scope}.
     *
     * The parent scope will propagate the {@link ng.$rootScope.Scope#$digest $digest()} and
     * {@link ng.$rootScope.Scope#$digest $digest()} events. The scope can be removed from the scope
     * hierarchy using {@link ng.$rootScope.Scope#$destroy $destroy()}.
     *
     * {@link ng.$rootScope.Scope#$destroy $destroy()} must be called on a scope when it is desired for
     * the scope and its child scopes to be permanently detached from the parent and thus stop
     * participating in model change detection and listener notification by invoking.
     *
     * @param {boolean} isolate if true then the scope does not prototypically inherit from the
     *         parent scope. The scope is isolated, as it can not see parent scope properties.
     *         When creating widgets it is useful for the widget to not accidentally read parent
     *         state.
     *
     * @returns {Object} The newly created child scope.
     *
     */
    $new: function(isolate) {
      var Child,
          child;

      if (isFunction(isolate)) {
        // TODO: remove at some point
        throw Error('API-CHANGE: Use $controller to instantiate controllers.');
      }
      if (isolate) {
        child = new Scope();
        child.$root = this.$root;
      } else {
        Child = function() {}; // should be anonymous; This is so that when the minifier munges
          // the name it does not become random set of chars. These will then show up as class
          // name in the debugger.
        Child.prototype = this;
        child = new Child();
        child.$id = nextUid();
      }
      child['this'] = child;
      child.$$listeners = {};
      child.$parent = this;
      child.$$asyncQueue = [];
      child.$$watchers = child.$$nextSibling = child.$$childHead = child.$$childTail = null;
      child.$$prevSibling = this.$$childTail;
      if (this.$$childHead) {
        this.$$childTail.$$nextSibling = child;
        this.$$childTail = child;
      } else {
        this.$$childHead = this.$$childTail = child;
      }
      return child;
    },

    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$watch
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * Registers a `listener` callback to be executed whenever the `watchExpression` changes.
     *
     * - The `watchExpression` is called on every call to {@link ng.$rootScope.Scope#$digest $digest()} and
     *   should return the value which will be watched. (Since {@link ng.$rootScope.Scope#$digest $digest()}
     *   reruns when it detects changes the `watchExpression` can execute multiple times per
     *   {@link ng.$rootScope.Scope#$digest $digest()} and should be idempotent.)
     * - The `listener` is called only when the value from the current `watchExpression` and the
     *   previous call to `watchExpression` are not equal (with the exception of the initial run,
     *   see below). The inequality is determined according to
     *   {@link angular.equals} function. To save the value of the object for later comparison, the
     *   {@link angular.copy} function is used. It also means that watching complex options will
     *   have adverse memory and performance implications.
     * - The watch `listener` may change the model, which may trigger other `listener`s to fire. This
     *   is achieved by rerunning the watchers until no changes are detected. The rerun iteration
     *   limit is 10 to prevent an infinite loop deadlock.
     *
     *
     * If you want to be notified whenever {@link ng.$rootScope.Scope#$digest $digest} is called,
     * you can register a `watchExpression` function with no `listener`. (Since `watchExpression`
     * can execute multiple times per {@link ng.$rootScope.Scope#$digest $digest} cycle when a change is
     * detected, be prepared for multiple calls to your listener.)
     *
     * After a watcher is registered with the scope, the `listener` fn is called asynchronously
     * (via {@link ng.$rootScope.Scope#$evalAsync $evalAsync}) to initialize the
     * watcher. In rare cases, this is undesirable because the listener is called when the result
     * of `watchExpression` didn't change. To detect this scenario within the `listener` fn, you
     * can compare the `newVal` and `oldVal`. If these two values are identical (`===`) then the
     * listener was called due to initialization.
     *
     *
     * # Example
     * <pre>
         // let's assume that scope was dependency injected as the $rootScope
         var scope = $rootScope;
         scope.name = 'misko';
         scope.counter = 0;

         expect(scope.counter).toEqual(0);
         scope.$watch('name', function(newValue, oldValue) { scope.counter = scope.counter + 1; });
         expect(scope.counter).toEqual(0);

         scope.$digest();
         // no variable change
         expect(scope.counter).toEqual(0);

         scope.name = 'adam';
         scope.$digest();
         expect(scope.counter).toEqual(1);
     * </pre>
     *
     *
     *
     * @param {(function()|string)} watchExpression Expression that is evaluated on each
     *    {@link ng.$rootScope.Scope#$digest $digest} cycle. A change in the return value triggers a
     *    call to the `listener`.
     *
     *    - `string`: Evaluated as {@link guide/expression expression}
     *    - `function(scope)`: called with current `scope` as a parameter.
     * @param {(function()|string)=} listener Callback called whenever the return value of
     *   the `watchExpression` changes.
     *
     *    - `string`: Evaluated as {@link guide/expression expression}
     *    - `function(newValue, oldValue, scope)`: called with current and previous values as parameters.
     *
     * @param {boolean=} objectEquality Compare object for equality rather than for reference.
     * @returns {function()} Returns a deregistration function for this listener.
     */
    $watch: function(watchExp, listener, objectEquality) {
      var scope = this,
          get = compileToFn(watchExp, 'watch'),
          array = scope.$$watchers,
          watcher = {
            fn: listener,
            last: initWatchVal,
            get: get,
            exp: watchExp,
            eq: !!objectEquality
          };

      // in the case user pass string, we need to compile it, do we really need this ?
      if (!isFunction(listener)) {
        var listenFn = compileToFn(listener || noop, 'listener');
        watcher.fn = function(newVal, oldVal, scope) {listenFn(scope);};
      }

      if (!array) {
        array = scope.$$watchers = [];
      }
      // we use unshift since we use a while loop in $digest for speed.
      // the while loop reads in reverse order.
      array.unshift(watcher);

      return function() {
        arrayRemove(array, watcher);
      };
    },

    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$digest
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * Process all of the {@link ng.$rootScope.Scope#$watch watchers} of the current scope and its children.
     * Because a {@link ng.$rootScope.Scope#$watch watcher}'s listener can change the model, the
     * `$digest()` keeps calling the {@link ng.$rootScope.Scope#$watch watchers} until no more listeners are
     * firing. This means that it is possible to get into an infinite loop. This function will throw
     * `'Maximum iteration limit exceeded.'` if the number of iterations exceeds 10.
     *
     * Usually you don't call `$digest()` directly in
     * {@link ng.directive:ngController controllers} or in
     * {@link ng.$compileProvider#directive directives}.
     * Instead a call to {@link ng.$rootScope.Scope#$apply $apply()} (typically from within a
     * {@link ng.$compileProvider#directive directives}) will force a `$digest()`.
     *
     * If you want to be notified whenever `$digest()` is called,
     * you can register a `watchExpression` function  with {@link ng.$rootScope.Scope#$watch $watch()}
     * with no `listener`.
     *
     * You may have a need to call `$digest()` from within unit-tests, to simulate the scope
     * life-cycle.
     *
     * # Example
     * <pre>
         var scope = ...;
         scope.name = 'misko';
         scope.counter = 0;

         expect(scope.counter).toEqual(0);
         scope.$watch('name', function(newValue, oldValue) {
           scope.counter = scope.counter + 1;
         });
         expect(scope.counter).toEqual(0);

         scope.$digest();
         // no variable change
         expect(scope.counter).toEqual(0);

         scope.name = 'adam';
         scope.$digest();
         expect(scope.counter).toEqual(1);
     * </pre>
     *
     */
    $digest: function() {
      var watch, value, last,
          watchers,
          asyncQueue,
          length,
          dirty, ttl = TTL,
          next, current, target = this,
          watchLog = [],
          logIdx, logMsg;

      beginPhase('$digest');

      do {
        dirty = false;
        current = target;
        do {
          asyncQueue = current.$$asyncQueue;
          while(asyncQueue.length) {
            try {
              current.$eval(asyncQueue.shift());
            } catch (e) {
              $exceptionHandler(e);
            }
          }
          if ((watchers = current.$$watchers)) {
            // process our watches
            length = watchers.length;
            while (length--) {
              try {
                watch = watchers[length];
                // Most common watches are on primitives, in which case we can short
                // circuit it with === operator, only when === fails do we use .equals
                if ((value = watch.get(current)) !== (last = watch.last) &&
                    !(watch.eq
                        ? equals(value, last)
                        : (typeof value == 'number' && typeof last == 'number'
                           && isNaN(value) && isNaN(last)))) {
                  dirty = true;
                  watch.last = watch.eq ? copy(value) : value;
                  watch.fn(value, ((last === initWatchVal) ? value : last), current);
                  if (ttl < 5) {
                    logIdx = 4 - ttl;
                    if (!watchLog[logIdx]) watchLog[logIdx] = [];
                    logMsg = (isFunction(watch.exp))
                        ? 'fn: ' + (watch.exp.name || watch.exp.toString())
                        : watch.exp;
                    logMsg += '; newVal: ' + toJson(value) + '; oldVal: ' + toJson(last);
                    watchLog[logIdx].push(logMsg);
                  }
                }
              } catch (e) {
                $exceptionHandler(e);
              }
            }
          }

          // Insanity Warning: scope depth-first traversal
          // yes, this code is a bit crazy, but it works and we have tests to prove it!
          // this piece should be kept in sync with the traversal in $broadcast
          if (!(next = (current.$$childHead || (current !== target && current.$$nextSibling)))) {
            while(current !== target && !(next = current.$$nextSibling)) {
              current = current.$parent;
            }
          }
        } while ((current = next));

        if(dirty && !(ttl--)) {
          clearPhase();
          throw Error(TTL + ' $digest() iterations reached. Aborting!\n' +
              'Watchers fired in the last 5 iterations: ' + toJson(watchLog));
        }
      } while (dirty || asyncQueue.length);

      clearPhase();
    },

    /**
     * @ngdoc event
     * @name ng.$rootScope.Scope#$destroy
     * @eventOf ng.$rootScope.Scope
     * @eventType broadcast on scope being destroyed
     *
     * @description
     * Broadcasted when a scope and its children are being destroyed.
     */

    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$destroy
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * Removes the current scope (and all of its children) from the parent scope. Removal implies
     * that calls to {@link ng.$rootScope.Scope#$digest $digest()} will no longer
     * propagate to the current scope and its children. Removal also implies that the current
     * scope is eligible for garbage collection.
     *
     * The `$destroy()` is usually used by directives such as
     * {@link ng.directive:ngRepeat ngRepeat} for managing the
     * unrolling of the loop.
     *
     * Just before a scope is destroyed a `$destroy` event is broadcasted on this scope.
     * Application code can register a `$destroy` event handler that will give it chance to
     * perform any necessary cleanup.
     */
    $destroy: function() {
      // we can't destroy the root scope or a scope that has been already destroyed
      if ($rootScope == this || this.$$destroyed) return;
      var parent = this.$parent;

      this.$broadcast('$destroy');
      this.$$destroyed = true;

      if (parent.$$childHead == this) parent.$$childHead = this.$$nextSibling;
      if (parent.$$childTail == this) parent.$$childTail = this.$$prevSibling;
      if (this.$$prevSibling) this.$$prevSibling.$$nextSibling = this.$$nextSibling;
      if (this.$$nextSibling) this.$$nextSibling.$$prevSibling = this.$$prevSibling;

      // This is bogus code that works around Chrome's GC leak
      // see: https://github.com/angular/angular.js/issues/1313#issuecomment-10378451
      this.$parent = this.$$nextSibling = this.$$prevSibling = this.$$childHead =
          this.$$childTail = null;
    },

    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$eval
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * Executes the `expression` on the current scope returning the result. Any exceptions in the
     * expression are propagated (uncaught). This is useful when evaluating Angular expressions.
     *
     * # Example
     * <pre>
         var scope = ng.$rootScope.Scope();
         scope.a = 1;
         scope.b = 2;

         expect(scope.$eval('a+b')).toEqual(3);
         expect(scope.$eval(function(scope){ return scope.a + scope.b; })).toEqual(3);
     * </pre>
     *
     * @param {(string|function())=} expression An angular expression to be executed.
     *
     *    - `string`: execute using the rules as defined in  {@link guide/expression expression}.
     *    - `function(scope)`: execute the function with the current `scope` parameter.
     *
     * @returns {*} The result of evaluating the expression.
     */
    $eval: function(expr, locals) {
      return $parse(expr)(this, locals);
    },

    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$evalAsync
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * Executes the expression on the current scope at a later point in time.
     *
     * The `$evalAsync` makes no guarantees as to when the `expression` will be executed, only that:
     *
     *   - it will execute in the current script execution context (before any DOM rendering).
     *   - at least one {@link ng.$rootScope.Scope#$digest $digest cycle} will be performed after
     *     `expression` execution.
     *
     * Any exceptions from the execution of the expression are forwarded to the
     * {@link ng.$exceptionHandler $exceptionHandler} service.
     *
     * @param {(string|function())=} expression An angular expression to be executed.
     *
     *    - `string`: execute using the rules as defined in  {@link guide/expression expression}.
     *    - `function(scope)`: execute the function with the current `scope` parameter.
     *
     */
    $evalAsync: function(expr) {
      this.$$asyncQueue.push(expr);
    },

    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$apply
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * `$apply()` is used to execute an expression in angular from outside of the angular framework.
     * (For example from browser DOM events, setTimeout, XHR or third party libraries).
     * Because we are calling into the angular framework we need to perform proper scope life-cycle
     * of {@link ng.$exceptionHandler exception handling},
     * {@link ng.$rootScope.Scope#$digest executing watches}.
     *
     * ## Life cycle
     *
     * # Pseudo-Code of `$apply()`
     * <pre>
         function $apply(expr) {
           try {
             return $eval(expr);
           } catch (e) {
             $exceptionHandler(e);
           } finally {
             $root.$digest();
           }
         }
     * </pre>
     *
     *
     * Scope's `$apply()` method transitions through the following stages:
     *
     * 1. The {@link guide/expression expression} is executed using the
     *    {@link ng.$rootScope.Scope#$eval $eval()} method.
     * 2. Any exceptions from the execution of the expression are forwarded to the
     *    {@link ng.$exceptionHandler $exceptionHandler} service.
     * 3. The {@link ng.$rootScope.Scope#$watch watch} listeners are fired immediately after the expression
     *    was executed using the {@link ng.$rootScope.Scope#$digest $digest()} method.
     *
     *
     * @param {(string|function())=} exp An angular expression to be executed.
     *
     *    - `string`: execute using the rules as defined in {@link guide/expression expression}.
     *    - `function(scope)`: execute the function with current `scope` parameter.
     *
     * @returns {*} The result of evaluating the expression.
     */
    $apply: function(expr) {
      try {
        beginPhase('$apply');
        return this.$eval(expr);
      } catch (e) {
        $exceptionHandler(e);
      } finally {
        clearPhase();
        try {
          $rootScope.$digest();
        } catch (e) {
          $exceptionHandler(e);
          throw e;
        }
      }
    },

    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$on
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * Listens on events of a given type. See {@link ng.$rootScope.Scope#$emit $emit} for discussion of
     * event life cycle.
     *
     * The event listener function format is: `function(event, args...)`. The `event` object
     * passed into the listener has the following attributes:
     *
     *   - `targetScope` - `{Scope}`: the scope on which the event was `$emit`-ed or `$broadcast`-ed.
     *   - `currentScope` - `{Scope}`: the current scope which is handling the event.
     *   - `name` - `{string}`: Name of the event.
     *   - `stopPropagation` - `{function=}`: calling `stopPropagation` function will cancel further event
     *     propagation (available only for events that were `$emit`-ed).
     *   - `preventDefault` - `{function}`: calling `preventDefault` sets `defaultPrevented` flag to true.
     *   - `defaultPrevented` - `{boolean}`: true if `preventDefault` was called.
     *
     * @param {string} name Event name to listen on.
     * @param {function(event, args...)} listener Function to call when the event is emitted.
     * @returns {function()} Returns a deregistration function for this listener.
     */
    $on: function(name, listener) {
      var namedListeners = this.$$listeners[name];
      if (!namedListeners) {
        this.$$listeners[name] = namedListeners = [];
      }
      namedListeners.push(listener);

      return function() {
        namedListeners[indexOf(namedListeners, listener)] = null;
      };
    },

    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$emit
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * Dispatches an event `name` upwards through the scope hierarchy notifying the
     * registered {@link ng.$rootScope.Scope#$on} listeners.
     *
     * The event life cycle starts at the scope on which `$emit` was called. All
     * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get notified.
     * Afterwards, the event traverses upwards toward the root scope and calls all registered
     * listeners along the way. The event will stop propagating if one of the listeners cancels it.
     *
     * Any exception emmited from the {@link ng.$rootScope.Scope#$on listeners} will be passed
     * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
     *
     * @param {string} name Event name to emit.
     * @param {...*} args Optional set of arguments which will be passed onto the event listeners.
     * @return {Object} Event object, see {@link ng.$rootScope.Scope#$on}
     */
    $emit: function(name, args) {
      var empty = [],
          namedListeners,
          scope = this,
          stopPropagation = false,
          event = {
            name: name,
            targetScope: scope,
            stopPropagation: function() {stopPropagation = true;},
            preventDefault: function() {
              event.defaultPrevented = true;
            },
            defaultPrevented: false
          },
          listenerArgs = concat([event], arguments, 1),
          i, length;

      do {
        namedListeners = scope.$$listeners[name] || empty;
        event.currentScope = scope;
        for (i=0, length=namedListeners.length; i<length; i++) {

          // if listeners were deregistered, defragment the array
          if (!namedListeners[i]) {
            namedListeners.splice(i, 1);
            i--;
            length--;
            continue;
          }
          try {
            namedListeners[i].apply(null, listenerArgs);
            if (stopPropagation) return event;
          } catch (e) {
            $exceptionHandler(e);
          }
        }
        //traverse upwards
        scope = scope.$parent;
      } while (scope);

      return event;
    },

    /**
     * @ngdoc function
     * @name ng.$rootScope.Scope#$broadcast
     * @methodOf ng.$rootScope.Scope
     * @function
     *
     * @description
     * Dispatches an event `name` downwards to all child scopes (and their children) notifying the
     * registered {@link ng.$rootScope.Scope#$on} listeners.
     *
     * The event life cycle starts at the scope on which `$broadcast` was called. All
     * {@link ng.$rootScope.Scope#$on listeners} listening for `name` event on this scope get notified.
     * Afterwards, the event propagates to all direct and indirect scopes of the current scope and
     * calls all registered listeners along the way. The event cannot be canceled.
     *
     * Any exception emmited from the {@link ng.$rootScope.Scope#$on listeners} will be passed
     * onto the {@link ng.$exceptionHandler $exceptionHandler} service.
     *
     * @param {string} name Event name to emit.
     * @param {...*} args Optional set of arguments which will be passed onto the event listeners.
     * @return {Object} Event object, see {@link ng.$rootScope.Scope#$on}
     */
    $broadcast: function(name, args) {
      var target = this,
          current = target,
          next = target,
          event = {
            name: name,
            targetScope: target,
            preventDefault: function() {
              event.defaultPrevented = true;
            },
            defaultPrevented: false
          },
          listenerArgs = concat([event], arguments, 1),
          listeners, i, length;

      //down while you can, then up and next sibling or up and next sibling until back at root
      do {
        current = next;
        event.currentScope = current;
        listeners = current.$$listeners[name] || [];
        for (i=0, length = listeners.length; i<length; i++) {
          // if listeners were deregistered, defragment the array
          if (!listeners[i]) {
            listeners.splice(i, 1);
            i--;
            length--;
            continue;
          }

          try {
            listeners[i].apply(null, listenerArgs);
          } catch(e) {
            $exceptionHandler(e);
          }
        }

        // Insanity Warning: scope depth-first traversal
        // yes, this code is a bit crazy, but it works and we have tests to prove it!
        // this piece should be kept in sync with the traversal in $digest
        if (!(next = (current.$$childHead || (current !== target && current.$$nextSibling)))) {
          while(current !== target && !(next = current.$$nextSibling)) {
            current = current.$parent;
          }
        }
      } while ((current = next));

      return event;
    }
  };

  var $rootScope = new Scope();

  return $rootScope;

  function beginPhase(phase) {
    if ($rootScope.$$phase) {
      throw Error($rootScope.$$phase + ' already in progress');
    }

    $rootScope.$$phase = phase;
  }

  function clearPhase() {
    $rootScope.$$phase = null;
  }

  function compileToFn(exp, name) {
    var fn = $parse(exp);
    assertArgFn(fn, name);
    return fn;
  }

  /**
   * function used as an initial value for watchers.
   * because it's unique we can easily tell it apart from other values
   */
  function initWatchVal() {}
}];

}

/**

* !!! This is an undocumented "private" service !!!
*
* @name ng.$sniffer
* @requires $window
*
* @property {boolean} history Does the browser support html5 history api ?
* @property {boolean} hashchange Does the browser support hashchange event ?
*
* @description
* This is very simple implementation of testing browser's features.
*/

function $SnifferProvider() {

this.$get = ['$window', function($window) {
  var eventSupport = {},
      android = int((/android (\d+)/.exec(lowercase($window.navigator.userAgent)) || [])[1]);

  return {
    // Android has history.pushState, but it does not update location correctly
    // so let's not use the history API at all.
    // http://code.google.com/p/android/issues/detail?id=17471
    // https://github.com/angular/angular.js/issues/904
    history: !!($window.history && $window.history.pushState && !(android < 4)),
    hashchange: 'onhashchange' in $window &&
                // IE8 compatible mode lies
                (!$window.document.documentMode || $window.document.documentMode > 7),
    hasEvent: function(event) {
      // IE9 implements 'input' event it's so fubared that we rather pretend that it doesn't have
      // it. In particular the event is not fired when backspace or delete key are pressed or
      // when cut operation is performed.
      if (event == 'input' && msie == 9) return false;

      if (isUndefined(eventSupport[event])) {
        var divElm = $window.document.createElement('div');
        eventSupport[event] = 'on' + event in divElm;
      }

      return eventSupport[event];
    },
    // TODO(i): currently there is no way to feature detect CSP without triggering alerts
    csp: false
  };
}];

}

/**

* @ngdoc object
* @name ng.$window
*
* @description
* A reference to the browser's `window` object. While `window`
* is globally available in JavaScript, it causes testability problems, because
* it is a global variable. In angular we always refer to it through the
* `$window` service, so it may be overriden, removed or mocked for testing.
*
* All expressions are evaluated with respect to current scope so they don't
* suffer from window globality.
*
* @example
  <doc:example>
    <doc:source>
      <input ng-init="$window = $service('$window'); greeting='Hello World!'" type="text" ng-model="greeting" />
      <button ng-click="$window.alert(greeting)">ALERT</button>
    </doc:source>
    <doc:scenario>
    </doc:scenario>
  </doc:example>
*/

function $WindowProvider(){

this.$get = valueFn(window);

}

/**

* Parse headers into key value object
*
* @param {string} headers Raw headers as a string
* @returns {Object} Parsed headers as key value object
*/

function parseHeaders(headers) {

var parsed = {}, key, val, i;

if (!headers) return parsed;

forEach(headers.split('\n'), function(line) {
  i = line.indexOf(':');
  key = lowercase(trim(line.substr(0, i)));
  val = trim(line.substr(i + 1));

  if (key) {
    if (parsed[key]) {
      parsed[key] += ', ' + val;
    } else {
      parsed[key] = val;
    }
  }
});

return parsed;

}

/**

* Returns a function that provides access to parsed headers.
*
* Headers are lazy parsed when first requested.
* @see parseHeaders
*
* @param {(string|Object)} headers Headers to provide access to.
* @returns {function(string=)} Returns a getter function which if called with:
*
*   - if called with single an argument returns a single header value or null
*   - if called with no arguments returns an object containing all headers.
*/

function headersGetter(headers) {

var headersObj = isObject(headers) ? headers : undefined;

return function(name) {
  if (!headersObj) headersObj =  parseHeaders(headers);

  if (name) {
    return headersObj[lowercase(name)] || null;
  }

  return headersObj;
};

}

/**

* Chain all given functions
*
* This function is used for both request and response transforming
*
* @param {*} data Data to transform.
* @param {function(string=)} headers Http headers getter fn.
* @param {(function|Array.<function>)} fns Function or an array of functions.
* @returns {*} Transformed data.
*/

function transformData(data, headers, fns) {

if (isFunction(fns))
  return fns(data, headers);

forEach(fns, function(fn) {
  data = fn(data, headers);
});

return data;

}

function isSuccess(status) {

return 200 <= status && status < 300;

}

function $HttpProvider() {

var JSON_START = /^\s*(\[|\{[^\{])/,
    JSON_END = /[\}\]]\s*$/,
    PROTECTION_PREFIX = /^\)\]\}',?\n/;

var $config = this.defaults = {
  // transform incoming response data
  transformResponse: [function(data) {
    if (isString(data)) {
      // strip json vulnerability protection prefix
      data = data.replace(PROTECTION_PREFIX, '');
      if (JSON_START.test(data) && JSON_END.test(data))
        data = fromJson(data, true);
    }
    return data;
  }],

  // transform outgoing request data
  transformRequest: [function(d) {
    return isObject(d) && !isFile(d) ? toJson(d) : d;
  }],

  // default headers
  headers: {
    common: {
      'Accept': 'application/json, text/plain, */*',
      'X-Requested-With': 'XMLHttpRequest'
    },
    post: {'Content-Type': 'application/json;charset=utf-8'},
    put:  {'Content-Type': 'application/json;charset=utf-8'}
  }
};

var providerResponseInterceptors = this.responseInterceptors = [];

this.$get = ['$httpBackend', '$browser', '$cacheFactory', '$rootScope', '$q', '$injector',
    function($httpBackend, $browser, $cacheFactory, $rootScope, $q, $injector) {

  var defaultCache = $cacheFactory('$http'),
      responseInterceptors = [];

  forEach(providerResponseInterceptors, function(interceptor) {
    responseInterceptors.push(
        isString(interceptor)
            ? $injector.get(interceptor)
            : $injector.invoke(interceptor)
    );
  });

  /**
   * @ngdoc function
   * @name ng.$http
   * @requires $httpBackend
   * @requires $browser
   * @requires $cacheFactory
   * @requires $rootScope
   * @requires $q
   * @requires $injector
   *
   * @description
   * The `$http` service is a core Angular service that facilitates communication with the remote
   * HTTP servers via browser's {@link https://developer.mozilla.org/en/xmlhttprequest
   * XMLHttpRequest} object or via {@link http://en.wikipedia.org/wiki/JSONP JSONP}.
   *
   * For unit testing applications that use `$http` service, see
   * {@link ngMock.$httpBackend $httpBackend mock}.
   *
   * For a higher level of abstraction, please check out the {@link ngResource.$resource
   * $resource} service.
   *
   * The $http API is based on the {@link ng.$q deferred/promise APIs} exposed by
   * the $q service. While for simple usage patters this doesn't matter much, for advanced usage,
   * it is important to familiarize yourself with these apis and guarantees they provide.
   *
   *
   * # General usage
   * The `$http` service is a function which takes a single argument — a configuration object —
   * that is used to generate an http request and returns  a {@link ng.$q promise}
   * with two $http specific methods: `success` and `error`.
   *
   * <pre>
   *   $http({method: 'GET', url: '/someUrl'}).
   *     success(function(data, status, headers, config) {
   *       // this callback will be called asynchronously
   *       // when the response is available
   *     }).
   *     error(function(data, status, headers, config) {
   *       // called asynchronously if an error occurs
   *       // or server returns response with an error status.
   *     });
   * </pre>
   *
   * Since the returned value of calling the $http function is a Promise object, you can also use
   * the `then` method to register callbacks, and these callbacks will receive a single argument –
   * an object representing the response. See the api signature and type info below for more
   * details.
   *
   * A response status code that falls in the [200, 300) range is considered a success status and
   * will result in the success callback being called. Note that if the response is a redirect,
   * XMLHttpRequest will transparently follow it, meaning that the error callback will not be
   * called for such responses.
   *
   * # Shortcut methods
   *
   * Since all invocation of the $http service require definition of the http method and url and
   * POST and PUT requests require response body/data to be provided as well, shortcut methods
   * were created to simplify using the api:
   *
   * <pre>
   *   $http.get('/someUrl').success(successCallback);
   *   $http.post('/someUrl', data).success(successCallback);
   * </pre>
   *
   * Complete list of shortcut methods:
   *
   * - {@link ng.$http#get $http.get}
   * - {@link ng.$http#head $http.head}
   * - {@link ng.$http#post $http.post}
   * - {@link ng.$http#put $http.put}
   * - {@link ng.$http#delete $http.delete}
   * - {@link ng.$http#jsonp $http.jsonp}
   *
   *
   * # Setting HTTP Headers
   *
   * The $http service will automatically add certain http headers to all requests. These defaults
   * can be fully configured by accessing the `$httpProvider.defaults.headers` configuration
   * object, which currently contains this default configuration:
   *
   * - `$httpProvider.defaults.headers.common` (headers that are common for all requests):
   *   - `Accept: application/json, text/plain, * / *`
   *   - `X-Requested-With: XMLHttpRequest`
   * - `$httpProvider.defaults.headers.post`: (header defaults for HTTP POST requests)
   *   - `Content-Type: application/json`
   * - `$httpProvider.defaults.headers.put` (header defaults for HTTP PUT requests)
   *   - `Content-Type: application/json`
   *
   * To add or overwrite these defaults, simply add or remove a property from this configuration
   * objects. To add headers for an HTTP method other than POST or PUT, simply add a new object
   * with name equal to the lower-cased http method name, e.g.
   * `$httpProvider.defaults.headers.get['My-Header']='value'`.
   *
   * Additionally, the defaults can be set at runtime via the `$http.defaults` object in a similar
   * fassion as described above.
   *
   *
   * # Transforming Requests and Responses
   *
   * Both requests and responses can be transformed using transform functions. By default, Angular
   * applies these transformations:
   *
   * Request transformations:
   *
   * - if the `data` property of the request config object contains an object, serialize it into
   *   JSON format.
   *
   * Response transformations:
   *
   *  - if XSRF prefix is detected, strip it (see Security Considerations section below)
   *  - if json response is detected, deserialize it using a JSON parser
   *
   * To globally augment or override the default transforms, modify the `$httpProvider.defaults.transformRequest` and
   * `$httpProvider.defaults.transformResponse` properties of the `$httpProvider`. These properties are by default an
   * array of transform functions, which allows you to `push` or `unshift` a new transformation function into the
   * transformation chain. You can also decide to completely override any default transformations by assigning your
   * transformation functions to these properties directly without the array wrapper.
   *
   * Similarly, to locally override the request/response transforms, augment the `transformRequest` and/or
   * `transformResponse` properties of the config object passed into `$http`.
   *
   *
   * # Caching
   *
   * To enable caching set the configuration property `cache` to `true`. When the cache is
   * enabled, `$http` stores the response from the server in local cache. Next time the
   * response is served from the cache without sending a request to the server.
   *
   * Note that even if the response is served from cache, delivery of the data is asynchronous in
   * the same way that real requests are.
   *
   * If there are multiple GET requests for the same url that should be cached using the same
   * cache, but the cache is not populated yet, only one request to the server will be made and
   * the remaining requests will be fulfilled using the response for the first request.
   *
   *
   * # Response interceptors
   *
   * Before you start creating interceptors, be sure to understand the
   * {@link ng.$q $q and deferred/promise APIs}.
   *
   * For purposes of global error handling, authentication or any kind of synchronous or
   * asynchronous preprocessing of received responses, it is desirable to be able to intercept
   * responses for http requests before they are handed over to the application code that
   * initiated these requests. The response interceptors leverage the {@link ng.$q
   * promise apis} to fulfil this need for both synchronous and asynchronous preprocessing.
   *
   * The interceptors are service factories that are registered with the $httpProvider by
   * adding them to the `$httpProvider.responseInterceptors` array. The factory is called and
   * injected with dependencies (if specified) and returns the interceptor  — a function that
   * takes a {@link ng.$q promise} and returns the original or a new promise.
   *
   * <pre>
   *   // register the interceptor as a service
   *   $provide.factory('myHttpInterceptor', function($q, dependency1, dependency2) {
   *     return function(promise) {
   *       return promise.then(function(response) {
   *         // do something on success
   *       }, function(response) {
   *         // do something on error
   *         if (canRecover(response)) {
   *           return responseOrNewPromise
   *         }
   *         return $q.reject(response);
   *       });
   *     }
   *   });
   *
   *   $httpProvider.responseInterceptors.push('myHttpInterceptor');
   *
   *
   *   // register the interceptor via an anonymous factory
   *   $httpProvider.responseInterceptors.push(function($q, dependency1, dependency2) {
   *     return function(promise) {
   *       // same as above
   *     }
   *   });
   * </pre>
   *
   *
   * # Security Considerations
   *
   * When designing web applications, consider security threats from:
   *
   * - {@link http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
   *   JSON Vulnerability}
   * - {@link http://en.wikipedia.org/wiki/Cross-site_request_forgery XSRF}
   *
   * Both server and the client must cooperate in order to eliminate these threats. Angular comes
   * pre-configured with strategies that address these issues, but for this to work backend server
   * cooperation is required.
   *
   * ## JSON Vulnerability Protection
   *
   * A {@link http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
   * JSON Vulnerability} allows third party web-site to turn your JSON resource URL into
   * {@link http://en.wikipedia.org/wiki/JSON#JSONP JSONP} request under some conditions. To
   * counter this your server can prefix all JSON requests with following string `")]}',\n"`.
   * Angular will automatically strip the prefix before processing it as JSON.
   *
   * For example if your server needs to return:
   * <pre>
   * ['one','two']
   * </pre>
   *
   * which is vulnerable to attack, your server can return:
   * <pre>
   * )]}',
   * ['one','two']
   * </pre>
   *
   * Angular will strip the prefix, before processing the JSON.
   *
   *
   * ## Cross Site Request Forgery (XSRF) Protection
   *
   * {@link http://en.wikipedia.org/wiki/Cross-site_request_forgery XSRF} is a technique by which
   * an unauthorized site can gain your user's private data. Angular provides following mechanism
   * to counter XSRF. When performing XHR requests, the $http service reads a token from a cookie
   * called `XSRF-TOKEN` and sets it as the HTTP header `X-XSRF-TOKEN`. Since only JavaScript that
   * runs on your domain could read the cookie, your server can be assured that the XHR came from
   * JavaScript running on your domain.
   *
   * To take advantage of this, your server needs to set a token in a JavaScript readable session
   * cookie called `XSRF-TOKEN` on first HTTP GET request. On subsequent non-GET requests the
   * server can verify that the cookie matches `X-XSRF-TOKEN` HTTP header, and therefore be sure
   * that only JavaScript running on your domain could have read the token. The token must be
   * unique for each user and must be verifiable by the server (to prevent the JavaScript making
   * up its own tokens). We recommend that the token is a digest of your site's authentication
   * cookie with {@link http://en.wikipedia.org/wiki/Rainbow_table salt for added security}.
   *
   *
   * @param {object} config Object describing the request to be made and how it should be
   *    processed. The object has following properties:
   *
   *    - **method** – `{string}` – HTTP method (e.g. 'GET', 'POST', etc)
   *    - **url** – `{string}` – Absolute or relative URL of the resource that is being requested.
   *    - **params** – `{Object.<string|Object>}` – Map of strings or objects which will be turned to
   *      `?key1=value1&key2=value2` after the url. If the value is not a string, it will be JSONified.
   *    - **data** – `{string|Object}` – Data to be sent as the request message data.
   *    - **headers** – `{Object}` – Map of strings representing HTTP headers to send to the server.
   *    - **transformRequest** – `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
   *      transform function or an array of such functions. The transform function takes the http
   *      request body and headers and returns its transformed (typically serialized) version.
   *    - **transformResponse** – `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
   *      transform function or an array of such functions. The transform function takes the http
   *      response body and headers and returns its transformed (typically deserialized) version.
   *    - **cache** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the
   *      GET request, otherwise if a cache instance built with
   *      {@link ng.$cacheFactory $cacheFactory}, this cache will be used for
   *      caching.
   *    - **timeout** – `{number}` – timeout in milliseconds.
   *    - **withCredentials** - `{boolean}` - whether to to set the `withCredentials` flag on the
   *      XHR object. See {@link https://developer.mozilla.org/en/http_access_control#section_5
   *      requests with credentials} for more information.
   *
   * @returns {HttpPromise} Returns a {@link ng.$q promise} object with the
   *   standard `then` method and two http specific methods: `success` and `error`. The `then`
   *   method takes two arguments a success and an error callback which will be called with a
   *   response object. The `success` and `error` methods take a single argument - a function that
   *   will be called when the request succeeds or fails respectively. The arguments passed into
   *   these functions are destructured representation of the response object passed into the
   *   `then` method. The response object has these properties:
   *
   *   - **data** – `{string|Object}` – The response body transformed with the transform functions.
   *   - **status** – `{number}` – HTTP status code of the response.
   *   - **headers** – `{function([headerName])}` – Header getter function.
   *   - **config** – `{Object}` – The configuration object that was used to generate the request.
   *
   * @property {Array.<Object>} pendingRequests Array of config objects for currently pending
   *   requests. This is primarily meant to be used for debugging purposes.
   *
   *
   * @example
    <example>
      <file name="index.html">
        <div ng-controller="FetchCtrl">
          <select ng-model="method">
            <option>GET</option>
            <option>JSONP</option>
          </select>
          <input type="text" ng-model="url" size="80"/>
          <button ng-click="fetch()">fetch</button><br>
          <button ng-click="updateModel('GET', 'http-hello.html')">Sample GET</button>
          <button ng-click="updateModel('JSONP', 'http://angularjs.org/greet.php?callback=JSON_CALLBACK&name=Super%20Hero')">Sample JSONP</button>
          <button ng-click="updateModel('JSONP', 'http://angularjs.org/doesntexist&callback=JSON_CALLBACK')">Invalid JSONP</button>
          <pre>http status code: {{status}}</pre>
          <pre>http response data: {{data}}</pre>
        </div>
      </file>
      <file name="script.js">
        function FetchCtrl($scope, $http, $templateCache) {
          $scope.method = 'GET';
          $scope.url = 'http-hello.html';

          $scope.fetch = function() {
            $scope.code = null;
            $scope.response = null;

            $http({method: $scope.method, url: $scope.url, cache: $templateCache}).
              success(function(data, status) {
                $scope.status = status;
                $scope.data = data;
              }).
              error(function(data, status) {
                $scope.data = data || "Request failed";
                $scope.status = status;
            });
          };

          $scope.updateModel = function(method, url) {
            $scope.method = method;
            $scope.url = url;
          };
        }
      </file>
      <file name="http-hello.html">
        Hello, $http!
      </file>
      <file name="scenario.js">
        it('should make an xhr GET request', function() {
          element(':button:contains("Sample GET")').click();
          element(':button:contains("fetch")').click();
          expect(binding('status')).toBe('200');
          expect(binding('data')).toMatch(/Hello, \$http!/);
        });

        it('should make a JSONP request to angularjs.org', function() {
          element(':button:contains("Sample JSONP")').click();
          element(':button:contains("fetch")').click();
          expect(binding('status')).toBe('200');
          expect(binding('data')).toMatch(/Super Hero!/);
        });

        it('should make JSONP request to invalid URL and invoke the error handler',
            function() {
          element(':button:contains("Invalid JSONP")').click();
          element(':button:contains("fetch")').click();
          expect(binding('status')).toBe('0');
          expect(binding('data')).toBe('Request failed');
        });
      </file>
    </example>
   */
  function $http(config) {
    config.method = uppercase(config.method);

    var reqTransformFn = config.transformRequest || $config.transformRequest,
        respTransformFn = config.transformResponse || $config.transformResponse,
        defHeaders = $config.headers,
        reqHeaders = extend({'X-XSRF-TOKEN': $browser.cookies()['XSRF-TOKEN']},
            defHeaders.common, defHeaders[lowercase(config.method)], config.headers),
        reqData = transformData(config.data, headersGetter(reqHeaders), reqTransformFn),
        promise;

    // strip content-type if data is undefined
    if (isUndefined(config.data)) {
      delete reqHeaders['Content-Type'];
    }

    // send request
    promise = sendReq(config, reqData, reqHeaders);

    // transform future response
    promise = promise.then(transformResponse, transformResponse);

    // apply interceptors
    forEach(responseInterceptors, function(interceptor) {
      promise = interceptor(promise);
    });

    promise.success = function(fn) {
      promise.then(function(response) {
        fn(response.data, response.status, response.headers, config);
      });
      return promise;
    };

    promise.error = function(fn) {
      promise.then(null, function(response) {
        fn(response.data, response.status, response.headers, config);
      });
      return promise;
    };

    return promise;

    function transformResponse(response) {
      // make a copy since the response must be cacheable
      var resp = extend({}, response, {
        data: transformData(response.data, response.headers, respTransformFn)
      });
      return (isSuccess(response.status))
        ? resp
        : $q.reject(resp);
    }
  }

  $http.pendingRequests = [];

  /**
   * @ngdoc method
   * @name ng.$http#get
   * @methodOf ng.$http
   *
   * @description
   * Shortcut method to perform `GET` request
   *
   * @param {string} url Relative or absolute URL specifying the destination of the request
   * @param {Object=} config Optional configuration object
   * @returns {HttpPromise} Future object
   */

  /**
   * @ngdoc method
   * @name ng.$http#delete
   * @methodOf ng.$http
   *
   * @description
   * Shortcut method to perform `DELETE` request
   *
   * @param {string} url Relative or absolute URL specifying the destination of the request
   * @param {Object=} config Optional configuration object
   * @returns {HttpPromise} Future object
   */

  /**
   * @ngdoc method
   * @name ng.$http#head
   * @methodOf ng.$http
   *
   * @description
   * Shortcut method to perform `HEAD` request
   *
   * @param {string} url Relative or absolute URL specifying the destination of the request
   * @param {Object=} config Optional configuration object
   * @returns {HttpPromise} Future object
   */

  /**
   * @ngdoc method
   * @name ng.$http#jsonp
   * @methodOf ng.$http
   *
   * @description
   * Shortcut method to perform `JSONP` request
   *
   * @param {string} url Relative or absolute URL specifying the destination of the request.
   *                     Should contain `JSON_CALLBACK` string.
   * @param {Object=} config Optional configuration object
   * @returns {HttpPromise} Future object
   */
  createShortMethods('get', 'delete', 'head', 'jsonp');

  /**
   * @ngdoc method
   * @name ng.$http#post
   * @methodOf ng.$http
   *
   * @description
   * Shortcut method to perform `POST` request
   *
   * @param {string} url Relative or absolute URL specifying the destination of the request
   * @param {*} data Request content
   * @param {Object=} config Optional configuration object
   * @returns {HttpPromise} Future object
   */

  /**
   * @ngdoc method
   * @name ng.$http#put
   * @methodOf ng.$http
   *
   * @description
   * Shortcut method to perform `PUT` request
   *
   * @param {string} url Relative or absolute URL specifying the destination of the request
   * @param {*} data Request content
   * @param {Object=} config Optional configuration object
   * @returns {HttpPromise} Future object
   */
  createShortMethodsWithData('post', 'put');

      /**
       * @ngdoc property
       * @name ng.$http#defaults
       * @propertyOf ng.$http
       *
       * @description
       * Runtime equivalent of the `$httpProvider.defaults` property. Allows configuration of
       * default headers as well as request and response transformations.
       *
       * See "Setting HTTP Headers" and "Transforming Requests and Responses" sections above.
       */
  $http.defaults = $config;

  return $http;

  function createShortMethods(names) {
    forEach(arguments, function(name) {
      $http[name] = function(url, config) {
        return $http(extend(config || {}, {
          method: name,
          url: url
        }));
      };
    });
  }

  function createShortMethodsWithData(name) {
    forEach(arguments, function(name) {
      $http[name] = function(url, data, config) {
        return $http(extend(config || {}, {
          method: name,
          url: url,
          data: data
        }));
      };
    });
  }

  /**
   * Makes the request
   *
   * !!! ACCESSES CLOSURE VARS:
   * $httpBackend, $config, $log, $rootScope, defaultCache, $http.pendingRequests
   */
  function sendReq(config, reqData, reqHeaders) {
    var deferred = $q.defer(),
        promise = deferred.promise,
        cache,
        cachedResp,
        url = buildUrl(config.url, config.params);

    $http.pendingRequests.push(config);
    promise.then(removePendingReq, removePendingReq);

    if (config.cache && config.method == 'GET') {
      cache = isObject(config.cache) ? config.cache : defaultCache;
    }

    if (cache) {
      cachedResp = cache.get(url);
      if (cachedResp) {
        if (cachedResp.then) {
          // cached request has already been sent, but there is no response yet
          cachedResp.then(removePendingReq, removePendingReq);
          return cachedResp;
        } else {
          // serving from cache
          if (isArray(cachedResp)) {
            resolvePromise(cachedResp[1], cachedResp[0], copy(cachedResp[2]));
          } else {
            resolvePromise(cachedResp, 200, {});
          }
        }
      } else {
        // put the promise for the non-transformed response into cache as a placeholder
        cache.put(url, promise);
      }
    }

    // if we won't have the response in cache, send the request to the backend
    if (!cachedResp) {
      $httpBackend(config.method, url, reqData, done, reqHeaders, config.timeout,
          config.withCredentials);
    }

    return promise;

    /**
     * Callback registered to $httpBackend():
     *  - caches the response if desired
     *  - resolves the raw $http promise
     *  - calls $apply
     */
    function done(status, response, headersString) {
      if (cache) {
        if (isSuccess(status)) {
          cache.put(url, [status, response, parseHeaders(headersString)]);
        } else {
          // remove promise from the cache
          cache.remove(url);
        }
      }

      resolvePromise(response, status, headersString);
      $rootScope.$apply();
    }

    /**
     * Resolves the raw $http promise.
     */
    function resolvePromise(response, status, headers) {
      // normalize internal statuses to 0
      status = Math.max(status, 0);

      (isSuccess(status) ? deferred.resolve : deferred.reject)({
        data: response,
        status: status,
        headers: headersGetter(headers),
        config: config
      });
    }

    function removePendingReq() {
      var idx = indexOf($http.pendingRequests, config);
      if (idx !== -1) $http.pendingRequests.splice(idx, 1);
    }
  }

  function buildUrl(url, params) {
        if (!params) return url;
        var parts = [];
        forEachSorted(params, function(value, key) {
          if (value == null || value == undefined) return;
          if (isObject(value)) {
            value = toJson(value);
          }
          parts.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));
        });
        return url + ((url.indexOf('?') == -1) ? '?' : '&') + parts.join('&');
      }

}];

}

var XHR = window.XMLHttpRequest || function() {

try { return new ActiveXObject("Msxml2.XMLHTTP.6.0"); } catch (e1) {}
try { return new ActiveXObject("Msxml2.XMLHTTP.3.0"); } catch (e2) {}
try { return new ActiveXObject("Msxml2.XMLHTTP"); } catch (e3) {}
throw new Error("This browser does not support XMLHttpRequest.");

};

/**

* @ngdoc object
* @name ng.$httpBackend
* @requires $browser
* @requires $window
* @requires $document
*
* @description
* HTTP backend used by the {@link ng.$http service} that delegates to
* XMLHttpRequest object or JSONP and deals with browser incompatibilities.
*
* You should never need to use this service directly, instead use the higher-level abstractions:
* {@link ng.$http $http} or {@link ngResource.$resource $resource}.
*
* During testing this implementation is swapped with {@link ngMock.$httpBackend mock
* $httpBackend} which can be trained with responses.
*/

function $HttpBackendProvider() {

this.$get = ['$browser', '$window', '$document', function($browser, $window, $document) {
  return createHttpBackend($browser, XHR, $browser.defer, $window.angular.callbacks,
      $document[0], $window.location.protocol.replace(':', ''));
}];

}

function createHttpBackend($browser, XHR, $browserDefer, callbacks, rawDocument, locationProtocol) {

// TODO(vojta): fix the signature
return function(method, url, post, callback, headers, timeout, withCredentials) {
  $browser.$$incOutstandingRequestCount();
  url = url || $browser.url();

  if (lowercase(method) == 'jsonp') {
    var callbackId = '_' + (callbacks.counter++).toString(36);
    callbacks[callbackId] = function(data) {
      callbacks[callbackId].data = data;
    };

    jsonpReq(url.replace('JSON_CALLBACK', 'angular.callbacks.' + callbackId),
        function() {
      if (callbacks[callbackId].data) {
        completeRequest(callback, 200, callbacks[callbackId].data);
      } else {
        completeRequest(callback, -2);
      }
      delete callbacks[callbackId];
    });
  } else {
    var xhr = new XHR();
    xhr.open(method, url, true);
    forEach(headers, function(value, key) {
      if (value) xhr.setRequestHeader(key, value);
    });

    var status;

    // In IE6 and 7, this might be called synchronously when xhr.send below is called and the
    // response is in the cache. the promise api will ensure that to the app code the api is
    // always async
    xhr.onreadystatechange = function() {
      if (xhr.readyState == 4) {
        var responseHeaders = xhr.getAllResponseHeaders();

        // TODO(vojta): remove once Firefox 21 gets released.
        // begin: workaround to overcome Firefox CORS http response headers bug
        // https://bugzilla.mozilla.org/show_bug.cgi?id=608735
        // Firefox already patched in nightly. Should land in Firefox 21.

        // CORS "simple response headers" http://www.w3.org/TR/cors/
        var value,
            simpleHeaders = ["Cache-Control", "Content-Language", "Content-Type",
                                "Expires", "Last-Modified", "Pragma"];
        if (!responseHeaders) {
          responseHeaders = "";
          forEach(simpleHeaders, function (header) {
            var value = xhr.getResponseHeader(header);
            if (value) {
                responseHeaders += header + ": " + value + "\n";
            }
          });
        }
        // end of the workaround.

        completeRequest(callback, status || xhr.status, xhr.responseText,
                        responseHeaders);
      }
    };

    if (withCredentials) {
      xhr.withCredentials = true;
    }

    xhr.send(post || '');

    if (timeout > 0) {
      $browserDefer(function() {
        status = -1;
        xhr.abort();
      }, timeout);
    }
  }

  function completeRequest(callback, status, response, headersString) {
    // URL_MATCH is defined in src/service/location.js
    var protocol = (url.match(URL_MATCH) || ['', locationProtocol])[1];

    // fix status code for file protocol (it's always 0)
    status = (protocol == 'file') ? (response ? 200 : 404) : status;

    // normalize IE bug (http://bugs.jquery.com/ticket/1450)
    status = status == 1223 ? 204 : status;

    callback(status, response, headersString);
    $browser.$$completeOutstandingRequest(noop);
  }
};

function jsonpReq(url, done) {
  // we can't use jQuery/jqLite here because jQuery does crazy shit with script elements, e.g.:
  // - fetches local scripts via XHR and evals them
  // - adds and immediately removes script elements from the document
  var script = rawDocument.createElement('script'),
      doneWrapper = function() {
        rawDocument.body.removeChild(script);
        if (done) done();
      };

  script.type = 'text/javascript';
  script.src = url;

  if (msie) {
    script.onreadystatechange = function() {
      if (/loaded|complete/.test(script.readyState)) doneWrapper();
    };
  } else {
    script.onload = script.onerror = doneWrapper;
  }

  rawDocument.body.appendChild(script);
}

}

/**

* @ngdoc object
* @name ng.$locale
*
* @description
* $locale service provides localization rules for various Angular components. As of right now the
* only public api is:
*
* * `id` – `{string}` – locale id formatted as `languageId-countryId` (e.g. `en-us`)
*/

function $LocaleProvider(){

this.$get = function() {
  return {
    id: 'en-us',

    NUMBER_FORMATS: {
      DECIMAL_SEP: '.',
      GROUP_SEP: ',',
      PATTERNS: [
        { // Decimal Pattern
          minInt: 1,
          minFrac: 0,
          maxFrac: 3,
          posPre: '',
          posSuf: '',
          negPre: '-',
          negSuf: '',
          gSize: 3,
          lgSize: 3
        },{ //Currency Pattern
          minInt: 1,
          minFrac: 2,
          maxFrac: 2,
          posPre: '\u00A4',
          posSuf: '',
          negPre: '(\u00A4',
          negSuf: ')',
          gSize: 3,
          lgSize: 3
        }
      ],
      CURRENCY_SYM: '$'
    },

    DATETIME_FORMATS: {
      MONTH: 'January,February,March,April,May,June,July,August,September,October,November,December'
              .split(','),
      SHORTMONTH:  'Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec'.split(','),
      DAY: 'Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday'.split(','),
      SHORTDAY: 'Sun,Mon,Tue,Wed,Thu,Fri,Sat'.split(','),
      AMPMS: ['AM','PM'],
      medium: 'MMM d, y h:mm:ss a',
      short: 'M/d/yy h:mm a',
      fullDate: 'EEEE, MMMM d, y',
      longDate: 'MMMM d, y',
      mediumDate: 'MMM d, y',
      shortDate: 'M/d/yy',
      mediumTime: 'h:mm:ss a',
      shortTime: 'h:mm a'
    },

    pluralCat: function(num) {
      if (num === 1) {
        return 'one';
      }
      return 'other';
    }
  };
};

}

function $TimeoutProvider() {

this.$get = ['$rootScope', '$browser', '$q', '$exceptionHandler',
     function($rootScope,   $browser,   $q,   $exceptionHandler) {
  var deferreds = {};

   /**
    * @ngdoc function
    * @name ng.$timeout
    * @requires $browser
    *
    * @description
    * Angular's wrapper for `window.setTimeout`. The `fn` function is wrapped into a try/catch
    * block and delegates any exceptions to
    * {@link ng.$exceptionHandler $exceptionHandler} service.
    *
    * The return value of registering a timeout function is a promise which will be resolved when
    * the timeout is reached and the timeout function is executed.
    *
    * To cancel a the timeout request, call `$timeout.cancel(promise)`.
    *
    * In tests you can use {@link ngMock.$timeout `$timeout.flush()`} to
    * synchronously flush the queue of deferred functions.
    *
    * @param {function()} fn A function, who's execution should be delayed.
    * @param {number=} [delay=0] Delay in milliseconds.
    * @param {boolean=} [invokeApply=true] If set to false skips model dirty checking, otherwise
    *   will invoke `fn` within the {@link ng.$rootScope.Scope#$apply $apply} block.
    * @returns {Promise} Promise that will be resolved when the timeout is reached. The value this
    *   promise will be resolved with is the return value of the `fn` function.
    */
  function timeout(fn, delay, invokeApply) {
    var deferred = $q.defer(),
        promise = deferred.promise,
        skipApply = (isDefined(invokeApply) && !invokeApply),
        timeoutId, cleanup;

    timeoutId = $browser.defer(function() {
      try {
        deferred.resolve(fn());
      } catch(e) {
        deferred.reject(e);
        $exceptionHandler(e);
      }

      if (!skipApply) $rootScope.$apply();
    }, delay);

    cleanup = function() {
      delete deferreds[promise.$$timeoutId];
    };

    promise.$$timeoutId = timeoutId;
    deferreds[timeoutId] = deferred;
    promise.then(cleanup, cleanup);

    return promise;
  }

   /**
    * @ngdoc function
    * @name ng.$timeout#cancel
    * @methodOf ng.$timeout
    *
    * @description
    * Cancels a task associated with the `promise`. As a result of this the promise will be
    * resolved with a rejection.
    *
    * @param {Promise=} promise Promise returned by the `$timeout` function.
    * @returns {boolean} Returns `true` if the task hasn't executed yet and was successfully
    *   canceled.
    */
  timeout.cancel = function(promise) {
    if (promise && promise.$$timeoutId in deferreds) {
      deferreds[promise.$$timeoutId].reject('canceled');
      return $browser.defer.cancel(promise.$$timeoutId);
    }
    return false;
  };

  return timeout;
}];

}

/**

* @ngdoc object
* @name ng.$filterProvider
* @description
*
* Filters are just functions which transform input to an output. However filters need to be Dependency Injected. To
* achieve this a filter definition consists of a factory function which is annotated with dependencies and is
* responsible for creating a filter function.
*
* <pre>
*   // Filter registration
*   function MyModule($provide, $filterProvider) {
*     // create a service to demonstrate injection (not always needed)
*     $provide.value('greet', function(name){
*       return 'Hello ' + name + '!';
*     });
*
*     // register a filter factory which uses the
*     // greet service to demonstrate DI.
*     $filterProvider.register('greet', function(greet){
*       // return the filter function which uses the greet service
*       // to generate salutation
*       return function(text) {
*         // filters need to be forgiving so check input validity
*         return text && greet(text) || text;
*       };
*     });
*   }
* </pre>
*
* The filter function is registered with the `$injector` under the filter name suffixe with `Filter`.
* <pre>
*   it('should be the same instance', inject(
*     function($filterProvider) {
*       $filterProvider.register('reverse', function(){
*         return ...;
*       });
*     },
*     function($filter, reverseFilter) {
*       expect($filter('reverse')).toBe(reverseFilter);
*     });
* </pre>
*
*
* For more information about how angular filters work, and how to create your own filters, see
* {@link guide/dev_guide.templates.filters Understanding Angular Filters} in the angular Developer
* Guide.
*/

/**

* @ngdoc method
* @name ng.$filterProvider#register
* @methodOf ng.$filterProvider
* @description
* Register filter factory function.
*
* @param {String} name Name of the filter.
* @param {function} fn The filter factory function which is injectable.
*/

/**

* @ngdoc function
* @name ng.$filter
* @function
* @description
* Filters are used for formatting data displayed to the user.
*
* The general syntax in templates is as follows:
*
*         {{ expression | [ filter_name ] }}
*
* @param {String} name Name of the filter function to retrieve
* @return {Function} the filter function
*/

$FilterProvider.$inject = ['$provide']; function $FilterProvider($provide) {

var suffix = 'Filter';

function register(name, factory) {
  return $provide.factory(name + suffix, factory);
}
this.register = register;

this.$get = ['$injector', function($injector) {
  return function(name) {
    return $injector.get(name + suffix);
  }
}];

////////////////////////////////////////

register('currency', currencyFilter);
register('date', dateFilter);
register('filter', filterFilter);
register('json', jsonFilter);
register('limitTo', limitToFilter);
register('lowercase', lowercaseFilter);
register('number', numberFilter);
register('orderBy', orderByFilter);
register('uppercase', uppercaseFilter);

}

/**

* @ngdoc filter
* @name ng.filter:filter
* @function
*
* @description
* Selects a subset of items from `array` and returns it as a new array.
*
* Note: This function is used to augment the `Array` type in Angular expressions. See
* {@link ng.$filter} for more information about Angular arrays.
*
* @param {Array} array The source array.
* @param {string|Object|function()} expression The predicate to be used for selecting items from
*   `array`.
*
*   Can be one of:
*
*   - `string`: Predicate that results in a substring match using the value of `expression`
*     string. All strings or objects with string properties in `array` that contain this string
*     will be returned. The predicate can be negated by prefixing the string with `!`.
*
*   - `Object`: A pattern object can be used to filter specific properties on objects contained
*     by `array`. For example `{name:"M", phone:"1"}` predicate will return an array of items
*     which have property `name` containing "M" and property `phone` containing "1". A special
*     property name `$` can be used (as in `{$:"text"}`) to accept a match against any
*     property of the object. That's equivalent to the simple substring match with a `string`
*     as described above.
*
*   - `function`: A predicate function can be used to write arbitrary filters. The function is
*     called for each element of `array`. The final result is an array of those elements that
*     the predicate returned true for.
*
* @example
  <doc:example>
    <doc:source>
      <div ng-init="friends = [{name:'John', phone:'555-1276'},
                               {name:'Mary', phone:'800-BIG-MARY'},
                               {name:'Mike', phone:'555-4321'},
                               {name:'Adam', phone:'555-5678'},
                               {name:'Julie', phone:'555-8765'}]"></div>

      Search: <input ng-model="searchText">
      <table id="searchTextResults">
        <tr><th>Name</th><th>Phone</th></tr>
        <tr ng-repeat="friend in friends | filter:searchText">
          <td>{{friend.name}}</td>
          <td>{{friend.phone}}</td>
        </tr>
      </table>
      <hr>
      Any: <input ng-model="search.$"> <br>
      Name only <input ng-model="search.name"><br>
      Phone only <input ng-model="search.phone"å><br>
      <table id="searchObjResults">
        <tr><th>Name</th><th>Phone</th></tr>
        <tr ng-repeat="friend in friends | filter:search">
          <td>{{friend.name}}</td>
          <td>{{friend.phone}}</td>
        </tr>
      </table>
    </doc:source>
    <doc:scenario>
      it('should search across all fields when filtering with a string', function() {
        input('searchText').enter('m');
        expect(repeater('#searchTextResults tr', 'friend in friends').column('friend.name')).
          toEqual(['Mary', 'Mike', 'Adam']);

        input('searchText').enter('76');
        expect(repeater('#searchTextResults tr', 'friend in friends').column('friend.name')).
          toEqual(['John', 'Julie']);
      });

      it('should search in specific fields when filtering with a predicate object', function() {
        input('search.$').enter('i');
        expect(repeater('#searchObjResults tr', 'friend in friends').column('friend.name')).
          toEqual(['Mary', 'Mike', 'Julie']);
      });
    </doc:scenario>
  </doc:example>
*/

function filterFilter() {

return function(array, expression) {
  if (!isArray(array)) return array;
  var predicates = [];
  predicates.check = function(value) {
    for (var j = 0; j < predicates.length; j++) {
      if(!predicates[j](value)) {
        return false;
      }
    }
    return true;
  };
  var search = function(obj, text){
    if (text.charAt(0) === '!') {
      return !search(obj, text.substr(1));
    }
    switch (typeof obj) {
      case "boolean":
      case "number":
      case "string":
        return ('' + obj).toLowerCase().indexOf(text) > -1;
      case "object":
        for ( var objKey in obj) {
          if (objKey.charAt(0) !== '$' && search(obj[objKey], text)) {
            return true;
          }
        }
        return false;
      case "array":
        for ( var i = 0; i < obj.length; i++) {
          if (search(obj[i], text)) {
            return true;
          }
        }
        return false;
      default:
        return false;
    }
  };
  switch (typeof expression) {
    case "boolean":
    case "number":
    case "string":
      expression = {$:expression};
    case "object":
      for (var key in expression) {
        if (key == '$') {
          (function() {
            var text = (''+expression[key]).toLowerCase();
            if (!text) return;
            predicates.push(function(value) {
              return search(value, text);
            });
          })();
        } else {
          (function() {
            var path = key;
            var text = (''+expression[key]).toLowerCase();
            if (!text) return;
            predicates.push(function(value) {
              return search(getter(value, path), text);
            });
          })();
        }
      }
      break;
    case 'function':
      predicates.push(expression);
      break;
    default:
      return array;
  }
  var filtered = [];
  for ( var j = 0; j < array.length; j++) {
    var value = array[j];
    if (predicates.check(value)) {
      filtered.push(value);
    }
  }
  return filtered;
}

}

/**

* @ngdoc filter
* @name ng.filter:currency
* @function
*
* @description
* Formats a number as a currency (ie $1,234.56). When no currency symbol is provided, default
* symbol for current locale is used.
*
* @param {number} amount Input to filter.
* @param {string=} symbol Currency symbol or identifier to be displayed.
* @returns {string} Formatted number.
*
*
* @example
  <doc:example>
    <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.amount = 1234.56;
        }
      </script>
      <div ng-controller="Ctrl">
        <input type="number" ng-model="amount"> <br>
        default currency symbol ($): {{amount | currency}}<br>
        custom currency identifier (USD$): {{amount | currency:"USD$"}}
      </div>
    </doc:source>
    <doc:scenario>
      it('should init with 1234.56', function() {
        expect(binding('amount | currency')).toBe('$1,234.56');
        expect(binding('amount | currency:"USD$"')).toBe('USD$1,234.56');
      });
      it('should update', function() {
        input('amount').enter('-1234');
        expect(binding('amount | currency')).toBe('($1,234.00)');
        expect(binding('amount | currency:"USD$"')).toBe('(USD$1,234.00)');
      });
    </doc:scenario>
  </doc:example>
*/

currencyFilter.$inject = ['$locale']; function currencyFilter($locale) {

var formats = $locale.NUMBER_FORMATS;
return function(amount, currencySymbol){
  if (isUndefined(currencySymbol)) currencySymbol = formats.CURRENCY_SYM;
  return formatNumber(amount, formats.PATTERNS[1], formats.GROUP_SEP, formats.DECIMAL_SEP, 2).
              replace(/\u00A4/g, currencySymbol);
};

}

/**

* @ngdoc filter
* @name ng.filter:number
* @function
*
* @description
* Formats a number as text.
*
* If the input is not a number an empty string is returned.
*
* @param {number|string} number Number to format.
* @param {(number|string)=} [fractionSize=2] Number of decimal places to round the number to.
* @returns {string} Number rounded to decimalPlaces and places a “,” after each third digit.
*
* @example
  <doc:example>
    <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.val = 1234.56789;
        }
      </script>
      <div ng-controller="Ctrl">
        Enter number: <input ng-model='val'><br>
        Default formatting: {{val | number}}<br>
        No fractions: {{val | number:0}}<br>
        Negative number: {{-val | number:4}}
      </div>
    </doc:source>
    <doc:scenario>
      it('should format numbers', function() {
        expect(binding('val | number')).toBe('1,234.568');
        expect(binding('val | number:0')).toBe('1,235');
        expect(binding('-val | number:4')).toBe('-1,234.5679');
      });

      it('should update', function() {
        input('val').enter('3374.333');
        expect(binding('val | number')).toBe('3,374.333');
        expect(binding('val | number:0')).toBe('3,374');
        expect(binding('-val | number:4')).toBe('-3,374.3330');
      });
    </doc:scenario>
  </doc:example>
*/

numberFilter.$inject = ['$locale']; function numberFilter($locale) {

var formats = $locale.NUMBER_FORMATS;
return function(number, fractionSize) {
  return formatNumber(number, formats.PATTERNS[0], formats.GROUP_SEP, formats.DECIMAL_SEP,
    fractionSize);
};

}

var DECIMAL_SEP = '.'; function formatNumber(number, pattern, groupSep, decimalSep, fractionSize) {

if (isNaN(number) || !isFinite(number)) return '';

var isNegative = number < 0;
number = Math.abs(number);
var numStr = number + '',
    formatedText = '',
    parts = [];

var hasExponent = false;
if (numStr.indexOf('e') !== -1) {
  var match = numStr.match(/([\d\.]+)e(-?)(\d+)/);
  if (match && match[2] == '-' && match[3] > fractionSize + 1) {
    numStr = '0';
  } else {
    formatedText = numStr;
    hasExponent = true;
  }
}

if (!hasExponent) {
  var fractionLen = (numStr.split(DECIMAL_SEP)[1] || '').length;

  // determine fractionSize if it is not specified
  if (isUndefined(fractionSize)) {
    fractionSize = Math.min(Math.max(pattern.minFrac, fractionLen), pattern.maxFrac);
  }

  var pow = Math.pow(10, fractionSize);
  number = Math.round(number * pow) / pow;
  var fraction = ('' + number).split(DECIMAL_SEP);
  var whole = fraction[0];
  fraction = fraction[1] || '';

  var pos = 0,
      lgroup = pattern.lgSize,
      group = pattern.gSize;

  if (whole.length >= (lgroup + group)) {
    pos = whole.length - lgroup;
    for (var i = 0; i < pos; i++) {
      if ((pos - i)%group === 0 && i !== 0) {
        formatedText += groupSep;
      }
      formatedText += whole.charAt(i);
    }
  }

  for (i = pos; i < whole.length; i++) {
    if ((whole.length - i)%lgroup === 0 && i !== 0) {
      formatedText += groupSep;
    }
    formatedText += whole.charAt(i);
  }

  // format fraction part.
  while(fraction.length < fractionSize) {
    fraction += '0';
  }

  if (fractionSize && fractionSize !== "0") formatedText += decimalSep + fraction.substr(0, fractionSize);
}

parts.push(isNegative ? pattern.negPre : pattern.posPre);
parts.push(formatedText);
parts.push(isNegative ? pattern.negSuf : pattern.posSuf);
return parts.join('');

}

function padNumber(num, digits, trim) {

var neg = '';
if (num < 0) {
  neg =  '-';
  num = -num;
}
num = '' + num;
while(num.length < digits) num = '0' + num;
if (trim)
  num = num.substr(num.length - digits);
return neg + num;

}

function dateGetter(name, size, offset, trim) {

return function(date) {
  var value = date['get' + name]();
  if (offset > 0 || value > -offset)
    value += offset;
  if (value === 0 && offset == -12 ) value = 12;
  return padNumber(value, size, trim);
};

}

function dateStrGetter(name, shortForm) {

return function(date, formats) {
  var value = date['get' + name]();
  var get = uppercase(shortForm ? ('SHORT' + name) : name);

  return formats[get][value];
};

}

function timeZoneGetter(date) {

var zone = -1 * date.getTimezoneOffset();
var paddedZone = (zone >= 0) ? "+" : "";

paddedZone += padNumber(Math[zone > 0 ? 'floor' : 'ceil'](zone / 60), 2) +
              padNumber(Math.abs(zone % 60), 2);

return paddedZone;

}

function ampmGetter(date, formats) {

return date.getHours() < 12 ? formats.AMPMS[0] : formats.AMPMS[1];

}

var DATE_FORMATS = {

yyyy: dateGetter('FullYear', 4),
  yy: dateGetter('FullYear', 2, 0, true),
   y: dateGetter('FullYear', 1),
MMMM: dateStrGetter('Month'),
 MMM: dateStrGetter('Month', true),
  MM: dateGetter('Month', 2, 1),
   M: dateGetter('Month', 1, 1),
  dd: dateGetter('Date', 2),
   d: dateGetter('Date', 1),
  HH: dateGetter('Hours', 2),
   H: dateGetter('Hours', 1),
  hh: dateGetter('Hours', 2, -12),
   h: dateGetter('Hours', 1, -12),
  mm: dateGetter('Minutes', 2),
   m: dateGetter('Minutes', 1),
  ss: dateGetter('Seconds', 2),
   s: dateGetter('Seconds', 1),
EEEE: dateStrGetter('Day'),
 EEE: dateStrGetter('Day', true),
   a: ampmGetter,
   Z: timeZoneGetter

};

var DATE_FORMATS_SPLIT = /((?:[^yMdHhmsaZE’]+)|(?:‘(?:|'')*')|(?:E+|y+|M+|d+|H+|h+|m+|s+|a|Z))(.*)/,

NUMBER_STRING = /^\d+$/;

/**

* @ngdoc filter
* @name ng.filter:date
* @function
*
* @description
*   Formats `date` to a string based on the requested `format`.
*
*   `format` string can be composed of the following elements:
*
*   * `'yyyy'`: 4 digit representation of year (e.g. AD 1 => 0001, AD 2010 => 2010)
*   * `'yy'`: 2 digit representation of year, padded (00-99). (e.g. AD 2001 => 01, AD 2010 => 10)
*   * `'y'`: 1 digit representation of year, e.g. (AD 1 => 1, AD 199 => 199)
*   * `'MMMM'`: Month in year (January-December)
*   * `'MMM'`: Month in year (Jan-Dec)
*   * `'MM'`: Month in year, padded (01-12)
*   * `'M'`: Month in year (1-12)
*   * `'dd'`: Day in month, padded (01-31)
*   * `'d'`: Day in month (1-31)
*   * `'EEEE'`: Day in Week,(Sunday-Saturday)
*   * `'EEE'`: Day in Week, (Sun-Sat)
*   * `'HH'`: Hour in day, padded (00-23)
*   * `'H'`: Hour in day (0-23)
*   * `'hh'`: Hour in am/pm, padded (01-12)
*   * `'h'`: Hour in am/pm, (1-12)
*   * `'mm'`: Minute in hour, padded (00-59)
*   * `'m'`: Minute in hour (0-59)
*   * `'ss'`: Second in minute, padded (00-59)
*   * `'s'`: Second in minute (0-59)
*   * `'a'`: am/pm marker
*   * `'Z'`: 4 digit (+sign) representation of the timezone offset (-1200-+1200)
*
*   `format` string can also be one of the following predefined
*   {@link guide/i18n localizable formats}:
*
*   * `'medium'`: equivalent to `'MMM d, y h:mm:ss a'` for en_US locale
*     (e.g. Sep 3, 2010 12:05:08 pm)
*   * `'short'`: equivalent to `'M/d/yy h:mm a'` for en_US  locale (e.g. 9/3/10 12:05 pm)
*   * `'fullDate'`: equivalent to `'EEEE, MMMM d,y'` for en_US  locale
*     (e.g. Friday, September 3, 2010)
*   * `'longDate'`: equivalent to `'MMMM d, y'` for en_US  locale (e.g. September 3, 2010
*   * `'mediumDate'`: equivalent to `'MMM d, y'` for en_US  locale (e.g. Sep 3, 2010)
*   * `'shortDate'`: equivalent to `'M/d/yy'` for en_US locale (e.g. 9/3/10)
*   * `'mediumTime'`: equivalent to `'h:mm:ss a'` for en_US locale (e.g. 12:05:08 pm)
*   * `'shortTime'`: equivalent to `'h:mm a'` for en_US locale (e.g. 12:05 pm)
*
*   `format` string can contain literal values. These need to be quoted with single quotes (e.g.
*   `"h 'in the morning'"`). In order to output single quote, use two single quotes in a sequence
*   (e.g. `"h o''clock"`).
*
* @param {(Date|number|string)} date Date to format either as Date object, milliseconds (string or
*    number) or various ISO 8601 datetime string formats (e.g. yyyy-MM-ddTHH:mm:ss.SSSZ and it's
*    shorter versions like yyyy-MM-ddTHH:mmZ, yyyy-MM-dd or yyyyMMddTHHmmssZ). If no timezone is
*    specified in the string input, the time is considered to be in the local timezone.
* @param {string=} format Formatting rules (see Description). If not specified,
*    `mediumDate` is used.
* @returns {string} Formatted string or the input if input is not recognized as date/millis.
*
* @example
  <doc:example>
    <doc:source>
      <span ng-non-bindable>{{1288323623006 | date:'medium'}}</span>:
          {{1288323623006 | date:'medium'}}<br>
      <span ng-non-bindable>{{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}</span>:
         {{1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'}}<br>
      <span ng-non-bindable>{{1288323623006 | date:'MM/dd/yyyy @ h:mma'}}</span>:
         {{'1288323623006' | date:'MM/dd/yyyy @ h:mma'}}<br>
    </doc:source>
    <doc:scenario>
      it('should format date', function() {
        expect(binding("1288323623006 | date:'medium'")).
           toMatch(/Oct 2\d, 2010 \d{1,2}:\d{2}:\d{2} (AM|PM)/);
        expect(binding("1288323623006 | date:'yyyy-MM-dd HH:mm:ss Z'")).
           toMatch(/2010\-10\-2\d \d{2}:\d{2}:\d{2} (\-|\+)?\d{4}/);
        expect(binding("'1288323623006' | date:'MM/dd/yyyy @ h:mma'")).
           toMatch(/10\/2\d\/2010 @ \d{1,2}:\d{2}(AM|PM)/);
      });
    </doc:scenario>
  </doc:example>
*/

dateFilter.$inject = ['$locale']; function dateFilter($locale) {

var R_ISO8601_STR = /^(\d{4})-?(\d\d)-?(\d\d)(?:T(\d\d)(?::?(\d\d)(?::?(\d\d)(?:\.(\d+))?)?)?(Z|([+-])(\d\d):?(\d\d))?)?$/;
function jsonStringToDate(string){
  var match;
  if (match = string.match(R_ISO8601_STR)) {
    var date = new Date(0),
        tzHour = 0,
        tzMin  = 0;
    if (match[9]) {
      tzHour = int(match[9] + match[10]);
      tzMin = int(match[9] + match[11]);
    }
    date.setUTCFullYear(int(match[1]), int(match[2]) - 1, int(match[3]));
    date.setUTCHours(int(match[4]||0) - tzHour, int(match[5]||0) - tzMin, int(match[6]||0), int(match[7]||0));
    return date;
  }
  return string;
}

return function(date, format) {
  var text = '',
      parts = [],
      fn, match;

  format = format || 'mediumDate';
  format = $locale.DATETIME_FORMATS[format] || format;
  if (isString(date)) {
    if (NUMBER_STRING.test(date)) {
      date = int(date);
    } else {
      date = jsonStringToDate(date);
    }
  }

  if (isNumber(date)) {
    date = new Date(date);
  }

  if (!isDate(date)) {
    return date;
  }

  while(format) {
    match = DATE_FORMATS_SPLIT.exec(format);
    if (match) {
      parts = concat(parts, match, 1);
      format = parts.pop();
    } else {
      parts.push(format);
      format = null;
    }
  }

  forEach(parts, function(value){
    fn = DATE_FORMATS[value];
    text += fn ? fn(date, $locale.DATETIME_FORMATS)
               : value.replace(/(^'|'$)/g, '').replace(/''/g, "'");
  });

  return text;
};

}

/**

* @ngdoc filter
* @name ng.filter:json
* @function
*
* @description
*   Allows you to convert a JavaScript object into JSON string.
*
*   This filter is mostly useful for debugging. When using the double curly {{value}} notation
*   the binding is automatically converted to JSON.
*
* @param {*} object Any JavaScript object (including arrays and primitive types) to filter.
* @returns {string} JSON string.
*
*
* @example:
  <doc:example>
    <doc:source>
      <pre>{{ {'name':'value'} | json }}</pre>
    </doc:source>
    <doc:scenario>
      it('should jsonify filtered objects', function() {
        expect(binding("{'name':'value'}")).toMatch(/\{\n  "name": ?"value"\n}/);
      });
    </doc:scenario>
  </doc:example>
*
*/

function jsonFilter() {

return function(object) {
  return toJson(object, true);
};

}

/**

* @ngdoc filter
* @name ng.filter:lowercase
* @function
* @description
* Converts string to lowercase.
* @see angular.lowercase
*/

var lowercaseFilter = valueFn(lowercase);

/**

* @ngdoc filter
* @name ng.filter:uppercase
* @function
* @description
* Converts string to uppercase.
* @see angular.uppercase
*/

var uppercaseFilter = valueFn(uppercase);

/**

* @ngdoc function
* @name ng.filter:limitTo
* @function
*
* @description
* Creates a new array containing only a specified number of elements in an array. The elements
* are taken from either the beginning or the end of the source array, as specified by the
* value and sign (positive or negative) of `limit`.
*
* Note: This function is used to augment the `Array` type in Angular expressions. See
* {@link ng.$filter} for more information about Angular arrays.
*
* @param {Array} array Source array to be limited.
* @param {string|Number} limit The length of the returned array. If the `limit` number is
*     positive, `limit` number of items from the beginning of the source array are copied.
*     If the number is negative, `limit` number  of items from the end of the source array are
*     copied. The `limit` will be trimmed if it exceeds `array.length`
* @returns {Array} A new sub-array of length `limit` or less if input array had less than `limit`
*     elements.
*
* @example
  <doc:example>
    <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.numbers = [1,2,3,4,5,6,7,8,9];
          $scope.limit = 3;
        }
      </script>
      <div ng-controller="Ctrl">
        Limit {{numbers}} to: <input type="integer" ng-model="limit">
        <p>Output: {{ numbers | limitTo:limit }}</p>
      </div>
    </doc:source>
    <doc:scenario>
      it('should limit the numer array to first three items', function() {
        expect(element('.doc-example-live input[ng-model=limit]').val()).toBe('3');
        expect(binding('numbers | limitTo:limit')).toEqual('[1,2,3]');
      });

      it('should update the output when -3 is entered', function() {
        input('limit').enter(-3);
        expect(binding('numbers | limitTo:limit')).toEqual('[7,8,9]');
      });

      it('should not exceed the maximum size of input array', function() {
        input('limit').enter(100);
        expect(binding('numbers | limitTo:limit')).toEqual('[1,2,3,4,5,6,7,8,9]');
      });
    </doc:scenario>
  </doc:example>
*/

function limitToFilter(){

return function(array, limit) {
  if (!(array instanceof Array)) return array;
  limit = int(limit);
  var out = [],
    i, n;

  // check that array is iterable
  if (!array || !(array instanceof Array))
    return out;

  // if abs(limit) exceeds maximum length, trim it
  if (limit > array.length)
    limit = array.length;
  else if (limit < -array.length)
    limit = -array.length;

  if (limit > 0) {
    i = 0;
    n = limit;
  } else {
    i = array.length + limit;
    n = array.length;
  }

  for (; i<n; i++) {
    out.push(array[i]);
  }

  return out;
}

}

/**

* @ngdoc function
* @name ng.filter:orderBy
* @function
*
* @description
* Orders a specified `array` by the `expression` predicate.
*
* Note: this function is used to augment the `Array` type in Angular expressions. See
* {@link ng.$filter} for more informaton about Angular arrays.
*
* @param {Array} array The array to sort.
* @param {function(*)|string|Array.<(function(*)|string)>} expression A predicate to be
*    used by the comparator to determine the order of elements.
*
*    Can be one of:
*
*    - `function`: Getter function. The result of this function will be sorted using the
*      `<`, `=`, `>` operator.
*    - `string`: An Angular expression which evaluates to an object to order by, such as 'name'
*      to sort by a property called 'name'. Optionally prefixed with `+` or `-` to control
*      ascending or descending sort order (for example, +name or -name).
*    - `Array`: An array of function or string predicates. The first predicate in the array
*      is used for sorting, but when two items are equivalent, the next predicate is used.
*
* @param {boolean=} reverse Reverse the order the array.
* @returns {Array} Sorted copy of the source array.
*
* @example
  <doc:example>
    <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.friends =
              [{name:'John', phone:'555-1212', age:10},
               {name:'Mary', phone:'555-9876', age:19},
               {name:'Mike', phone:'555-4321', age:21},
               {name:'Adam', phone:'555-5678', age:35},
               {name:'Julie', phone:'555-8765', age:29}]
          $scope.predicate = '-age';
        }
      </script>
      <div ng-controller="Ctrl">
        <pre>Sorting predicate = {{predicate}}; reverse = {{reverse}}</pre>
        <hr/>
        [ <a href="" ng-click="predicate=''">unsorted</a> ]
        <table class="friend">
          <tr>
            <th><a href="" ng-click="predicate = 'name'; reverse=false">Name</a>
                (<a href ng-click="predicate = '-name'; reverse=false">^</a>)</th>
            <th><a href="" ng-click="predicate = 'phone'; reverse=!reverse">Phone Number</a></th>
            <th><a href="" ng-click="predicate = 'age'; reverse=!reverse">Age</a></th>
          </tr>
          <tr ng-repeat="friend in friends | orderBy:predicate:reverse">
            <td>{{friend.name}}</td>
            <td>{{friend.phone}}</td>
            <td>{{friend.age}}</td>
          </tr>
        </table>
      </div>
    </doc:source>
    <doc:scenario>
      it('should be reverse ordered by aged', function() {
        expect(binding('predicate')).toBe('-age');
        expect(repeater('table.friend', 'friend in friends').column('friend.age')).
          toEqual(['35', '29', '21', '19', '10']);
        expect(repeater('table.friend', 'friend in friends').column('friend.name')).
          toEqual(['Adam', 'Julie', 'Mike', 'Mary', 'John']);
      });

      it('should reorder the table when user selects different predicate', function() {
        element('.doc-example-live a:contains("Name")').click();
        expect(repeater('table.friend', 'friend in friends').column('friend.name')).
          toEqual(['Adam', 'John', 'Julie', 'Mary', 'Mike']);
        expect(repeater('table.friend', 'friend in friends').column('friend.age')).
          toEqual(['35', '10', '29', '19', '21']);

        element('.doc-example-live a:contains("Phone")').click();
        expect(repeater('table.friend', 'friend in friends').column('friend.phone')).
          toEqual(['555-9876', '555-8765', '555-5678', '555-4321', '555-1212']);
        expect(repeater('table.friend', 'friend in friends').column('friend.name')).
          toEqual(['Mary', 'Julie', 'Adam', 'Mike', 'John']);
      });
    </doc:scenario>
  </doc:example>
*/

orderByFilter.$inject = ['$parse']; function orderByFilter($parse){

return function(array, sortPredicate, reverseOrder) {
  if (!isArray(array)) return array;
  if (!sortPredicate) return array;
  sortPredicate = isArray(sortPredicate) ? sortPredicate: [sortPredicate];
  sortPredicate = map(sortPredicate, function(predicate){
    var descending = false, get = predicate || identity;
    if (isString(predicate)) {
      if ((predicate.charAt(0) == '+' || predicate.charAt(0) == '-')) {
        descending = predicate.charAt(0) == '-';
        predicate = predicate.substring(1);
      }
      get = $parse(predicate);
    }
    return reverseComparator(function(a,b){
      return compare(get(a),get(b));
    }, descending);
  });
  var arrayCopy = [];
  for ( var i = 0; i < array.length; i++) { arrayCopy.push(array[i]); }
  return arrayCopy.sort(reverseComparator(comparator, reverseOrder));

  function comparator(o1, o2){
    for ( var i = 0; i < sortPredicate.length; i++) {
      var comp = sortPredicate[i](o1, o2);
      if (comp !== 0) return comp;
    }
    return 0;
  }
  function reverseComparator(comp, descending) {
    return toBoolean(descending)
        ? function(a,b){return comp(b,a);}
        : comp;
  }
  function compare(v1, v2){
    var t1 = typeof v1;
    var t2 = typeof v2;
    if (t1 == t2) {
      if (t1 == "string") v1 = v1.toLowerCase();
      if (t1 == "string") v2 = v2.toLowerCase();
      if (v1 === v2) return 0;
      return v1 < v2 ? -1 : 1;
    } else {
      return t1 < t2 ? -1 : 1;
    }
  }
}

}

function ngDirective(directive) {

if (isFunction(directive)) {
  directive = {
    link: directive
  }
}
directive.restrict = directive.restrict || 'AC';
return valueFn(directive);

}

/**

* @ngdoc directive
* @name ng.directive:a
* @restrict E
*
* @description
* Modifies the default behavior of html A tag, so that the default action is prevented when href
* attribute is empty.
*
* The reasoning for this change is to allow easy creation of action links with `ngClick` directive
* without changing the location or causing page reloads, e.g.:
* `<a href="" ng-click="model.$save()">Save</a>`
*/

var htmlAnchorDirective = valueFn({

restrict: 'E',
compile: function(element, attr) {

  if (msie <= 8) {

    // turn <a href ng-click="..">link</a> into a stylable link in IE
    // but only if it doesn't have name attribute, in which case it's an anchor
    if (!attr.href && !attr.name) {
      attr.$set('href', '');
    }

    // add a comment node to anchors to workaround IE bug that causes element content to be reset
    // to new attribute content if attribute is updated with value containing @ and element also
    // contains value with @
    // see issue #1949
    element.append(document.createComment('IE fix'));
  }

  return function(scope, element) {
    element.bind('click', function(event){
      // if we have no href url, then don't navigate anywhere.
      if (!element.attr('href')) {
        event.preventDefault();
      }
    });
  }
}

});

/**

* @ngdoc directive
* @name ng.directive:ngHref
* @restrict A
*
* @description
* Using Angular markup like {{hash}} in an href attribute makes
* the page open to a wrong URL, if the user clicks that link before
* angular has a chance to replace the {{hash}} with actual URL, the
* link will be broken and will most likely return a 404 error.
* The `ngHref` directive solves this problem.
*
* The buggy way to write it:
* <pre>
* <a href="http://www.gravatar.com/avatar/{{hash}}"/>
* </pre>
*
* The correct way to write it:
* <pre>
* <a ng-href="http://www.gravatar.com/avatar/{{hash}}"/>
* </pre>
*
* @element A
* @param {template} ngHref any string which can contain `{{}}` markup.
*
* @example
* This example uses `link` variable inside `href` attribute:
   <doc:example>
     <doc:source>
       <input ng-model="value" /><br />
       <a id="link-1" href ng-click="value = 1">link 1</a> (link, don't reload)<br />
       <a id="link-2" href="" ng-click="value = 2">link 2</a> (link, don't reload)<br />
       <a id="link-3" ng-href="/{{'123'}}">link 3</a> (link, reload!)<br />
       <a id="link-4" href="" name="xx" ng-click="value = 4">anchor</a> (link, don't reload)<br />
       <a id="link-5" name="xxx" ng-click="value = 5">anchor</a> (no link)<br />
       <a id="link-6" ng-href="{{value}}">link</a> (link, change location)
     </doc:source>
     <doc:scenario>
       it('should execute ng-click but not reload when href without value', function() {
         element('#link-1').click();
         expect(input('value').val()).toEqual('1');
         expect(element('#link-1').attr('href')).toBe("");
       });

       it('should execute ng-click but not reload when href empty string', function() {
         element('#link-2').click();
         expect(input('value').val()).toEqual('2');
         expect(element('#link-2').attr('href')).toBe("");
       });

       it('should execute ng-click and change url when ng-href specified', function() {
         expect(element('#link-3').attr('href')).toBe("/123");

         element('#link-3').click();
         expect(browser().window().path()).toEqual('/123');
       });

       it('should execute ng-click but not reload when href empty string and name specified', function() {
         element('#link-4').click();
         expect(input('value').val()).toEqual('4');
         expect(element('#link-4').attr('href')).toBe('');
       });

       it('should execute ng-click but not reload when no href but name specified', function() {
         element('#link-5').click();
         expect(input('value').val()).toEqual('5');
         expect(element('#link-5').attr('href')).toBe(undefined);
       });

       it('should only change url when only ng-href', function() {
         input('value').enter('6');
         expect(element('#link-6').attr('href')).toBe('6');

         element('#link-6').click();
         expect(browser().location().url()).toEqual('/6');
       });
     </doc:scenario>
   </doc:example>
*/

/**

* @ngdoc directive
* @name ng.directive:ngSrc
* @restrict A
*
* @description
* Using Angular markup like `{{hash}}` in a `src` attribute doesn't
* work right: The browser will fetch from the URL with the literal
* text `{{hash}}` until Angular replaces the expression inside
* `{{hash}}`. The `ngSrc` directive solves this problem.
*
* The buggy way to write it:
* <pre>
* <img src="http://www.gravatar.com/avatar/{{hash}}"/>
* </pre>
*
* The correct way to write it:
* <pre>
* <img ng-src="http://www.gravatar.com/avatar/{{hash}}"/>
* </pre>
*
* @element IMG
* @param {template} ngSrc any string which can contain `{{}}` markup.
*/

/**

* @ngdoc directive
* @name ng.directive:ngDisabled
* @restrict A
*
* @description
*
* The following markup will make the button enabled on Chrome/Firefox but not on IE8 and older IEs:
* <pre>
* <div ng-init="scope = { isDisabled: false }">
*  <button disabled="{{scope.isDisabled}}">Disabled</button>
* </div>
* </pre>
*
* The HTML specs do not require browsers to preserve the special attributes such as disabled.
* (The presence of them means true and absence means false)
* This prevents the angular compiler from correctly retrieving the binding expression.
* To solve this problem, we introduce the `ngDisabled` directive.
*
* @example
   <doc:example>
     <doc:source>
       Click me to toggle: <input type="checkbox" ng-model="checked"><br/>
       <button ng-model="button" ng-disabled="checked">Button</button>
     </doc:source>
     <doc:scenario>
       it('should toggle button', function() {
         expect(element('.doc-example-live :button').prop('disabled')).toBeFalsy();
         input('checked').check();
         expect(element('.doc-example-live :button').prop('disabled')).toBeTruthy();
       });
     </doc:scenario>
   </doc:example>
*
* @element INPUT
* @param {expression} ngDisabled Angular expression that will be evaluated.
*/

/**

* @ngdoc directive
* @name ng.directive:ngChecked
* @restrict A
*
* @description
* The HTML specs do not require browsers to preserve the special attributes such as checked.
* (The presence of them means true and absence means false)
* This prevents the angular compiler from correctly retrieving the binding expression.
* To solve this problem, we introduce the `ngChecked` directive.
* @example
   <doc:example>
     <doc:source>
       Check me to check both: <input type="checkbox" ng-model="master"><br/>
       <input id="checkSlave" type="checkbox" ng-checked="master">
     </doc:source>
     <doc:scenario>
       it('should check both checkBoxes', function() {
         expect(element('.doc-example-live #checkSlave').prop('checked')).toBeFalsy();
         input('master').check();
         expect(element('.doc-example-live #checkSlave').prop('checked')).toBeTruthy();
       });
     </doc:scenario>
   </doc:example>
*
* @element INPUT
* @param {expression} ngChecked Angular expression that will be evaluated.
*/

/**

* @ngdoc directive
* @name ng.directive:ngMultiple
* @restrict A
*
* @description
* The HTML specs do not require browsers to preserve the special attributes such as multiple.
* (The presence of them means true and absence means false)
* This prevents the angular compiler from correctly retrieving the binding expression.
* To solve this problem, we introduce the `ngMultiple` directive.
*
* @example
    <doc:example>
      <doc:source>
        Check me check multiple: <input type="checkbox" ng-model="checked"><br/>
        <select id="select" ng-multiple="checked">
          <option>Misko</option>
          <option>Igor</option>
          <option>Vojta</option>
          <option>Di</option>
        </select>
      </doc:source>
      <doc:scenario>
        it('should toggle multiple', function() {
          expect(element('.doc-example-live #select').prop('multiple')).toBeFalsy();
          input('checked').check();
          expect(element('.doc-example-live #select').prop('multiple')).toBeTruthy();
        });
      </doc:scenario>
    </doc:example>
*
* @element SELECT
* @param {expression} ngMultiple Angular expression that will be evaluated.
*/

/**

* @ngdoc directive
* @name ng.directive:ngReadonly
* @restrict A
*
* @description
* The HTML specs do not require browsers to preserve the special attributes such as readonly.
* (The presence of them means true and absence means false)
* This prevents the angular compiler from correctly retrieving the binding expression.
* To solve this problem, we introduce the `ngReadonly` directive.
* @example
   <doc:example>
     <doc:source>
       Check me to make text readonly: <input type="checkbox" ng-model="checked"><br/>
       <input type="text" ng-readonly="checked" value="I'm Angular"/>
     </doc:source>
     <doc:scenario>
       it('should toggle readonly attr', function() {
         expect(element('.doc-example-live :text').prop('readonly')).toBeFalsy();
         input('checked').check();
         expect(element('.doc-example-live :text').prop('readonly')).toBeTruthy();
       });
     </doc:scenario>
   </doc:example>
*
* @element INPUT
* @param {string} expression Angular expression that will be evaluated.
*/

/**

* @ngdoc directive
* @name ng.directive:ngSelected
* @restrict A
*
* @description
* The HTML specs do not require browsers to preserve the special attributes such as selected.
* (The presence of them means true and absence means false)
* This prevents the angular compiler from correctly retrieving the binding expression.
* To solve this problem, we introduced the `ngSelected` directive.
* @example
   <doc:example>
     <doc:source>
       Check me to select: <input type="checkbox" ng-model="selected"><br/>
       <select>
         <option>Hello!</option>
         <option id="greet" ng-selected="selected">Greetings!</option>
       </select>
     </doc:source>
     <doc:scenario>
       it('should select Greetings!', function() {
         expect(element('.doc-example-live #greet').prop('selected')).toBeFalsy();
         input('selected').check();
         expect(element('.doc-example-live #greet').prop('selected')).toBeTruthy();
       });
     </doc:scenario>
   </doc:example>
*
* @element OPTION
* @param {string} expression Angular expression that will be evaluated.
*/

var ngAttributeAliasDirectives = {};

// boolean attrs are evaluated forEach(BOOLEAN_ATTR, function(propName, attrName) {

var normalized = directiveNormalize('ng-' + attrName);
ngAttributeAliasDirectives[normalized] = function() {
  return {
    priority: 100,
    compile: function() {
      return function(scope, element, attr) {
        scope.$watch(attr[normalized], function ngBooleanAttrWatchAction(value) {
          attr.$set(attrName, !!value);
        });
      };
    }
  };
};

});

// ng-src, ng-href are interpolated forEach(['src', 'href'], function(attrName) {

var normalized = directiveNormalize('ng-' + attrName);
ngAttributeAliasDirectives[normalized] = function() {
  return {
    priority: 99, // it needs to run after the attributes are interpolated
    link: function(scope, element, attr) {
      attr.$observe(normalized, function(value) {
        if (!value)
           return;

        attr.$set(attrName, value);

        // on IE, if "ng:src" directive declaration is used and "src" attribute doesn't exist
        // then calling element.setAttribute('src', 'foo') doesn't do anything, so we need
        // to set the property as well to achieve the desired effect.
        // we use attr[attrName] value since $set can sanitize the url.
        if (msie) element.prop(attrName, attr[attrName]);
      });
    }
  };
};

});

var nullFormCtrl = {

$addControl: noop,
$removeControl: noop,
$setValidity: noop,
$setDirty: noop

};

/**

* @ngdoc object
* @name ng.directive:form.FormController
*
* @property {boolean} $pristine True if user has not interacted with the form yet.
* @property {boolean} $dirty True if user has already interacted with the form.
* @property {boolean} $valid True if all of the containing forms and controls are valid.
* @property {boolean} $invalid True if at least one containing control or form is invalid.
*
* @property {Object} $error Is an object hash, containing references to all invalid controls or
*  forms, where:
*
*  - keys are validation tokens (error names) — such as `required`, `url` or `email`),
*  - values are arrays of controls or forms that are invalid with given error.
*
* @description
* `FormController` keeps track of all its controls and nested forms as well as state of them,
* such as being valid/invalid or dirty/pristine.
*
* Each {@link ng.directive:form form} directive creates an instance
* of `FormController`.
*
*/

//asks for $scope to fool the BC controller module FormController.$inject = ['$element', '$attrs', '$scope']; function FormController(element, attrs) {

var form = this,
    parentForm = element.parent().controller('form') || nullFormCtrl,
    invalidCount = 0, // used to easily determine if we are valid
    errors = form.$error = {};

// init state
form.$name = attrs.name;
form.$dirty = false;
form.$pristine = true;
form.$valid = true;
form.$invalid = false;

parentForm.$addControl(form);

// Setup initial state of the control
element.addClass(PRISTINE_CLASS);
toggleValidCss(true);

// convenience method for easy toggling of classes
function toggleValidCss(isValid, validationErrorKey) {
  validationErrorKey = validationErrorKey ? '-' + snake_case(validationErrorKey, '-') : '';
  element.
    removeClass((isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey).
    addClass((isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey);
}

form.$addControl = function(control) {
  if (control.$name && !form.hasOwnProperty(control.$name)) {
    form[control.$name] = control;
  }
};

form.$removeControl = function(control) {
  if (control.$name && form[control.$name] === control) {
    delete form[control.$name];
  }
  forEach(errors, function(queue, validationToken) {
    form.$setValidity(validationToken, true, control);
  });
};

form.$setValidity = function(validationToken, isValid, control) {
  var queue = errors[validationToken];

  if (isValid) {
    if (queue) {
      arrayRemove(queue, control);
      if (!queue.length) {
        invalidCount--;
        if (!invalidCount) {
          toggleValidCss(isValid);
          form.$valid = true;
          form.$invalid = false;
        }
        errors[validationToken] = false;
        toggleValidCss(true, validationToken);
        parentForm.$setValidity(validationToken, true, form);
      }
    }

  } else {
    if (!invalidCount) {
      toggleValidCss(isValid);
    }
    if (queue) {
      if (includes(queue, control)) return;
    } else {
      errors[validationToken] = queue = [];
      invalidCount++;
      toggleValidCss(false, validationToken);
      parentForm.$setValidity(validationToken, false, form);
    }
    queue.push(control);

    form.$valid = false;
    form.$invalid = true;
  }
};

form.$setDirty = function() {
  element.removeClass(PRISTINE_CLASS).addClass(DIRTY_CLASS);
  form.$dirty = true;
  form.$pristine = false;
  parentForm.$setDirty();
};

}

/**

* @ngdoc directive
* @name ng.directive:ngForm
* @restrict EAC
*
* @description
* Nestable alias of {@link ng.directive:form `form`} directive. HTML
* does not allow nesting of form elements. It is useful to nest forms, for example if the validity of a
* sub-group of controls needs to be determined.
*
* @param {string=} name|ngForm Name of the form. If specified, the form controller will be published into
*                       related scope, under this name.
*
*/

/**
* @ngdoc directive
* @name ng.directive:form
* @restrict E
*
* @description
* Directive that instantiates
* {@link ng.directive:form.FormController FormController}.
*
* If `name` attribute is specified, the form controller is published onto the current scope under
* this name.
*
* # Alias: {@link ng.directive:ngForm `ngForm`}
*
* In angular forms can be nested. This means that the outer form is valid when all of the child
* forms are valid as well. However browsers do not allow nesting of `<form>` elements, for this
* reason angular provides {@link ng.directive:ngForm `ngForm`} alias
* which behaves identical to `<form>` but allows form nesting.
*
*
* # CSS classes
*  - `ng-valid` Is set if the form is valid.
*  - `ng-invalid` Is set if the form is invalid.
*  - `ng-pristine` Is set if the form is pristine.
*  - `ng-dirty` Is set if the form is dirty.
*
*
* # Submitting a form and preventing default action
*
* Since the role of forms in client-side Angular applications is different than in classical
* roundtrip apps, it is desirable for the browser not to translate the form submission into a full
* page reload that sends the data to the server. Instead some javascript logic should be triggered
* to handle the form submission in application specific way.
*
* For this reason, Angular prevents the default action (form submission to the server) unless the
* `<form>` element has an `action` attribute specified.
*
* You can use one of the following two ways to specify what javascript method should be called when
* a form is submitted:
*
* - {@link ng.directive:ngSubmit ngSubmit} directive on the form element
* - {@link ng.directive:ngClick ngClick} directive on the first
 *  button or input field of type submit (input[type=submit])
*
* To prevent double execution of the handler, use only one of ngSubmit or ngClick directives. This
* is because of the following form submission rules coming from the html spec:
*
* - If a form has only one input field then hitting enter in this field triggers form submit
* (`ngSubmit`)
* - if a form has has 2+ input fields and no buttons or input[type=submit] then hitting enter
* doesn't trigger submit
* - if a form has one or more input fields and one or more buttons or input[type=submit] then
* hitting enter in any of the input fields will trigger the click handler on the *first* button or
* input[type=submit] (`ngClick`) *and* a submit handler on the enclosing form (`ngSubmit`)
*
* @param {string=} name Name of the form. If specified, the form controller will be published into
*                       related scope, under this name.
*
* @example
   <doc:example>
     <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.userType = 'guest';
        }
      </script>
      <form name="myForm" ng-controller="Ctrl">
        userType: <input name="input" ng-model="userType" required>
        <span class="error" ng-show="myForm.input.$error.required">Required!</span><br>
        <tt>userType = {{userType}}</tt><br>
        <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br>
        <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br>
        <tt>myForm.$valid = {{myForm.$valid}}</tt><br>
        <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br>
       </form>
     </doc:source>
     <doc:scenario>
       it('should initialize to model', function() {
        expect(binding('userType')).toEqual('guest');
        expect(binding('myForm.input.$valid')).toEqual('true');
       });

       it('should be invalid if empty', function() {
        input('userType').enter('');
        expect(binding('userType')).toEqual('');
        expect(binding('myForm.input.$valid')).toEqual('false');
       });
     </doc:scenario>
   </doc:example>
*/

var formDirectiveFactory = function(isNgForm) {

return ['$timeout', function($timeout) {
  var formDirective = {
    name: 'form',
    restrict: 'E',
    controller: FormController,
    compile: function() {
      return {
        pre: function(scope, formElement, attr, controller) {
          if (!attr.action) {
            // we can't use jq events because if a form is destroyed during submission the default
            // action is not prevented. see #1238
            //
            // IE 9 is not affected because it doesn't fire a submit event and try to do a full
            // page reload if the form was destroyed by submission of the form via a click handler
            // on a button in the form. Looks like an IE9 specific bug.
            var preventDefaultListener = function(event) {
              event.preventDefault
                ? event.preventDefault()
                : event.returnValue = false; // IE
            };

            addEventListenerFn(formElement[0], 'submit', preventDefaultListener);

            // unregister the preventDefault listener so that we don't not leak memory but in a
            // way that will achieve the prevention of the default action.
            formElement.bind('$destroy', function() {
              $timeout(function() {
                removeEventListenerFn(formElement[0], 'submit', preventDefaultListener);
              }, 0, false);
            });
          }

          var parentFormCtrl = formElement.parent().controller('form'),
              alias = attr.name || attr.ngForm;

          if (alias) {
            scope[alias] = controller;
          }
          if (parentFormCtrl) {
            formElement.bind('$destroy', function() {
              parentFormCtrl.$removeControl(controller);
              if (alias) {
                scope[alias] = undefined;
              }
              extend(controller, nullFormCtrl); //stop propagating child destruction handlers upwards
            });
          }
        }
      };
    }
  };

  return isNgForm ? extend(copy(formDirective), {restrict: 'EAC'}) : formDirective;
}];

};

var formDirective = formDirectiveFactory(); var ngFormDirective = formDirectiveFactory(true);

var URL_REGEXP = /^(ftp|http|https)://(w+:{0,1}w*@)?(S+)(:+)?(/|/([w#!:.?+=&%@!-/]))?$/; var EMAIL_REGEXP = /^[A-Za-z0-9._%-]@+.[A-Za-z]{2,4}$/; var NUMBER_REGEXP = /^s*(-|+)?(d+|(d*(.d*)))s*$/;

var inputType = {

/**
 * @ngdoc inputType
 * @name ng.directive:input.text
 *
 * @description
 * Standard HTML text input with angular data binding.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 * @param {string=} name Property name of the form under which the control is published.
 * @param {string=} required Adds `required` validation error key if the value is not entered.
 * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
 *    the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
 *    `required` when you want to data-bind to the `required` attribute.
 * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
 *    minlength.
 * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
 *    maxlength.
 * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
 *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
 *    patterns defined as scope expressions.
 * @param {string=} ngChange Angular expression to be executed when input changes due to user
 *    interaction with the input element.
 *
 * @example
    <doc:example>
      <doc:source>
       <script>
         function Ctrl($scope) {
           $scope.text = 'guest';
           $scope.word = /^\w*$/;
         }
       </script>
       <form name="myForm" ng-controller="Ctrl">
         Single word: <input type="text" name="input" ng-model="text"
                             ng-pattern="word" required>
         <span class="error" ng-show="myForm.input.$error.required">
           Required!</span>
         <span class="error" ng-show="myForm.input.$error.pattern">
           Single word only!</span>

         <tt>text = {{text}}</tt><br/>
         <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
         <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
         <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
         <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
        </form>
      </doc:source>
      <doc:scenario>
        it('should initialize to model', function() {
          expect(binding('text')).toEqual('guest');
          expect(binding('myForm.input.$valid')).toEqual('true');
        });

        it('should be invalid if empty', function() {
          input('text').enter('');
          expect(binding('text')).toEqual('');
          expect(binding('myForm.input.$valid')).toEqual('false');
        });

        it('should be invalid if multi word', function() {
          input('text').enter('hello world');
          expect(binding('myForm.input.$valid')).toEqual('false');
        });
      </doc:scenario>
    </doc:example>
 */
'text': textInputType,

/**
 * @ngdoc inputType
 * @name ng.directive:input.number
 *
 * @description
 * Text input with number validation and transformation. Sets the `number` validation
 * error if not a valid number.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 * @param {string=} name Property name of the form under which the control is published.
 * @param {string=} min Sets the `min` validation error key if the value entered is less then `min`.
 * @param {string=} max Sets the `max` validation error key if the value entered is greater then `min`.
 * @param {string=} required Sets `required` validation error key if the value is not entered.
 * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
 *    the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
 *    `required` when you want to data-bind to the `required` attribute.
 * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
 *    minlength.
 * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
 *    maxlength.
 * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
 *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
 *    patterns defined as scope expressions.
 * @param {string=} ngChange Angular expression to be executed when input changes due to user
 *    interaction with the input element.
 *
 * @example
    <doc:example>
      <doc:source>
       <script>
         function Ctrl($scope) {
           $scope.value = 12;
         }
       </script>
       <form name="myForm" ng-controller="Ctrl">
         Number: <input type="number" name="input" ng-model="value"
                        min="0" max="99" required>
         <span class="error" ng-show="myForm.list.$error.required">
           Required!</span>
         <span class="error" ng-show="myForm.list.$error.number">
           Not valid number!</span>
         <tt>value = {{value}}</tt><br/>
         <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
         <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
         <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
         <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
        </form>
      </doc:source>
      <doc:scenario>
        it('should initialize to model', function() {
         expect(binding('value')).toEqual('12');
         expect(binding('myForm.input.$valid')).toEqual('true');
        });

        it('should be invalid if empty', function() {
         input('value').enter('');
         expect(binding('value')).toEqual('');
         expect(binding('myForm.input.$valid')).toEqual('false');
        });

        it('should be invalid if over max', function() {
         input('value').enter('123');
         expect(binding('value')).toEqual('');
         expect(binding('myForm.input.$valid')).toEqual('false');
        });
      </doc:scenario>
    </doc:example>
 */
'number': numberInputType,

/**
 * @ngdoc inputType
 * @name ng.directive:input.url
 *
 * @description
 * Text input with URL validation. Sets the `url` validation error key if the content is not a
 * valid URL.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 * @param {string=} name Property name of the form under which the control is published.
 * @param {string=} required Sets `required` validation error key if the value is not entered.
 * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
 *    the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
 *    `required` when you want to data-bind to the `required` attribute.
 * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
 *    minlength.
 * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
 *    maxlength.
 * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
 *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
 *    patterns defined as scope expressions.
 * @param {string=} ngChange Angular expression to be executed when input changes due to user
 *    interaction with the input element.
 *
 * @example
    <doc:example>
      <doc:source>
       <script>
         function Ctrl($scope) {
           $scope.text = 'http://google.com';
         }
       </script>
       <form name="myForm" ng-controller="Ctrl">
         URL: <input type="url" name="input" ng-model="text" required>
         <span class="error" ng-show="myForm.input.$error.required">
           Required!</span>
         <span class="error" ng-show="myForm.input.$error.url">
           Not valid url!</span>
         <tt>text = {{text}}</tt><br/>
         <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
         <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
         <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
         <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
         <tt>myForm.$error.url = {{!!myForm.$error.url}}</tt><br/>
        </form>
      </doc:source>
      <doc:scenario>
        it('should initialize to model', function() {
          expect(binding('text')).toEqual('http://google.com');
          expect(binding('myForm.input.$valid')).toEqual('true');
        });

        it('should be invalid if empty', function() {
          input('text').enter('');
          expect(binding('text')).toEqual('');
          expect(binding('myForm.input.$valid')).toEqual('false');
        });

        it('should be invalid if not url', function() {
          input('text').enter('xxx');
          expect(binding('myForm.input.$valid')).toEqual('false');
        });
      </doc:scenario>
    </doc:example>
 */
'url': urlInputType,

/**
 * @ngdoc inputType
 * @name ng.directive:input.email
 *
 * @description
 * Text input with email validation. Sets the `email` validation error key if not a valid email
 * address.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 * @param {string=} name Property name of the form under which the control is published.
 * @param {string=} required Sets `required` validation error key if the value is not entered.
 * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
 *    the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
 *    `required` when you want to data-bind to the `required` attribute.
 * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
 *    minlength.
 * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
 *    maxlength.
 * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
 *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
 *    patterns defined as scope expressions.
 *
 * @example
    <doc:example>
      <doc:source>
       <script>
         function Ctrl($scope) {
           $scope.text = 'me@example.com';
         }
       </script>
         <form name="myForm" ng-controller="Ctrl">
           Email: <input type="email" name="input" ng-model="text" required>
           <span class="error" ng-show="myForm.input.$error.required">
             Required!</span>
           <span class="error" ng-show="myForm.input.$error.email">
             Not valid email!</span>
           <tt>text = {{text}}</tt><br/>
           <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
           <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
           <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
           <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
           <tt>myForm.$error.email = {{!!myForm.$error.email}}</tt><br/>
         </form>
      </doc:source>
      <doc:scenario>
        it('should initialize to model', function() {
          expect(binding('text')).toEqual('me@example.com');
          expect(binding('myForm.input.$valid')).toEqual('true');
        });

        it('should be invalid if empty', function() {
          input('text').enter('');
          expect(binding('text')).toEqual('');
          expect(binding('myForm.input.$valid')).toEqual('false');
        });

        it('should be invalid if not email', function() {
          input('text').enter('xxx');
          expect(binding('myForm.input.$valid')).toEqual('false');
        });
      </doc:scenario>
    </doc:example>
 */
'email': emailInputType,

/**
 * @ngdoc inputType
 * @name ng.directive:input.radio
 *
 * @description
 * HTML radio button.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 * @param {string} value The value to which the expression should be set when selected.
 * @param {string=} name Property name of the form under which the control is published.
 * @param {string=} ngChange Angular expression to be executed when input changes due to user
 *    interaction with the input element.
 *
 * @example
    <doc:example>
      <doc:source>
       <script>
         function Ctrl($scope) {
           $scope.color = 'blue';
         }
       </script>
       <form name="myForm" ng-controller="Ctrl">
         <input type="radio" ng-model="color" value="red">  Red <br/>
         <input type="radio" ng-model="color" value="green"> Green <br/>
         <input type="radio" ng-model="color" value="blue"> Blue <br/>
         <tt>color = {{color}}</tt><br/>
        </form>
      </doc:source>
      <doc:scenario>
        it('should change state', function() {
          expect(binding('color')).toEqual('blue');

          input('color').select('red');
          expect(binding('color')).toEqual('red');
        });
      </doc:scenario>
    </doc:example>
 */
'radio': radioInputType,

/**
 * @ngdoc inputType
 * @name ng.directive:input.checkbox
 *
 * @description
 * HTML checkbox.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 * @param {string=} name Property name of the form under which the control is published.
 * @param {string=} ngTrueValue The value to which the expression should be set when selected.
 * @param {string=} ngFalseValue The value to which the expression should be set when not selected.
 * @param {string=} ngChange Angular expression to be executed when input changes due to user
 *    interaction with the input element.
 *
 * @example
    <doc:example>
      <doc:source>
       <script>
         function Ctrl($scope) {
           $scope.value1 = true;
           $scope.value2 = 'YES'
         }
       </script>
       <form name="myForm" ng-controller="Ctrl">
         Value1: <input type="checkbox" ng-model="value1"> <br/>
         Value2: <input type="checkbox" ng-model="value2"
                        ng-true-value="YES" ng-false-value="NO"> <br/>
         <tt>value1 = {{value1}}</tt><br/>
         <tt>value2 = {{value2}}</tt><br/>
        </form>
      </doc:source>
      <doc:scenario>
        it('should change state', function() {
          expect(binding('value1')).toEqual('true');
          expect(binding('value2')).toEqual('YES');

          input('value1').check();
          input('value2').check();
          expect(binding('value1')).toEqual('false');
          expect(binding('value2')).toEqual('NO');
        });
      </doc:scenario>
    </doc:example>
 */
'checkbox': checkboxInputType,

'hidden': noop,
'button': noop,
'submit': noop,
'reset': noop

};

function isEmpty(value) {

return isUndefined(value) || value === '' || value === null || value !== value;

}

function textInputType(scope, element, attr, ctrl, $sniffer, $browser) {

var listener = function() {
  var value = trim(element.val());

  if (ctrl.$viewValue !== value) {
    scope.$apply(function() {
      ctrl.$setViewValue(value);
    });
  }
};

// if the browser does support "input" event, we are fine - except on IE9 which doesn't fire the
// input event on backspace, delete or cut
if ($sniffer.hasEvent('input')) {
  element.bind('input', listener);
} else {
  var timeout;

  element.bind('keydown', function(event) {
    var key = event.keyCode;

    // ignore
    //    command            modifiers                   arrows
    if (key === 91 || (15 < key && key < 19) || (37 <= key && key <= 40)) return;

    if (!timeout) {
      timeout = $browser.defer(function() {
        listener();
        timeout = null;
      });
    }
  });

  // if user paste into input using mouse, we need "change" event to catch it
  element.bind('change', listener);
}

ctrl.$render = function() {
  element.val(isEmpty(ctrl.$viewValue) ? '' : ctrl.$viewValue);
};

// pattern validator
var pattern = attr.ngPattern,
    patternValidator;

var validate = function(regexp, value) {
  if (isEmpty(value) || regexp.test(value)) {
    ctrl.$setValidity('pattern', true);
    return value;
  } else {
    ctrl.$setValidity('pattern', false);
    return undefined;
  }
};

if (pattern) {
  if (pattern.match(/^\/(.*)\/$/)) {
    pattern = new RegExp(pattern.substr(1, pattern.length - 2));
    patternValidator = function(value) {
      return validate(pattern, value)
    };
  } else {
    patternValidator = function(value) {
      var patternObj = scope.$eval(pattern);

      if (!patternObj || !patternObj.test) {
        throw new Error('Expected ' + pattern + ' to be a RegExp but was ' + patternObj);
      }
      return validate(patternObj, value);
    };
  }

  ctrl.$formatters.push(patternValidator);
  ctrl.$parsers.push(patternValidator);
}

// min length validator
if (attr.ngMinlength) {
  var minlength = int(attr.ngMinlength);
  var minLengthValidator = function(value) {
    if (!isEmpty(value) && value.length < minlength) {
      ctrl.$setValidity('minlength', false);
      return undefined;
    } else {
      ctrl.$setValidity('minlength', true);
      return value;
    }
  };

  ctrl.$parsers.push(minLengthValidator);
  ctrl.$formatters.push(minLengthValidator);
}

// max length validator
if (attr.ngMaxlength) {
  var maxlength = int(attr.ngMaxlength);
  var maxLengthValidator = function(value) {
    if (!isEmpty(value) && value.length > maxlength) {
      ctrl.$setValidity('maxlength', false);
      return undefined;
    } else {
      ctrl.$setValidity('maxlength', true);
      return value;
    }
  };

  ctrl.$parsers.push(maxLengthValidator);
  ctrl.$formatters.push(maxLengthValidator);
}

}

function numberInputType(scope, element, attr, ctrl, $sniffer, $browser) {

textInputType(scope, element, attr, ctrl, $sniffer, $browser);

ctrl.$parsers.push(function(value) {
  var empty = isEmpty(value);
  if (empty || NUMBER_REGEXP.test(value)) {
    ctrl.$setValidity('number', true);
    return value === '' ? null : (empty ? value : parseFloat(value));
  } else {
    ctrl.$setValidity('number', false);
    return undefined;
  }
});

ctrl.$formatters.push(function(value) {
  return isEmpty(value) ? '' : '' + value;
});

if (attr.min) {
  var min = parseFloat(attr.min);
  var minValidator = function(value) {
    if (!isEmpty(value) && value < min) {
      ctrl.$setValidity('min', false);
      return undefined;
    } else {
      ctrl.$setValidity('min', true);
      return value;
    }
  };

  ctrl.$parsers.push(minValidator);
  ctrl.$formatters.push(minValidator);
}

if (attr.max) {
  var max = parseFloat(attr.max);
  var maxValidator = function(value) {
    if (!isEmpty(value) && value > max) {
      ctrl.$setValidity('max', false);
      return undefined;
    } else {
      ctrl.$setValidity('max', true);
      return value;
    }
  };

  ctrl.$parsers.push(maxValidator);
  ctrl.$formatters.push(maxValidator);
}

ctrl.$formatters.push(function(value) {

  if (isEmpty(value) || isNumber(value)) {
    ctrl.$setValidity('number', true);
    return value;
  } else {
    ctrl.$setValidity('number', false);
    return undefined;
  }
});

}

function urlInputType(scope, element, attr, ctrl, $sniffer, $browser) {

textInputType(scope, element, attr, ctrl, $sniffer, $browser);

var urlValidator = function(value) {
  if (isEmpty(value) || URL_REGEXP.test(value)) {
    ctrl.$setValidity('url', true);
    return value;
  } else {
    ctrl.$setValidity('url', false);
    return undefined;
  }
};

ctrl.$formatters.push(urlValidator);
ctrl.$parsers.push(urlValidator);

}

function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) {

textInputType(scope, element, attr, ctrl, $sniffer, $browser);

var emailValidator = function(value) {
  if (isEmpty(value) || EMAIL_REGEXP.test(value)) {
    ctrl.$setValidity('email', true);
    return value;
  } else {
    ctrl.$setValidity('email', false);
    return undefined;
  }
};

ctrl.$formatters.push(emailValidator);
ctrl.$parsers.push(emailValidator);

}

function radioInputType(scope, element, attr, ctrl) {

// make the name unique, if not defined
if (isUndefined(attr.name)) {
  element.attr('name', nextUid());
}

element.bind('click', function() {
  if (element[0].checked) {
    scope.$apply(function() {
      ctrl.$setViewValue(attr.value);
    });
  }
});

ctrl.$render = function() {
  var value = attr.value;
  element[0].checked = (value == ctrl.$viewValue);
};

attr.$observe('value', ctrl.$render);

}

function checkboxInputType(scope, element, attr, ctrl) {

var trueValue = attr.ngTrueValue,
    falseValue = attr.ngFalseValue;

if (!isString(trueValue)) trueValue = true;
if (!isString(falseValue)) falseValue = false;

element.bind('click', function() {
  scope.$apply(function() {
    ctrl.$setViewValue(element[0].checked);
  });
});

ctrl.$render = function() {
  element[0].checked = ctrl.$viewValue;
};

ctrl.$formatters.push(function(value) {
  return value === trueValue;
});

ctrl.$parsers.push(function(value) {
  return value ? trueValue : falseValue;
});

}

/**

* @ngdoc directive
* @name ng.directive:textarea
* @restrict E
*
* @description
* HTML textarea element control with angular data-binding. The data-binding and validation
* properties of this element are exactly the same as those of the
* {@link ng.directive:input input element}.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
*    the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
*    `required` when you want to data-bind to the `required` attribute.
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
*    minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
*    maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
*    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
*    patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
*    interaction with the input element.
*/

/**

* @ngdoc directive
* @name ng.directive:input
* @restrict E
*
* @description
* HTML input element control with angular data-binding. Input control follows HTML5 input types
* and polyfills the HTML5 validation behavior for older browsers.
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required Sets `required` validation error key if the value is not entered.
* @param {boolean=} ngRequired Sets `required` attribute if set to true
* @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
*    minlength.
* @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
*    maxlength.
* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
*    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
*    patterns defined as scope expressions.
* @param {string=} ngChange Angular expression to be executed when input changes due to user
*    interaction with the input element.
*
* @example
   <doc:example>
     <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.user = {name: 'guest', last: 'visitor'};
        }
      </script>
      <div ng-controller="Ctrl">
        <form name="myForm">
          User name: <input type="text" name="userName" ng-model="user.name" required>
          <span class="error" ng-show="myForm.userName.$error.required">
            Required!</span><br>
          Last name: <input type="text" name="lastName" ng-model="user.last"
            ng-minlength="3" ng-maxlength="10">
          <span class="error" ng-show="myForm.lastName.$error.minlength">
            Too short!</span>
          <span class="error" ng-show="myForm.lastName.$error.maxlength">
            Too long!</span><br>
        </form>
        <hr>
        <tt>user = {{user}}</tt><br/>
        <tt>myForm.userName.$valid = {{myForm.userName.$valid}}</tt><br>
        <tt>myForm.userName.$error = {{myForm.userName.$error}}</tt><br>
        <tt>myForm.lastName.$valid = {{myForm.lastName.$valid}}</tt><br>
        <tt>myForm.userName.$error = {{myForm.lastName.$error}}</tt><br>
        <tt>myForm.$valid = {{myForm.$valid}}</tt><br>
        <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br>
        <tt>myForm.$error.minlength = {{!!myForm.$error.minlength}}</tt><br>
        <tt>myForm.$error.maxlength = {{!!myForm.$error.maxlength}}</tt><br>
      </div>
     </doc:source>
     <doc:scenario>
       it('should initialize to model', function() {
         expect(binding('user')).toEqual('{"name":"guest","last":"visitor"}');
         expect(binding('myForm.userName.$valid')).toEqual('true');
         expect(binding('myForm.$valid')).toEqual('true');
       });

       it('should be invalid if empty when required', function() {
         input('user.name').enter('');
         expect(binding('user')).toEqual('{"last":"visitor"}');
         expect(binding('myForm.userName.$valid')).toEqual('false');
         expect(binding('myForm.$valid')).toEqual('false');
       });

       it('should be valid if empty when min length is set', function() {
         input('user.last').enter('');
         expect(binding('user')).toEqual('{"name":"guest","last":""}');
         expect(binding('myForm.lastName.$valid')).toEqual('true');
         expect(binding('myForm.$valid')).toEqual('true');
       });

       it('should be invalid if less than required min length', function() {
         input('user.last').enter('xx');
         expect(binding('user')).toEqual('{"name":"guest"}');
         expect(binding('myForm.lastName.$valid')).toEqual('false');
         expect(binding('myForm.lastName.$error')).toMatch(/minlength/);
         expect(binding('myForm.$valid')).toEqual('false');
       });

       it('should be invalid if longer than max length', function() {
         input('user.last').enter('some ridiculously long name');
         expect(binding('user'))
           .toEqual('{"name":"guest"}');
         expect(binding('myForm.lastName.$valid')).toEqual('false');
         expect(binding('myForm.lastName.$error')).toMatch(/maxlength/);
         expect(binding('myForm.$valid')).toEqual('false');
       });
     </doc:scenario>
   </doc:example>
*/

var inputDirective = ['$browser', '$sniffer', function($browser, $sniffer) {

return {
  restrict: 'E',
  require: '?ngModel',
  link: function(scope, element, attr, ctrl) {
    if (ctrl) {
      (inputType[lowercase(attr.type)] || inputType.text)(scope, element, attr, ctrl, $sniffer,
                                                          $browser);
    }
  }
};

}];

var VALID_CLASS = 'ng-valid',

INVALID_CLASS = 'ng-invalid',
PRISTINE_CLASS = 'ng-pristine',
DIRTY_CLASS = 'ng-dirty';

/**

* @ngdoc object
* @name ng.directive:ngModel.NgModelController
*
* @property {string} $viewValue Actual string value in the view.
* @property {*} $modelValue The value in the model, that the control is bound to.
* @property {Array.<Function>} $parsers Whenever the control reads value from the DOM, it executes
*     all of these functions to sanitize / convert the value as well as validate.
*
* @property {Array.<Function>} $formatters Whenever the model value changes, it executes all of
*     these functions to convert the value as well as validate.
*
* @property {Object} $error An bject hash with all errors as keys.
*
* @property {boolean} $pristine True if user has not interacted with the control yet.
* @property {boolean} $dirty True if user has already interacted with the control.
* @property {boolean} $valid True if there is no error.
* @property {boolean} $invalid True if at least one error on the control.
*
* @description
*
* `NgModelController` provides API for the `ng-model` directive. The controller contains
* services for data-binding, validation, CSS update, value formatting and parsing. It
* specifically does not contain any logic which deals with DOM rendering or listening to
* DOM events. The `NgModelController` is meant to be extended by other directives where, the
* directive provides DOM manipulation and the `NgModelController` provides the data-binding.
*
* This example shows how to use `NgModelController` with a custom control to achieve
* data-binding. Notice how different directives (`contenteditable`, `ng-model`, and `required`)
* collaborate together to achieve the desired result.
*
* <example module="customControl">
   <file name="style.css">
     [contenteditable] {
       border: 1px solid black;
       background-color: white;
       min-height: 20px;
     }

     .ng-invalid {
       border: 1px solid red;
     }

   </file>
   <file name="script.js">
     angular.module('customControl', []).
       directive('contenteditable', function() {
         return {
           restrict: 'A', // only activate on element attribute
           require: '?ngModel', // get a hold of NgModelController
           link: function(scope, element, attrs, ngModel) {
             if(!ngModel) return; // do nothing if no ng-model

             // Specify how UI should be updated
             ngModel.$render = function() {
               element.html(ngModel.$viewValue || '');
             };

             // Listen for change events to enable binding
             element.bind('blur keyup change', function() {
               scope.$apply(read);
             });
             read(); // initialize

             // Write data to the model
             function read() {
               ngModel.$setViewValue(element.html());
             }
           }
         };
       });
   </file>
   <file name="index.html">
     <form name="myForm">
      <div contenteditable
           name="myWidget" ng-model="userContent"
           required>Change me!</div>
       <span ng-show="myForm.myWidget.$error.required">Required!</span>
      <hr>
      <textarea ng-model="userContent"></textarea>
     </form>
   </file>
   <file name="scenario.js">
     it('should data-bind and become invalid', function() {
       var contentEditable = element('[contenteditable]');

       expect(contentEditable.text()).toEqual('Change me!');
       input('userContent').enter('');
       expect(contentEditable.text()).toEqual('');
       expect(contentEditable.prop('className')).toMatch(/ng-invalid-required/);
     });
   </file>
* </example>
*
*/

var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$parse',

  function($scope, $exceptionHandler, $attr, $element, $parse) {
this.$viewValue = Number.NaN;
this.$modelValue = Number.NaN;
this.$parsers = [];
this.$formatters = [];
this.$viewChangeListeners = [];
this.$pristine = true;
this.$dirty = false;
this.$valid = true;
this.$invalid = false;
this.$name = $attr.name;

var ngModelGet = $parse($attr.ngModel),
    ngModelSet = ngModelGet.assign;

if (!ngModelSet) {
  throw Error(NON_ASSIGNABLE_MODEL_EXPRESSION + $attr.ngModel +
      ' (' + startingTag($element) + ')');
}

/**
 * @ngdoc function
 * @name ng.directive:ngModel.NgModelController#$render
 * @methodOf ng.directive:ngModel.NgModelController
 *
 * @description
 * Called when the view needs to be updated. It is expected that the user of the ng-model
 * directive will implement this method.
 */
this.$render = noop;

var parentForm = $element.inheritedData('$formController') || nullFormCtrl,
    invalidCount = 0, // used to easily determine if we are valid
    $error = this.$error = {}; // keep invalid keys here

// Setup initial state of the control
$element.addClass(PRISTINE_CLASS);
toggleValidCss(true);

// convenience method for easy toggling of classes
function toggleValidCss(isValid, validationErrorKey) {
  validationErrorKey = validationErrorKey ? '-' + snake_case(validationErrorKey, '-') : '';
  $element.
    removeClass((isValid ? INVALID_CLASS : VALID_CLASS) + validationErrorKey).
    addClass((isValid ? VALID_CLASS : INVALID_CLASS) + validationErrorKey);
}

/**
 * @ngdoc function
 * @name ng.directive:ngModel.NgModelController#$setValidity
 * @methodOf ng.directive:ngModel.NgModelController
 *
 * @description
 * Change the validity state, and notifies the form when the control changes validity. (i.e. it
 * does not notify form if given validator is already marked as invalid).
 *
 * This method should be called by validators - i.e. the parser or formatter functions.
 *
 * @param {string} validationErrorKey Name of the validator. the `validationErrorKey` will assign
 *        to `$error[validationErrorKey]=isValid` so that it is available for data-binding.
 *        The `validationErrorKey` should be in camelCase and will get converted into dash-case
 *        for class name. Example: `myError` will result in `ng-valid-my-error` and `ng-invalid-my-error`
 *        class and can be bound to as  `{{someForm.someControl.$error.myError}}` .
 * @param {boolean} isValid Whether the current state is valid (true) or invalid (false).
 */
this.$setValidity = function(validationErrorKey, isValid) {
  if ($error[validationErrorKey] === !isValid) return;

  if (isValid) {
    if ($error[validationErrorKey]) invalidCount--;
    if (!invalidCount) {
      toggleValidCss(true);
      this.$valid = true;
      this.$invalid = false;
    }
  } else {
    toggleValidCss(false);
    this.$invalid = true;
    this.$valid = false;
    invalidCount++;
  }

  $error[validationErrorKey] = !isValid;
  toggleValidCss(isValid, validationErrorKey);

  parentForm.$setValidity(validationErrorKey, isValid, this);
};

/**
 * @ngdoc function
 * @name ng.directive:ngModel.NgModelController#$setViewValue
 * @methodOf ng.directive:ngModel.NgModelController
 *
 * @description
 * Read a value from view.
 *
 * This method should be called from within a DOM event handler.
 * For example {@link ng.directive:input input} or
 * {@link ng.directive:select select} directives call it.
 *
 * It internally calls all `formatters` and if resulted value is valid, updates the model and
 * calls all registered change listeners.
 *
 * @param {string} value Value from the view.
 */
this.$setViewValue = function(value) {
  this.$viewValue = value;

  // change to dirty
  if (this.$pristine) {
    this.$dirty = true;
    this.$pristine = false;
    $element.removeClass(PRISTINE_CLASS).addClass(DIRTY_CLASS);
    parentForm.$setDirty();
  }

  forEach(this.$parsers, function(fn) {
    value = fn(value);
  });

  if (this.$modelValue !== value) {
    this.$modelValue = value;
    ngModelSet($scope, value);
    forEach(this.$viewChangeListeners, function(listener) {
      try {
        listener();
      } catch(e) {
        $exceptionHandler(e);
      }
    })
  }
};

// model -> value
var ctrl = this;

$scope.$watch(function ngModelWatch() {
  var value = ngModelGet($scope);

  // if scope model value and ngModel value are out of sync
  if (ctrl.$modelValue !== value) {

    var formatters = ctrl.$formatters,
        idx = formatters.length;

    ctrl.$modelValue = value;
    while(idx--) {
      value = formatters[idx](value);
    }

    if (ctrl.$viewValue !== value) {
      ctrl.$viewValue = value;
      ctrl.$render();
    }
  }
});

}];

/**

* @ngdoc directive
* @name ng.directive:ngModel
*
* @element input
*
* @description
* Is directive that tells Angular to do two-way data binding. It works together with `input`,
* `select`, `textarea`. You can easily write your own directives to use `ngModel` as well.
*
* `ngModel` is responsible for:
*
* - binding the view into the model, which other directives such as `input`, `textarea` or `select`
*   require,
* - providing validation behavior (i.e. required, number, email, url),
* - keeping state of the control (valid/invalid, dirty/pristine, validation errors),
* - setting related css class onto the element (`ng-valid`, `ng-invalid`, `ng-dirty`, `ng-pristine`),
* - register the control with parent {@link ng.directive:form form}.
*
* For basic examples, how to use `ngModel`, see:
*
*  - {@link ng.directive:input input}
*    - {@link ng.directive:input.text text}
*    - {@link ng.directive:input.checkbox checkbox}
*    - {@link ng.directive:input.radio radio}
*    - {@link ng.directive:input.number number}
*    - {@link ng.directive:input.email email}
*    - {@link ng.directive:input.url url}
*  - {@link ng.directive:select select}
*  - {@link ng.directive:textarea textarea}
*
*/

var ngModelDirective = function() {

return {
  require: ['ngModel', '^?form'],
  controller: NgModelController,
  link: function(scope, element, attr, ctrls) {
    // notify others, especially parent forms

    var modelCtrl = ctrls[0],
        formCtrl = ctrls[1] || nullFormCtrl;

    formCtrl.$addControl(modelCtrl);

    element.bind('$destroy', function() {
      formCtrl.$removeControl(modelCtrl);
    });
  }
};

};

/**

* @ngdoc directive
* @name ng.directive:ngChange
* @restrict E
*
* @description
* Evaluate given expression when user changes the input.
* The expression is not evaluated when the value change is coming from the model.
*
* Note, this directive requires `ngModel` to be present.
*
* @element input
*
* @example
* <doc:example>
*   <doc:source>
*     <script>
*       function Controller($scope) {
*         $scope.counter = 0;
*         $scope.change = function() {
*           $scope.counter++;
*         };
*       }
*     </script>
*     <div ng-controller="Controller">
*       <input type="checkbox" ng-model="confirmed" ng-change="change()" id="ng-change-example1" />
*       <input type="checkbox" ng-model="confirmed" id="ng-change-example2" />
*       <label for="ng-change-example2">Confirmed</label><br />
*       debug = {{confirmed}}<br />
*       counter = {{counter}}
*     </div>
*   </doc:source>
*   <doc:scenario>
*     it('should evaluate the expression if changing from view', function() {
*       expect(binding('counter')).toEqual('0');
*       element('#ng-change-example1').click();
*       expect(binding('counter')).toEqual('1');
*       expect(binding('confirmed')).toEqual('true');
*     });
*
*     it('should not evaluate the expression if changing from model', function() {
*       element('#ng-change-example2').click();
*       expect(binding('counter')).toEqual('0');
*       expect(binding('confirmed')).toEqual('true');
*     });
*   </doc:scenario>
* </doc:example>
*/

var ngChangeDirective = valueFn({

require: 'ngModel',
link: function(scope, element, attr, ctrl) {
  ctrl.$viewChangeListeners.push(function() {
    scope.$eval(attr.ngChange);
  });
}

});

var requiredDirective = function() {

return {
  require: '?ngModel',
  link: function(scope, elm, attr, ctrl) {
    if (!ctrl) return;
    attr.required = true; // force truthy in case we are on non input element

    var validator = function(value) {
      if (attr.required && (isEmpty(value) || value === false)) {
        ctrl.$setValidity('required', false);
        return;
      } else {
        ctrl.$setValidity('required', true);
        return value;
      }
    };

    ctrl.$formatters.push(validator);
    ctrl.$parsers.unshift(validator);

    attr.$observe('required', function() {
      validator(ctrl.$viewValue);
    });
  }
};

};

/**

* @ngdoc directive
* @name ng.directive:ngList
*
* @description
* Text input that converts between comma-separated string into an array of strings.
*
* @element input
* @param {string=} ngList optional delimiter that should be used to split the value. If
*   specified in form `/something/` then the value will be converted into a regular expression.
*
* @example
   <doc:example>
     <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.names = ['igor', 'misko', 'vojta'];
        }
      </script>
      <form name="myForm" ng-controller="Ctrl">
        List: <input name="namesInput" ng-model="names" ng-list required>
        <span class="error" ng-show="myForm.list.$error.required">
          Required!</span>
        <tt>names = {{names}}</tt><br/>
        <tt>myForm.namesInput.$valid = {{myForm.namesInput.$valid}}</tt><br/>
        <tt>myForm.namesInput.$error = {{myForm.namesInput.$error}}</tt><br/>
        <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
        <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
       </form>
     </doc:source>
     <doc:scenario>
       it('should initialize to model', function() {
         expect(binding('names')).toEqual('["igor","misko","vojta"]');
         expect(binding('myForm.namesInput.$valid')).toEqual('true');
       });

       it('should be invalid if empty', function() {
         input('names').enter('');
         expect(binding('names')).toEqual('[]');
         expect(binding('myForm.namesInput.$valid')).toEqual('false');
       });
     </doc:scenario>
   </doc:example>
*/

var ngListDirective = function() {

return {
  require: 'ngModel',
  link: function(scope, element, attr, ctrl) {
    var match = /\/(.*)\//.exec(attr.ngList),
        separator = match && new RegExp(match[1]) || attr.ngList || ',';

    var parse = function(viewValue) {
      var list = [];

      if (viewValue) {
        forEach(viewValue.split(separator), function(value) {
          if (value) list.push(trim(value));
        });
      }

      return list;
    };

    ctrl.$parsers.push(parse);
    ctrl.$formatters.push(function(value) {
      if (isArray(value)) {
        return value.join(', ');
      }

      return undefined;
    });
  }
};

};

var CONSTANT_VALUE_REGEXP = /^(true|false|d+)$/;

var ngValueDirective = function() {

return {
  priority: 100,
  compile: function(tpl, tplAttr) {
    if (CONSTANT_VALUE_REGEXP.test(tplAttr.ngValue)) {
      return function(scope, elm, attr) {
        attr.$set('value', scope.$eval(attr.ngValue));
      };
    } else {
      return function(scope, elm, attr) {
        scope.$watch(attr.ngValue, function valueWatchAction(value) {
          attr.$set('value', value, false);
        });
      };
    }
  }
};

};

/**

* @ngdoc directive
* @name ng.directive:ngBind
*
* @description
* The `ngBind` attribute tells Angular to replace the text content of the specified HTML element
* with the value of a given expression, and to update the text content when the value of that
* expression changes.
*
* Typically, you don't use `ngBind` directly, but instead you use the double curly markup like
* `{{ expression }}` which is similar but less verbose.
*
* Once scenario in which the use of `ngBind` is prefered over `{{ expression }}` binding is when
* it's desirable to put bindings into template that is momentarily displayed by the browser in its
* raw state before Angular compiles it. Since `ngBind` is an element attribute, it makes the
* bindings invisible to the user while the page is loading.
*
* An alternative solution to this problem would be using the
* {@link ng.directive:ngCloak ngCloak} directive.
*
*
* @element ANY
* @param {expression} ngBind {@link guide/expression Expression} to evaluate.
*
* @example
* Enter a name in the Live Preview text box; the greeting below the text box changes instantly.
  <doc:example>
    <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.name = 'Whirled';
        }
      </script>
      <div ng-controller="Ctrl">
        Enter name: <input type="text" ng-model="name"><br>
        Hello <span ng-bind="name"></span>!
      </div>
    </doc:source>
    <doc:scenario>
      it('should check ng-bind', function() {
        expect(using('.doc-example-live').binding('name')).toBe('Whirled');
        using('.doc-example-live').input('name').enter('world');
        expect(using('.doc-example-live').binding('name')).toBe('world');
      });
    </doc:scenario>
  </doc:example>
*/

var ngBindDirective = ngDirective(function(scope, element, attr) {

element.addClass('ng-binding').data('$binding', attr.ngBind);
scope.$watch(attr.ngBind, function ngBindWatchAction(value) {
  element.text(value == undefined ? '' : value);
});

});

/**

* @ngdoc directive
* @name ng.directive:ngBindTemplate
*
* @description
* The `ngBindTemplate` directive specifies that the element
* text should be replaced with the template in ngBindTemplate.
* Unlike ngBind the ngBindTemplate can contain multiple `{{` `}}`
* expressions. (This is required since some HTML elements
* can not have SPAN elements such as TITLE, or OPTION to name a few.)
*
* @element ANY
* @param {string} ngBindTemplate template of form
*   <tt>{{</tt> <tt>expression</tt> <tt>}}</tt> to eval.
*
* @example
* Try it here: enter text in text box and watch the greeting change.
  <doc:example>
    <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.salutation = 'Hello';
          $scope.name = 'World';
        }
      </script>
      <div ng-controller="Ctrl">
       Salutation: <input type="text" ng-model="salutation"><br>
       Name: <input type="text" ng-model="name"><br>
       <pre ng-bind-template="{{salutation}} {{name}}!"></pre>
      </div>
    </doc:source>
    <doc:scenario>
      it('should check ng-bind', function() {
        expect(using('.doc-example-live').binding('salutation')).
          toBe('Hello');
        expect(using('.doc-example-live').binding('name')).
          toBe('World');
        using('.doc-example-live').input('salutation').enter('Greetings');
        using('.doc-example-live').input('name').enter('user');
        expect(using('.doc-example-live').binding('salutation')).
          toBe('Greetings');
        expect(using('.doc-example-live').binding('name')).
          toBe('user');
      });
    </doc:scenario>
  </doc:example>
*/

var ngBindTemplateDirective = ['$interpolate', function($interpolate) {

return function(scope, element, attr) {
  // TODO: move this to scenario runner
  var interpolateFn = $interpolate(element.attr(attr.$attr.ngBindTemplate));
  element.addClass('ng-binding').data('$binding', interpolateFn);
  attr.$observe('ngBindTemplate', function(value) {
    element.text(value);
  });
}

}];

/**

* @ngdoc directive
* @name ng.directive:ngBindHtmlUnsafe
*
* @description
* Creates a binding that will innerHTML the result of evaluating the `expression` into the current
* element. *The innerHTML-ed content will not be sanitized!* You should use this directive only if
* {@link ngSanitize.directive:ngBindHtml ngBindHtml} directive is too
* restrictive and when you absolutely trust the source of the content you are binding to.
*
* See {@link ngSanitize.$sanitize $sanitize} docs for examples.
*
* @element ANY
* @param {expression} ngBindHtmlUnsafe {@link guide/expression Expression} to evaluate.
*/

var ngBindHtmlUnsafeDirective = [function() {

return function(scope, element, attr) {
  element.addClass('ng-binding').data('$binding', attr.ngBindHtmlUnsafe);
  scope.$watch(attr.ngBindHtmlUnsafe, function ngBindHtmlUnsafeWatchAction(value) {
    element.html(value || '');
  });
};

}];

function classDirective(name, selector) {

name = 'ngClass' + name;
return ngDirective(function(scope, element, attr) {
  var oldVal = undefined;

  scope.$watch(attr[name], ngClassWatchAction, true);

  attr.$observe('class', function(value) {
    var ngClass = scope.$eval(attr[name]);
    ngClassWatchAction(ngClass, ngClass);
  });

  if (name !== 'ngClass') {
    scope.$watch('$index', function($index, old$index) {
      var mod = $index % 2;
      if (mod !== old$index % 2) {
        if (mod == selector) {
          addClass(scope.$eval(attr[name]));
        } else {
          removeClass(scope.$eval(attr[name]));
        }
      }
    });
  }

  function ngClassWatchAction(newVal) {
    if (selector === true || scope.$index % 2 === selector) {
      if (oldVal && (newVal !== oldVal)) {
        removeClass(oldVal);
      }
      addClass(newVal);
    }
    oldVal = newVal;
  }

  function removeClass(classVal) {
    if (isObject(classVal) && !isArray(classVal)) {
      classVal = map(classVal, function(v, k) { if (v) return k });
    }
    element.removeClass(isArray(classVal) ? classVal.join(' ') : classVal);
  }

  function addClass(classVal) {
    if (isObject(classVal) && !isArray(classVal)) {
      classVal = map(classVal, function(v, k) { if (v) return k });
    }
    if (classVal) {
      element.addClass(isArray(classVal) ? classVal.join(' ') : classVal);
    }
  }
});

}

/**

* @ngdoc directive
* @name ng.directive:ngClass
*
* @description
* The `ngClass` allows you to set CSS class on HTML element dynamically by databinding an
* expression that represents all classes to be added.
*
* The directive won't add duplicate classes if a particular class was already set.
*
* When the expression changes, the previously added classes are removed and only then the
* new classes are added.
*
* @element ANY
* @param {expression} ngClass {@link guide/expression Expression} to eval. The result
*   of the evaluation can be a string representing space delimited class
*   names, an array, or a map of class names to boolean values.
*
* @example
  <example>
    <file name="index.html">
     <input type="button" value="set" ng-click="myVar='my-class'">
     <input type="button" value="clear" ng-click="myVar=''">
     <br>
     <span ng-class="myVar">Sample Text</span>
    </file>
    <file name="style.css">
      .my-class {
        color: red;
      }
    </file>
    <file name="scenario.js">
      it('should check ng-class', function() {
        expect(element('.doc-example-live span').prop('className')).not().
          toMatch(/my-class/);

        using('.doc-example-live').element(':button:first').click();

        expect(element('.doc-example-live span').prop('className')).
          toMatch(/my-class/);

        using('.doc-example-live').element(':button:last').click();

        expect(element('.doc-example-live span').prop('className')).not().
          toMatch(/my-class/);
      });
    </file>
  </example>
*/

var ngClassDirective = classDirective('', true);

/**

* @ngdoc directive
* @name ng.directive:ngClassOdd
*
* @description
* The `ngClassOdd` and `ngClassEven` directives work exactly as
* {@link ng.directive:ngClass ngClass}, except it works in
* conjunction with `ngRepeat` and takes affect only on odd (even) rows.
*
* This directive can be applied only within a scope of an
* {@link ng.directive:ngRepeat ngRepeat}.
*
* @element ANY
* @param {expression} ngClassOdd {@link guide/expression Expression} to eval. The result
*   of the evaluation can be a string representing space delimited class names or an array.
*
* @example
  <example>
    <file name="index.html">
       <ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']">
         <li ng-repeat="name in names">
          <span ng-class-odd="'odd'" ng-class-even="'even'">
            {{name}}
          </span>
         </li>
       </ol>
    </file>
    <file name="style.css">
      .odd {
        color: red;
      }
      .even {
        color: blue;
      }
    </file>
    <file name="scenario.js">
      it('should check ng-class-odd and ng-class-even', function() {
        expect(element('.doc-example-live li:first span').prop('className')).
          toMatch(/odd/);
        expect(element('.doc-example-live li:last span').prop('className')).
          toMatch(/even/);
      });
    </file>
  </example>
*/

var ngClassOddDirective = classDirective('Odd', 0);

/**

* @ngdoc directive
* @name ng.directive:ngClassEven
*
* @description
* The `ngClassOdd` and `ngClassEven` works exactly as
* {@link ng.directive:ngClass ngClass}, except it works in
* conjunction with `ngRepeat` and takes affect only on odd (even) rows.
*
* This directive can be applied only within a scope of an
* {@link ng.directive:ngRepeat ngRepeat}.
*
* @element ANY
* @param {expression} ngClassEven {@link guide/expression Expression} to eval. The
*   result of the evaluation can be a string representing space delimited class names or an array.
*
* @example
  <example>
    <file name="index.html">
       <ol ng-init="names=['John', 'Mary', 'Cate', 'Suz']">
         <li ng-repeat="name in names">
          <span ng-class-odd="'odd'" ng-class-even="'even'">
            {{name}} &nbsp; &nbsp; &nbsp;
          </span>
         </li>
       </ol>
    </file>
    <file name="style.css">
      .odd {
        color: red;
      }
      .even {
        color: blue;
      }
    </file>
    <file name="scenario.js">
      it('should check ng-class-odd and ng-class-even', function() {
        expect(element('.doc-example-live li:first span').prop('className')).
          toMatch(/odd/);
        expect(element('.doc-example-live li:last span').prop('className')).
          toMatch(/even/);
      });
    </file>
  </example>
*/

var ngClassEvenDirective = classDirective('Even', 1);

/**

* @ngdoc directive
* @name ng.directive:ngCloak
*
* @description
* The `ngCloak` directive is used to prevent the Angular html template from being briefly
* displayed by the browser in its raw (uncompiled) form while your application is loading. Use this
* directive to avoid the undesirable flicker effect caused by the html template display.
*
* The directive can be applied to the `<body>` element, but typically a fine-grained application is
* prefered in order to benefit from progressive rendering of the browser view.
*
* `ngCloak` works in cooperation with a css rule that is embedded within `angular.js` and
*  `angular.min.js` files. Following is the css rule:
*
* <pre>
* [ng\:cloak], [ng-cloak], [data-ng-cloak], [x-ng-cloak], .ng-cloak, .x-ng-cloak {
*   display: none;
* }
* </pre>
*
* When this css rule is loaded by the browser, all html elements (including their children) that
* are tagged with the `ng-cloak` directive are hidden. When Angular comes across this directive
* during the compilation of the template it deletes the `ngCloak` element attribute, which
* makes the compiled element visible.
*
* For the best result, `angular.js` script must be loaded in the head section of the html file;
* alternatively, the css rule (above) must be included in the external stylesheet of the
* application.
*
* Legacy browsers, like IE7, do not provide attribute selector support (added in CSS 2.1) so they
* cannot match the `[ng\:cloak]` selector. To work around this limitation, you must add the css
* class `ngCloak` in addition to `ngCloak` directive as shown in the example below.
*
* @element ANY
*
* @example
  <doc:example>
    <doc:source>
       <div id="template1" ng-cloak>{{ 'hello' }}</div>
       <div id="template2" ng-cloak class="ng-cloak">{{ 'hello IE7' }}</div>
    </doc:source>
    <doc:scenario>
      it('should remove the template directive and css class', function() {
        expect(element('.doc-example-live #template1').attr('ng-cloak')).
          not().toBeDefined();
        expect(element('.doc-example-live #template2').attr('ng-cloak')).
          not().toBeDefined();
      });
    </doc:scenario>
  </doc:example>
*
*/

var ngCloakDirective = ngDirective({

compile: function(element, attr) {
  attr.$set('ngCloak', undefined);
  element.removeClass('ng-cloak');
}

});

/**

* @ngdoc directive
* @name ng.directive:ngController
*
* @description
* The `ngController` directive assigns behavior to a scope. This is a key aspect of how angular
* supports the principles behind the Model-View-Controller design pattern.
*
* MVC components in angular:
*
* * Model — The Model is data in scope properties; scopes are attached to the DOM.
* * View — The template (HTML with data bindings) is rendered into the View.
* * Controller — The `ngController` directive specifies a Controller class; the class has
*   methods that typically express the business logic behind the application.
*
* Note that an alternative way to define controllers is via the `{@link ng.$route}`
* service.
*
* @element ANY
* @scope
* @param {expression} ngController Name of a globally accessible constructor function or an
*     {@link guide/expression expression} that on the current scope evaluates to a
*     constructor function.
*
* @example
* Here is a simple form for editing user contact information. Adding, removing, clearing, and
* greeting are methods declared on the controller (see source tab). These methods can
* easily be called from the angular markup. Notice that the scope becomes the `this` for the
* controller's instance. This allows for easy access to the view data from the controller. Also
* notice that any changes to the data are automatically reflected in the View without the need
* for a manual update.
  <doc:example>
    <doc:source>
     <script>
       function SettingsController($scope) {
         $scope.name = "John Smith";
         $scope.contacts = [
           {type:'phone', value:'408 555 1212'},
           {type:'email', value:'john.smith@example.org'} ];

         $scope.greet = function() {
          alert(this.name);
         };

         $scope.addContact = function() {
          this.contacts.push({type:'email', value:'yourname@example.org'});
         };

         $scope.removeContact = function(contactToRemove) {
          var index = this.contacts.indexOf(contactToRemove);
          this.contacts.splice(index, 1);
         };

         $scope.clearContact = function(contact) {
          contact.type = 'phone';
          contact.value = '';
         };
       }
     </script>
     <div ng-controller="SettingsController">
       Name: <input type="text" ng-model="name"/>
       [ <a href="" ng-click="greet()">greet</a> ]<br/>
       Contact:
       <ul>
         <li ng-repeat="contact in contacts">
           <select ng-model="contact.type">
              <option>phone</option>
              <option>email</option>
           </select>
           <input type="text" ng-model="contact.value"/>
           [ <a href="" ng-click="clearContact(contact)">clear</a>
           | <a href="" ng-click="removeContact(contact)">X</a> ]
         </li>
         <li>[ <a href="" ng-click="addContact()">add</a> ]</li>
      </ul>
     </div>
    </doc:source>
    <doc:scenario>
      it('should check controller', function() {
        expect(element('.doc-example-live div>:input').val()).toBe('John Smith');
        expect(element('.doc-example-live li:nth-child(1) input').val())
          .toBe('408 555 1212');
        expect(element('.doc-example-live li:nth-child(2) input').val())
          .toBe('john.smith@example.org');

        element('.doc-example-live li:first a:contains("clear")').click();
        expect(element('.doc-example-live li:first input').val()).toBe('');

        element('.doc-example-live li:last a:contains("add")').click();
        expect(element('.doc-example-live li:nth-child(3) input').val())
          .toBe('yourname@example.org');
      });
    </doc:scenario>
  </doc:example>
*/

var ngControllerDirective = [function() {

return {
  scope: true,
  controller: '@'
};

}];

/**

* @ngdoc directive
* @name ng.directive:ngCsp
* @priority 1000
*
* @description
* Enables [CSP (Content Security Policy)](https://developer.mozilla.org/en/Security/CSP) support.
* This directive should be used on the root element of the application (typically the `<html>`
* element or other element with the {@link ng.directive:ngApp ngApp}
* directive).
*
* If enabled the performance of template expression evaluator will suffer slightly, so don't enable
* this mode unless you need it.
*
* @element html
*/

var ngCspDirective = ['$sniffer', function($sniffer) {

return {
  priority: 1000,
  compile: function() {
    $sniffer.csp = true;
  }
};

}];

/**

* @ngdoc directive
* @name ng.directive:ngClick
*
* @description
* The ngClick allows you to specify custom behavior when
* element is clicked.
*
* @element ANY
* @param {expression} ngClick {@link guide/expression Expression} to evaluate upon
* click. (Event object is available as `$event`)
*
* @example
  <doc:example>
    <doc:source>
     <button ng-click="count = count + 1" ng-init="count=0">
       Increment
     </button>
     count: {{count}}
    </doc:source>
    <doc:scenario>
      it('should check ng-click', function() {
        expect(binding('count')).toBe('0');
        element('.doc-example-live :button').click();
        expect(binding('count')).toBe('1');
      });
    </doc:scenario>
  </doc:example>
*/

/*

* A directive that allows creation of custom onclick handlers that are defined as angular
* expressions and are compiled and executed within the current scope.
*
* Events that are handled via these handler are always configured not to propagate further.
*/

var ngEventDirectives = {}; forEach(

'click dblclick mousedown mouseup mouseover mouseout mousemove mouseenter mouseleave'.split(' '),
function(name) {
  var directiveName = directiveNormalize('ng-' + name);
  ngEventDirectives[directiveName] = ['$parse', function($parse) {
    return function(scope, element, attr) {
      var fn = $parse(attr[directiveName]);
      element.bind(lowercase(name), function(event) {
        scope.$apply(function() {
          fn(scope, {$event:event});
        });
      });
    };
  }];
}

);

/**

* @ngdoc directive
* @name ng.directive:ngDblclick
*
* @description
* The `ngDblclick` directive allows you to specify custom behavior on dblclick event.
*
* @element ANY
* @param {expression} ngDblclick {@link guide/expression Expression} to evaluate upon
* dblclick. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/

/**

* @ngdoc directive
* @name ng.directive:ngMousedown
*
* @description
* The ngMousedown directive allows you to specify custom behavior on mousedown event.
*
* @element ANY
* @param {expression} ngMousedown {@link guide/expression Expression} to evaluate upon
* mousedown. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/

/**

* @ngdoc directive
* @name ng.directive:ngMouseup
*
* @description
* Specify custom behavior on mouseup event.
*
* @element ANY
* @param {expression} ngMouseup {@link guide/expression Expression} to evaluate upon
* mouseup. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/

/**

* @ngdoc directive
* @name ng.directive:ngMouseover
*
* @description
* Specify custom behavior on mouseover event.
*
* @element ANY
* @param {expression} ngMouseover {@link guide/expression Expression} to evaluate upon
* mouseover. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/

/**

* @ngdoc directive
* @name ng.directive:ngMouseenter
*
* @description
* Specify custom behavior on mouseenter event.
*
* @element ANY
* @param {expression} ngMouseenter {@link guide/expression Expression} to evaluate upon
* mouseenter. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/

/**

* @ngdoc directive
* @name ng.directive:ngMouseleave
*
* @description
* Specify custom behavior on mouseleave event.
*
* @element ANY
* @param {expression} ngMouseleave {@link guide/expression Expression} to evaluate upon
* mouseleave. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/

/**

* @ngdoc directive
* @name ng.directive:ngMousemove
*
* @description
* Specify custom behavior on mousemove event.
*
* @element ANY
* @param {expression} ngMousemove {@link guide/expression Expression} to evaluate upon
* mousemove. (Event object is available as `$event`)
*
* @example
* See {@link ng.directive:ngClick ngClick}
*/

/**

* @ngdoc directive
* @name ng.directive:ngSubmit
*
* @description
* Enables binding angular expressions to onsubmit events.
*
* Additionally it prevents the default action (which for form means sending the request to the
* server and reloading the current page).
*
* @element form
* @param {expression} ngSubmit {@link guide/expression Expression} to eval.
*
* @example
  <doc:example>
    <doc:source>
     <script>
       function Ctrl($scope) {
         $scope.list = [];
         $scope.text = 'hello';
         $scope.submit = function() {
           if (this.text) {
             this.list.push(this.text);
             this.text = '';
           }
         };
       }
     </script>
     <form ng-submit="submit()" ng-controller="Ctrl">
       Enter text and hit enter:
       <input type="text" ng-model="text" name="text" />
       <input type="submit" id="submit" value="Submit" />
       <pre>list={{list}}</pre>
     </form>
    </doc:source>
    <doc:scenario>
      it('should check ng-submit', function() {
        expect(binding('list')).toBe('[]');
        element('.doc-example-live #submit').click();
        expect(binding('list')).toBe('["hello"]');
        expect(input('text').val()).toBe('');
      });
      it('should ignore empty strings', function() {
        expect(binding('list')).toBe('[]');
        element('.doc-example-live #submit').click();
        element('.doc-example-live #submit').click();
        expect(binding('list')).toBe('["hello"]');
      });
    </doc:scenario>
  </doc:example>
*/

var ngSubmitDirective = ngDirective(function(scope, element, attrs) {

element.bind('submit', function() {
  scope.$apply(attrs.ngSubmit);
});

});

/**

* @ngdoc directive
* @name ng.directive:ngInclude
* @restrict ECA
*
* @description
* Fetches, compiles and includes an external HTML fragment.
*
* Keep in mind that Same Origin Policy applies to included resources
* (e.g. ngInclude won't work for cross-domain requests on all browsers and for
*  file:// access on some browsers).
*
* @scope
*
* @param {string} ngInclude|src angular expression evaluating to URL. If the source is a string constant,
*                 make sure you wrap it in quotes, e.g. `src="'myPartialTemplate.html'"`.
* @param {string=} onload Expression to evaluate when a new partial is loaded.
*
* @param {string=} autoscroll Whether `ngInclude` should call {@link ng.$anchorScroll
*                  $anchorScroll} to scroll the viewport after the content is loaded.
*
*                  - If the attribute is not set, disable scrolling.
*                  - If the attribute is set without value, enable scrolling.
*                  - Otherwise enable scrolling only if the expression evaluates to truthy value.
*
* @example
 <example>
   <file name="index.html">
    <div ng-controller="Ctrl">
      <select ng-model="template" ng-options="t.name for t in templates">
       <option value="">(blank)</option>
      </select>
      url of the template: <tt>{{template.url}}</tt>
      <hr/>
      <div ng-include src="template.url"></div>
    </div>
   </file>
   <file name="script.js">
     function Ctrl($scope) {
       $scope.templates =
         [ { name: 'template1.html', url: 'template1.html'}
         , { name: 'template2.html', url: 'template2.html'} ];
       $scope.template = $scope.templates[0];
     }
    </file>
   <file name="template1.html">
     Content of template1.html
   </file>
   <file name="template2.html">
     Content of template2.html
   </file>
   <file name="scenario.js">
     it('should load template1.html', function() {
      expect(element('.doc-example-live [ng-include]').text()).
        toMatch(/Content of template1.html/);
     });
     it('should load template2.html', function() {
      select('template').option('1');
      expect(element('.doc-example-live [ng-include]').text()).
        toMatch(/Content of template2.html/);
     });
     it('should change to blank', function() {
      select('template').option('');
      expect(element('.doc-example-live [ng-include]').text()).toEqual('');
     });
   </file>
 </example>
*/

/**

* @ngdoc event
* @name ng.directive:ngInclude#$includeContentLoaded
* @eventOf ng.directive:ngInclude
* @eventType emit on the current ngInclude scope
* @description
* Emitted every time the ngInclude content is reloaded.
*/

var ngIncludeDirective = ['$http', '$templateCache', '$anchorScroll', '$compile',

                function($http,   $templateCache,   $anchorScroll,   $compile) {
return {
  restrict: 'ECA',
  terminal: true,
  compile: function(element, attr) {
    var srcExp = attr.ngInclude || attr.src,
        onloadExp = attr.onload || '',
        autoScrollExp = attr.autoscroll;

    return function(scope, element) {
      var changeCounter = 0,
          childScope;

      var clearContent = function() {
        if (childScope) {
          childScope.$destroy();
          childScope = null;
        }

        element.html('');
      };

      scope.$watch(srcExp, function ngIncludeWatchAction(src) {
        var thisChangeId = ++changeCounter;

        if (src) {
          $http.get(src, {cache: $templateCache}).success(function(response) {
            if (thisChangeId !== changeCounter) return;

            if (childScope) childScope.$destroy();
            childScope = scope.$new();

            element.html(response);
            $compile(element.contents())(childScope);

            if (isDefined(autoScrollExp) && (!autoScrollExp || scope.$eval(autoScrollExp))) {
              $anchorScroll();
            }

            childScope.$emit('$includeContentLoaded');
            scope.$eval(onloadExp);
          }).error(function() {
            if (thisChangeId === changeCounter) clearContent();
          });
        } else clearContent();
      });
    };
  }
};

}];

/**

* @ngdoc directive
* @name ng.directive:ngInit
*
* @description
* The `ngInit` directive specifies initialization tasks to be executed
*  before the template enters execution mode during bootstrap.
*
* @element ANY
* @param {expression} ngInit {@link guide/expression Expression} to eval.
*
* @example
  <doc:example>
    <doc:source>
   <div ng-init="greeting='Hello'; person='World'">
     {{greeting}} {{person}}!
   </div>
    </doc:source>
    <doc:scenario>
      it('should check greeting', function() {
        expect(binding('greeting')).toBe('Hello');
        expect(binding('person')).toBe('World');
      });
    </doc:scenario>
  </doc:example>
*/

var ngInitDirective = ngDirective({

compile: function() {
  return {
    pre: function(scope, element, attrs) {
      scope.$eval(attrs.ngInit);
    }
  }
}

});

/**

* @ngdoc directive
* @name ng.directive:ngNonBindable
* @priority 1000
*
* @description
* Sometimes it is necessary to write code which looks like bindings but which should be left alone
* by angular. Use `ngNonBindable` to make angular ignore a chunk of HTML.
*
* @element ANY
*
* @example
* In this example there are two location where a simple binding (`{{}}`) is present, but the one
* wrapped in `ngNonBindable` is left alone.
*
* @example
   <doc:example>
     <doc:source>
       <div>Normal: {{1 + 2}}</div>
       <div ng-non-bindable>Ignored: {{1 + 2}}</div>
     </doc:source>
     <doc:scenario>
      it('should check ng-non-bindable', function() {
        expect(using('.doc-example-live').binding('1 + 2')).toBe('3');
        expect(using('.doc-example-live').element('div:last').text()).
          toMatch(/1 \+ 2/);
      });
     </doc:scenario>
   </doc:example>
*/

var ngNonBindableDirective = ngDirective({ terminal: true, priority: 1000 });

/**

* @ngdoc directive
* @name ng.directive:ngPluralize
* @restrict EA
*
* @description
* # Overview
* `ngPluralize` is a directive that displays messages according to en-US localization rules.
* These rules are bundled with angular.js and the rules can be overridden
* (see {@link guide/i18n Angular i18n} dev guide). You configure ngPluralize directive
* by specifying the mappings between
* {@link http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
* plural categories} and the strings to be displayed.
*
* # Plural categories and explicit number rules
* There are two
* {@link http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html
* plural categories} in Angular's default en-US locale: "one" and "other".
*
* While a pural category may match many numbers (for example, in en-US locale, "other" can match
* any number that is not 1), an explicit number rule can only match one number. For example, the
* explicit number rule for "3" matches the number 3. You will see the use of plural categories
* and explicit number rules throughout later parts of this documentation.
*
* # Configuring ngPluralize
* You configure ngPluralize by providing 2 attributes: `count` and `when`.
* You can also provide an optional attribute, `offset`.
*
* The value of the `count` attribute can be either a string or an {@link guide/expression
* Angular expression}; these are evaluated on the current scope for its bound value.
*
* The `when` attribute specifies the mappings between plural categories and the actual
* string to be displayed. The value of the attribute should be a JSON object so that Angular
* can interpret it correctly.
*
* The following example shows how to configure ngPluralize:
*
* <pre>
* <ng-pluralize count="personCount"
                when="{'0': 'Nobody is viewing.',
*                      'one': '1 person is viewing.',
*                      'other': '{} people are viewing.'}">
* </ng-pluralize>
*</pre>
*
* In the example, `"0: Nobody is viewing."` is an explicit number rule. If you did not
* specify this rule, 0 would be matched to the "other" category and "0 people are viewing"
* would be shown instead of "Nobody is viewing". You can specify an explicit number rule for
* other numbers, for example 12, so that instead of showing "12 people are viewing", you can
* show "a dozen people are viewing".
*
* You can use a set of closed braces(`{}`) as a placeholder for the number that you want substituted
* into pluralized strings. In the previous example, Angular will replace `{}` with
* <span ng-non-bindable>`{{personCount}}`</span>. The closed braces `{}` is a placeholder
* for <span ng-non-bindable>{{numberExpression}}</span>.
*
* # Configuring ngPluralize with offset
* The `offset` attribute allows further customization of pluralized text, which can result in
* a better user experience. For example, instead of the message "4 people are viewing this document",
* you might display "John, Kate and 2 others are viewing this document".
* The offset attribute allows you to offset a number by any desired value.
* Let's take a look at an example:
*
* <pre>
* <ng-pluralize count="personCount" offset=2
*               when="{'0': 'Nobody is viewing.',
*                      '1': '{{person1}} is viewing.',
*                      '2': '{{person1}} and {{person2}} are viewing.',
*                      'one': '{{person1}}, {{person2}} and one other person are viewing.',
*                      'other': '{{person1}}, {{person2}} and {} other people are viewing.'}">
* </ng-pluralize>
* </pre>
*
* Notice that we are still using two plural categories(one, other), but we added
* three explicit number rules 0, 1 and 2.
* When one person, perhaps John, views the document, "John is viewing" will be shown.
* When three people view the document, no explicit number rule is found, so
* an offset of 2 is taken off 3, and Angular uses 1 to decide the plural category.
* In this case, plural category 'one' is matched and "John, Marry and one other person are viewing"
* is shown.
*
* Note that when you specify offsets, you must provide explicit number rules for
* numbers from 0 up to and including the offset. If you use an offset of 3, for example,
* you must provide explicit number rules for 0, 1, 2 and 3. You must also provide plural strings for
* plural categories "one" and "other".
*
* @param {string|expression} count The variable to be bounded to.
* @param {string} when The mapping between plural category to its correspoding strings.
* @param {number=} offset Offset to deduct from the total number.
*
* @example
   <doc:example>
     <doc:source>
       <script>
         function Ctrl($scope) {
           $scope.person1 = 'Igor';
           $scope.person2 = 'Misko';
           $scope.personCount = 1;
         }
       </script>
       <div ng-controller="Ctrl">
         Person 1:<input type="text" ng-model="person1" value="Igor" /><br/>
         Person 2:<input type="text" ng-model="person2" value="Misko" /><br/>
         Number of People:<input type="text" ng-model="personCount" value="1" /><br/>

         <!--- Example with simple pluralization rules for en locale --->
         Without Offset:
         <ng-pluralize count="personCount"
                       when="{'0': 'Nobody is viewing.',
                              'one': '1 person is viewing.',
                              'other': '{} people are viewing.'}">
         </ng-pluralize><br>

         <!--- Example with offset --->
         With Offset(2):
         <ng-pluralize count="personCount" offset=2
                       when="{'0': 'Nobody is viewing.',
                              '1': '{{person1}} is viewing.',
                              '2': '{{person1}} and {{person2}} are viewing.',
                              'one': '{{person1}}, {{person2}} and one other person are viewing.',
                              'other': '{{person1}}, {{person2}} and {} other people are viewing.'}">
         </ng-pluralize>
       </div>
     </doc:source>
     <doc:scenario>
       it('should show correct pluralized string', function() {
         expect(element('.doc-example-live ng-pluralize:first').text()).
                                            toBe('1 person is viewing.');
         expect(element('.doc-example-live ng-pluralize:last').text()).
                                               toBe('Igor is viewing.');

         using('.doc-example-live').input('personCount').enter('0');
         expect(element('.doc-example-live ng-pluralize:first').text()).
                                              toBe('Nobody is viewing.');
         expect(element('.doc-example-live ng-pluralize:last').text()).
                                             toBe('Nobody is viewing.');

         using('.doc-example-live').input('personCount').enter('2');
         expect(element('.doc-example-live ng-pluralize:first').text()).
                                           toBe('2 people are viewing.');
         expect(element('.doc-example-live ng-pluralize:last').text()).
                             toBe('Igor and Misko are viewing.');

         using('.doc-example-live').input('personCount').enter('3');
         expect(element('.doc-example-live ng-pluralize:first').text()).
                                           toBe('3 people are viewing.');
         expect(element('.doc-example-live ng-pluralize:last').text()).
                             toBe('Igor, Misko and one other person are viewing.');

         using('.doc-example-live').input('personCount').enter('4');
         expect(element('.doc-example-live ng-pluralize:first').text()).
                                           toBe('4 people are viewing.');
         expect(element('.doc-example-live ng-pluralize:last').text()).
                             toBe('Igor, Misko and 2 other people are viewing.');
       });

       it('should show data-binded names', function() {
         using('.doc-example-live').input('personCount').enter('4');
         expect(element('.doc-example-live ng-pluralize:last').text()).
             toBe('Igor, Misko and 2 other people are viewing.');

         using('.doc-example-live').input('person1').enter('Di');
         using('.doc-example-live').input('person2').enter('Vojta');
         expect(element('.doc-example-live ng-pluralize:last').text()).
             toBe('Di, Vojta and 2 other people are viewing.');
       });
     </doc:scenario>
   </doc:example>
*/

var ngPluralizeDirective = ['$locale', '$interpolate', function($locale, $interpolate) {

var BRACE = /{}/g;
return {
  restrict: 'EA',
  link: function(scope, element, attr) {
    var numberExp = attr.count,
        whenExp = element.attr(attr.$attr.when), // this is because we have {{}} in attrs
        offset = attr.offset || 0,
        whens = scope.$eval(whenExp),
        whensExpFns = {},
        startSymbol = $interpolate.startSymbol(),
        endSymbol = $interpolate.endSymbol();

    forEach(whens, function(expression, key) {
      whensExpFns[key] =
        $interpolate(expression.replace(BRACE, startSymbol + numberExp + '-' +
          offset + endSymbol));
    });

    scope.$watch(function ngPluralizeWatch() {
      var value = parseFloat(scope.$eval(numberExp));

      if (!isNaN(value)) {
        //if explicit number rule such as 1, 2, 3... is defined, just use it. Otherwise,
        //check it against pluralization rules in $locale service
        if (!whens[value]) value = $locale.pluralCat(value - offset);
         return whensExpFns[value](scope, element, true);
      } else {
        return '';
      }
    }, function ngPluralizeWatchAction(newVal) {
      element.text(newVal);
    });
  }
};

}];

/**

* @ngdoc directive
* @name ng.directive:ngRepeat
*
* @description
* The `ngRepeat` directive instantiates a template once per item from a collection. Each template
* instance gets its own scope, where the given loop variable is set to the current collection item,
* and `$index` is set to the item index or key.
*
* Special properties are exposed on the local scope of each template instance, including:
*
*   * `$index` – `{number}` – iterator offset of the repeated element (0..length-1)
*   * `$first` – `{boolean}` – true if the repeated element is first in the iterator.
*   * `$middle` – `{boolean}` – true if the repeated element is between the first and last in the iterator.
*   * `$last` – `{boolean}` – true if the repeated element is last in the iterator.
*
*
* @element ANY
* @scope
* @priority 1000
* @param {repeat_expression} ngRepeat The expression indicating how to enumerate a collection. Two
*   formats are currently supported:
*
*   * `variable in expression` – where variable is the user defined loop variable and `expression`
*     is a scope expression giving the collection to enumerate.
*
*     For example: `track in cd.tracks`.
*
*   * `(key, value) in expression` – where `key` and `value` can be any user defined identifiers,
*     and `expression` is the scope expression giving the collection to enumerate.
*
*     For example: `(name, age) in {'adam':10, 'amalie':12}`.
*
* @example
* This example initializes the scope to a list of names and
* then uses `ngRepeat` to display every person:
   <doc:example>
     <doc:source>
       <div ng-init="friends = [{name:'John', age:25}, {name:'Mary', age:28}]">
         I have {{friends.length}} friends. They are:
         <ul>
           <li ng-repeat="friend in friends">
             [{{$index + 1}}] {{friend.name}} who is {{friend.age}} years old.
           </li>
         </ul>
       </div>
     </doc:source>
     <doc:scenario>
        it('should check ng-repeat', function() {
          var r = using('.doc-example-live').repeater('ul li');
          expect(r.count()).toBe(2);
          expect(r.row(0)).toEqual(["1","John","25"]);
          expect(r.row(1)).toEqual(["2","Mary","28"]);
        });
     </doc:scenario>
   </doc:example>
*/

var ngRepeatDirective = ngDirective({

transclude: 'element',
priority: 1000,
terminal: true,
compile: function(element, attr, linker) {
  return function(scope, iterStartElement, attr){
    var expression = attr.ngRepeat;
    var match = expression.match(/^\s*(.+)\s+in\s+(.*)\s*$/),
      lhs, rhs, valueIdent, keyIdent;
    if (! match) {
      throw Error("Expected ngRepeat in form of '_item_ in _collection_' but got '" +
        expression + "'.");
    }
    lhs = match[1];
    rhs = match[2];
    match = lhs.match(/^(?:([\$\w]+)|\(([\$\w]+)\s*,\s*([\$\w]+)\))$/);
    if (!match) {
      throw Error("'item' in 'item in collection' should be identifier or (key, value) but got '" +
          lhs + "'.");
    }
    valueIdent = match[3] || match[1];
    keyIdent = match[2];

    // Store a list of elements from previous run. This is a hash where key is the item from the
    // iterator, and the value is an array of objects with following properties.
    //   - scope: bound scope
    //   - element: previous element.
    //   - index: position
    // We need an array of these objects since the same object can be returned from the iterator.
    // We expect this to be a rare case.
    var lastOrder = new HashQueueMap();

    scope.$watch(function ngRepeatWatch(scope){
      var index, length,
          collection = scope.$eval(rhs),
          cursor = iterStartElement,     // current position of the node
          // Same as lastOrder but it has the current state. It will become the
          // lastOrder on the next iteration.
          nextOrder = new HashQueueMap(),
          arrayBound,
          childScope,
          key, value, // key/value of iteration
          array,
          last;       // last object information {scope, element, index}

      if (!isArray(collection)) {
        // if object, extract keys, sort them and use to determine order of iteration over obj props
        array = [];
        for(key in collection) {
          if (collection.hasOwnProperty(key) && key.charAt(0) != '$') {
            array.push(key);
          }
        }
        array.sort();
      } else {
        array = collection || [];
      }

      arrayBound = array.length-1;

      // we are not using forEach for perf reasons (trying to avoid #call)
      for (index = 0, length = array.length; index < length; index++) {
        key = (collection === array) ? index : array[index];
        value = collection[key];

        last = lastOrder.shift(value);

        if (last) {
          // if we have already seen this object, then we need to reuse the
          // associated scope/element
          childScope = last.scope;
          nextOrder.push(value, last);

          if (index === last.index) {
            // do nothing
            cursor = last.element;
          } else {
            // existing item which got moved
            last.index = index;
            // This may be a noop, if the element is next, but I don't know of a good way to
            // figure this out,  since it would require extra DOM access, so let's just hope that
            // the browsers realizes that it is noop, and treats it as such.
            cursor.after(last.element);
            cursor = last.element;
          }
        } else {
          // new item which we don't know about
          childScope = scope.$new();
        }

        childScope[valueIdent] = value;
        if (keyIdent) childScope[keyIdent] = key;
        childScope.$index = index;

        childScope.$first = (index === 0);
        childScope.$last = (index === arrayBound);
        childScope.$middle = !(childScope.$first || childScope.$last);

        if (!last) {
          linker(childScope, function(clone){
            cursor.after(clone);
            last = {
                scope: childScope,
                element: (cursor = clone),
                index: index
              };
            nextOrder.push(value, last);
          });
        }
      }

      //shrink children
      for (key in lastOrder) {
        if (lastOrder.hasOwnProperty(key)) {
          array = lastOrder[key];
          while(array.length) {
            value = array.pop();
            value.element.remove();
            value.scope.$destroy();
          }
        }
      }

      lastOrder = nextOrder;
    });
  };
}

});

/**

* @ngdoc directive
* @name ng.directive:ngShow
*
* @description
* The `ngShow` and `ngHide` directives show or hide a portion of the DOM tree (HTML)
* conditionally.
*
* @element ANY
* @param {expression} ngShow If the {@link guide/expression expression} is truthy
*     then the element is shown or hidden respectively.
*
* @example
  <doc:example>
    <doc:source>
       Click me: <input type="checkbox" ng-model="checked"><br/>
       Show: <span ng-show="checked">I show up when your checkbox is checked.</span> <br/>
       Hide: <span ng-hide="checked">I hide when your checkbox is checked.</span>
    </doc:source>
    <doc:scenario>
      it('should check ng-show / ng-hide', function() {
        expect(element('.doc-example-live span:first:hidden').count()).toEqual(1);
        expect(element('.doc-example-live span:last:visible').count()).toEqual(1);

        input('checked').check();

        expect(element('.doc-example-live span:first:visible').count()).toEqual(1);
        expect(element('.doc-example-live span:last:hidden').count()).toEqual(1);
      });
    </doc:scenario>
  </doc:example>
*/

//TODO(misko): refactor to remove element from the DOM var ngShowDirective = ngDirective(function(scope, element, attr){

scope.$watch(attr.ngShow, function ngShowWatchAction(value){
  element.css('display', toBoolean(value) ? '' : 'none');
});

});

/**

* @ngdoc directive
* @name ng.directive:ngHide
*
* @description
* The `ngHide` and `ngShow` directives hide or show a portion of the DOM tree (HTML)
* conditionally.
*
* @element ANY
* @param {expression} ngHide If the {@link guide/expression expression} is truthy then
*     the element is shown or hidden respectively.
*
* @example
  <doc:example>
    <doc:source>
       Click me: <input type="checkbox" ng-model="checked"><br/>
       Show: <span ng-show="checked">I show up when you checkbox is checked?</span> <br/>
       Hide: <span ng-hide="checked">I hide when you checkbox is checked?</span>
    </doc:source>
    <doc:scenario>
      it('should check ng-show / ng-hide', function() {
        expect(element('.doc-example-live span:first:hidden').count()).toEqual(1);
        expect(element('.doc-example-live span:last:visible').count()).toEqual(1);

        input('checked').check();

        expect(element('.doc-example-live span:first:visible').count()).toEqual(1);
        expect(element('.doc-example-live span:last:hidden').count()).toEqual(1);
      });
    </doc:scenario>
  </doc:example>
*/

//TODO(misko): refactor to remove element from the DOM var ngHideDirective = ngDirective(function(scope, element, attr){

scope.$watch(attr.ngHide, function ngHideWatchAction(value){
  element.css('display', toBoolean(value) ? 'none' : '');
});

});

/**

* @ngdoc directive
* @name ng.directive:ngStyle
*
* @description
* The `ngStyle` directive allows you to set CSS style on an HTML element conditionally.
*
* @element ANY
* @param {expression} ngStyle {@link guide/expression Expression} which evals to an
*      object whose keys are CSS style names and values are corresponding values for those CSS
*      keys.
*
* @example
  <example>
    <file name="index.html">
       <input type="button" value="set" ng-click="myStyle={color:'red'}">
       <input type="button" value="clear" ng-click="myStyle={}">
       <br/>
       <span ng-style="myStyle">Sample Text</span>
       <pre>myStyle={{myStyle}}</pre>
    </file>
    <file name="style.css">
      span {
        color: black;
      }
    </file>
    <file name="scenario.js">
      it('should check ng-style', function() {
        expect(element('.doc-example-live span').css('color')).toBe('rgb(0, 0, 0)');
        element('.doc-example-live :button[value=set]').click();
        expect(element('.doc-example-live span').css('color')).toBe('rgb(255, 0, 0)');
        element('.doc-example-live :button[value=clear]').click();
        expect(element('.doc-example-live span').css('color')).toBe('rgb(0, 0, 0)');
      });
    </file>
  </example>
*/

var ngStyleDirective = ngDirective(function(scope, element, attr) {

scope.$watch(attr.ngStyle, function ngStyleWatchAction(newStyles, oldStyles) {
  if (oldStyles && (newStyles !== oldStyles)) {
    forEach(oldStyles, function(val, style) { element.css(style, '');});
  }
  if (newStyles) element.css(newStyles);
}, true);

});

/**

* @ngdoc directive
* @name ng.directive:ngSwitch
* @restrict EA
*
* @description
* Conditionally change the DOM structure.
*
* @usage
* <ANY ng-switch="expression">
*   <ANY ng-switch-when="matchValue1">...</ANY>
*   <ANY ng-switch-when="matchValue2">...</ANY>
*   ...
*   <ANY ng-switch-default>...</ANY>
* </ANY>
*
* @scope
* @param {*} ngSwitch|on expression to match against <tt>ng-switch-when</tt>.
* @paramDescription
* On child elments add:
*
* * `ngSwitchWhen`: the case statement to match against. If match then this
*   case will be displayed.
* * `ngSwitchDefault`: the default case when no other casses match.
*
* @example
   <doc:example>
     <doc:source>
       <script>
         function Ctrl($scope) {
           $scope.items = ['settings', 'home', 'other'];
           $scope.selection = $scope.items[0];
         }
       </script>
       <div ng-controller="Ctrl">
         <select ng-model="selection" ng-options="item for item in items">
         </select>
         <tt>selection={{selection}}</tt>
         <hr/>
         <div ng-switch on="selection" >
           <div ng-switch-when="settings">Settings Div</div>
           <span ng-switch-when="home">Home Span</span>
           <span ng-switch-default>default</span>
         </div>
       </div>
     </doc:source>
     <doc:scenario>
       it('should start in settings', function() {
        expect(element('.doc-example-live [ng-switch]').text()).toMatch(/Settings Div/);
       });
       it('should change to home', function() {
        select('selection').option('home');
        expect(element('.doc-example-live [ng-switch]').text()).toMatch(/Home Span/);
       });
       it('should select deafault', function() {
        select('selection').option('other');
        expect(element('.doc-example-live [ng-switch]').text()).toMatch(/default/);
       });
     </doc:scenario>
   </doc:example>
*/

var NG_SWITCH = 'ng-switch'; var ngSwitchDirective = valueFn({

restrict: 'EA',
require: 'ngSwitch',
// asks for $scope to fool the BC controller module
controller: ['$scope', function ngSwitchController() {
  this.cases = {};
}],
link: function(scope, element, attr, ctrl) {
  var watchExpr = attr.ngSwitch || attr.on,
      selectedTransclude,
      selectedElement,
      selectedScope;

  scope.$watch(watchExpr, function ngSwitchWatchAction(value) {
    if (selectedElement) {
      selectedScope.$destroy();
      selectedElement.remove();
      selectedElement = selectedScope = null;
    }
    if ((selectedTransclude = ctrl.cases['!' + value] || ctrl.cases['?'])) {
      scope.$eval(attr.change);
      selectedScope = scope.$new();
      selectedTransclude(selectedScope, function(caseElement) {
        selectedElement = caseElement;
        element.append(caseElement);
      });
    }
  });
}

});

var ngSwitchWhenDirective = ngDirective({

transclude: 'element',
priority: 500,
require: '^ngSwitch',
compile: function(element, attrs, transclude) {
  return function(scope, element, attr, ctrl) {
    ctrl.cases['!' + attrs.ngSwitchWhen] = transclude;
  };
}

});

var ngSwitchDefaultDirective = ngDirective({

transclude: 'element',
priority: 500,
require: '^ngSwitch',
compile: function(element, attrs, transclude) {
  return function(scope, element, attr, ctrl) {
    ctrl.cases['?'] = transclude;
  };
}

});

/**

* @ngdoc directive
* @name ng.directive:ngTransclude
*
* @description
* Insert the transcluded DOM here.
*
* @element ANY
*
* @example
  <doc:example module="transclude">
    <doc:source>
      <script>
        function Ctrl($scope) {
          $scope.title = 'Lorem Ipsum';
          $scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...';
        }

        angular.module('transclude', [])
         .directive('pane', function(){
            return {
              restrict: 'E',
              transclude: true,
              scope: 'isolate',
              locals: { title:'bind' },
              template: '<div style="border: 1px solid black;">' +
                          '<div style="background-color: gray">{{title}}</div>' +
                          '<div ng-transclude></div>' +
                        '</div>'
            };
        });
      </script>
      <div ng-controller="Ctrl">
        <input ng-model="title"><br>
        <textarea ng-model="text"></textarea> <br/>
        <pane title="{{title}}">{{text}}</pane>
      </div>
    </doc:source>
    <doc:scenario>
       it('should have transcluded', function() {
         input('title').enter('TITLE');
         input('text').enter('TEXT');
         expect(binding('title')).toEqual('TITLE');
         expect(binding('text')).toEqual('TEXT');
       });
    </doc:scenario>
  </doc:example>
*
*/

var ngTranscludeDirective = ngDirective({

controller: ['$transclude', '$element', function($transclude, $element) {
  $transclude(function(clone) {
    $element.append(clone);
  });
}]

});

/**

* @ngdoc directive
* @name ng.directive:ngView
* @restrict ECA
*
* @description
* # Overview
* `ngView` is a directive that complements the {@link ng.$route $route} service by
* including the rendered template of the current route into the main layout (`index.html`) file.
* Every time the current route changes, the included view changes with it according to the
* configuration of the `$route` service.
*
* @scope
* @example
   <example module="ngView">
     <file name="index.html">
       <div ng-controller="MainCntl">
         Choose:
         <a href="Book/Moby">Moby</a> |
         <a href="Book/Moby/ch/1">Moby: Ch1</a> |
         <a href="Book/Gatsby">Gatsby</a> |
         <a href="Book/Gatsby/ch/4?key=value">Gatsby: Ch4</a> |
         <a href="Book/Scarlet">Scarlet Letter</a><br/>

         <div ng-view></div>
         <hr />

         <pre>$location.path() = {{$location.path()}}</pre>
         <pre>$route.current.templateUrl = {{$route.current.templateUrl}}</pre>
         <pre>$route.current.params = {{$route.current.params}}</pre>
         <pre>$route.current.scope.name = {{$route.current.scope.name}}</pre>
         <pre>$routeParams = {{$routeParams}}</pre>
       </div>
     </file>

     <file name="book.html">
       controller: {{name}}<br />
       Book Id: {{params.bookId}}<br />
     </file>

     <file name="chapter.html">
       controller: {{name}}<br />
       Book Id: {{params.bookId}}<br />
       Chapter Id: {{params.chapterId}}
     </file>

     <file name="script.js">
       angular.module('ngView', [], function($routeProvider, $locationProvider) {
         $routeProvider.when('/Book/:bookId', {
           templateUrl: 'book.html',
           controller: BookCntl
         });
         $routeProvider.when('/Book/:bookId/ch/:chapterId', {
           templateUrl: 'chapter.html',
           controller: ChapterCntl
         });

         // configure html5 to get links working on jsfiddle
         $locationProvider.html5Mode(true);
       });

       function MainCntl($scope, $route, $routeParams, $location) {
         $scope.$route = $route;
         $scope.$location = $location;
         $scope.$routeParams = $routeParams;
       }

       function BookCntl($scope, $routeParams) {
         $scope.name = "BookCntl";
         $scope.params = $routeParams;
       }

       function ChapterCntl($scope, $routeParams) {
         $scope.name = "ChapterCntl";
         $scope.params = $routeParams;
       }
     </file>

     <file name="scenario.js">
       it('should load and compile correct template', function() {
         element('a:contains("Moby: Ch1")').click();
         var content = element('.doc-example-live [ng-view]').text();
         expect(content).toMatch(/controller\: ChapterCntl/);
         expect(content).toMatch(/Book Id\: Moby/);
         expect(content).toMatch(/Chapter Id\: 1/);

         element('a:contains("Scarlet")').click();
         content = element('.doc-example-live [ng-view]').text();
         expect(content).toMatch(/controller\: BookCntl/);
         expect(content).toMatch(/Book Id\: Scarlet/);
       });
     </file>
   </example>
*/

/**

* @ngdoc event
* @name ng.directive:ngView#$viewContentLoaded
* @eventOf ng.directive:ngView
* @eventType emit on the current ngView scope
* @description
* Emitted every time the ngView content is reloaded.
*/

var ngViewDirective = ['$http', '$templateCache', '$route', '$anchorScroll', '$compile',

                     '$controller',
             function($http,   $templateCache,   $route,   $anchorScroll,   $compile,
                      $controller) {
return {
  restrict: 'ECA',
  terminal: true,
  link: function(scope, element, attr) {
    var lastScope,
        onloadExp = attr.onload || '';

    scope.$on('$routeChangeSuccess', update);
    update();

    function destroyLastScope() {
      if (lastScope) {
        lastScope.$destroy();
        lastScope = null;
      }
    }

    function clearContent() {
      element.html('');
      destroyLastScope();
    }

    function update() {
      var locals = $route.current && $route.current.locals,
          template = locals && locals.$template;

      if (template) {
        element.html(template);
        destroyLastScope();

        var link = $compile(element.contents()),
            current = $route.current,
            controller;

        lastScope = current.scope = scope.$new();
        if (current.controller) {
          locals.$scope = lastScope;
          controller = $controller(current.controller, locals);
          element.children().data('$ngControllerController', controller);
        }

        link(lastScope);
        lastScope.$emit('$viewContentLoaded');
        lastScope.$eval(onloadExp);

        // $anchorScroll might listen on event...
        $anchorScroll();
      } else {
        clearContent();
      }
    }
  }
};

}];

/**

* @ngdoc directive
* @name ng.directive:script
*
* @description
* Load content of a script tag, with type `text/ng-template`, into `$templateCache`, so that the
* template can be used by `ngInclude`, `ngView` or directive templates.
*
* @restrict E
* @param {'text/ng-template'} type must be set to `'text/ng-template'`
*
* @example
 <doc:example>
   <doc:source>
     <script type="text/ng-template" id="/tpl.html">
       Content of the template.
     </script>

     <a ng-click="currentTpl='/tpl.html'" id="tpl-link">Load inlined template</a>
     <div id="tpl-content" ng-include src="currentTpl"></div>
   </doc:source>
   <doc:scenario>
     it('should load template defined inside script tag', function() {
       element('#tpl-link').click();
       expect(element('#tpl-content').text()).toMatch(/Content of the template/);
     });
   </doc:scenario>
 </doc:example>
*/

var scriptDirective = ['$templateCache', function($templateCache) {

return {
  restrict: 'E',
  terminal: true,
  compile: function(element, attr) {
    if (attr.type == 'text/ng-template') {
      var templateUrl = attr.id,
          // IE is not consistent, in scripts we have to read .text but in other nodes we have to read .textContent
          text = element[0].text;

      $templateCache.put(templateUrl, text);
    }
  }
};

}];

/**

* @ngdoc directive
* @name ng.directive:select
* @restrict E
*
* @description
* HTML `SELECT` element with angular data-binding.
*
* # `ngOptions`
*
* Optionally `ngOptions` attribute can be used to dynamically generate a list of `<option>`
* elements for a `<select>` element using an array or an object obtained by evaluating the
* `ngOptions` expression.
*˝˝
* When an item in the select menu is select, the value of array element or object property
* represented by the selected option will be bound to the model identified by the `ngModel`
* directive of the parent select element.
*
* Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
* be nested into the `<select>` element. This element will then represent `null` or "not selected"
* option. See example below for demonstration.
*
* Note: `ngOptions` provides iterator facility for `<option>` element which should be used instead
* of {@link ng.directive:ngRepeat ngRepeat} when you want the
* `select` model to be bound to a non-string value. This is because an option element can currently
* be bound to string values only.
*
* @param {string} name assignable expression to data-bind to.
* @param {string=} required The control is considered valid only if value is entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
*    the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
*    `required` when you want to data-bind to the `required` attribute.
* @param {comprehension_expression=} ngOptions in one of the following forms:
*
*   * for array data sources:
*     * `label` **`for`** `value` **`in`** `array`
*     * `select` **`as`** `label` **`for`** `value` **`in`** `array`
*     * `label`  **`group by`** `group` **`for`** `value` **`in`** `array`
*     * `select` **`as`** `label` **`group by`** `group` **`for`** `value` **`in`** `array`
*   * for object data sources:
*     * `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
*     * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
*     * `label` **`group by`** `group` **`for (`**`key`**`,`** `value`**`) in`** `object`
*     * `select` **`as`** `label` **`group by`** `group`
*         **`for` `(`**`key`**`,`** `value`**`) in`** `object`
*
* Where:
*
*   * `array` / `object`: an expression which evaluates to an array / object to iterate over.
*   * `value`: local variable which will refer to each item in the `array` or each property value
*      of `object` during iteration.
*   * `key`: local variable which will refer to a property name in `object` during iteration.
*   * `label`: The result of this expression will be the label for `<option>` element. The
*     `expression` will most likely refer to the `value` variable (e.g. `value.propertyName`).
*   * `select`: The result of this expression will be bound to the model of the parent `<select>`
*      element. If not specified, `select` expression will default to `value`.
*   * `group`: The result of this expression will be used to group options using the `<optgroup>`
*      DOM element.
*
* @example
   <doc:example>
     <doc:source>
       <script>
       function MyCntrl($scope) {
         $scope.colors = [
           {name:'black', shade:'dark'},
           {name:'white', shade:'light'},
           {name:'red', shade:'dark'},
           {name:'blue', shade:'dark'},
           {name:'yellow', shade:'light'}
         ];
         $scope.color = $scope.colors[2]; // red
       }
       </script>
       <div ng-controller="MyCntrl">
         <ul>
           <li ng-repeat="color in colors">
             Name: <input ng-model="color.name">
             [<a href ng-click="colors.splice($index, 1)">X</a>]
           </li>
           <li>
             [<a href ng-click="colors.push({})">add</a>]
           </li>
         </ul>
         <hr/>
         Color (null not allowed):
         <select ng-model="color" ng-options="c.name for c in colors"></select><br>

         Color (null allowed):
         <span  class="nullable">
           <select ng-model="color" ng-options="c.name for c in colors">
             <option value="">-- chose color --</option>
           </select>
         </span><br/>

         Color grouped by shade:
         <select ng-model="color" ng-options="c.name group by c.shade for c in colors">
         </select><br/>

         Select <a href ng-click="color={name:'not in list'}">bogus</a>.<br>
         <hr/>
         Currently selected: {{ {selected_color:color}  }}
         <div style="border:solid 1px black; height:20px"
              ng-style="{'background-color':color.name}">
         </div>
       </div>
     </doc:source>
     <doc:scenario>
        it('should check ng-options', function() {
          expect(binding('{selected_color:color}')).toMatch('red');
          select('color').option('0');
          expect(binding('{selected_color:color}')).toMatch('black');
          using('.nullable').select('color').option('');
          expect(binding('{selected_color:color}')).toMatch('null');
        });
     </doc:scenario>
   </doc:example>
*/

var ngOptionsDirective = valueFn({ terminal: true }); var selectDirective = ['$compile', '$parse', function($compile, $parse) {

                       //0000111110000000000022220000000000000000000000333300000000000000444444444444444440000000005555555555555555500000006666666666666666600000000000000077770
var NG_OPTIONS_REGEXP = /^\s*(.*?)(?:\s+as\s+(.*?))?(?:\s+group\s+by\s+(.*))?\s+for\s+(?:([\$\w][\$\w\d]*)|(?:\(\s*([\$\w][\$\w\d]*)\s*,\s*([\$\w][\$\w\d]*)\s*\)))\s+in\s+(.*)$/,
    nullModelCtrl = {$setViewValue: noop};

return {
  restrict: 'E',
  require: ['select', '?ngModel'],
  controller: ['$element', '$scope', '$attrs', function($element, $scope, $attrs) {
    var self = this,
        optionsMap = {},
        ngModelCtrl = nullModelCtrl,
        nullOption,
        unknownOption;

    self.databound = $attrs.ngModel;

    self.init = function(ngModelCtrl_, nullOption_, unknownOption_) {
      ngModelCtrl = ngModelCtrl_;
      nullOption = nullOption_;
      unknownOption = unknownOption_;
    }

    self.addOption = function(value) {
      optionsMap[value] = true;

      if (ngModelCtrl.$viewValue == value) {
        $element.val(value);
        if (unknownOption.parent()) unknownOption.remove();
      }
    };

    self.removeOption = function(value) {
      if (this.hasOption(value)) {
        delete optionsMap[value];
        if (ngModelCtrl.$viewValue == value) {
          this.renderUnknownOption(value);
        }
      }
    };

    self.renderUnknownOption = function(val) {
      var unknownVal = '? ' + hashKey(val) + ' ?';
      unknownOption.val(unknownVal);
      $element.prepend(unknownOption);
      $element.val(unknownVal);
      unknownOption.prop('selected', true); // needed for IE
    }

    self.hasOption = function(value) {
      return optionsMap.hasOwnProperty(value);
    }

    $scope.$on('$destroy', function() {
      // disable unknown option so that we don't do work when the whole select is being destroyed
      self.renderUnknownOption = noop;
    });
  }],

  link: function(scope, element, attr, ctrls) {
    // if ngModel is not defined, we don't need to do anything
    if (!ctrls[1]) return;

    var selectCtrl = ctrls[0],
        ngModelCtrl = ctrls[1],
        multiple = attr.multiple,
        optionsExp = attr.ngOptions,
        nullOption = false, // if false, user will not be able to select it (used by ngOptions)
        emptyOption,
        // we can't just jqLite('<option>') since jqLite is not smart enough
        // to create it in <select> and IE barfs otherwise.
        optionTemplate = jqLite(document.createElement('option')),
        optGroupTemplate =jqLite(document.createElement('optgroup')),
        unknownOption = optionTemplate.clone();

    // find "null" option
    for(var i = 0, children = element.children(), ii = children.length; i < ii; i++) {
      if (children[i].value == '') {
        emptyOption = nullOption = children.eq(i);
        break;
      }
    }

    selectCtrl.init(ngModelCtrl, nullOption, unknownOption);

    // required validator
    if (multiple && (attr.required || attr.ngRequired)) {
      var requiredValidator = function(value) {
        ngModelCtrl.$setValidity('required', !attr.required || (value && value.length));
        return value;
      };

      ngModelCtrl.$parsers.push(requiredValidator);
      ngModelCtrl.$formatters.unshift(requiredValidator);

      attr.$observe('required', function() {
        requiredValidator(ngModelCtrl.$viewValue);
      });
    }

    if (optionsExp) Options(scope, element, ngModelCtrl);
    else if (multiple) Multiple(scope, element, ngModelCtrl);
    else Single(scope, element, ngModelCtrl, selectCtrl);

    ////////////////////////////

    function Single(scope, selectElement, ngModelCtrl, selectCtrl) {
      ngModelCtrl.$render = function() {
        var viewValue = ngModelCtrl.$viewValue;

        if (selectCtrl.hasOption(viewValue)) {
          if (unknownOption.parent()) unknownOption.remove();
          selectElement.val(viewValue);
          if (viewValue === '') emptyOption.prop('selected', true); // to make IE9 happy
        } else {
          if (isUndefined(viewValue) && emptyOption) {
            selectElement.val('');
          } else {
            selectCtrl.renderUnknownOption(viewValue);
          }
        }
      };

      selectElement.bind('change', function() {
        scope.$apply(function() {
          if (unknownOption.parent()) unknownOption.remove();
          ngModelCtrl.$setViewValue(selectElement.val());
        });
      });
    }

    function Multiple(scope, selectElement, ctrl) {
      var lastView;
      ctrl.$render = function() {
        var items = new HashMap(ctrl.$viewValue);
        forEach(selectElement.find('option'), function(option) {
          option.selected = isDefined(items.get(option.value));
        });
      };

      // we have to do it on each watch since ngModel watches reference, but
      // we need to work of an array, so we need to see if anything was inserted/removed
      scope.$watch(function selectMultipleWatch() {
        if (!equals(lastView, ctrl.$viewValue)) {
          lastView = copy(ctrl.$viewValue);
          ctrl.$render();
        }
      });

      selectElement.bind('change', function() {
        scope.$apply(function() {
          var array = [];
          forEach(selectElement.find('option'), function(option) {
            if (option.selected) {
              array.push(option.value);
            }
          });
          ctrl.$setViewValue(array);
        });
      });
    }

    function Options(scope, selectElement, ctrl) {
      var match;

      if (! (match = optionsExp.match(NG_OPTIONS_REGEXP))) {
        throw Error(
          "Expected ngOptions in form of '_select_ (as _label_)? for (_key_,)?_value_ in _collection_'" +
          " but got '" + optionsExp + "'.");
      }

      var displayFn = $parse(match[2] || match[1]),
          valueName = match[4] || match[6],
          keyName = match[5],
          groupByFn = $parse(match[3] || ''),
          valueFn = $parse(match[2] ? match[1] : valueName),
          valuesFn = $parse(match[7]),
          // This is an array of array of existing option groups in DOM. We try to reuse these if possible
          // optionGroupsCache[0] is the options with no option group
          // optionGroupsCache[?][0] is the parent: either the SELECT or OPTGROUP element
          optionGroupsCache = [[{element: selectElement, label:''}]];

      if (nullOption) {
        // compile the element since there might be bindings in it
        $compile(nullOption)(scope);

        // remove the class, which is added automatically because we recompile the element and it
        // becomes the compilation root
        nullOption.removeClass('ng-scope');

        // we need to remove it before calling selectElement.html('') because otherwise IE will
        // remove the label from the element. wtf?
        nullOption.remove();
      }

      // clear contents, we'll add what's needed based on the model
      selectElement.html('');

      selectElement.bind('change', function() {
        scope.$apply(function() {
          var optionGroup,
              collection = valuesFn(scope) || [],
              locals = {},
              key, value, optionElement, index, groupIndex, length, groupLength;

          if (multiple) {
            value = [];
            for (groupIndex = 0, groupLength = optionGroupsCache.length;
                 groupIndex < groupLength;
                 groupIndex++) {
              // list of options for that group. (first item has the parent)
              optionGroup = optionGroupsCache[groupIndex];

              for(index = 1, length = optionGroup.length; index < length; index++) {
                if ((optionElement = optionGroup[index].element)[0].selected) {
                  key = optionElement.val();
                  if (keyName) locals[keyName] = key;
                  locals[valueName] = collection[key];
                  value.push(valueFn(scope, locals));
                }
              }
            }
          } else {
            key = selectElement.val();
            if (key == '?') {
              value = undefined;
            } else if (key == ''){
              value = null;
            } else {
              locals[valueName] = collection[key];
              if (keyName) locals[keyName] = key;
              value = valueFn(scope, locals);
            }
          }
          ctrl.$setViewValue(value);
        });
      });

      ctrl.$render = render;

      // TODO(vojta): can't we optimize this ?
      scope.$watch(render);

      function render() {
        var optionGroups = {'':[]}, // Temporary location for the option groups before we render them
            optionGroupNames = [''],
            optionGroupName,
            optionGroup,
            option,
            existingParent, existingOptions, existingOption,
            modelValue = ctrl.$modelValue,
            values = valuesFn(scope) || [],
            keys = keyName ? sortedKeys(values) : values,
            groupLength, length,
            groupIndex, index,
            locals = {},
            selected,
            selectedSet = false, // nothing is selected yet
            lastElement,
            element,
            label;

        if (multiple) {
          selectedSet = new HashMap(modelValue);
        } else if (modelValue === null || nullOption) {
          // if we are not multiselect, and we are null then we have to add the nullOption
          optionGroups[''].push({selected:modelValue === null, id:'', label:''});
          selectedSet = true;
        }

        // We now build up the list of options we need (we merge later)
        for (index = 0; length = keys.length, index < length; index++) {
             locals[valueName] = values[keyName ? locals[keyName]=keys[index]:index];
             optionGroupName = groupByFn(scope, locals) || '';
          if (!(optionGroup = optionGroups[optionGroupName])) {
            optionGroup = optionGroups[optionGroupName] = [];
            optionGroupNames.push(optionGroupName);
          }
          if (multiple) {
            selected = selectedSet.remove(valueFn(scope, locals)) != undefined;
          } else {
            selected = modelValue === valueFn(scope, locals);
            selectedSet = selectedSet || selected; // see if at least one item is selected
          }
          label = displayFn(scope, locals); // what will be seen by the user
          label = label === undefined ? '' : label; // doing displayFn(scope, locals) || '' overwrites zero values
          optionGroup.push({
            id: keyName ? keys[index] : index,   // either the index into array or key from object
            label: label,
            selected: selected                   // determine if we should be selected
          });
        }
        if (!multiple && !selectedSet) {
          // nothing was selected, we have to insert the undefined item
          optionGroups[''].unshift({id:'?', label:'', selected:true});
        }

        // Now we need to update the list of DOM nodes to match the optionGroups we computed above
        for (groupIndex = 0, groupLength = optionGroupNames.length;
             groupIndex < groupLength;
             groupIndex++) {
          // current option group name or '' if no group
          optionGroupName = optionGroupNames[groupIndex];

          // list of options for that group. (first item has the parent)
          optionGroup = optionGroups[optionGroupName];

          if (optionGroupsCache.length <= groupIndex) {
            // we need to grow the optionGroups
            existingParent = {
              element: optGroupTemplate.clone().attr('label', optionGroupName),
              label: optionGroup.label
            };
            existingOptions = [existingParent];
            optionGroupsCache.push(existingOptions);
            selectElement.append(existingParent.element);
          } else {
            existingOptions = optionGroupsCache[groupIndex];
            existingParent = existingOptions[0];  // either SELECT (no group) or OPTGROUP element

            // update the OPTGROUP label if not the same.
            if (existingParent.label != optionGroupName) {
              existingParent.element.attr('label', existingParent.label = optionGroupName);
            }
          }

          lastElement = null;  // start at the beginning
          for(index = 0, length = optionGroup.length; index < length; index++) {
            option = optionGroup[index];
            if ((existingOption = existingOptions[index+1])) {
              // reuse elements
              lastElement = existingOption.element;
              if (existingOption.label !== option.label) {
                lastElement.text(existingOption.label = option.label);
              }
              if (existingOption.id !== option.id) {
                lastElement.val(existingOption.id = option.id);
              }
              if (existingOption.element.selected !== option.selected) {
                lastElement.prop('selected', (existingOption.selected = option.selected));
              }
            } else {
              // grow elements

              // if it's a null option
              if (option.id === '' && nullOption) {
                // put back the pre-compiled element
                element = nullOption;
              } else {
                // jQuery(v1.4.2) Bug: We should be able to chain the method calls, but
                // in this version of jQuery on some browser the .text() returns a string
                // rather then the element.
                (element = optionTemplate.clone())
                    .val(option.id)
                    .attr('selected', option.selected)
                    .text(option.label);
              }

              existingOptions.push(existingOption = {
                  element: element,
                  label: option.label,
                  id: option.id,
                  selected: option.selected
              });
              if (lastElement) {
                lastElement.after(element);
              } else {
                existingParent.element.append(element);
              }
              lastElement = element;
            }
          }
          // remove any excessive OPTIONs in a group
          index++; // increment since the existingOptions[0] is parent element not OPTION
          while(existingOptions.length > index) {
            existingOptions.pop().element.remove();
          }
        }
        // remove any excessive OPTGROUPs from select
        while(optionGroupsCache.length > groupIndex) {
          optionGroupsCache.pop()[0].element.remove();
        }
      }
    }
  }
}

}];

var optionDirective = ['$interpolate', function($interpolate) {

var nullSelectCtrl = {
  addOption: noop,
  removeOption: noop
};

return {
  restrict: 'E',
  priority: 100,
  compile: function(element, attr) {
    if (isUndefined(attr.value)) {
      var interpolateFn = $interpolate(element.text(), true);
      if (!interpolateFn) {
        attr.$set('value', element.text());
      }
    }

    return function (scope, element, attr) {
      var selectCtrlName = '$selectController',
          parent = element.parent(),
          selectCtrl = parent.data(selectCtrlName) ||
            parent.parent().data(selectCtrlName); // in case we are in optgroup

      if (selectCtrl && selectCtrl.databound) {
        // For some reason Opera defaults to true and if not overridden this messes up the repeater.
        // We don't want the view to drive the initialization of the model anyway.
        element.prop('selected', false);
      } else {
        selectCtrl = nullSelectCtrl;
      }

      if (interpolateFn) {
        scope.$watch(interpolateFn, function interpolateWatchAction(newVal, oldVal) {
          attr.$set('value', newVal);
          if (newVal !== oldVal) selectCtrl.removeOption(oldVal);
          selectCtrl.addOption(newVal);
        });
      } else {
        selectCtrl.addOption(attr.value);
      }

      element.bind('$destroy', function() {
        selectCtrl.removeOption(attr.value);
      });
    };
  }
}

}];

var styleDirective = valueFn({

restrict: 'E',
terminal: true

});

/**

* Setup file for the Scenario.
* Must be first in the compilation/bootstrap list.
*/

// Public namespace angular.scenario = angular.scenario || {};

/**

* Defines a new output format.
*
* @param {string} name the name of the new output format
* @param {function()} fn function(context, runner) that generates the output
*/

angular.scenario.output = angular.scenario.output || function(name, fn) {

angular.scenario.output[name] = fn;

};

/**

* Defines a new DSL statement. If your factory function returns a Future
* it's returned, otherwise the result is assumed to be a map of functions
* for chaining. Chained functions are subject to the same rules.
*
* Note: All functions on the chain are bound to the chain scope so values
*   set on "this" in your statement function are available in the chained
*   functions.
*
* @param {string} name The name of the statement
* @param {function()} fn Factory function(), return a function for
*  the statement.
*/

angular.scenario.dsl = angular.scenario.dsl || function(name, fn) {

angular.scenario.dsl[name] = function() {
  function executeStatement(statement, args) {
    var result = statement.apply(this, args);
    if (angular.isFunction(result) || result instanceof angular.scenario.Future)
      return result;
    var self = this;
    var chain = angular.extend({}, result);
    angular.forEach(chain, function(value, name) {
      if (angular.isFunction(value)) {
        chain[name] = function() {
          return executeStatement.call(self, value, arguments);
        };
      } else {
        chain[name] = value;
      }
    });
    return chain;
  }
  var statement = fn.apply(this, arguments);
  return function() {
    return executeStatement.call(this, statement, arguments);
  };
};

};

/**

* Defines a new matcher for use with the expects() statement. The value
* this.actual (like in Jasmine) is available in your matcher to compare
* against. Your function should return a boolean. The future is automatically
* created for you.
*
* @param {string} name The name of the matcher
* @param {function()} fn The matching function(expected).
*/

angular.scenario.matcher = angular.scenario.matcher || function(name, fn) {

angular.scenario.matcher[name] = function(expected) {
  var prefix = 'expect ' + this.future.name + ' ';
  if (this.inverse) {
    prefix += 'not ';
  }
  var self = this;
  this.addFuture(prefix + name + ' ' + angular.toJson(expected),
    function(done) {
      var error;
      self.actual = self.future.value;
      if ((self.inverse && fn.call(self, expected)) ||
          (!self.inverse && !fn.call(self, expected))) {
        error = 'expected ' + angular.toJson(expected) +
          ' but was ' + angular.toJson(self.actual);
      }
      done(error);
  });
};

};

/**

* Initialize the scenario runner and run !
*
* Access global window and document object
* Access $runner through closure
*
* @param {Object=} config Config options
*/

angular.scenario.setUpAndRun = function(config) {

var href = window.location.href;
var body = _jQuery(document.body);
var output = [];
var objModel = new angular.scenario.ObjectModel($runner);

if (config && config.scenario_output) {
  output = config.scenario_output.split(',');
}

angular.forEach(angular.scenario.output, function(fn, name) {
  if (!output.length || indexOf(output,name) != -1) {
    var context = body.append('<div></div>').find('div:last');
    context.attr('id', name);
    fn.call({}, context, $runner, objModel);
  }
});

if (!/^http/.test(href) && !/^https/.test(href)) {
  body.append('<p id="system-error"></p>');
  body.find('#system-error').text(
    'Scenario runner must be run using http or https. The protocol ' +
    href.split(':')[0] + ':// is not supported.'
  );
  return;
}

var appFrame = body.append('<div id="application"></div>').find('#application');
var application = new angular.scenario.Application(appFrame);

$runner.on('RunnerEnd', function() {
  appFrame.css('display', 'none');
  appFrame.find('iframe').attr('src', 'about:blank');
});

$runner.on('RunnerError', function(error) {
  if (window.console) {
    console.log(formatException(error));
  } else {
    // Do something for IE
    alert(error);
  }
});

$runner.run(application);

};

/**

* Iterates through list with iterator function that must call the
* continueFunction to continute iterating.
*
* @param {Array} list list to iterate over
* @param {function()} iterator Callback function(value, continueFunction)
* @param {function()} done Callback function(error, result) called when
*   iteration finishes or an error occurs.
*/

function asyncForEach(list, iterator, done) {

var i = 0;
function loop(error, index) {
  if (index && index > i) {
    i = index;
  }
  if (error || i >= list.length) {
    done(error);
  } else {
    try {
      iterator(list[i++], loop);
    } catch (e) {
      done(e);
    }
  }
}
loop();

}

/**

* Formats an exception into a string with the stack trace, but limits
* to a specific line length.
*
* @param {Object} error The exception to format, can be anything throwable
* @param {Number=} [maxStackLines=5] max lines of the stack trace to include
*  default is 5.
*/

function formatException(error, maxStackLines) {

maxStackLines = maxStackLines || 5;
var message = error.toString();
if (error.stack) {
  var stack = error.stack.split('\n');
  if (stack[0].indexOf(message) === -1) {
    maxStackLines++;
    stack.unshift(error.message);
  }
  message = stack.slice(0, maxStackLines).join('\n');
}
return message;

}

/**

* Returns a function that gets the file name and line number from a
* location in the stack if available based on the call site.
*
* Note: this returns another function because accessing .stack is very
* expensive in Chrome.
*
* @param {Number} offset Number of stack lines to skip
*/

function callerFile(offset) {

var error = new Error();

return function() {
  var line = (error.stack || '').split('\n')[offset];

  // Clean up the stack trace line
  if (line) {
    if (line.indexOf('@') !== -1) {
      // Firefox
      line = line.substring(line.indexOf('@')+1);
    } else {
      // Chrome
      line = line.substring(line.indexOf('(')+1).replace(')', '');
    }
  }

  return line || '';
};

}

/**

* Triggers a browser event. Attempts to choose the right event if one is
* not specified.
*
* @param {Object} element Either a wrapped jQuery/jqLite node or a DOMElement
* @param {string} type Optional event type.
* @param {Array.<string>=} keys Optional list of pressed keys
*        (valid values: 'alt', 'meta', 'shift', 'ctrl')
*/

function browserTrigger(element, type, keys) {

if (element && !element.nodeName) element = element[0];
if (!element) return;
if (!type) {
  type = {
      'text':            'change',
      'textarea':        'change',
      'hidden':          'change',
      'password':        'change',
      'button':          'click',
      'submit':          'click',
      'reset':           'click',
      'image':           'click',
      'checkbox':        'click',
      'radio':           'click',
      'select-one':      'change',
      'select-multiple': 'change'
  }[lowercase(element.type)] || 'click';
}
if (lowercase(nodeName_(element)) == 'option') {
  element.parentNode.value = element.value;
  element = element.parentNode;
  type = 'change';
}

keys = keys || [];
function pressed(key) {
  return indexOf(keys, key) !== -1;
}

if (msie < 9) {
  switch(element.type) {
    case 'radio':
    case 'checkbox':
      element.checked = !element.checked;
      break;
  }
  // WTF!!! Error: Unspecified error.
  // Don't know why, but some elements when detached seem to be in inconsistent state and
  // calling .fireEvent() on them will result in very unhelpful error (Error: Unspecified error)
  // forcing the browser to compute the element position (by reading its CSS)
  // puts the element in consistent state.
  element.style.posLeft;

  // TODO(vojta): create event objects with pressed keys to get it working on IE<9
  var ret = element.fireEvent('on' + type);
  if (lowercase(element.type) == 'submit') {
    while(element) {
      if (lowercase(element.nodeName) == 'form') {
        element.fireEvent('onsubmit');
        break;
      }
      element = element.parentNode;
    }
  }
  return ret;
} else {
  var evnt = document.createEvent('MouseEvents'),
      originalPreventDefault = evnt.preventDefault,
      iframe = _jQuery('#application iframe')[0],
      appWindow = iframe ? iframe.contentWindow : window,
      fakeProcessDefault = true,
      finalProcessDefault,
      angular = appWindow.angular || {};

  // igor: temporary fix for https://bugzilla.mozilla.org/show_bug.cgi?id=684208
  angular['ff-684208-preventDefault'] = false;
  evnt.preventDefault = function() {
    fakeProcessDefault = false;
    return originalPreventDefault.apply(evnt, arguments);
  };

  evnt.initMouseEvent(type, true, true, window, 0, 0, 0, 0, 0, pressed('ctrl'), pressed('alt'),
                      pressed('shift'), pressed('meta'), 0, element);

  element.dispatchEvent(evnt);
  finalProcessDefault = !(angular['ff-684208-preventDefault'] || !fakeProcessDefault);

  delete angular['ff-684208-preventDefault'];

  return finalProcessDefault;
}

}

/**

* Don't use the jQuery trigger method since it works incorrectly.
*
* jQuery notifies listeners and then changes the state of a checkbox and
* does not create a real browser event. A real click changes the state of
* the checkbox and then notifies listeners.
*
* To work around this we instead use our own handler that fires a real event.
*/

(function(fn){

var parentTrigger = fn.trigger;
fn.trigger = function(type) {
  if (/(click|change|keydown|blur|input)/.test(type)) {
    var processDefaults = [];
    this.each(function(index, node) {
      processDefaults.push(browserTrigger(node, type));
    });

    // this is not compatible with jQuery - we return an array of returned values,
    // so that scenario runner know whether JS code has preventDefault() of the event or not...
    return processDefaults;
  }
  return parentTrigger.apply(this, arguments);
};

})(_jQuery.fn);

/**

* Finds all bindings with the substring match of name and returns an
* array of their values.
*
* @param {string} bindExp The name to match
* @return {Array.<string>} String of binding values
*/

_jQuery.fn.bindings = function(windowJquery, bindExp) {

var result = [], match,
    bindSelector = '.ng-binding:visible';
if (angular.isString(bindExp)) {
  bindExp = bindExp.replace(/\s/g, '');
  match = function (actualExp) {
    if (actualExp) {
      actualExp = actualExp.replace(/\s/g, '');
      if (actualExp == bindExp) return true;
      if (actualExp.indexOf(bindExp) == 0) {
        return actualExp.charAt(bindExp.length) == '|';
      }
    }
  }
} else if (bindExp) {
  match = function(actualExp) {
    return actualExp && bindExp.exec(actualExp);
  }
} else {
  match = function(actualExp) {
    return !!actualExp;
  };
}
var selection = this.find(bindSelector);
if (this.is(bindSelector)) {
  selection = selection.add(this);
}

function push(value) {
  if (value == undefined) {
    value = '';
  } else if (typeof value != 'string') {
    value = angular.toJson(value);
  }
  result.push('' + value);
}

selection.each(function() {
  var element = windowJquery(this),
      binding;
  if (binding = element.data('$binding')) {
    if (typeof binding == 'string') {
      if (match(binding)) {
        push(element.scope().$eval(binding));
      }
    } else {
      if (!angular.isArray(binding)) {
        binding = [binding];
      }
      for(var fns, j=0, jj=binding.length;  j<jj; j++) {
        fns = binding[j];
        if (fns.parts) {
          fns = fns.parts;
        } else {
          fns = [fns];
        }
        for (var scope, fn, i = 0, ii = fns.length; i < ii; i++) {
          if(match((fn = fns[i]).exp)) {
            push(fn(scope = scope || element.scope()));
          }
        }
      }
    }
  }
});
return result;

};

/**

* Represents the application currently being tested and abstracts usage
* of iframes or separate windows.
*
* @param {Object} context jQuery wrapper around HTML context.
*/

angular.scenario.Application = function(context) {

this.context = context;
context.append(
  '<h2>Current URL: <a href="about:blank">None</a></h2>' +
  '<div id="test-frames"></div>'
);

};

/**

* Gets the jQuery collection of frames. Don't use this directly because
* frames may go stale.
*
* @private
* @return {Object} jQuery collection
*/

angular.scenario.Application.prototype.getFrame_ = function() {

return this.context.find('#test-frames iframe:last');

};

/**

* Gets the window of the test runner frame. Always favor executeAction()
* instead of this method since it prevents you from getting a stale window.
*
* @private
* @return {Object} the window of the frame
*/

angular.scenario.Application.prototype.getWindow_ = function() {

var contentWindow = this.getFrame_().prop('contentWindow');
if (!contentWindow)
  throw 'Frame window is not accessible.';
return contentWindow;

};

/**

* Changes the location of the frame.
*
* @param {string} url The URL. If it begins with a # then only the
*   hash of the page is changed.
* @param {function()} loadFn function($window, $document) Called when frame loads.
* @param {function()} errorFn function(error) Called if any error when loading.
*/

angular.scenario.Application.prototype.navigateTo = function(url, loadFn, errorFn) {

var self = this;
var frame = this.getFrame_();
//TODO(esprehn): Refactor to use rethrow()
errorFn = errorFn || function(e) { throw e; };
if (url === 'about:blank') {
  errorFn('Sandbox Error: Navigating to about:blank is not allowed.');
} else if (url.charAt(0) === '#') {
  url = frame.attr('src').split('#')[0] + url;
  frame.attr('src', url);
  this.executeAction(loadFn);
} else {
  frame.remove();
  this.context.find('#test-frames').append('<iframe>');
  frame = this.getFrame_();
  frame.load(function() {
    frame.unbind();
    try {
      self.executeAction(loadFn);
    } catch (e) {
      errorFn(e);
    }
  }).attr('src', url);
}
this.context.find('> h2 a').attr('href', url).text(url);

};

/**

* Executes a function in the context of the tested application. Will wait
* for all pending angular xhr requests before executing.
*
* @param {function()} action The callback to execute. function($window, $document)
*  $document is a jQuery wrapped document.
*/

angular.scenario.Application.prototype.executeAction = function(action) {

var self = this;
var $window = this.getWindow_();
if (!$window.document) {
  throw 'Sandbox Error: Application document not accessible.';
}
if (!$window.angular) {
  return action.call(this, $window, _jQuery($window.document));
}
angularInit($window.document, function(element) {
  var $injector = $window.angular.element(element).injector();
  var $element = _jQuery(element);

  $element.injector = function() {
    return $injector;
  };

  $injector.invoke(function($browser){
    $browser.notifyWhenNoOutstandingRequests(function() {
      action.call(self, $window, $element);
    });
  });
});

};

/**

* The representation of define blocks. Don't used directly, instead use
* define() in your tests.
*
* @param {string} descName Name of the block
* @param {Object} parent describe or undefined if the root.
*/

angular.scenario.Describe = function(descName, parent) {

this.only = parent && parent.only;
this.beforeEachFns = [];
this.afterEachFns = [];
this.its = [];
this.children = [];
this.name = descName;
this.parent = parent;
this.id = angular.scenario.Describe.id++;

/**
 * Calls all before functions.
 */
var beforeEachFns = this.beforeEachFns;
this.setupBefore = function() {
  if (parent) parent.setupBefore.call(this);
  angular.forEach(beforeEachFns, function(fn) { fn.call(this); }, this);
};

/**
 * Calls all after functions.
 */
var afterEachFns = this.afterEachFns;
this.setupAfter  = function() {
  angular.forEach(afterEachFns, function(fn) { fn.call(this); }, this);
  if (parent) parent.setupAfter.call(this);
};

};

// Shared Unique ID generator for every describe block angular.scenario.Describe.id = 0;

// Shared Unique ID generator for every it (spec) angular.scenario.Describe.specId = 0;

/**

* Defines a block to execute before each it or nested describe.
*
* @param {function()} body Body of the block.
*/

angular.scenario.Describe.prototype.beforeEach = function(body) {

this.beforeEachFns.push(body);

};

/**

* Defines a block to execute after each it or nested describe.
*
* @param {function()} body Body of the block.
*/

angular.scenario.Describe.prototype.afterEach = function(body) {

this.afterEachFns.push(body);

};

/**

* Creates a new describe block that's a child of this one.
*
* @param {string} name Name of the block. Appended to the parent block's name.
* @param {function()} body Body of the block.
*/

angular.scenario.Describe.prototype.describe = function(name, body) {

var child = new angular.scenario.Describe(name, this);
this.children.push(child);
body.call(child);

};

/**

* Same as describe() but makes ddescribe blocks the only to run.
*
* @param {string} name Name of the test.
* @param {function()} body Body of the block.
*/

angular.scenario.Describe.prototype.ddescribe = function(name, body) {

var child = new angular.scenario.Describe(name, this);
child.only = true;
this.children.push(child);
body.call(child);

};

/**

* Use to disable a describe block.
*/

angular.scenario.Describe.prototype.xdescribe = angular.noop;

/**

* Defines a test.
*
* @param {string} name Name of the test.
* @param {function()} vody Body of the block.
*/

angular.scenario.Describe.prototype.it = function(name, body) {

this.its.push({
  id: angular.scenario.Describe.specId++,
  definition: this,
  only: this.only,
  name: name,
  before: this.setupBefore,
  body: body,
  after: this.setupAfter
});

};

/**

* Same as it() but makes iit tests the only test to run.
*
* @param {string} name Name of the test.
* @param {function()} body Body of the block.
*/

angular.scenario.Describe.prototype.iit = function(name, body) {

this.it.apply(this, arguments);
this.its[this.its.length-1].only = true;

};

/**

* Use to disable a test block.
*/

angular.scenario.Describe.prototype.xit = angular.noop;

/**

* Gets an array of functions representing all the tests (recursively).
* that can be executed with SpecRunner's.
*
* @return {Array<Object>} Array of it blocks {
*   definition : Object // parent Describe
*   only: boolean
*   name: string
*   before: Function
*   body: Function
*   after: Function
*  }
*/

angular.scenario.Describe.prototype.getSpecs = function() {

var specs = arguments[0] || [];
angular.forEach(this.children, function(child) {
  child.getSpecs(specs);
});
angular.forEach(this.its, function(it) {
  specs.push(it);
});
var only = [];
angular.forEach(specs, function(it) {
  if (it.only) {
    only.push(it);
  }
});
return (only.length && only) || specs;

};

/**

* A future action in a spec.
*
* @param {string} name of the future action
* @param {function()} future callback(error, result)
* @param {function()} Optional. function that returns the file/line number.
*/

angular.scenario.Future = function(name, behavior, line) {

this.name = name;
this.behavior = behavior;
this.fulfilled = false;
this.value = undefined;
this.parser = angular.identity;
this.line = line || function() { return ''; };

};

/**

* Executes the behavior of the closure.
*
* @param {function()} doneFn Callback function(error, result)
*/

angular.scenario.Future.prototype.execute = function(doneFn) {

var self = this;
this.behavior(function(error, result) {
  self.fulfilled = true;
  if (result) {
    try {
      result = self.parser(result);
    } catch(e) {
      error = e;
    }
  }
  self.value = error || result;
  doneFn(error, result);
});

};

/**

* Configures the future to convert it's final with a function fn(value)
*
* @param {function()} fn function(value) that returns the parsed value
*/

angular.scenario.Future.prototype.parsedWith = function(fn) {

this.parser = fn;
return this;

};

/**

* Configures the future to parse it's final value from JSON
* into objects.
*/

angular.scenario.Future.prototype.fromJson = function() {

return this.parsedWith(angular.fromJson);

};

/**

* Configures the future to convert it's final value from objects
* into JSON.
*/

angular.scenario.Future.prototype.toJson = function() {

return this.parsedWith(angular.toJson);

};

/**

* Maintains an object tree from the runner events.
*
* @param {Object} runner The scenario Runner instance to connect to.
*
* TODO(esprehn): Every output type creates one of these, but we probably
*  want one global shared instance. Need to handle events better too
*  so the HTML output doesn't need to do spec model.getSpec(spec.id)
*  silliness.
*
* TODO(vojta) refactor on, emit methods (from all objects) - use inheritance
*/

angular.scenario.ObjectModel = function(runner) {

var self = this;

this.specMap = {};
this.listeners = [];
this.value = {
  name: '',
  children: {}
};

runner.on('SpecBegin', function(spec) {
  var block = self.value,
      definitions = [];

  angular.forEach(self.getDefinitionPath(spec), function(def) {
    if (!block.children[def.name]) {
      block.children[def.name] = {
        id: def.id,
        name: def.name,
        children: {},
        specs: {}
      };
    }
    block = block.children[def.name];
    definitions.push(def.name);
  });

  var it = self.specMap[spec.id] =
           block.specs[spec.name] =
           new angular.scenario.ObjectModel.Spec(spec.id, spec.name, definitions);

  // forward the event
  self.emit('SpecBegin', it);
});

runner.on('SpecError', function(spec, error) {
  var it = self.getSpec(spec.id);
  it.status = 'error';
  it.error = error;

  // forward the event
  self.emit('SpecError', it, error);
});

runner.on('SpecEnd', function(spec) {
  var it = self.getSpec(spec.id);
  complete(it);

  // forward the event
  self.emit('SpecEnd', it);
});

runner.on('StepBegin', function(spec, step) {
  var it = self.getSpec(spec.id);
  var step = new angular.scenario.ObjectModel.Step(step.name);
  it.steps.push(step);

  // forward the event
  self.emit('StepBegin', it, step);
});

runner.on('StepEnd', function(spec) {
  var it = self.getSpec(spec.id);
  var step = it.getLastStep();
  if (step.name !== step.name)
    throw 'Events fired in the wrong order. Step names don\'t match.';
  complete(step);

  // forward the event
  self.emit('StepEnd', it, step);
});

runner.on('StepFailure', function(spec, step, error) {
  var it = self.getSpec(spec.id),
      modelStep = it.getLastStep();

  modelStep.setErrorStatus('failure', error, step.line());
  it.setStatusFromStep(modelStep);

  // forward the event
  self.emit('StepFailure', it, modelStep, error);
});

runner.on('StepError', function(spec, step, error) {
  var it = self.getSpec(spec.id),
      modelStep = it.getLastStep();

  modelStep.setErrorStatus('error', error, step.line());
  it.setStatusFromStep(modelStep);

  // forward the event
  self.emit('StepError', it, modelStep, error);
});

runner.on('RunnerBegin', function() {
  self.emit('RunnerBegin');
});
runner.on('RunnerEnd', function() {
  self.emit('RunnerEnd');
});

function complete(item) {
  item.endTime = new Date().getTime();
  item.duration = item.endTime - item.startTime;
  item.status = item.status || 'success';
}

};

/**

* Adds a listener for an event.
*
* @param {string} eventName Name of the event to add a handler for
* @param {function()} listener Function that will be called when event is fired
*/

angular.scenario.ObjectModel.prototype.on = function(eventName, listener) {

eventName = eventName.toLowerCase();
this.listeners[eventName] = this.listeners[eventName] || [];
this.listeners[eventName].push(listener);

};

/**

* Emits an event which notifies listeners and passes extra
* arguments.
*
* @param {string} eventName Name of the event to fire.
*/

angular.scenario.ObjectModel.prototype.emit = function(eventName) {

var self = this,
    args = Array.prototype.slice.call(arguments, 1),
    eventName = eventName.toLowerCase();

if (this.listeners[eventName]) {
  angular.forEach(this.listeners[eventName], function(listener) {
    listener.apply(self, args);
  });
}

};

/**

* Computes the path of definition describe blocks that wrap around
* this spec.
*
* @param spec Spec to compute the path for.
* @return {Array<Describe>} The describe block path
*/

angular.scenario.ObjectModel.prototype.getDefinitionPath = function(spec) {

var path = [];
var currentDefinition = spec.definition;
while (currentDefinition && currentDefinition.name) {
  path.unshift(currentDefinition);
  currentDefinition = currentDefinition.parent;
}
return path;

};

/**

* Gets a spec by id.
*
* @param {string} The id of the spec to get the object for.
* @return {Object} the Spec instance
*/

angular.scenario.ObjectModel.prototype.getSpec = function(id) {

return this.specMap[id];

};

/**

* A single it block.
*
* @param {string} id Id of the spec
* @param {string} name Name of the spec
* @param {Array<string>=} definitionNames List of all describe block names that wrap this spec
*/

angular.scenario.ObjectModel.Spec = function(id, name, definitionNames) {

this.id = id;
this.name = name;
this.startTime = new Date().getTime();
this.steps = [];
this.fullDefinitionName = (definitionNames || []).join(' ');

};

/**

* Adds a new step to the Spec.
*
* @param {string} step Name of the step (really name of the future)
* @return {Object} the added step
*/

angular.scenario.ObjectModel.Spec.prototype.addStep = function(name) {

var step = new angular.scenario.ObjectModel.Step(name);
this.steps.push(step);
return step;

};

/**

* Gets the most recent step.
*
* @return {Object} the step
*/

angular.scenario.ObjectModel.Spec.prototype.getLastStep = function() {

return this.steps[this.steps.length-1];

};

/**

* Set status of the Spec from given Step
*
* @param {angular.scenario.ObjectModel.Step} step
*/

angular.scenario.ObjectModel.Spec.prototype.setStatusFromStep = function(step) {

if (!this.status || step.status == 'error') {
  this.status = step.status;
  this.error = step.error;
  this.line = step.line;
}

};

/**

* A single step inside a Spec.
*
* @param {string} step Name of the step
*/

angular.scenario.ObjectModel.Step = function(name) {

this.name = name;
this.startTime = new Date().getTime();

};

/**

* Helper method for setting all error status related properties
*
* @param {string} status
* @param {string} error
* @param {string} line
*/

angular.scenario.ObjectModel.Step.prototype.setErrorStatus = function(status, error, line) {

this.status = status;
this.error = error;
this.line = line;

};

/**

* Runner for scenarios
*
* Has to be initialized before any test is loaded,
* because it publishes the API into window (global space).
*/

angular.scenario.Runner = function($window) {

this.listeners = [];
this.$window = $window;
this.rootDescribe = new angular.scenario.Describe();
this.currentDescribe = this.rootDescribe;
this.api = {
  it: this.it,
  iit: this.iit,
  xit: angular.noop,
  describe: this.describe,
  ddescribe: this.ddescribe,
  xdescribe: angular.noop,
  beforeEach: this.beforeEach,
  afterEach: this.afterEach
};
angular.forEach(this.api, angular.bind(this, function(fn, key) {
  this.$window[key] = angular.bind(this, fn);
}));

};

/**

* Emits an event which notifies listeners and passes extra
* arguments.
*
* @param {string} eventName Name of the event to fire.
*/

angular.scenario.Runner.prototype.emit = function(eventName) {

var self = this;
var args = Array.prototype.slice.call(arguments, 1);
eventName = eventName.toLowerCase();
if (!this.listeners[eventName])
  return;
angular.forEach(this.listeners[eventName], function(listener) {
  listener.apply(self, args);
});

};

/**

* Adds a listener for an event.
*
* @param {string} eventName The name of the event to add a handler for
* @param {string} listener The fn(...) that takes the extra arguments from emit()
*/

angular.scenario.Runner.prototype.on = function(eventName, listener) {

eventName = eventName.toLowerCase();
this.listeners[eventName] = this.listeners[eventName] || [];
this.listeners[eventName].push(listener);

};

/**

* Defines a describe block of a spec.
*
* @see Describe.js
*
* @param {string} name Name of the block
* @param {function()} body Body of the block
*/

angular.scenario.Runner.prototype.describe = function(name, body) {

var self = this;
this.currentDescribe.describe(name, function() {
  var parentDescribe = self.currentDescribe;
  self.currentDescribe = this;
  try {
    body.call(this);
  } finally {
    self.currentDescribe = parentDescribe;
  }
});

};

/**

* Same as describe, but makes ddescribe the only blocks to run.
*
* @see Describe.js
*
* @param {string} name Name of the block
* @param {function()} body Body of the block
*/

angular.scenario.Runner.prototype.ddescribe = function(name, body) {

var self = this;
this.currentDescribe.ddescribe(name, function() {
  var parentDescribe = self.currentDescribe;
  self.currentDescribe = this;
  try {
    body.call(this);
  } finally {
    self.currentDescribe = parentDescribe;
  }
});

};

/**

* Defines a test in a describe block of a spec.
*
* @see Describe.js
*
* @param {string} name Name of the block
* @param {function()} body Body of the block
*/

angular.scenario.Runner.prototype.it = function(name, body) {

this.currentDescribe.it(name, body);

};

/**

* Same as it, but makes iit tests the only tests to run.
*
* @see Describe.js
*
* @param {string} name Name of the block
* @param {function()} body Body of the block
*/

angular.scenario.Runner.prototype.iit = function(name, body) {

this.currentDescribe.iit(name, body);

};

/**

* Defines a function to be called before each it block in the describe
* (and before all nested describes).
*
* @see Describe.js
*
* @param {function()} Callback to execute
*/

angular.scenario.Runner.prototype.beforeEach = function(body) {

this.currentDescribe.beforeEach(body);

};

/**

* Defines a function to be called after each it block in the describe
* (and before all nested describes).
*
* @see Describe.js
*
* @param {function()} Callback to execute
*/

angular.scenario.Runner.prototype.afterEach = function(body) {

this.currentDescribe.afterEach(body);

};

/**

* Creates a new spec runner.
*
* @private
* @param {Object} scope parent scope
*/

angular.scenario.Runner.prototype.createSpecRunner_ = function(scope) {

var child = scope.$new();
var Cls = angular.scenario.SpecRunner;

// Export all the methods to child scope manually as now we don't mess controllers with scopes
// TODO(vojta): refactor scenario runner so that these objects are not tightly coupled as current
for (var name in Cls.prototype)
  child[name] = angular.bind(child, Cls.prototype[name]);

Cls.call(child);
return child;

};

/**

* Runs all the loaded tests with the specified runner class on the
* provided application.
*
* @param {angular.scenario.Application} application App to remote control.
*/

angular.scenario.Runner.prototype.run = function(application) {

var self = this;
var $root = angular.injector(['ng']).get('$rootScope');
angular.extend($root, this);
angular.forEach(angular.scenario.Runner.prototype, function(fn, name) {
  $root[name] = angular.bind(self, fn);
});
$root.application = application;
$root.emit('RunnerBegin');
asyncForEach(this.rootDescribe.getSpecs(), function(spec, specDone) {
  var dslCache = {};
  var runner = self.createSpecRunner_($root);
  angular.forEach(angular.scenario.dsl, function(fn, key) {
    dslCache[key] = fn.call($root);
  });
  angular.forEach(angular.scenario.dsl, function(fn, key) {
    self.$window[key] = function() {
      var line = callerFile(3);
      var scope = runner.$new();

      // Make the dsl accessible on the current chain
      scope.dsl = {};
      angular.forEach(dslCache, function(fn, key) {
        scope.dsl[key] = function() {
          return dslCache[key].apply(scope, arguments);
        };
      });

      // Make these methods work on the current chain
      scope.addFuture = function() {
        Array.prototype.push.call(arguments, line);
        return angular.scenario.SpecRunner.
          prototype.addFuture.apply(scope, arguments);
      };
      scope.addFutureAction = function() {
        Array.prototype.push.call(arguments, line);
        return angular.scenario.SpecRunner.
          prototype.addFutureAction.apply(scope, arguments);
      };

      return scope.dsl[key].apply(scope, arguments);
    };
  });
  runner.run(spec, function() {
    runner.$destroy();
    specDone.apply(this, arguments);
  });
},
function(error) {
  if (error) {
    self.emit('RunnerError', error);
  }
  self.emit('RunnerEnd');
});

};

/**

* This class is the "this" of the it/beforeEach/afterEach method.
* Responsibilities:
*   - "this" for it/beforeEach/afterEach
*   - keep state for single it/beforeEach/afterEach execution
*   - keep track of all of the futures to execute
*   - run single spec (execute each future)
*/

angular.scenario.SpecRunner = function() {

this.futures = [];
this.afterIndex = 0;

};

/**

* Executes a spec which is an it block with associated before/after functions
* based on the describe nesting.
*
* @param {Object} spec A spec object
* @param {function()} specDone function that is called when the spec finshes. Function(error, index)
*/

angular.scenario.SpecRunner.prototype.run = function(spec, specDone) {

var self = this;
this.spec = spec;

this.emit('SpecBegin', spec);

try {
  spec.before.call(this);
  spec.body.call(this);
  this.afterIndex = this.futures.length;
  spec.after.call(this);
} catch (e) {
  this.emit('SpecError', spec, e);
  this.emit('SpecEnd', spec);
  specDone();
  return;
}

var handleError = function(error, done) {
  if (self.error) {
    return done();
  }
  self.error = true;
  done(null, self.afterIndex);
};

asyncForEach(
  this.futures,
  function(future, futureDone) {
    self.step = future;
    self.emit('StepBegin', spec, future);
    try {
      future.execute(function(error) {
        if (error) {
          self.emit('StepFailure', spec, future, error);
          self.emit('StepEnd', spec, future);
          return handleError(error, futureDone);
        }
        self.emit('StepEnd', spec, future);
        self.$window.setTimeout(function() { futureDone(); }, 0);
      });
    } catch (e) {
      self.emit('StepError', spec, future, e);
      self.emit('StepEnd', spec, future);
      handleError(e, futureDone);
    }
  },
  function(e) {
    if (e) {
      self.emit('SpecError', spec, e);
    }
    self.emit('SpecEnd', spec);
    // Call done in a timeout so exceptions don't recursively
    // call this function
    self.$window.setTimeout(function() { specDone(); }, 0);
  }
);

};

/**

* Adds a new future action.
*
* Note: Do not pass line manually. It happens automatically.
*
* @param {string} name Name of the future
* @param {function()} behavior Behavior of the future
* @param {function()} line fn() that returns file/line number
*/

angular.scenario.SpecRunner.prototype.addFuture = function(name, behavior, line) {

var future = new angular.scenario.Future(name, angular.bind(this, behavior), line);
this.futures.push(future);
return future;

};

/**

* Adds a new future action to be executed on the application window.
*
* Note: Do not pass line manually. It happens automatically.
*
* @param {string} name Name of the future
* @param {function()} behavior Behavior of the future
* @param {function()} line fn() that returns file/line number
*/

angular.scenario.SpecRunner.prototype.addFutureAction = function(name, behavior, line) {

var self = this;
var NG = /\[ng\\\:/;
return this.addFuture(name, function(done) {
  this.application.executeAction(function($window, $document) {

    //TODO(esprehn): Refactor this so it doesn't need to be in here.
    $document.elements = function(selector) {
      var args = Array.prototype.slice.call(arguments, 1);
      selector = (self.selector || '') + ' ' + (selector || '');
      selector = _jQuery.trim(selector) || '*';
      angular.forEach(args, function(value, index) {
        selector = selector.replace('$' + (index + 1), value);
      });
      var result = $document.find(selector);
      if (selector.match(NG)) {
        angular.forEach(['[ng-','[data-ng-','[x-ng-'], function(value, index){
          result = result.add(selector.replace(NG, value), $document);
        });
      }
      if (!result.length) {
        throw {
          type: 'selector',
          message: 'Selector ' + selector + ' did not match any elements.'
        };
      }

      return result;
    };

    try {
      behavior.call(self, $window, $document, done);
    } catch(e) {
      if (e.type && e.type === 'selector') {
        done(e.message);
      } else {
        throw e;
      }
    }
  });
}, line);

};

/**

* Shared DSL statements that are useful to all scenarios.
*/

/**
* Usage:
*    pause() pauses until you call resume() in the console
*/

angular.scenario.dsl('pause', function() {

return function() {
  return this.addFuture('pausing for you to resume', function(done) {
    this.emit('InteractivePause', this.spec, this.step);
    this.$window.resume = function() { done(); };
  });
};

});

/**

* Usage:
*    sleep(seconds) pauses the test for specified number of seconds
*/

angular.scenario.dsl('sleep', function() {

return function(time) {
  return this.addFuture('sleep for ' + time + ' seconds', function(done) {
    this.$window.setTimeout(function() { done(null, time * 1000); }, time * 1000);
  });
};

});

/**

* Usage:
*    browser().navigateTo(url) Loads the url into the frame
*    browser().navigateTo(url, fn) where fn(url) is called and returns the URL to navigate to
*    browser().reload() refresh the page (reload the same URL)
*    browser().window.href() window.location.href
*    browser().window.path() window.location.pathname
*    browser().window.search() window.location.search
*    browser().window.hash() window.location.hash without # prefix
*    browser().location().url() see ng.$location#url
*    browser().location().path() see ng.$location#path
*    browser().location().search() see ng.$location#search
*    browser().location().hash() see ng.$location#hash
*/

angular.scenario.dsl('browser', function() {

var chain = {};

chain.navigateTo = function(url, delegate) {
  var application = this.application;
  return this.addFuture("browser navigate to '" + url + "'", function(done) {
    if (delegate) {
      url = delegate.call(this, url);
    }
    application.navigateTo(url, function() {
      done(null, url);
    }, done);
  });
};

chain.reload = function() {
  var application = this.application;
  return this.addFutureAction('browser reload', function($window, $document, done) {
    var href = $window.location.href;
    application.navigateTo(href, function() {
      done(null, href);
    }, done);
  });
};

chain.window = function() {
  var api = {};

  api.href = function() {
    return this.addFutureAction('window.location.href', function($window, $document, done) {
      done(null, $window.location.href);
    });
  };

  api.path = function() {
    return this.addFutureAction('window.location.path', function($window, $document, done) {
      done(null, $window.location.pathname);
    });
  };

  api.search = function() {
    return this.addFutureAction('window.location.search', function($window, $document, done) {
      done(null, $window.location.search);
    });
  };

  api.hash = function() {
    return this.addFutureAction('window.location.hash', function($window, $document, done) {
      done(null, $window.location.hash.replace('#', ''));
    });
  };

  return api;
};

chain.location = function() {
  var api = {};

  api.url = function() {
    return this.addFutureAction('$location.url()', function($window, $document, done) {
      done(null, $document.injector().get('$location').url());
    });
  };

  api.path = function() {
    return this.addFutureAction('$location.path()', function($window, $document, done) {
      done(null, $document.injector().get('$location').path());
    });
  };

  api.search = function() {
    return this.addFutureAction('$location.search()', function($window, $document, done) {
      done(null, $document.injector().get('$location').search());
    });
  };

  api.hash = function() {
    return this.addFutureAction('$location.hash()', function($window, $document, done) {
      done(null, $document.injector().get('$location').hash());
    });
  };

  return api;
};

return function() {
  return chain;
};

});

/**

* Usage:
*    expect(future).{matcher} where matcher is one of the matchers defined
*    with angular.scenario.matcher
*
* ex. expect(binding("name")).toEqual("Elliott")
*/

angular.scenario.dsl('expect', function() {

var chain = angular.extend({}, angular.scenario.matcher);

chain.not = function() {
  this.inverse = true;
  return chain;
};

return function(future) {
  this.future = future;
  return chain;
};

});

/**

* Usage:
*    using(selector, label) scopes the next DSL element selection
*
* ex.
*   using('#foo', "'Foo' text field").input('bar')
*/

angular.scenario.dsl('using', function() {

return function(selector, label) {
  this.selector = _jQuery.trim((this.selector||'') + ' ' + selector);
  if (angular.isString(label) && label.length) {
    this.label = label + ' ( ' + this.selector + ' )';
  } else {
    this.label = this.selector;
  }
  return this.dsl;
};

});

/**

* Usage:
*    binding(name) returns the value of the first matching binding
*/

angular.scenario.dsl('binding', function() {

return function(name) {
  return this.addFutureAction("select binding '" + name + "'", function($window, $document, done) {
    var values = $document.elements().bindings($window.angular.element, name);
    if (!values.length) {
      return done("Binding selector '" + name + "' did not match.");
    }
    done(null, values[0]);
  });
};

});

/**

* Usage:
*    input(name).enter(value) enters value in input with specified name
*    input(name).check() checks checkbox
*    input(name).select(value) selects the radio button with specified name/value
*    input(name).val() returns the value of the input.
*/

angular.scenario.dsl('input', function() {

var chain = {};
var supportInputEvent =  'oninput' in document.createElement('div') && msie != 9;

chain.enter = function(value, event) {
  return this.addFutureAction("input '" + this.name + "' enter '" + value + "'", function($window, $document, done) {
    var input = $document.elements('[ng\\:model="$1"]', this.name).filter(':input');
    input.val(value);
    input.trigger(event || (supportInputEvent ? 'input' : 'change'));
    done();
  });
};

chain.check = function() {
  return this.addFutureAction("checkbox '" + this.name + "' toggle", function($window, $document, done) {
    var input = $document.elements('[ng\\:model="$1"]', this.name).filter(':checkbox');
    input.trigger('click');
    done();
  });
};

chain.select = function(value) {
  return this.addFutureAction("radio button '" + this.name + "' toggle '" + value + "'", function($window, $document, done) {
    var input = $document.
      elements('[ng\\:model="$1"][value="$2"]', this.name, value).filter(':radio');
    input.trigger('click');
    done();
  });
};

chain.val = function() {
  return this.addFutureAction("return input val", function($window, $document, done) {
    var input = $document.elements('[ng\\:model="$1"]', this.name).filter(':input');
    done(null,input.val());
  });
};

return function(name) {
  this.name = name;
  return chain;
};

});

/**

* Usage:
*    repeater('#products table', 'Product List').count() number of rows
*    repeater('#products table', 'Product List').row(1) all bindings in row as an array
*    repeater('#products table', 'Product List').column('product.name') all values across all rows in an array
*/

angular.scenario.dsl('repeater', function() {

var chain = {};

chain.count = function() {
  return this.addFutureAction("repeater '" + this.label + "' count", function($window, $document, done) {
    try {
      done(null, $document.elements().length);
    } catch (e) {
      done(null, 0);
    }
  });
};

chain.column = function(binding) {
  return this.addFutureAction("repeater '" + this.label + "' column '" + binding + "'", function($window, $document, done) {
    done(null, $document.elements().bindings($window.angular.element, binding));
  });
};

chain.row = function(index) {
  return this.addFutureAction("repeater '" + this.label + "' row '" + index + "'", function($window, $document, done) {
    var matches = $document.elements().slice(index, index + 1);
    if (!matches.length)
      return done('row ' + index + ' out of bounds');
    done(null, matches.bindings($window.angular.element));
  });
};

return function(selector, label) {
  this.dsl.using(selector, label);
  return chain;
};

});

/**

* Usage:
*    select(name).option('value') select one option
*    select(name).options('value1', 'value2', ...) select options from a multi select
*/

angular.scenario.dsl('select', function() {

var chain = {};

chain.option = function(value) {
  return this.addFutureAction("select '" + this.name + "' option '" + value + "'", function($window, $document, done) {
    var select = $document.elements('select[ng\\:model="$1"]', this.name);
    var option = select.find('option[value="' + value + '"]');
    if (option.length) {
      select.val(value);
    } else {
      option = select.find('option:contains("' + value + '")');
      if (option.length) {
        select.val(option.val());
      }
    }
    select.trigger('change');
    done();
  });
};

chain.options = function() {
  var values = arguments;
  return this.addFutureAction("select '" + this.name + "' options '" + values + "'", function($window, $document, done) {
    var select = $document.elements('select[multiple][ng\\:model="$1"]', this.name);
    select.val(values);
    select.trigger('change');
    done();
  });
};

return function(name) {
  this.name = name;
  return chain;
};

});

/**

* Usage:
*    element(selector, label).count() get the number of elements that match selector
*    element(selector, label).click() clicks an element
*    element(selector, label).query(fn) executes fn(selectedElements, done)
*    element(selector, label).{method}() gets the value (as defined by jQuery, ex. val)
*    element(selector, label).{method}(value) sets the value (as defined by jQuery, ex. val)
*    element(selector, label).{method}(key) gets the value (as defined by jQuery, ex. attr)
*    element(selector, label).{method}(key, value) sets the value (as defined by jQuery, ex. attr)
*/

angular.scenario.dsl('element', function() {

var KEY_VALUE_METHODS = ['attr', 'css', 'prop'];
var VALUE_METHODS = [
  'val', 'text', 'html', 'height', 'innerHeight', 'outerHeight', 'width',
  'innerWidth', 'outerWidth', 'position', 'scrollLeft', 'scrollTop', 'offset'
];
var chain = {};

chain.count = function() {
  return this.addFutureAction("element '" + this.label + "' count", function($window, $document, done) {
    try {
      done(null, $document.elements().length);
    } catch (e) {
      done(null, 0);
    }
  });
};

chain.click = function() {
  return this.addFutureAction("element '" + this.label + "' click", function($window, $document, done) {
    var elements = $document.elements();
    var href = elements.attr('href');
    var eventProcessDefault = elements.trigger('click')[0];

    if (href && elements[0].nodeName.toUpperCase() === 'A' && eventProcessDefault) {
      this.application.navigateTo(href, function() {
        done();
      }, done);
    } else {
      done();
    }
  });
};

chain.query = function(fn) {
  return this.addFutureAction('element ' + this.label + ' custom query', function($window, $document, done) {
    fn.call(this, $document.elements(), done);
  });
};

angular.forEach(KEY_VALUE_METHODS, function(methodName) {
  chain[methodName] = function(name, value) {
    var args = arguments,
        futureName = (args.length == 1)
            ? "element '" + this.label + "' get " + methodName + " '" + name + "'"
            : "element '" + this.label + "' set " + methodName + " '" + name + "' to " + "'" + value + "'";

    return this.addFutureAction(futureName, function($window, $document, done) {
      var element = $document.elements();
      done(null, element[methodName].apply(element, args));
    });
  };
});

angular.forEach(VALUE_METHODS, function(methodName) {
  chain[methodName] = function(value) {
    var args = arguments,
        futureName = (args.length == 0)
            ? "element '" + this.label + "' " + methodName
            : futureName = "element '" + this.label + "' set " + methodName + " to '" + value + "'";

    return this.addFutureAction(futureName, function($window, $document, done) {
      var element = $document.elements();
      done(null, element[methodName].apply(element, args));
    });
  };
});

return function(selector, label) {
  this.dsl.using(selector, label);
  return chain;
};

});

/**

* Matchers for implementing specs. Follows the Jasmine spec conventions.
*/

angular.scenario.matcher('toEqual', function(expected) {

return angular.equals(this.actual, expected);

});

angular.scenario.matcher('toBe', function(expected) {

return this.actual === expected;

});

angular.scenario.matcher('toBeDefined', function() {

return angular.isDefined(this.actual);

});

angular.scenario.matcher('toBeTruthy', function() {

return this.actual;

});

angular.scenario.matcher('toBeFalsy', function() {

return !this.actual;

});

angular.scenario.matcher('toMatch', function(expected) {

return new RegExp(expected).test(this.actual);

});

angular.scenario.matcher('toBeNull', function() {

return this.actual === null;

});

angular.scenario.matcher('toContain', function(expected) {

return includes(this.actual, expected);

});

angular.scenario.matcher('toBeLessThan', function(expected) {

return this.actual < expected;

});

angular.scenario.matcher('toBeGreaterThan', function(expected) {

return this.actual > expected;

});

/**

* User Interface for the Scenario Runner.
*
* TODO(esprehn): This should be refactored now that ObjectModel exists
*  to use angular bindings for the UI.
*/

angular.scenario.output('html', function(context, runner, model) {

var specUiMap = {},
    lastStepUiMap = {};

context.append(
  '<div id="header">' +
  '  <h1><span class="angular">AngularJS</span>: Scenario Test Runner</h1>' +
  '  <ul id="status-legend" class="status-display">' +
  '    <li class="status-error">0 Errors</li>' +
  '    <li class="status-failure">0 Failures</li>' +
  '    <li class="status-success">0 Passed</li>' +
  '  </ul>' +
  '</div>' +
  '<div id="specs">' +
  '  <div class="test-children"></div>' +
  '</div>'
);

runner.on('InteractivePause', function(spec) {
  var ui = lastStepUiMap[spec.id];
  ui.find('.test-title').
    html('paused... <a href="javascript:resume()">resume</a> when ready.');
});

runner.on('SpecBegin', function(spec) {
  var ui = findContext(spec);
  ui.find('> .tests').append(
    '<li class="status-pending test-it"></li>'
  );
  ui = ui.find('> .tests li:last');
  ui.append(
    '<div class="test-info">' +
    '  <p class="test-title">' +
    '    <span class="timer-result"></span>' +
    '    <span class="test-name"></span>' +
    '  </p>' +
    '</div>' +
    '<div class="scrollpane">' +
    '  <ol class="test-actions"></ol>' +
    '</div>'
  );
  ui.find('> .test-info .test-name').text(spec.name);
  ui.find('> .test-info').click(function() {
    var scrollpane = ui.find('> .scrollpane');
    var actions = scrollpane.find('> .test-actions');
    var name = context.find('> .test-info .test-name');
    if (actions.find(':visible').length) {
      actions.hide();
      name.removeClass('open').addClass('closed');
    } else {
      actions.show();
      scrollpane.attr('scrollTop', scrollpane.attr('scrollHeight'));
      name.removeClass('closed').addClass('open');
    }
  });

  specUiMap[spec.id] = ui;
});

runner.on('SpecError', function(spec, error) {
  var ui = specUiMap[spec.id];
  ui.append('<pre></pre>');
  ui.find('> pre').text(formatException(error));
});

runner.on('SpecEnd', function(spec) {
  var ui = specUiMap[spec.id];
  spec = model.getSpec(spec.id);
  ui.removeClass('status-pending');
  ui.addClass('status-' + spec.status);
  ui.find("> .test-info .timer-result").text(spec.duration + "ms");
  if (spec.status === 'success') {
    ui.find('> .test-info .test-name').addClass('closed');
    ui.find('> .scrollpane .test-actions').hide();
  }
  updateTotals(spec.status);
});

runner.on('StepBegin', function(spec, step) {
  var ui = specUiMap[spec.id];
  spec = model.getSpec(spec.id);
  step = spec.getLastStep();
  ui.find('> .scrollpane .test-actions').append('<li class="status-pending"></li>');
  var stepUi = lastStepUiMap[spec.id] = ui.find('> .scrollpane .test-actions li:last');
  stepUi.append(
    '<div class="timer-result"></div>' +
    '<div class="test-title"></div>'
  );
  stepUi.find('> .test-title').text(step.name);
  var scrollpane = stepUi.parents('.scrollpane');
  scrollpane.attr('scrollTop', scrollpane.attr('scrollHeight'));
});

runner.on('StepFailure', function(spec, step, error) {
  var ui = lastStepUiMap[spec.id];
  addError(ui, step.line, error);
});

runner.on('StepError', function(spec, step, error) {
  var ui = lastStepUiMap[spec.id];
  addError(ui, step.line, error);
});

runner.on('StepEnd', function(spec, step) {
  var stepUi = lastStepUiMap[spec.id];
  spec = model.getSpec(spec.id);
  step = spec.getLastStep();
  stepUi.find('.timer-result').text(step.duration + 'ms');
  stepUi.removeClass('status-pending');
  stepUi.addClass('status-' + step.status);
  var scrollpane = specUiMap[spec.id].find('> .scrollpane');
  scrollpane.attr('scrollTop', scrollpane.attr('scrollHeight'));
});

/**
 * Finds the context of a spec block defined by the passed definition.
 *
 * @param {Object} The definition created by the Describe object.
 */
function findContext(spec) {
  var currentContext = context.find('#specs');
  angular.forEach(model.getDefinitionPath(spec), function(defn) {
    var id = 'describe-' + defn.id;
    if (!context.find('#' + id).length) {
      currentContext.find('> .test-children').append(
        '<div class="test-describe" id="' + id + '">' +
        '  <h2></h2>' +
        '  <div class="test-children"></div>' +
        '  <ul class="tests"></ul>' +
        '</div>'
      );
      context.find('#' + id).find('> h2').text('describe: ' + defn.name);
    }
    currentContext = context.find('#' + id);
  });
  return context.find('#describe-' + spec.definition.id);
}

/**
 * Updates the test counter for the status.
 *
 * @param {string} the status.
 */
function updateTotals(status) {
  var legend = context.find('#status-legend .status-' + status);
  var parts = legend.text().split(' ');
  var value = (parts[0] * 1) + 1;
  legend.text(value + ' ' + parts[1]);
}

/**
 * Add an error to a step.
 *
 * @param {Object} The JQuery wrapped context
 * @param {function()} fn() that should return the file/line number of the error
 * @param {Object} the error.
 */
function addError(context, line, error) {
  context.find('.test-title').append('<pre></pre>');
  var message = _jQuery.trim(line() + '\n\n' + formatException(error));
  context.find('.test-title pre:last').text(message);
}

});

/**

* Generates JSON output into a context.
*/

angular.scenario.output('json', function(context, runner, model) {

model.on('RunnerEnd', function() {
  context.text(angular.toJson(model.value));
});

});

/**

* Generates XML output into a context.
*/

angular.scenario.output('xml', function(context, runner, model) {

var $ = function(args) {return new context.init(args);};
model.on('RunnerEnd', function() {
  var scenario = $('<scenario></scenario>');
  context.append(scenario);
  serializeXml(scenario, model.value);
});

/**
 * Convert the tree into XML.
 *
 * @param {Object} context jQuery context to add the XML to.
 * @param {Object} tree node to serialize
 */
function serializeXml(context, tree) {
   angular.forEach(tree.children, function(child) {
     var describeContext = $('<describe></describe>');
     describeContext.attr('id', child.id);
     describeContext.attr('name', child.name);
     context.append(describeContext);
     serializeXml(describeContext, child);
   });
   var its = $('<its></its>');
   context.append(its);
   angular.forEach(tree.specs, function(spec) {
     var it = $('<it></it>');
     it.attr('id', spec.id);
     it.attr('name', spec.name);
     it.attr('duration', spec.duration);
     it.attr('status', spec.status);
     its.append(it);
     angular.forEach(spec.steps, function(step) {
       var stepContext = $('<step></step>');
       stepContext.attr('name', step.name);
       stepContext.attr('duration', step.duration);
       stepContext.attr('status', step.status);
       it.append(stepContext);
       if (step.error) {
         var error = $('<error></error>');
         stepContext.append(error);
         error.text(formatException(step.error));
       }
     });
   });
 }

});

/**

* Creates a global value $result with the result of the runner.
*/

angular.scenario.output('object', function(context, runner, model) {

runner.$window.$result = model.value;

});

bindJQuery(); publishExternalAPI(angular);

var $runner = new angular.scenario.Runner(window),

scripts = document.getElementsByTagName('script'),
script = scripts[scripts.length - 1],
config = {};

angular.forEach(script.attributes, function(attr) {

var match = attr.name.match(/ng[:\-](.*)/);
if (match) {
  config[match[1]] = attr.value || true;
}

});

if (config.autotest) {

JQLite(document).ready(function() {
  angular.scenario.setUpAndRun(config);
});

} })(window, document);

angular.element(document).find('head').append('<style type=“text/css”>@charset “UTF-8”;nn, [ng-cloak], [data-ng-cloak], [x-ng-cloak],n.ng-cloak, .x-ng-cloak {n display: none;n}nnng\:form {n display: block;n}n</style>'); angular.element(document).find('head').append('<style type=“text/css”>@charset “UTF-8”;n/* CSS Document */nn/** Structure */nbody {n font-family: Arial, sans-serif;n margin: 0;n font-size: 14px;n}nn#system-error {n font-size: 1.5em;n text-align: center;n}nn#json, xml {n display: none;n}nn#header {n position: fixed;n width: 100%;n}nn#specs {n padding-top: 50px;n}nn#header .angular {n font-family: Courier New, monospace;n font-weight: bold;n}nn#header h1 {n font-weight: normal;n float: left;n font-size: 30px;n line-height: 30px;n margin: 0;n padding: 10px 10px;n height: 30px;n}nn#application h2,n#specs h2 {n margin: 0;n padding: 0.5em;n font-size: 1.1em;n}nn#status-legend {n margin-top: 10px;n margin-right: 10px;n}nn#header,n#application,n.test-info,n.test-actions li {n overflow: hidden;n}nn#application {n margin: 10px;n}nn#application iframe {n width: 100%;n height: 758px;n}nn#application .popout {n float: right;n}nn#application iframe {n border: none;n}nn.tests li,n.test-actions li,n.test-it li,n.test-it ol,n.status-display {n list-style-type: none;n}nn.tests,n.test-it ol,n.status-display {n margin: 0;n padding: 0;n}nn.test-info {n margin-left: 1em;n margin-top: 0.5em;n border-radius: 8px 0 0 8px;n -webkit-border-radius: 8px 0 0 8px;n -moz-border-radius: 8px 0 0 8px;n cursor: pointer;n}nn.test-info:hover .test-name {n text-decoration: underline;n}nn.test-info .closed:before {n content: '\25b8\00A0';n}nn.test-info .open:before {n content: '\25be\00A0';n font-weight: bold;n}nn.test-it ol {n margin-left: 2.5em;n}nn.status-display,n.status-display li {n float: right;n}nn.status-display li {n padding: 5px 10px;n}nn.timer-result,n.test-title {n display: inline-block;n margin: 0;n padding: 4px;n}nn.test-actions .test-title,n.test-actions .test-result {n display: table-cell;n padding-left: 0.5em;n padding-right: 0.5em;n}nn.test-actions {n display: table;n}nn.test-actions li {n display: table-row;n}nn.timer-result {n width: 4em;n padding: 0 10px;n text-align: right;n font-family: monospace;n}nn.test-it pre,n.test-actions pre {n clear: left;n color: black;n margin-left: 6em;n}nn.test-describe {n padding-bottom: 0.5em;n}nn.test-describe .test-describe {n margin: 5px 5px 10px 2em;n}nn.test-actions .status-pending .test-title:before {n content: '\00bb\00A0';n}nn.scrollpane {n max-height: 20em;n overflow: auto;n}nn/** Colors */nn#header {n background-color: #F2C200;n}nn#specs h2 {n border-top: 2px solid #BABAD1;n}nn#specs h2,n#application h2 {n background-color: efefef;n}nn#application {n border: 1px solid #BABAD1;n}nn.test-describe .test-describe {n border-left: 1px solid #BABAD1;n border-right: 1px solid #BABAD1;n border-bottom: 1px solid #BABAD1;n}nn.status-display {n border: 1px solid #777;n}nn.status-display .status-pending,n.status-pending .test-info {n background-color: #F9EEBC;n}nn.status-display .status-success,n.status-success .test-info {n background-color: #B1D7A1;n}nn.status-display .status-failure,n.status-failure .test-info {n background-color: #FF8286;n}nn.status-display .status-error,n.status-error .test-info {n background-color: black;n color: white;n}nn.test-actions .status-success .test-title {n color: #30B30A;n}nn.test-actions .status-failure .test-title {n color: #DF0000;n}nn.test-actions .status-error .test-title {n color: black;n}nn.test-actions .timer-result {n color: #888;n}n</style>');