mons: comparison annot-server/static/js/lib.js

Mercurial Mercurial > mons / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

annot-server/static/js/lib.js

changeset 117	c0034b35c44e
parent 84	d7c5bffdd2d8
child 159	f2e4641681f6

equal deleted inserted replaced

-:9fcb0e0991ed
+:c0034b35c44e
 /*!
-* jQuery JavaScript Library v2.1.1
+* jQuery JavaScript Library v2.1.3
 * http://jquery.com/
 *
 * Includes Sizzle.js
 * http://sizzlejs.com/
 *
 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
 * Released under the MIT license
 * http://jquery.org/license
 *
-* Date: 2014-05-01T17:11Z
+* Date: 2014-12-18T15:11Z
 */
 (function( global, factory ) {
 	if ( typeof module === "object" && typeof module.exports === "object" ) {
-		// For CommonJS and CommonJS-like environments where a proper window is present,
+		// For CommonJS and CommonJS-like environments where a proper `window`
-		// execute the factory and get jQuery
+		// is present, execute the factory and get jQuery.
-		// For environments that do not inherently posses a window with a document
+		// For environments that do not have a `window` with a `document`
-		// (such as Node.js), expose a jQuery-making factory as module.exports
+		// (such as Node.js), expose a factory as module.exports.
-		// This accentuates the need for the creation of a real window
+		// This accentuates the need for the creation of a real `window`.
 		// e.g. var jQuery = require("jquery")(window);
-		// See ticket #14549 for more info
+		// See ticket #14549 for more info.
 		module.exports = global.document ?
 			factory( global, true ) :
 			function( w ) {
 				if ( !w.document ) {
 					throw new Error( "jQuery requires a window with a document" );
 	}
 // Pass this if window is not defined yet
 }(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
-// Can't do this because several apps including ASP.NET trace
+// Support: Firefox 18+
+// Can't be in strict mode, several libs including ASP.NET trace
 // the stack via arguments.caller.callee and Firefox dies if
 // you try to trace through "use strict" call chains. (#13335)
-// Support: Firefox 18+
 //
 var arr = [];
 var slice = arr.slice;
 var
 	// Use the correct document accordingly with window argument (sandbox)
 	document = window.document,
-	version = "2.1.1",
+	version = "2.1.3",
 	// Define a local copy of jQuery
 	jQuery = function( selector, context ) {
 		// The jQuery object is actually just the init constructor 'enhanced'
 		// Need init if jQuery is called (just allow error to be thrown if not included)
 	// Handle a deep copy situation
 	if ( typeof target === "boolean" ) {
 		deep = target;
-		// skip the boolean and the target
+		// Skip the boolean and the target
 		target = arguments[ i ] || {};
 		i++;
 	}
 	// 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
+	// Extend jQuery itself if only one argument is passed
 	if ( i === length ) {
 		target = this;
 		i--;
 	}
 		throw new Error( msg );
 	},
 	noop: function() {},
-	// 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,
 	isNumeric: function( obj ) {
 		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
 		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
 		// subtraction forces infinities to NaN
-		return !jQuery.isArray( obj ) && obj - parseFloat( obj ) >= 0;
+		// adding 1 corrects loss of precision from parseFloat (#15100)
+		return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;
 	},
 	isPlainObject: function( obj ) {
 		// Not plain objects:
 		// - Any object or value whose internal [[Class]] property is not "[object Object]"
 	type: function( obj ) {
 		if ( obj == null ) {
 			return obj + "";
 		}
-		// Support: Android < 4.0, iOS < 6 (functionish RegExp)
+		// Support: Android<4.0, iOS<6 (functionish RegExp)
 		return typeof obj === "object" || typeof obj === "function" ?
 			class2type[ toString.call(obj) ] || "object" :
 			typeof obj;
 	},
 			}
 		}
 	},
 	// Convert dashed to camelCase; used by the css and data modules
+	// Support: IE9-11+
 	// Microsoft forgot to hump their vendor prefix (#9572)
 	camelCase: function( string ) {
 		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
 	},
 	return type === "array" || length === 0 ||
 		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
 }
 var Sizzle =
 /*!
-* Sizzle CSS Selector Engine v1.10.19
+* Sizzle CSS Selector Engine v2.2.0-pre
 * http://sizzlejs.com/
 *
-* Copyright 2013 jQuery Foundation, Inc. and other contributors
+* Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors
 * Released under the MIT license
 * http://jquery.org/license
 *
-* Date: 2014-04-18
+* Date: 2014-12-16
 */
 (function( window ) {
 var i,
 	support,
 	rbuggyMatches,
 	matches,
 	contains,
 	// Instance-specific data
-	expando = "sizzle" + -(new Date()),
+	expando = "sizzle" + 1 * new Date(),
 	preferredDoc = window.document,
 	dirruns = 0,
 	done = 0,
 	classCache = createCache(),
 	tokenCache = createCache(),
 		}
 		return 0;
 	},
 	// General-purpose constants
-	strundefined = typeof undefined,
 	MAX_NEGATIVE = 1 << 31,
 	// Instance methods
 	hasOwn = ({}).hasOwnProperty,
 	arr = [],
 	pop = arr.pop,
 	push_native = arr.push,
 	push = arr.push,
 	slice = arr.slice,
-	// Use a stripped-down indexOf if we can't use a native one
+	// Use a stripped-down indexOf as it's faster than native
-	indexOf = arr.indexOf || function( elem ) {
+	// http://jsperf.com/thor-indexof-vs-for/5
+	indexOf = function( list, elem ) {
 		var i = 0,
-			len = this.length;
+			len = list.length;
 		for ( ; i < len; i++ ) {
-			if ( this[i] === elem ) {
+			if ( list[i] === elem ) {
 				return i;
 			}
 		}
 		return -1;
 	},
 		// 3. anything else (capture 2)
 		".*" +
 		")\\)|)",
 	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+	rwhitespace = new RegExp( whitespace + "+", "g" ),
 	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
 	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
 	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
 			high < 0 ?
 				// BMP codepoint
 				String.fromCharCode( high + 0x10000 ) :
 				// Supplemental Plane codepoint (surrogate pair)
 				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
+	},
+	// Used for iframes
+	// See setDocument()
+	// Removing the function wrapper causes a "Permission Denied"
+	// error in IE
+	unloadHandler = function() {
+		setDocument();
 	};
 // Optimize for push.apply( _, NodeList )
 try {
 	push.apply(
 		setDocument( context );
 	}
 	context = context || document;
 	results = results || [];
+	nodeType = context.nodeType;
-	if ( !selector || typeof selector !== "string" ) {
+	if ( typeof selector !== "string" || !selector ||
+		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
 		return results;
 	}
-	if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
+	if ( !seed && documentIsHTML ) {
-		return [];
-	}
+		// Try to shortcut find operations when possible (e.g., not under DocumentFragment)
+		if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
-	if ( documentIsHTML && !seed ) {
-		// Shortcuts
-		if ( (match = rquickExpr.exec( selector )) ) {
 			// Speed-up: Sizzle("#ID")
 			if ( (m = match[1]) ) {
 				if ( nodeType === 9 ) {
 					elem = context.getElementById( m );
 					// Check parentNode to catch when Blackberry 4.6 returns
 			} else if ( match[2] ) {
 				push.apply( results, context.getElementsByTagName( selector ) );
 				return results;
 			// Speed-up: Sizzle(".CLASS")
-			} else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) {
+			} else if ( (m = match[3]) && support.getElementsByClassName ) {
 				push.apply( results, context.getElementsByClassName( m ) );
 				return results;
 			}
 		}
 		// QSA path
 		if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
 			nid = old = expando;
 			newContext = context;
-			newSelector = nodeType === 9 && selector;
+			newSelector = nodeType !== 1 && selector;
 			// 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
 * Checks a node for validity as a Sizzle context
 * @param {Element|Object=} context
 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
 */
 function testContext( context ) {
-	return context && typeof context.getElementsByTagName !== strundefined && context;
+	return context && typeof context.getElementsByTagName !== "undefined" && context;
 }
 // Expose support vars for convenience
 support = Sizzle.support = {};
 * Sets document-related variables once based on the current document
 * @param {Element|Object} [doc] An element or document object to use to set the document
 * @returns {Object} Returns the current document
 */
 setDocument = Sizzle.setDocument = function( node ) {
-	var hasCompare,
+	var hasCompare, parent,
-		doc = node ? node.ownerDocument || node : preferredDoc,
+		doc = node ? node.ownerDocument || node : preferredDoc;
-		parent = doc.defaultView;
 	// If no document and documentElement is available, return
 	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
 		return document;
 	}
 	// Set our document
 	document = doc;
 	docElem = doc.documentElement;
+	parent = doc.defaultView;
-	// Support tests
-	documentIsHTML = !isXML( doc );
 	// Support: IE>8
 	// If iframe document is assigned to "document" variable and if iframe has been reloaded,
 	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
 	// IE6-8 do not support the defaultView property so parent will be undefined
 	if ( parent && parent !== parent.top ) {
 		// IE11 does not have attachEvent, so all must suffer
 		if ( parent.addEventListener ) {
-			parent.addEventListener( "unload", function() {
+			parent.addEventListener( "unload", unloadHandler, false );
-				setDocument();
-			}, false );
 		} else if ( parent.attachEvent ) {
-			parent.attachEvent( "onunload", function() {
+			parent.attachEvent( "onunload", unloadHandler );
-				setDocument();
-			});
 		}
 	}
+	/* Support tests
+	---------------------------------------------------------------------- */
+	documentIsHTML = !isXML( doc );
 	/* Attributes
 	---------------------------------------------------------------------- */
 	// Support: IE<8
-	// Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
+	// Verify that getAttribute really returns attributes and not properties
+	// (excepting IE8 booleans)
 	support.attributes = assert(function( div ) {
 		div.className = "i";
 		return !div.getAttribute("className");
 	});
 	support.getElementsByTagName = assert(function( div ) {
 		div.appendChild( doc.createComment("") );
 		return !div.getElementsByTagName("*").length;
 	});
-	// Check if getElementsByClassName can be trusted
+	// Support: IE<9
-	support.getElementsByClassName = rnative.test( doc.getElementsByClassName ) && assert(function( div ) {
+	support.getElementsByClassName = rnative.test( doc.getElementsByClassName );
-		div.innerHTML = "<div class='a'></div><div class='a i'></div>";
-		// Support: Safari<4
-		// Catch class over-caching
-		div.firstChild.className = "i";
-		// Support: Opera<10
-		// Catch gEBCN failure to find non-leading classes
-		return div.getElementsByClassName("i").length === 2;
-	});
 	// Support: IE<10
 	// Check if getElementById returns elements by name
 	// The broken getElementById methods don't pick up programatically-set names,
 	// so use a roundabout getElementsByName test
 	});
 	// ID find and filter
 	if ( support.getById ) {
 		Expr.find["ID"] = function( id, context ) {
-			if ( typeof context.getElementById !== strundefined && documentIsHTML ) {
+			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
 				var m = context.getElementById( id );
 				// Check parentNode to catch when Blackberry 4.6 returns
 				// nodes that are no longer in the document #6963
 				return m && m.parentNode ? [ m ] : [];
 			}
 		delete Expr.find["ID"];
 		Expr.filter["ID"] =  function( id ) {
 			var attrId = id.replace( runescape, funescape );
 			return function( elem ) {
-				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
+				var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
 				return node && node.value === attrId;
 			};
 		};
 	}
 	// Tag
 	Expr.find["TAG"] = support.getElementsByTagName ?
 		function( tag, context ) {
-			if ( typeof context.getElementsByTagName !== strundefined ) {
+			if ( typeof context.getElementsByTagName !== "undefined" ) {
 				return context.getElementsByTagName( tag );
+			// DocumentFragment nodes don't have gEBTN
+			} else if ( support.qsa ) {
+				return context.querySelectorAll( tag );
 			}
 		} :
 		function( tag, context ) {
 			var elem,
 				tmp = [],
 				i = 0,
+				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
 				results = context.getElementsByTagName( tag );
 			// Filter out possible comments
 			if ( tag === "*" ) {
 				while ( (elem = results[i++]) ) {
 			return results;
 		};
 	// Class
 	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
-		if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
+		if ( documentIsHTML ) {
 			return context.getElementsByClassName( className );
 		}
 	};
 	/* QSA/matchesSelector
 			// Select is set to empty string on purpose
 			// This is to test IE's treatment of not explicitly
 			// setting a boolean content attribute,
 			// since its presence should be enough
 			// http://bugs.jquery.com/ticket/12359
-			div.innerHTML = "<select msallowclip=''><option selected=''></option></select>";
+			docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +
+				"<select id='" + expando + "-\f]' msallowcapture=''>" +
+				"<option selected=''></option></select>";
 			// Support: IE8, Opera 11-12.16
 			// Nothing should be selected when empty strings follow ^= or $= or *=
 			// The test attribute must be unknown in Opera but "safe" for WinRT
 			// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
-			if ( div.querySelectorAll("[msallowclip^='']").length ) {
+			if ( div.querySelectorAll("[msallowcapture^='']").length ) {
 				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
 			}
 			// Support: IE8
 			// Boolean attributes and "value" are not treated correctly
 			if ( !div.querySelectorAll("[selected]").length ) {
 				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
 			}
+			// Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+
+			if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
+				rbuggyQSA.push("~=");
+			}
 			// Webkit/Opera - :checked should return selected option elements
 			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
 			// IE8 throws error here and will not see later tests
 			if ( !div.querySelectorAll(":checked").length ) {
 				rbuggyQSA.push(":checked");
+			}
+			// Support: Safari 8+, iOS 8+
+			// https://bugs.webkit.org/show_bug.cgi?id=136851
+			// In-page `selector#id sibing-combinator selector` fails
+			if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
+				rbuggyQSA.push(".#.+[+~]");
 			}
 		});
 		assert(function( div ) {
 			// Support: Windows 8 Native Apps
 				return 1;
 			}
 			// Maintain original order
 			return sortInput ?
-				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
+				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
 				0;
 		}
 		return compare & 4 ? -1 : 1;
 	} :
 			return a === doc ? -1 :
 				b === doc ? 1 :
 				aup ? -1 :
 				bup ? 1 :
 				sortInput ?
-				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
+				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
 				0;
 		// If the nodes are siblings, we can do a quick check
 		} else if ( aup === bup ) {
 			return siblingCheck( a, b );
 					// As well, disconnected nodes are said to be in a document
 					// fragment in IE 9
 					elem.document && elem.document.nodeType !== 11 ) {
 				return ret;
 			}
-		} catch(e) {}
+		} catch (e) {}
 	}
 	return Sizzle( expr, document, null, [ elem ] ).length > 0;
 };
 			var pattern = classCache[ className + " " ];
 			return pattern ||
 				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
 				classCache( className, function( elem ) {
-					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
+					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
 				});
 		},
 		"ATTR": function( name, operator, check ) {
 			return function( elem ) {
 				return operator === "=" ? result === check :
 					operator === "!=" ? result !== check :
 					operator === "^=" ? check && result.indexOf( check ) === 0 :
 					operator === "*=" ? check && result.indexOf( check ) > -1 :
 					operator === "$=" ? check && result.slice( -check.length ) === check :
-					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
+					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
 					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
 					false;
 			};
 		},
 					markFunction(function( seed, matches ) {
 						var idx,
 							matched = fn( seed, argument ),
 							i = matched.length;
 						while ( i-- ) {
-							idx = indexOf.call( seed, matched[i] );
+							idx = indexOf( seed, matched[i] );
 							seed[ idx ] = !( matches[ idx ] = matched[i] );
 						}
 					}) :
 					function( elem ) {
 						return fn( elem, 0, args );
 					}
 				}) :
 				function( elem, context, xml ) {
 					input[0] = elem;
 					matcher( input, null, xml, results );
+					// Don't keep the element (issue #299)
+					input[0] = null;
 					return !results.pop();
 				};
 		}),
 		"has": markFunction(function( selector ) {
 				return Sizzle( selector, elem ).length > 0;
 			};
 		}),
 		"contains": markFunction(function( text ) {
+			text = text.replace( runescape, funescape );
 			return function( elem ) {
 				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
 			};
 		}),
 				// Move matched elements from seed to results to keep them synchronized
 				i = matcherOut.length;
 				while ( i-- ) {
 					if ( (elem = matcherOut[i]) &&
-						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
+						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
 						seed[temp] = !(results[temp] = elem);
 					}
 				}
 			}
 		// The foundational matcher ensures that elements are reachable from top-level context(s)
 		matchContext = addCombinator( function( elem ) {
 			return elem === checkContext;
 		}, implicitRelative, true ),
 		matchAnyContext = addCombinator( function( elem ) {
-			return indexOf.call( checkContext, elem ) > -1;
+			return indexOf( checkContext, elem ) > -1;
 		}, implicitRelative, true ),
 		matchers = [ function( elem, context, xml ) {
-			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
+			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
 				(checkContext = context).nodeType ?
 					matchContext( elem, context, xml ) :
 					matchAnyContext( elem, context, xml ) );
+			// Avoid hanging onto element (issue #299)
+			checkContext = null;
+			return ret;
 		} ];
 	for ( ; i < len; i++ ) {
 		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
 			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
 // One-time assignments
 // Sort stability
 support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
-// Support: Chrome<14
+// Support: Chrome 14-35+
 // Always assume duplicates if they aren't passed to the comparison function
 support.detectDuplicates = !!hasDuplicate;
 // Initialize against the default document
 setDocument();
 				// HANDLE: $(html) -> $(array)
 				if ( match[1] ) {
 					context = context instanceof jQuery ? context[0] : context;
-					// scripts is true for back-compat
+					// Option to run scripts is true for back-compat
 					// Intentionally let the error be thrown if parseHTML is not present
 					jQuery.merge( this, jQuery.parseHTML(
 						match[1],
 						context && context.nodeType ? context.ownerDocument || context : document,
 						true
 				// HANDLE: $(#id)
 				} else {
 					elem = document.getElementById( match[2] );
-					// Check parentNode to catch when Blackberry 4.6 returns
+					// Support: Blackberry 4.6
-					// nodes that are no longer in the document #6963
+					// gEBID returns nodes no longer in the document (#6963)
 					if ( elem && elem.parentNode ) {
 						// Inject the element directly into the jQuery object
 						this.length = 1;
 						this[0] = elem;
 					}
 // Initialize central reference
 rootjQuery = jQuery( document );
 var rparentsprev = /^(?:parents|prev(?:Until|All))/,
-	// methods guaranteed to produce a unique set when starting from a unique set
+	// Methods guaranteed to produce a unique set when starting from a unique set
 	guaranteedUnique = {
 		children: true,
 		contents: true,
 		next: true,
 		prev: true
 		}
 		return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );
 	},
-	// Determine the position of an element within
+	// Determine the position of an element within the set
-	// the matched set of elements
 	index: function( elem ) {
 		// No argument, return index in parent
 		if ( !elem ) {
 			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
 		}
-		// index in selector
+		// Index in selector
 		if ( typeof elem === "string" ) {
 			return indexOf.call( jQuery( elem ), this[ 0 ] );
 		}
 		// Locate the position of the desired element
 				};
 			},
 			progressValues, progressContexts, resolveContexts;
-		// add listeners to Deferred subordinates; treat others as resolved
+		// Add listeners to Deferred subordinates; treat others as resolved
 		if ( length > 1 ) {
 			progressValues = new Array( length );
 			progressContexts = new Array( length );
 			resolveContexts = new Array( length );
 			for ( ; i < length; i++ ) {
 					--remaining;
 				}
 			}
 		}
-		// if we're not waiting on anything, resolve the master
+		// If we're not waiting on anything, resolve the master
 		if ( !remaining ) {
 			deferred.resolveWith( resolveContexts, resolveValues );
 		}
 		return deferred.promise();
 	if ( !readyList ) {
 		readyList = jQuery.Deferred();
 		// Catch cases where $(document).ready() is called after the browser event has already occurred.
-		// we once tried to use readyState "interactive" here, but it caused issues like the one
+		// We once tried to use readyState "interactive" here, but it caused issues like the one
 		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
 		if ( document.readyState === "complete" ) {
 			// Handle it asynchronously to allow scripts the opportunity to delay ready
 			setTimeout( jQuery.ready );
 	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
 };
 function Data() {
-	// Support: Android < 4,
+	// Support: Android<4,
 	// Old WebKit does not have Object.preventExtensions/freeze method,
 	// return new empty object instead with no [[set]] accessor
 	Object.defineProperty( this.cache = {}, 0, {
 		get: function() {
 			return {};
 		}
 	});
-	this.expando = jQuery.expando + Math.random();
+	this.expando = jQuery.expando + Data.uid++;
 }
 Data.uid = 1;
 Data.accepts = jQuery.acceptData;
 			// Secure it in a non-enumerable, non-writable property
 			try {
 				descriptor[ this.expando ] = { value: unlock };
 				Object.defineProperties( owner, descriptor );
-			// Support: Android < 4
+			// Support: Android<4
 			// Fallback to a less secure definition
 			} catch ( e ) {
 				descriptor[ this.expando ] = unlock;
 				jQuery.extend( owner, descriptor );
 			}
 var data_user = new Data();
-/*
+//	Implementation Summary
-	Implementation Summary
+//
+//	1. Enforce API surface and semantic compatibility with 1.9.x branch
-	1. Enforce API surface and semantic compatibility with 1.9.x branch
+//	2. Improve the module's maintainability by reducing the storage
-	2. Improve the module's maintainability by reducing the storage
+//		paths to a single mechanism.
-		paths to a single mechanism.
+//	3. Use the same single mechanism to support "private" and "user" data.
-	3. Use the same single mechanism to support "private" and "user" data.
+//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
-	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
+//	5. Avoid exposing implementation details on user objects (eg. expando properties)
-	5. Avoid exposing implementation details on user objects (eg. expando properties)
+//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
-	6. Provide a clear path for implementation upgrade to WeakMap in 2014
-*/
 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
 	rmultiDash = /([A-Z])/g;
 function dataAttr( elem, key, data ) {
 	var name;
 			// automatically dequeued
 			if ( type === "fx" ) {
 				queue.unshift( "inprogress" );
 			}
-			// clear up the last queue stop function
+			// Clear up the last queue stop function
 			delete hooks.stop;
 			fn.call( elem, next, hooks );
 		}
 		if ( !startLength && hooks ) {
 			hooks.empty.fire();
 		}
 	},
-	// not intended for public consumption - generates a queueHooks object, or returns the current one
+	// Not public - generate a queueHooks object, or return the current one
 	_queueHooks: function( elem, type ) {
 		var key = type + "queueHooks";
 		return data_priv.get( elem, key ) || data_priv.access( elem, key, {
 			empty: jQuery.Callbacks("once memory").add(function() {
 				data_priv.remove( elem, [ type + "queue", key ] );
 		return data === undefined ?
 			this :
 			this.each(function() {
 				var queue = jQuery.queue( this, type, data );
-				// ensure a hooks for this queue
+				// Ensure a hooks for this queue
 				jQuery._queueHooks( this, type );
 				if ( type === "fx" && queue[0] !== "inprogress" ) {
 					jQuery.dequeue( this, type );
 				}
 (function() {
 	var fragment = document.createDocumentFragment(),
 		div = fragment.appendChild( document.createElement( "div" ) ),
 		input = document.createElement( "input" );
-	// #11217 - WebKit loses check when the name is after the checked attribute
+	// Support: Safari<=5.1
+	// Check state lost if the name is set (#11217)
 	// Support: Windows Web Apps (WWA)
-	// `name` and `type` need .setAttribute for WWA
+	// `name` and `type` must use .setAttribute for WWA (#14901)
 	input.setAttribute( "type", "radio" );
 	input.setAttribute( "checked", "checked" );
 	input.setAttribute( "name", "t" );
 	div.appendChild( input );
-	// Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3
+	// Support: Safari<=5.1, Android<4.2
-	// old WebKit doesn't clone checked state correctly in fragments
+	// Older WebKit doesn't clone checked state correctly in fragments
 	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
+	// Support: IE<=11+
 	// Make sure textarea (and checkbox) defaultValue is properly cloned
-	// Support: IE9-IE11+
 	div.innerHTML = "<textarea>x</textarea>";
 	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
 })();
 var strundefined = typeof undefined;
 			event.currentTarget = matched.elem;
 			j = 0;
 			while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
-				// Triggered event must either 1) have no namespace, or
+				// Triggered event must either 1) have no namespace, or 2) have namespace(s)
-				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
+				// a subset or equal to those in the bound event (both can have no namespace).
 				if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
 					event.handleObj = handleObj;
 					event.data = handleObj.data;
 		// All events should have a target; Cordova deviceready doesn't
 		if ( !event.target ) {
 			event.target = document;
 		}
-		// Support: Safari 6.0+, Chrome < 28
+		// Support: Safari 6.0+, Chrome<28
 		// Target should not be a text node (#504, #13143)
 		if ( event.target.nodeType === 3 ) {
 			event.target = event.target.parentNode;
 		}
 		// 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.defaultPrevented === undefined &&
-				// Support: Android < 4.0
+				// Support: Android<4.0
 				src.returnValue === false ?
 			returnTrue :
 			returnFalse;
 	// Event type
 			return ret;
 		}
 	};
 });
+// Support: Firefox, Chrome, Safari
 // Create "bubbling" focus and blur events
-// Support: Firefox, Chrome, Safari
 if ( !support.focusinBubbles ) {
 	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
 		// Attach a single capturing handler on the document while someone wants focusin/focusout
 		var handler = function( event ) {
 	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
 	// We have to close these tags to support XHTML (#13200)
 	wrapMap = {
-		// Support: IE 9
+		// Support: IE9
 		option: [ 1, "<select multiple='multiple'>", "</select>" ],
 		thead: [ 1, "<table>", "</table>" ],
 		col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
 		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
 		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
 		_default: [ 0, "", "" ]
 	};
-// Support: IE 9
+// Support: IE9
 wrapMap.optgroup = wrapMap.option;
 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
 wrapMap.th = wrapMap.td;
 	return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
 		jQuery.merge( [ context ], ret ) :
 		ret;
 }
-// Support: IE >= 9
+// Fix IE bugs, see support tests
 function fixInput( src, dest ) {
 	var nodeName = dest.nodeName.toLowerCase();
 	// Fails to persist the checked state of a cloned checkbox or radio button.
 	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
 	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
 		var i, l, srcElements, destElements,
 			clone = elem.cloneNode( true ),
 			inPage = jQuery.contains( elem.ownerDocument, elem );
-		// Support: IE >= 9
+		// Fix IE cloning issues
-		// Fix Cloning issues
 		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
 				!jQuery.isXMLDoc( elem ) ) {
 			// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
 			destElements = getAll( clone );
 			if ( elem || elem === 0 ) {
 				// Add nodes directly
 				if ( jQuery.type( elem ) === "object" ) {
-					// Support: QtWebKit
+					// Support: QtWebKit, PhantomJS
-					// jQuery.merge because push.apply(_, arraylike) throws
+					// push.apply(_, arraylike) throws on ancient WebKit
 					jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
 				// Convert non-html into a text node
 				} else if ( !rhtml.test( elem ) ) {
 					nodes.push( context.createTextNode( elem ) );
 					j = wrap[ 0 ];
 					while ( j-- ) {
 						tmp = tmp.lastChild;
 					}
-					// Support: QtWebKit
+					// Support: QtWebKit, PhantomJS
-					// jQuery.merge because push.apply(_, arraylike) throws
+					// push.apply(_, arraylike) throws on ancient WebKit
 					jQuery.merge( nodes, tmp.childNodes );
 					// Remember the top-level container
 					tmp = fragment.firstChild;
-					// Fixes #12346
+					// Ensure the created nodes are orphaned (#12392)
-					// Support: Webkit, IE
 					tmp.textContent = "";
 				}
 			}
 		}
 		elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
 		// getDefaultComputedStyle might be reliably used only on attached element
 		display = window.getDefaultComputedStyle && ( style = window.getDefaultComputedStyle( elem[ 0 ] ) ) ?
-			// Use of this method is a temporary fix (more like optmization) until something better comes along,
+			// Use of this method is a temporary fix (more like optimization) until something better comes along,
 			// since it was removed from specification and supported only in FF
 			style.display : jQuery.css( elem[ 0 ], "display" );
 	// We don't have any data stored on the element,
 	// so use "detach" method as fast way to get rid of the element
 var rmargin = (/^margin/);
 var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
 var getStyles = function( elem ) {
-		return elem.ownerDocument.defaultView.getComputedStyle( elem, null );
+		// Support: IE<=11+, Firefox<=30+ (#15098, #14150)
+		// IE throws on elements created in popups
+		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
+		if ( elem.ownerDocument.defaultView.opener ) {
+			return elem.ownerDocument.defaultView.getComputedStyle( elem, null );
+		}
+		return window.getComputedStyle( elem, null );
 	};
 function curCSS( elem, name, computed ) {
 		style = elem.style;
 	computed = computed || getStyles( elem );
 	// Support: IE9
-	// getPropertyValue is only needed for .css('filter') in IE9, see #12537
+	// getPropertyValue is only needed for .css('filter') (#12537)
 	if ( computed ) {
 		ret = computed.getPropertyValue( name ) || computed[ name ];
 	}
 	if ( computed ) {
 function addGetHookIf( conditionFn, hookFn ) {
 	// Define the hook, we'll check on the first run if it's really needed.
 	return {
 		get: function() {
 			if ( conditionFn() ) {
-				// Hook not needed (or it's not possible to use it due to missing dependency),
+				// Hook not needed (or it's not possible to use it due
-				// remove it.
+				// to missing dependency), remove it.
-				// Since there are no other hooks for marginRight, remove the whole object.
 				delete this.get;
 				return;
 			}
 			// Hook needed; redefine it so that the support test is not executed again.
 			return (this.get = hookFn).apply( this, arguments );
 		}
 	};
 }
 	if ( !div.style ) {
 		return;
 	}
+	// Support: IE9-11+
+	// Style of cloned element affects source element cloned (#8908)
 	div.style.backgroundClip = "content-box";
 	div.cloneNode( true ).style.backgroundClip = "";
 	support.clearCloneStyle = div.style.backgroundClip === "content-box";
 	container.style.cssText = "border:0;width:0;height:0;top:0;left:-9999px;margin-top:1px;" +
 	// Support: node.js jsdom
 	// Don't assume that getComputedStyle is a property of the global object
 	if ( window.getComputedStyle ) {
 		jQuery.extend( support, {
 			pixelPosition: function() {
 				// This test is executed only once but we still do memoizing
 				// since we can use the boxSizingReliable pre-computing.
 				// No need to check if the test was already performed, though.
 				computePixelPositionAndBoxSizingReliable();
 				return pixelPositionVal;
 					computePixelPositionAndBoxSizingReliable();
 				}
 				return boxSizingReliableVal;
 			},
 			reliableMarginRight: function() {
 				// Support: Android 2.3
 				// Check if div with explicit width and no margin-right incorrectly
 				// gets computed margin-right based on width of container. (#3333)
 				// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
 				// This support function is only executed once so no memoizing is needed.
 				docElem.appendChild( container );
 				ret = !parseFloat( window.getComputedStyle( marginDiv, null ).marginRight );
 				docElem.removeChild( container );
+				div.removeChild( marginDiv );
 				return ret;
 			}
 		});
 	}
 	return ret;
 };
 var
-	// swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
+	// Swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
-	// see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
+	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
 	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
 	rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
 	rrelNum = new RegExp( "^([+-])=(" + pnum + ")", "i" ),
 	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
 		fontWeight: "400"
 	},
 	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];
-// return a css property mapped to a potentially vendor prefixed property
+// Return a css property mapped to a potentially vendor prefixed property
 function vendorPropName( style, name ) {
-	// shortcut for names that are not vendor prefixed
+	// Shortcut for names that are not vendor prefixed
 	if ( name in style ) {
 		return name;
 	}
-	// check for vendor prefixed names
+	// Check for vendor prefixed names
 	var capName = name[0].toUpperCase() + name.slice(1),
 		origName = name,
 		i = cssPrefixes.length;
 	while ( i-- ) {
 		name === "width" ? 1 : 0,
 		val = 0;
 	for ( ; i < 4; i += 2 ) {
-		// both box models exclude margin, so add it if we want it
+		// Both box models exclude margin, so add it if we want it
 		if ( extra === "margin" ) {
 			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
 		}
 		if ( isBorderBox ) {
 			// border-box includes padding, so remove it if we want content
 			if ( extra === "content" ) {
 				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
 			}
-			// at this point, extra isn't border nor margin, so remove border
+			// At this point, extra isn't border nor margin, so remove border
 			if ( extra !== "margin" ) {
 				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 			}
 		} else {
-			// at this point, extra isn't content, so add padding
+			// At this point, extra isn't content, so add padding
 			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
-			// at this point, extra isn't content nor padding, so add border
+			// At this point, extra isn't content nor padding, so add border
 			if ( extra !== "padding" ) {
 				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
 			}
 		}
 	}
 	var valueIsBorderBox = true,
 		val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
 		styles = getStyles( elem ),
 		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
-	// some non-html elements return undefined for offsetWidth, so check for null/undefined
+	// Some non-html elements return undefined for offsetWidth, so check for null/undefined
 	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
 	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
 	if ( val <= 0 || val == null ) {
 		// Fall back to computed then uncomputed css if necessary
 		val = curCSS( elem, name, styles );
 		// Computed unit is not pixels. Stop here and return.
 		if ( rnumnonpx.test(val) ) {
 			return val;
 		}
-		// we need the check for style in case a browser which returns unreliable values
+		// Check for style in case a browser which returns unreliable values
 		// for getComputedStyle silently falls back to the reliable elem.style
 		valueIsBorderBox = isBorderBox &&
 			( support.boxSizingReliable() || val === elem.style[ name ] );
 		// Normalize "", auto, and prepare for extra
 		val = parseFloat( val ) || 0;
 	}
-	// use the active box-sizing model to add/subtract irrelevant styles
+	// Use the active box-sizing model to add/subtract irrelevant styles
 	return ( val +
 		augmentWidthOrHeight(
 			elem,
 			name,
 			extra || ( isBorderBox ? "border" : "content" ),
 	return elements;
 }
 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;
 				}
 			}
 	},
 	// Add in properties whose names you wish to fix before
 	// setting or getting the value
 	cssProps: {
-		// normalize float css property
 		"float": "cssFloat"
 	},
 	// 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;
 		}
 			origName = jQuery.camelCase( name ),
 			style = elem.style;
 		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
-		// gets hook for the prefixed version
+		// Gets hook for the prefixed version, then unprefixed version
-		// followed by the unprefixed version
 		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
 		// Check if we're setting a value
 		if ( value !== undefined ) {
 			type = typeof value;
-			// convert relative number strings (+= or -=) to relative numbers. #7345
+			// Convert "+=" 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 null and NaN values aren't set. See: #7116
+			// Make sure that null and NaN values aren't set (#7116)
 			if ( value == null || value !== value ) {
 				return;
 			}
-			// If a number was passed in, add 'px' to the (except for certain CSS properties)
+			// If a number, add 'px' to the (except for certain CSS properties)
 			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
 				value += "px";
 			}
-			// Fixes #8908, it can be done more correctly by specifying setters in cssHooks,
+			// Support: IE9-11+
-			// but it would mean to define eight (for every problematic property) identical functions
+			// background-* props affect original clone's values
 			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
 				style[ name ] = "inherit";
 			}
 			// If a hook was provided, use that value, otherwise just set the specified value
 			origName = jQuery.camelCase( name );
 		// Make sure that we're working with the right name
 		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
-		// gets hook for the prefixed version
+		// Try prefixed name followed by the unprefixed name
-		// followed by the unprefixed version
 		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
 		// If a hook was provided get the computed value from there
 		if ( hooks && "get" in hooks ) {
 			val = hooks.get( elem, true, extra );
 		// Otherwise, if a way to get the computed value exists, use that
 		if ( val === undefined ) {
 			val = curCSS( elem, name, styles );
 		}
-		//convert "normal" to computed value
+		// Convert "normal" to computed value
 		if ( val === "normal" && name in cssNormalTransform ) {
 			val = cssNormalTransform[ name ];
 		}
-		// Return, converting to number if forced or a qualifier was provided and val looks numeric
+		// Make numeric if forced or a qualifier was provided and val looks numeric
 		if ( extra === "" || extra ) {
 			num = parseFloat( val );
 			return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
 		}
 		return val;
 jQuery.each([ "height", "width" ], function( i, name ) {
 	jQuery.cssHooks[ name ] = {
 		get: function( elem, computed, extra ) {
 			if ( computed ) {
-				// certain elements can have dimension info if we invisibly show them
-				// however, it must have a current display style that would benefit from this
+				// Certain elements can have dimension info if we invisibly show them
+				// but it must have a current display style that would benefit
 				return rdisplayswap.test( jQuery.css( elem, "display" ) ) && elem.offsetWidth === 0 ?
 					jQuery.swap( elem, cssShow, function() {
 						return getWidthOrHeight( elem, name, extra );
 					}) :
 					getWidthOrHeight( elem, name, extra );
 // Support: Android 2.3
 jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
 	function( elem, computed ) {
 		if ( 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" },
 				curCSS, [ elem, "marginRight" ] );
 		}
 	}
 );
 	jQuery.cssHooks[ prefix + suffix ] = {
 		expand: function( value ) {
 			var i = 0,
 				expanded = {},
-				// assumes a single number if not a string
+				// Assumes a single number if not a string
 				parts = typeof value === "string" ? value.split(" ") : [ value ];
 			for ( ; i < 4; i++ ) {
 				expanded[ prefix + cssExpand[ i ] + suffix ] =
 					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
 			if ( tween.elem[ tween.prop ] != null &&
 				(!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
 				return tween.elem[ tween.prop ];
 			}
-			// passing an empty string as a 3rd parameter to .css will automatically
+			// Passing an empty string as a 3rd parameter to .css will automatically
-			// attempt a parseFloat and fallback to a string if the parse fails
+			// attempt a parseFloat and fallback to a string if the parse fails.
-			// so, simple values such as "10px" are parsed to Float.
+			// Simple values such as "10px" are parsed to Float;
-			// complex values such as "rotate(1rad)" are returned as is.
+			// complex values such as "rotate(1rad)" are returned as-is.
 			result = jQuery.css( tween.elem, tween.prop, "" );
 			// Empty strings, null, undefined and "auto" are converted to 0.
 			return !result || result === "auto" ? 0 : result;
 		},
 		set: function( tween ) {
-			// use step hook for back compat - use cssHook if its there - use .style if its
+			// Use step hook for back compat.
-			// available and use plain properties where available
+			// Use cssHook if its there.
+			// Use .style if available and use plain properties where available.
 			if ( jQuery.fx.step[ tween.prop ] ) {
 				jQuery.fx.step[ tween.prop ]( tween );
 			} else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
 				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
 			} else {
 	}
 };
 // Support: IE9
 // Panic based approach to setting things on disconnected nodes
 Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
 	set: function( tween ) {
 		if ( tween.elem.nodeType && tween.elem.parentNode ) {
 			tween.elem[ tween.prop ] = tween.now;
 		}
 				// Iteratively approximate from a nonzero starting point
 				start = +target || 1;
 				do {
-					// If previous iteration zeroed out, double until we get *something*
+					// If previous iteration zeroed out, double until we get *something*.
-					// Use a string for doubling factor so we don't accidentally see scale as unchanged below
+					// Use string for doubling so we don't accidentally see scale as unchanged below
 					scale = scale || ".5";
 					// Adjust and apply
 					start = start / scale;
 					jQuery.style( tween.elem, prop, start + unit );
-				// Update scale, tolerating zero or NaN from tween.cur()
+				// Update scale, tolerating zero or NaN from tween.cur(),
-				// And breaking the loop if scale is unchanged or perfect, or if we've just had enough
+				// break the loop if scale is unchanged or perfect, or if we've just had enough
 				} while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
 			}
 			// Update tween properties
 			if ( parts ) {
 function genFx( type, includeWidth ) {
 	var which,
 		i = 0,
 		attrs = { height: type };
-	// if we include width, step value is 1 to do all cssExpand values,
+	// If we include width, step value is 1 to do all cssExpand values,
-	// if we don't include width, step value is 2 to skip over Left and Right
+	// otherwise step value is 2 to skip over Left and Right
 	includeWidth = includeWidth ? 1 : 0;
 	for ( ; i < 4 ; i += 2 - includeWidth ) {
 		which = cssExpand[ i ];
 		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
 	}
 		index = 0,
 		length = collection.length;
 	for ( ; index < length; index++ ) {
 		if ( (tween = collection[ index ].call( animation, prop, value )) ) {
-			// we're done with this property
+			// We're done with this property
 			return tween;
 		}
 	}
 }
 		orig = {},
 		style = elem.style,
 		hidden = elem.nodeType && isHidden( elem ),
 		dataShow = data_priv.get( elem, "fxshow" );
-	// handle queue: false promises
+	// Handle queue: false promises
 	if ( !opts.queue ) {
 		hooks = jQuery._queueHooks( elem, "fx" );
 		if ( hooks.unqueued == null ) {
 			hooks.unqueued = 0;
 			oldfire = hooks.empty.fire;
 			};
 		}
 		hooks.unqueued++;
 		anim.always(function() {
-			// doing this makes sure that the complete handler will be called
+			// Ensure the complete handler is called before this completes
-			// before this completes
 			anim.always(function() {
 				hooks.unqueued--;
 				if ( !jQuery.queue( elem, "fx" ).length ) {
 					hooks.empty.fire();
 				}
 			});
 		});
 	}
-	// height/width overflow pass
+	// Height/width overflow pass
 	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
 		// Make sure that nothing sneaks out
 		// Record all 3 overflow attributes because IE9-10 do not
 		// change the overflow attribute when overflowX and
 		// overflowY are set to the same value
 			}
 		} else {
 			dataShow = data_priv.access( elem, "fxshow", {} );
 		}
-		// store state if its toggle - enables .stop().toggle() to "reverse"
+		// Store state if its toggle - enables .stop().toggle() to "reverse"
 		if ( toggle ) {
 			dataShow.hidden = !hidden;
 		}
 		if ( hidden ) {
 			jQuery( elem ).show();
 		hooks = jQuery.cssHooks[ name ];
 		if ( hooks && "expand" in hooks ) {
 			value = hooks.expand( value );
 			delete props[ name ];
-			// not quite $.extend, this wont overwrite keys already present.
+			// Not quite $.extend, this won't overwrite existing keys.
-			// also - reusing 'index' from above because we have the correct "name"
+			// Reusing 'index' because we have the correct "name"
 			for ( index in value ) {
 				if ( !( index in props ) ) {
 					props[ index ] = value[ index ];
 					specialEasing[ index ] = easing;
 				}
 	var result,
 		stopped,
 		index = 0,
 		length = animationPrefilters.length,
 		deferred = jQuery.Deferred().always( function() {
-			// don't match elem in the :animated selector
+			// Don't match elem in the :animated selector
 			delete tick.elem;
 		}),
 		tick = function() {
 			if ( stopped ) {
 				return false;
 			}
 			var currentTime = fxNow || createFxNow(),
 				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
-				// archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497)
+				// Support: Android 2.3
+				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
 				temp = remaining / animation.duration || 0,
 				percent = 1 - temp,
 				index = 0,
 				length = animation.tweens.length;
 				animation.tweens.push( tween );
 				return tween;
 			},
 			stop: function( gotoEnd ) {
 				var index = 0,
-					// if we are going to the end, we want to run all the tweens
+					// If we are going to the end, we want to run all the tweens
 					// otherwise we skip this part
 					length = gotoEnd ? animation.tweens.length : 0;
 				if ( stopped ) {
 					return this;
 				}
 				stopped = true;
 				for ( ; index < length ; index++ ) {
 					animation.tweens[ index ].run( 1 );
 				}
-				// resolve when we played the last frame
+				// Resolve when we played the last frame; otherwise, reject
-				// otherwise, reject
 				if ( gotoEnd ) {
 					deferred.resolveWith( elem, [ animation, gotoEnd ] );
 				} else {
 					deferred.rejectWith( elem, [ animation, gotoEnd ] );
 				}
 	};
 	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"
+	// Normalize opt.queue - true/undefined/null -> "fx"
 	if ( opt.queue == null || opt.queue === true ) {
 		opt.queue = "fx";
 	}
 	// Queueing
 };
 jQuery.fn.extend({
 	fadeTo: function( speed, to, easing, callback ) {
-		// show any hidden elements after setting opacity to 0
+		// Show any hidden elements after setting opacity to 0
 		return this.filter( isHidden ).css( "opacity", 0 ).show()
-			// animate to the value specified
+			// Animate to the value specified
 			.end().animate({ opacity: to }, speed, easing, callback );
 	},
 	animate: function( prop, speed, easing, callback ) {
 		var empty = jQuery.isEmptyObject( prop ),
 			optall = jQuery.speed( speed, easing, callback ),
 					dequeue = false;
 					timers.splice( index, 1 );
 				}
 			}
-			// start the next in the queue if the last step wasn't forced
+			// Start the next in the queue if the last step wasn't forced.
-			// timers currently will call their complete callbacks, which will dequeue
+			// Timers currently will call their complete callbacks, which
-			// but only if they were gotoEnd
+			// will dequeue but only if they were gotoEnd.
 			if ( dequeue || !gotoEnd ) {
 				jQuery.dequeue( this, type );
 			}
 		});
 	},
 				queue = data[ type + "queue" ],
 				hooks = data[ type + "queueHooks" ],
 				timers = jQuery.timers,
 				length = queue ? queue.length : 0;
-			// enable finishing flag on private data
+			// Enable finishing flag on private data
 			data.finish = true;
-			// empty the queue first
+			// Empty the queue first
 			jQuery.queue( this, type, [] );
 			if ( hooks && hooks.stop ) {
 				hooks.stop.call( this, true );
 			}
-			// look for any active animations, and finish them
+			// Look for any active animations, and finish them
 			for ( index = timers.length; index--; ) {
 				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
 					timers[ index ].anim.stop( true );
 					timers.splice( index, 1 );
 				}
 			}
-			// look for any animations in the old queue and finish them
+			// Look for any animations in the old queue and finish them
 			for ( index = 0; index < length; index++ ) {
 				if ( queue[ index ] && queue[ index ].finish ) {
 					queue[ index ].finish.call( this );
 				}
 			}
-			// turn off finishing flag
+			// Turn off finishing flag
 			delete data.finish;
 		});
 	}
 });
 		select = document.createElement( "select" ),
 		opt = select.appendChild( document.createElement( "option" ) );
 	input.type = "checkbox";
-	// Support: iOS 5.1, Android 4.x, Android 2.3
+	// Support: iOS<=5.1, Android<=4.2+
-	// Check the default checkbox/radio value ("" on old WebKit; "on" elsewhere)
+	// Default value for a checkbox should be "on"
 	support.checkOn = input.value !== "";
-	// Must access the parent to make an option select properly
+	// Support: IE<=11+
-	// Support: IE9, IE10
+	// Must access selectedIndex to make default options select
 	support.optSelected = opt.selected;
-	// Make sure that the options inside disabled selects aren't marked as disabled
+	// Support: Android<=2.3
-	// (WebKit marks them as disabled)
+	// Options inside disabled selects are incorrectly marked as disabled
 	select.disabled = true;
 	support.optDisabled = !opt.disabled;
-	// Check if an input maintains its value after becoming a radio
+	// Support: IE<=11+
-	// Support: IE9, IE10
+	// An input loses its value after becoming a radio
 	input = document.createElement( "input" );
 	input.value = "t";
 	input.type = "radio";
 	support.radioValue = input.value === "t";
 })();
 	attrHooks: {
 		type: {
 			set: function( elem, value ) {
 				if ( !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 default in case type is set after value during creation
 					var val = elem.value;
 					elem.setAttribute( "type", value );
 					if ( val ) {
 						elem.value = val;
 					}
 	prop: function( elem, name, value ) {
 		var ret, hooks, notxml,
 			nType = elem.nodeType;
-		// don't get/set properties on text, comment and attribute nodes
+		// 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 );
 			}
 		}
 	}
 });
-// Support: IE9+
-// Selectedness for an option in an optgroup can be inaccurate
 if ( !support.optSelected ) {
 	jQuery.propHooks.selected = {
 		get: function( elem ) {
 			var parent = elem.parentNode;
 			if ( parent && parent.parentNode ) {
 						while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
 							cur = cur.replace( " " + clazz + " ", " " );
 						}
 					}
-					// only assign if different to avoid unneeded rendering.
+					// Only assign if different to avoid unneeded rendering.
 					finalValue = value ? jQuery.trim( cur ) : "";
 					if ( elem.className !== finalValue ) {
 						elem.className = finalValue;
 					}
 				}
 			});
 		}
 		return this.each(function() {
 			if ( type === "string" ) {
-				// toggle individual class names
+				// Toggle individual class names
 				var className,
 					i = 0,
 					self = jQuery( this ),
 					classNames = value.match( rnotwhite ) || [];
 				while ( (className = classNames[ i++ ]) ) {
-					// check each className given, space separated list
+					// Check each className given, space separated list
 					if ( self.hasClass( className ) ) {
 						self.removeClass( className );
 					} else {
 						self.addClass( className );
 					}
 				if ( this.className ) {
 					// store className if set
 					data_priv.set( this, "__className__", this.className );
 				}
-				// If the element has a class name or if we're passed "false",
+				// If the element has a class name or if we're passed `false`,
 				// then remove the whole classname (if there was one, the above saved it).
 				// Otherwise bring back whatever was previously saved (if anything),
 				// falling back to the empty string if nothing was stored.
 				this.className = this.className || value === false ? "" : data_priv.get( this, "__className__" ) || "";
 			}
 				}
 				ret = elem.value;
 				return typeof ret === "string" ?
-					// handle most common string cases
+					// Handle most common string cases
 					ret.replace(rreturn, "") :
-					// handle cases where value is null/undef or number
+					// Handle cases where value is null/undef or number
 					ret == null ? "" : ret;
 			}
 			return;
 		}
 					if ( (option.selected = jQuery.inArray( option.value, values ) >= 0) ) {
 						optionSet = true;
 					}
 				}
-				// force browsers to behave consistently when non-matching value is set
+				// Force browsers to behave consistently when non-matching value is set
 				if ( !optionSet ) {
 					elem.selectedIndex = -1;
 				}
 				return values;
 			}
 			}
 		}
 	};
 	if ( !support.checkOn ) {
 		jQuery.valHooks[ this ].get = function( elem ) {
-			// Support: Webkit
-			// "" is returned instead of "on" if a value isn't specified
 			return elem.getAttribute("value") === null ? "on" : elem.value;
 		};
 	}
 });
 	return xml;
 };
 var
-	// Document location
-	ajaxLocParts,
-	ajaxLocation,
 	rhash = /#.*$/,
 	rts = /([?&])_=[^&]*/,
 	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
 	// #7653, #8125, #8152: local protocol detection
 	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
 	 * 3) selection will start with transport dataType and THEN go to "*" if needed
 	 */
 	transports = {},
 	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
-	allTypes = "*/".concat("*");
+	allTypes = "*/".concat( "*" ),
-// #8138, IE may throw an exception when accessing
+	// Document location
-// a field from window.location if document.domain has been set
+	ajaxLocation = window.location.href,
-try {
-	ajaxLocation = location.href;
+	// Segment location into parts
-} catch( e ) {
+	ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
-	// 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 "*"
 		if ( state === 2 ) {
 			return jqXHR;
 		}
 		// We can fire global events as of now if asked to
-		fireGlobals = s.global;
+		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
+		fireGlobals = jQuery.event && s.global;
 		// Watch for a new set of requests
 		if ( fireGlobals && jQuery.active++ === 0 ) {
 			jQuery.event.trigger("ajaxStart");
 		}
 		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
 			// Abort if not done already and return
 			return jqXHR.abort();
 		}
-		// aborting is no longer a cancellation
+		// Aborting is no longer a cancellation
 		strAbort = "abort";
 		// Install callbacks on deferreds
 		for ( i in { success: 1, error: 1, complete: 1 } ) {
 			jqXHR[ i ]( s[ i ] );
 					success = response.data;
 					error = response.error;
 					isSuccess = !error;
 				}
 			} else {
-				// We extract error from statusText
+				// Extract error from statusText and normalize for non-aborts
-				// then normalize statusText and status for non-aborts
 				error = statusText;
 				if ( status || !statusText ) {
 					statusText = "error";
 					if ( status < 0 ) {
 						status = 0;
 	}
 });
 jQuery.each( [ "get", "post" ], function( i, method ) {
 	jQuery[ method ] = function( url, data, callback, type ) {
-		// shift arguments if data argument was omitted
+		// Shift arguments if data argument was omitted
 		if ( jQuery.isFunction( data ) ) {
 			type = type || callback;
 			callback = data;
 			data = undefined;
 		}
 			type: method,
 			dataType: type,
 			data: data,
 			success: callback
 		});
-	};
-});
-// Attach a bunch of functions for handling common AJAX events
-jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) {
-	jQuery.fn[ type ] = function( fn ) {
-		return this.on( type, fn );
 	};
 });
 jQuery._evalUrl = function( url ) {
 	},
 	xhrSupported = jQuery.ajaxSettings.xhr();
 // Support: IE9
 // Open requests must be manually aborted on unload (#5280)
-if ( window.ActiveXObject ) {
+// See https://support.microsoft.com/kb/2856746 for more info
-	jQuery( window ).on( "unload", function() {
+if ( window.attachEvent ) {
+	window.attachEvent( "onunload", function() {
 		for ( var key in xhrCallbacks ) {
 			xhrCallbacks[ key ]();
 		}
 	});
 }
 };
+// Attach a bunch of functions for handling common AJAX events
+jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) {
+	jQuery.fn[ type ] = function( fn ) {
+		return this.on( type, fn );
+	};
+});
 jQuery.expr.filters.animated = function( elem ) {
 	return jQuery.grep(jQuery.timers, function( fn ) {
 		return elem === fn.elem;
 	}).length;
 };
 		curCSSTop = jQuery.css( elem, "top" );
 		curCSSLeft = jQuery.css( elem, "left" );
 		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
 			( curCSSTop + curCSSLeft ).indexOf("auto") > -1;
-		// Need to be able to calculate position if either top or left is auto and position is either absolute or fixed
+		// 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;
 		// Make sure it's not a disconnected DOM node
 		if ( !jQuery.contains( docElem, elem ) ) {
 			return box;
 		}
+		// Support: BlackBerry 5, iOS 3 (original iPhone)
 		// If we don't have gBCR, just use 0,0 rather than error
-		// BlackBerry 5, iOS 3 (original iPhone)
 		if ( typeof elem.getBoundingClientRect !== strundefined ) {
 			box = elem.getBoundingClientRect();
 		}
 		win = getWindow( doc );
 		return {
 			elem = this[ 0 ],
 			parentOffset = { top: 0, left: 0 };
 		// Fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is its only offset parent
 		if ( jQuery.css( elem, "position" ) === "fixed" ) {
-			// We assume that getBoundingClientRect is available when computed position is fixed
+			// Assume getBoundingClientRect is there when computed position is fixed
 			offset = elem.getBoundingClientRect();
 		} else {
 			// Get *real* offsetParent
 			offsetParent = this.offsetParent();
 			}
 		}, method, val, arguments.length, null );
 	};
 });
+// Support: Safari<7+, Chrome<37+
 // Add the top/left cssHooks using jQuery.fn.position
 // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
-// getComputedStyle returns percent when specified for top/left/bottom/right
+// Blink bug: https://code.google.com/p/chromium/issues/detail?id=229280
-// rather than make the css module depend on the offset module, we just check for it here
+// getComputedStyle returns percent when specified for top/left/bottom/right;
+// rather than make the css module depend on the offset module, just check for it here
 jQuery.each( [ "top", "left" ], function( i, prop ) {
 	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
 		function( elem, computed ) {
 			if ( computed ) {
 				computed = curCSS( elem, prop );
-				// if curCSS returns percentage, fallback to offset
+				// If curCSS returns percentage, fallback to offset
 				return rnumnonpx.test( computed ) ?
 					jQuery( elem ).position()[ prop ] + "px" :
 					computed;
 			}
 		}
 // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
 jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
 	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
-		// margin is only for outerHeight, outerWidth
+		// Margin is only for outerHeight, outerWidth
 		jQuery.fn[ funcName ] = function( margin, value ) {
 			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
 				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
 			return access( this, function( elem, type, value ) {
 	}
 	return jQuery;
 };
-// Expose jQuery and $ identifiers, even in
+// Expose jQuery and $ identifiers, even in AMD
-// AMD (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
+// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
 // and CommonJS for browser emulators (#13566)
 if ( typeof noGlobal === strundefined ) {
 	window.jQuery = window.$ = jQuery;
 }
 return jQuery;
 }));
 /**
-* @license AngularJS v1.3.0-rc.5
+* @license AngularJS v1.3.8
 * (c) 2010-2014 Google, Inc. http://angularjs.org
 * License: MIT
 */
 (function(window, document, undefined) {'use strict';
 * @returns {function(code:string, template:string, ...templateArgs): Error} minErr instance
 */
 function minErr(module, ErrorConstructor) {
 ErrorConstructor = ErrorConstructor || Error;
-return function () {
+return function() {
 var code = arguments[0],
 prefix = '[' + (module ? module + ':' : '') + code + '] ',
 template = arguments[1],
 templateArgs = arguments,
-stringify = function (obj) {
-if (typeof obj === 'function') {
-return obj.toString().replace(/ \{[\s\S]*$/, '');
-} else if (typeof obj === 'undefined') {
-return 'undefined';
-} else if (typeof obj !== 'string') {
-return JSON.stringify(obj);
-}
-return obj;
-},
 message, i;
-message = prefix + template.replace(/\{\d+\}/g, function (match) {
+message = prefix + template.replace(/\{\d+\}/g, function(match) {
 var index = +match.slice(1, -1), arg;
 if (index + 2 < templateArgs.length) {
-arg = templateArgs[index + 2];
+return toDebugString(templateArgs[index + 2]);
-if (typeof arg === 'function') {
-return arg.toString().replace(/ ?\{[\s\S]*$/, '');
-} else if (typeof arg === 'undefined') {
-return 'undefined';
-} else if (typeof arg !== 'string') {
-return toJson(arg);
-}
-return arg;
 }
 return match;
 });
-message = message + '\nhttp://errors.angularjs.org/1.3.0-rc.5/' +
+message = message + '\nhttp://errors.angularjs.org/1.3.8/' +
 (module ? module + '/' : '') + code;
 for (i = 2; i < arguments.length; i++) {
-message = message + (i == 2 ? '?' : '&') + 'p' + (i-2) + '=' +
+message = message + (i == 2 ? '?' : '&') + 'p' + (i - 2) + '=' +
-encodeURIComponent(stringify(arguments[i]));
+encodeURIComponent(toDebugString(arguments[i]));
 }
 return new ErrorConstructor(message);
 };
 }
 isFunction: true,
 isRegExp: true,
 isWindow: true,
 isScope: true,
 isFile: true,
+isFormData: true,
 isBlob: true,
 isBoolean: true,
 isPromiseLike: true,
 trim: true,
+escapeForRegexp: true,
 isElement: true,
 makeMap: true,
-size: true,
 includes: true,
 arrayRemove: true,
-isLeafNode: true,
 copy: true,
 shallowCopy: true,
 equals: true,
 csp: true,
 concat: true,
 *
 * @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;};
+var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 /**
 * @ngdoc function
 * @name angular.uppercase
 *
 * @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 uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;};
 var manualLowercase = function(s) {
 /* jshint bitwise: false */
 return isString(s)
 lowercase = manualLowercase;
 uppercase = manualUppercase;
 }
-var /** holds major version number for IE or NaN for real browsers */
+var
-msie,
+msie,             // holds major version number for IE, or NaN if UA is not IE.
 jqLite,           // delay binding since jQuery could be loaded after us.
 jQuery,           // delay binding
 slice             = [].slice,
 splice            = [].splice,
 push              = [].push,
 * is the value of an object property or an array element, `key` is the object property key or
 * array element index and obj is the `obj` itself. Specifying a `context` for the function is optional.
 *
 * It is worth noting that `.forEach` does not iterate over inherited properties because it filters
 * using the `hasOwnProperty` method.
+*
+* Unlike ES262's
+* [Array.prototype.forEach](http://www.ecma-international.org/ecma-262/5.1/#sec-15.4.4.18),
+* Providing 'undefined' or 'null' values for `obj` will not throw a TypeError, but rather just
+* return the value provided.
 *
 ```js
 var values = {name: 'misko', gender: 'male'};
 var log = [];
 angular.forEach(values, function(value, key) {
 }
 return obj;
 }
 function sortedKeys(obj) {
-var keys = [];
+return Object.keys(obj).sort();
-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++) {
+for (var i = 0; i < keys.length; i++) {
 iterator.call(context, obj[keys[i]], keys[i]);
 }
 return keys;
 }
 * @module ng
 * @kind function
 *
 * @description
 * Extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
-* to `dst`. You can specify multiple `src` objects.
+* to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
+* by passing an empty object as the target: `var object = angular.extend({}, object1, object2)`.
+* Note: Keep in mind that `angular.extend` does not support recursive merge (deep copy).
 *
 * @param {Object} dst Destination object.
 * @param {...Object} src Source object(s).
 * @returns {Object} Reference to `dst`.
 */
 return parseInt(str, 10);
 }
 function inherit(parent, extra) {
-return extend(new (extend(function() {}, {prototype:parent}))(), extra);
+return extend(Object.create(parent), extra);
 }
 /**
 * @ngdoc function
 * @name angular.noop
 ```js
 function transformer(transformationFn, value) {
 return (transformationFn || angular.identity)(value);
 };
 ```
+* @param {*} value to be returned.
+* @returns {*} the value passed in.
 */
 function identity($) {return $;}
 identity.$inject = [];
 * 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';}
+function isUndefined(value) {return typeof value === 'undefined';}
 /**
 * @ngdoc function
 * @name angular.isDefined
 * 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';}
+function isDefined(value) {return typeof value !== 'undefined';}
 /**
 * @ngdoc function
 * @name angular.isObject
 * considered to be objects. Note that JavaScript arrays are objects.
 *
 * @param {*} value Reference to check.
 * @returns {boolean} True if `value` is an `Object` but not `null`.
 */
-function isObject(value){
+function isObject(value) {
 // http://jsperf.com/isobject4
 return value !== null && typeof value === 'object';
 }
 * 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';}
+function isString(value) {return typeof value === 'string';}
 /**
 * @ngdoc function
 * @name angular.isNumber
 * 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';}
+function isNumber(value) {return typeof value === 'number';}
 /**
 * @ngdoc function
 * @name angular.isDate
 * 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';}
+function isFunction(value) {return typeof value === 'function';}
 /**
 * Determines if a value is a regular expression object.
 *
 function isFile(obj) {
 return toString.call(obj) === '[object File]';
 }
+function isFormData(obj) {
+return toString.call(obj) === '[object FormData]';
+}
 function isBlob(obj) {
 return toString.call(obj) === '[object Blob]';
 }
 }
 var trim = function(value) {
 return isString(value) ? value.trim() : value;
+};
+// Copied from:
+// http://docs.closure-library.googlecode.com/git/local_closure_goog_string_string.js.source.html#line1021
+// Prereq: s is a string.
+var escapeForRegexp = function(s) {
+return s.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1').
+replace(/\x08/g, '\\x08');
 };
 /**
 * @ngdoc function
 * @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++ )
+for (i = 0; i < items.length; i++)
 obj[ items[i] ] = true;
 return obj;
 }
 function nodeName_(element) {
-return lowercase(element.nodeName || element[0].nodeName);
+return lowercase(element.nodeName || (element[0] && element[0].nodeName));
 }
-/**
-* @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 count = 0, key;
-if (isArray(obj) || isString(obj)) {
-return obj.length;
-} else if (isObject(obj)) {
-for (key in obj)
-if (!ownPropsOnly || obj.hasOwnProperty(key))
-count++;
-}
-return count;
-}
 function includes(array, obj) {
 return Array.prototype.indexOf.call(array, obj) != -1;
 }
 function arrayRemove(array, value) {
 var index = array.indexOf(value);
-if (index >=0)
+if (index >= 0)
 array.splice(index, 1);
 return value;
-}
-function isLeafNode (node) {
-if (node) {
-switch (nodeName_(node)) {
-case "option":
-case "pre":
-case "title":
-return true;
-}
-}
-return false;
 }
 /**
 * @ngdoc function
 * @name angular.copy
 *
 * @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)
+* * If a destination is provided, all of its elements (for arrays) 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 (inc. `null` and `undefined`), `source` is returned.
 * * If `source` is identical to 'destination' an exception will be thrown.
 *
 * @param {*} source The source that will be used to make a copy.
 }
 var result;
 if (isArray(source)) {
 destination.length = 0;
-for ( var i = 0; i < source.length; i++) {
+for (var i = 0; i < source.length; i++) {
 result = copy(source[i], null, stackSource, stackDest);
 if (isObject(source[i])) {
 stackSource.push(source[i]);
 stackDest.push(result);
 }
 } else {
 forEach(destination, function(value, key) {
 delete destination[key];
 });
 }
-for ( var key in source) {
+for (var key in source) {
-if(source.hasOwnProperty(key)) {
+if (source.hasOwnProperty(key)) {
 result = copy(source[key], null, stackSource, stackDest);
 if (isObject(source[key])) {
 stackSource.push(source[key]);
 stackDest.push(result);
 }
 if (t1 == t2) {
 if (t1 == 'object') {
 if (isArray(o1)) {
 if (!isArray(o2)) return false;
 if ((length = o1.length) == o2.length) {
-for(key=0; key<length; key++) {
+for (key = 0; key < length; key++) {
 if (!equals(o1[key], o2[key])) return false;
 }
 return true;
 }
 } else if (isDate(o1)) {
 } else if (isRegExp(o1) && isRegExp(o2)) {
 return o1.toString() == o2.toString();
 } else {
 if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) || isArray(o2)) return false;
 keySet = {};
-for(key in o1) {
+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) {
+for (key in o2) {
 if (!keySet.hasOwnProperty(key) &&
 key.charAt(0) !== '$' &&
 o2[key] !== undefined &&
 !isFunction(o2[key])) return false;
 }
 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, concat(curryArgs, arguments, 0))
 : fn.apply(self, curryArgs);
 }
 : function() {
 return arguments.length
 ? fn.apply(self, arguments)
 * @description
 * Serializes input into a JSON-formatted string. Properties with leading $$ characters will be
 * stripped since angular uses this notation internally.
 *
 * @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.
+* @param {boolean|number=} pretty If set to true, the JSON output will contain newlines and whitespace.
+*    If set to an integer, the JSON output will contain that many spaces per indentation (the default is 2).
 * @returns {string|undefined} JSON-ified string representing `obj`.
 */
 function toJson(obj, pretty) {
 if (typeof obj === 'undefined') return undefined;
-return JSON.stringify(obj, toJsonReplacer, pretty ? '  ' : null);
+if (!isNumber(pretty)) {
+pretty = pretty ? 2 : null;
+}
+return JSON.stringify(obj, toJsonReplacer, pretty);
 }
 /**
 * @ngdoc function
 *
 * @description
 * Deserializes a JSON string.
 *
 * @param {string} json JSON string to deserialize.
-* @returns {Object|Array|string|number} Deserialized thingy.
+* @returns {Object|Array|string|number} Deserialized JSON string.
 */
 function fromJson(json) {
 return isString(json)
 ? JSON.parse(json)
 : json;
 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.empty();
-} catch(e) {}
+} catch (e) {}
 var elemHtml = jqLite('<div>').append(element).html();
 try {
 return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
 elemHtml.
 match(/^(<[^>]+>)/)[1].
 replace(/^<([\w\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });
-} catch(e) {
+} catch (e) {
 return lowercase(elemHtml);
 }
 }
 * with the decodeURIComponent function.
 */
 function tryDecodeURIComponent(value) {
 try {
 return decodeURIComponent(value);
-} catch(e) {
+} catch (e) {
 // Ignore any invalid uri component
 }
 }
 * @returns {Object.<string,boolean|Array>}
 */
 function parseKeyValue(/**string*/keyValue) {
 var obj = {}, key_value, key;
 forEach((keyValue || "").split('&'), function(keyValue) {
-if ( keyValue ) {
+if (keyValue) {
 key_value = keyValue.replace(/\+/g,'%20').split('=');
 key = tryDecodeURIComponent(key_value[0]);
-if ( isDefined(key) ) {
+if (isDefined(key)) {
 var val = isDefined(key_value[1]) ? tryDecodeURIComponent(key_value[1]) : true;
 if (!hasOwnProperty.call(obj, key)) {
 obj[key] = val;
-} else if(isArray(obj[key])) {
+} else if (isArray(obj[key])) {
 obj[key].push(val);
 } else {
 obj[key] = [obj[key],val];
 }
 }
 var ngAttrPrefixes = ['ng-', 'data-ng-', 'ng:', 'x-ng-'];
 function getNgAttribute(element, ngAttr) {
 var attr, i, ii = ngAttrPrefixes.length;
 element = jqLite(element);
-for (i=0; i<ii; ++i) {
+for (i = 0; i < ii; ++i) {
 attr = ngAttrPrefixes[i] + ngAttr;
 if (isString(attr = element.attr(attr))) {
 return attr;
 }
 }
 * found in the document will be used to define the root element to auto-bootstrap as an
 * application. To run multiple applications in an HTML document you must manually bootstrap them using
 * {@link angular.bootstrap} instead. AngularJS applications cannot be nested within each other.
 *
 * You can specify an **AngularJS module** to be used as the root module for the application.  This
-* module will be loaded into the {@link auto.$injector} when the application is bootstrapped and
+* module will be loaded into the {@link auto.$injector} when the application is bootstrapped. It
 * should contain the application code needed or have dependencies on other modules that will
 * contain the code. See {@link angular.module} for more information.
 *
 * In the example below if the `ngApp` directive were not placed on the `html` element then the
 * document would not be compiled, the `AppController` would not be instantiated and the `{{ a+b }}`
 * would not be resolved to `3`.
 *
-* `ngApp` is the easiest, and most common, way to bootstrap an application.
+* `ngApp` is the easiest, and most common way to bootstrap an application.
 *
 <example module="ngAppDemo">
 <file name="index.html">
 <div ng-controller="ngAppDemoController">
 I can add: {{a}} + {{b}} =  {{ a+b }}
 *     function that will be invoked by the injector as a run block.
 *     See: {@link angular.module modules}
 * @param {Object=} config an object for defining configuration options for the application. The
 *     following keys are supported:
 *
-*     - `strictDi`: disable automatic function annotation for the application. This is meant to
+* * `strictDi` - disable automatic function annotation for the application. This is meant to
-*       assist in finding bugs which break minified code.
+*   assist in finding bugs which break minified code. Defaults to `false`.
 *
 * @returns {auto.$injector} Returns the newly created injector for this app.
 */
 function bootstrap(element, modules, config) {
 if (!isObject(config)) config = {};
 * Get the testability service for the instance of Angular on the given
 * element.
 * @param {DOMElement} element DOM element which is the root of angular application.
 */
 function getTestability(rootElement) {
-return angular.element(rootElement).injector().get('$$testability');
+var injector = angular.element(rootElement).injector();
+if (!injector) {
+throw ngMinErr('test',
+'no injector found for element argument to getTestability');
+}
+return injector.get('$$testability');
 }
 var SNAKE_CASE_REGEXP = /[A-Z]/g;
 function snake_case(name, separator) {
 separator = separator || '_';
 *     }
 *   }
 * })
 * ```
 *
-* See {@link ngAnimate.$animateProvider#register $animateProvider.register()} and
+* See {@link ng.$animateProvider#register $animateProvider.register()} and
 * {@link ngAnimate ngAnimate module} for more information.
 */
 animation: invokeLater('$animateProvider', 'register'),
 /**
 * @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.
 * For more about how to configure services, see
-* {@link providers#providers_provider-recipe Provider Recipe}.
+* {@link providers#provider-recipe Provider Recipe}.
 */
 config: config,
 /**
 * @ngdoc method
 if (configFn) {
 config(configFn);
 }
-return  moduleInstance;
+return moduleInstance;
 /**
 * @param {string} provider
 * @param {string} method
 * @param {String=} insertMethod
 }
 });
 };
 });
+}
+/* global: toDebugString: true */
+function serializeObject(obj) {
+var seen = [];
+return JSON.stringify(obj, function(key, val) {
+val = toJsonReplacer(key, val);
+if (isObject(val)) {
+if (seen.indexOf(val) >= 0) return '<<already seen>>';
+seen.push(val);
+}
+return val;
+});
+}
+function toDebugString(obj) {
+if (typeof obj === 'function') {
+return obj.toString().replace(/ \{[\s\S]*$/, '');
+} else if (typeof obj === 'undefined') {
+return 'undefined';
+} else if (typeof obj !== 'string') {
+return serializeObject(obj);
+}
+return obj;
 }
 /* global angularModule: true,
 version: true,
 $TemplateRequestProvider,
 $$TestabilityProvider,
 $TimeoutProvider,
 $$RAFProvider,
 $$AsyncCallbackProvider,
-$WindowProvider
+$WindowProvider,
+$$jqLiteProvider
 */
 /**
 * @ngdoc object
 * - `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.3.0-rc.5',    // all of these placeholder strings will be replaced by grunt's
+full: '1.3.8',    // all of these placeholder strings will be replaced by grunt's
 major: 1,    // package task
 minor: 3,
-dot: 0,
+dot: 8,
-codeName: 'impossible-choreography'
+codeName: 'prophetic-narwhal'
 };
-function publishExternalAPI(angular){
+function publishExternalAPI(angular) {
 extend(angular, {
 'bootstrap': bootstrap,
 'copy': copy,
 'extend': extend,
 'equals': equals,
 $templateRequest: $TemplateRequestProvider,
 $$testability: $$TestabilityProvider,
 $timeout: $TimeoutProvider,
 $window: $WindowProvider,
 $$rAF: $$RAFProvider,
-$$asyncCallback : $$AsyncCallbackProvider
+$$asyncCallback: $$AsyncCallbackProvider,
+$$jqLite: $$jqLiteProvider
 });
 }
 ]);
 }
 * jqLite provides only the following jQuery 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/)
+* - [`attr()`](http://api.jquery.com/attr/) - Does not support functions as parameters
 * - [`bind()`](http://api.jquery.com/bind/) - Does not support namespaces, selectors or eventData
 * - [`children()`](http://api.jquery.com/children/) - Does not support selectors
 * - [`clone()`](http://api.jquery.com/clone/)
 * - [`contents()`](http://api.jquery.com/contents/)
-* - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyles()`
+* - [`css()`](http://api.jquery.com/css/) - Only retrieves inline-styles, does not call `getComputedStyle()`
 * - [`data()`](http://api.jquery.com/data/)
 * - [`detach()`](http://api.jquery.com/detach/)
 * - [`empty()`](http://api.jquery.com/empty/)
 * - [`eq()`](http://api.jquery.com/eq/)
 * - [`find()`](http://api.jquery.com/find/) - Limited to lookups by tag name
 *   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 ng.$rootScope.Scope scope} of the current
-*   element or its parent.
+*   element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to
+*   be enabled.
 * - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the
 *   current element. This getter should be used only on elements that contain a directive which starts a new isolate
 *   scope. Calling `scope()` on this element always returns the original non-isolate scope.
+*   Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled.
 * - `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.
 function jqNextId() { return ++jqId; }
 var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
 var MOZ_HACK_REGEXP = /^moz([A-Z])/;
-var MOUSE_EVENT_MAP= { mouseleave : "mouseout", mouseenter : "mouseover"};
+var MOUSE_EVENT_MAP= { mouseleave: "mouseout", mouseenter: "mouseover"};
 var jqLiteMinErr = minErr('jqLite');
 /**
 * Converts snake_case to camelCase.
 * Also there is special case for Moz prefix starting with upper case letter.
 function jqLiteClone(element) {
 return element.cloneNode(true);
 }
-function jqLiteDealoc(element, onlyDescendants){
+function jqLiteDealoc(element, onlyDescendants) {
 if (!onlyDescendants) jqLiteRemoveData(element);
 if (element.querySelectorAll) {
 var descendants = element.querySelectorAll('*');
 for (var i = 0, l = descendants.length; i < l; i++) {
 if (!handle) return; //no listeners registered
 if (!type) {
 for (type in events) {
 if (type !== '$destroy') {
-removeEventListenerFn(element, type, events[type]);
+removeEventListenerFn(element, type, handle);
 }
 delete events[type];
 }
 } else {
 forEach(type.split(' '), function(type) {
-if (isUndefined(fn)) {
+if (isDefined(fn)) {
-removeEventListenerFn(element, type, events[type]);
+var listenerFns = events[type];
-delete events[type];
+arrayRemove(listenerFns || [], fn);
-} else {
+if (listenerFns && listenerFns.length > 0) {
-arrayRemove(events[type] || [], fn);
+return;
+}
 }
+removeEventListenerFn(element, type, handle);
+delete events[type];
 });
 }
 }
 function jqLiteRemoveData(element, name) {
 }
 function jqLiteHasClass(element, selector) {
 if (!element.getAttribute) return false;
 return ((" " + (element.getAttribute('class') || '') + " ").replace(/[\n\t]/g, " ").
-indexOf( " " + selector + " " ) > -1);
+indexOf(" " + selector + " ") > -1);
 }
 function jqLiteRemoveClass(element, cssClasses) {
 if (cssClasses && element.setAttribute) {
 forEach(cssClasses.split(' '), function(cssClass) {
 }
 }
 function jqLiteController(element, name) {
-return jqLiteInheritedData(element, '$' + (name || 'ngController' ) + 'Controller');
+return jqLiteInheritedData(element, '$' + (name || 'ngController') + 'Controller');
 }
 function jqLiteInheritedData(element, name, value) {
 // if element is the document object work with the html element instead
 // this makes $(document).scope() possible
-if(element.nodeType == NODE_TYPE_DOCUMENT) {
+if (element.nodeType == NODE_TYPE_DOCUMENT) {
 element = element.documentElement;
 }
 var names = isArray(name) ? name : [name];
 while (element) {
 if (!keepData) jqLiteDealoc(element);
 var parent = element.parentNode;
 if (parent) parent.removeChild(element);
 }
+function jqLiteDocumentLoaded(action, win) {
+win = win || window;
+if (win.document.readyState === 'complete') {
+// Force the action to be run async for consistent behaviour
+// from the action's point of view
+// i.e. it will definitely not be in a $apply
+win.setTimeout(action);
+} else {
+// No need to unbind this handler as load is only ever called once
+jqLite(win).on('load', action);
+}
+}
 //////////////////////////////////////////
 // Functions which are declared directly.
 //////////////////////////////////////////
 var JQLitePrototype = JQLite.prototype = {
 ready: function(fn) {
 fired = true;
 fn();
 }
 // check if document is already loaded
-if (document.readyState === 'complete'){
+if (document.readyState === 'complete') {
 setTimeout(trigger);
 } else {
 this.on('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.
 // jshint -W064
 JQLite(window).on('load', trigger); // fallback to window.onload for others
 // jshint +W064
-this.on('DOMContentLoaded', trigger);
 }
 },
 toString: function() {
 var value = [];
-forEach(this, function(e){ value.push('' + e);});
+forEach(this, function(e) { value.push('' + e);});
 return '[' + value.join(', ') + ']';
 },
 eq: function(index) {
 return (index >= 0) ? jqLite(this[index]) : jqLite(this[this.length + index]);
 var BOOLEAN_ELEMENTS = {};
 forEach('input,select,option,textarea,button,form,details'.split(','), function(value) {
 BOOLEAN_ELEMENTS[value] = true;
 });
 var ALIASED_ATTR = {
-'ngMinlength' : 'minlength',
+'ngMinlength': 'minlength',
-'ngMaxlength' : 'maxlength',
+'ngMaxlength': 'maxlength',
-'ngMin' : 'min',
+'ngMin': 'min',
-'ngMax' : 'max',
+'ngMax': 'max',
-'ngPattern' : 'pattern'
+'ngPattern': 'pattern'
 };
 function getBooleanAttrName(element, name) {
 // check dom last since we will most likely fail on name
 var booleanAttr = BOOLEAN_ATTR[name.toLowerCase()];
 } else {
 return element.style[name];
 }
 },
-attr: function(element, name, value){
+attr: function(element, name, value) {
 var lowercasedName = lowercase(name);
 if (BOOLEAN_ATTR[lowercasedName]) {
 if (isDefined(value)) {
 if (!!value) {
 element[name] = true;
 element[name] = false;
 element.removeAttribute(lowercasedName);
 }
 } else {
 return (element[name] ||
-(element.attributes.getNamedItem(name)|| noop).specified)
+(element.attributes.getNamedItem(name) || noop).specified)
 ? lowercasedName
 : undefined;
 }
 } else if (isDefined(value)) {
 element.setAttribute(name, value);
 val: function(element, value) {
 if (isUndefined(value)) {
 if (element.multiple && nodeName_(element) === 'select') {
 var result = [];
-forEach(element.options, function (option) {
+forEach(element.options, function(option) {
 if (option.selected) {
 result.push(option.value || option.text);
 }
 });
 return result.length === 0 ? null : result;
 jqLiteDealoc(element, true);
 element.innerHTML = value;
 },
 empty: jqLiteEmpty
-}, function(fn, name){
+}, function(fn, name) {
 /**
 * Properties: writes return selection, reads return first value
 */
 JQLite.prototype[name] = function(arg1, arg2) {
 var i, key;
 }
 };
 });
 function createEventHandler(element, events) {
-var eventHandler = function (event, type) {
+var eventHandler = function(event, type) {
 // jQuery specific api
 event.isDefaultPrevented = function() {
 return event.defaultPrevented;
 };
 // selector.
 //////////////////////////////////////////
 forEach({
 removeData: jqLiteRemoveData,
-on: function jqLiteOn(element, type, fn, unsupported){
+on: function jqLiteOn(element, type, fn, unsupported) {
 if (isDefined(unsupported)) throw jqLiteMinErr('onargs', 'jqLite#on() does not support the `selector` or `eventData` parameters');
 // Do not add event handlers to non-elements because they will not be cleaned up.
 if (!jqLiteAcceptsData(element)) {
 return;
 jqLiteOn(element, MOUSE_EVENT_MAP[type], function(event) {
 var target = this, related = event.relatedTarget;
 // 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 && !target.contains(related)) ){
+if (!related || (related !== target && !target.contains(related))) {
 handle(event, type);
 }
 });
 } else {
 },
 replaceWith: function(element, replaceNode) {
 var index, parent = element.parentNode;
 jqLiteDealoc(element);
-forEach(new JQLite(replaceNode), function(node){
+forEach(new JQLite(replaceNode), function(node) {
 if (index) {
 parent.insertBefore(node, index.nextSibling);
 } else {
 parent.replaceChild(node, element);
 }
 });
 },
 children: function(element) {
 var children = [];
-forEach(element.childNodes, function(element){
+forEach(element.childNodes, function(element) {
 if (element.nodeType === NODE_TYPE_ELEMENT)
 children.push(element);
 });
 return children;
 },
 },
 prepend: function(element, node) {
 if (element.nodeType === NODE_TYPE_ELEMENT) {
 var index = element.firstChild;
-forEach(new JQLite(node), function(child){
+forEach(new JQLite(node), function(child) {
 element.insertBefore(child, index);
 });
 }
 },
 addClass: jqLiteAddClass,
 removeClass: jqLiteRemoveClass,
 toggleClass: function(element, selector, condition) {
 if (selector) {
-forEach(selector.split(' '), function(className){
+forEach(selector.split(' '), function(className) {
 var classCondition = condition;
 if (isUndefined(classCondition)) {
 classCondition = !jqLiteHasClass(element, className);
 }
 (classCondition ? jqLiteAddClass : jqLiteRemoveClass)(element, className);
 fn.apply(element, handlerArgs);
 }
 });
 }
 }
-}, function(fn, name){
+}, function(fn, name) {
 /**
 * chaining functions
 */
 JQLite.prototype[name] = function(arg1, arg2, arg3) {
 var value;
-for(var i = 0, ii = this.length; i < ii; i++) {
+for (var i = 0, ii = this.length; i < ii; i++) {
 if (isUndefined(value)) {
 value = fn(this[i], arg1, arg2, arg3);
 if (isDefined(value)) {
 // any function which returns a value needs to be wrapped
 value = jqLite(value);
 // bind legacy bind/unbind to on/off
 JQLite.prototype.bind = JQLite.prototype.on;
 JQLite.prototype.unbind = JQLite.prototype.off;
 });
+// Provider for private $$jqLite service
+function $$jqLiteProvider() {
+this.$get = function $$jqLite() {
+return extend(JQLite, {
+hasClass: function(node, classes) {
+if (node.attr) node = node[0];
+return jqLiteHasClass(node, classes);
+},
+addClass: function(node, classes) {
+if (node.attr) node = node[0];
+return jqLiteAddClass(node, classes);
+},
+removeClass: function(node, classes) {
+if (node.attr) node = node[0];
+return jqLiteRemoveClass(node, classes);
+}
+});
+};
+}
 /**
 * Computes a hash of an 'obj'.
 * Hash of a:
 *  string is string
 *
 * @description
 * Creates an injector object 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.
+*     {@link angular.module}. The `ng` module must be explicitly added.
-* @returns {function()} Injector object. See {@link auto.$injector $injector}.
+* @param {boolean=} [strictDi=false] Whether the injector should be in strict mode, which
+*     disallows argument name annotation inference.
+* @returns {injector} Injector object. See {@link auto.$injector $injector}.
 *
 * @example
 * Typical usage
 * ```js
 *   // create an injector
 * ```
 *
 * ## 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
+* can then be parsed and the function arguments can be extracted. This method of discovering
-* minification, and obfuscation tools since these tools change the argument names.
+* annotations is disallowed when the injector is in strict mode.
+* *NOTE:* This does not work with minification, and obfuscation tools since these tools change the
+* argument names.
 *
 * ## `$inject` Annotation
 * By adding an `$inject` property onto a function the injection parameters can be specified.
 *
 * ## Inline
 *
 * @description
 * Return an instance of the service.
 *
 * @param {string} name The name of the instance to retrieve.
+* @param {string} caller An optional string to provide the origin of the function call for error messages.
 * @return {*} The instance.
 */
 /**
 * @ngdoc method
 *   }
 *
 *   // Then
 *   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
 * ```
+*
+* You can disallow this method by using strict injection mode.
 *
 * This method does not work with code minification / obfuscation. For this reason the following
 * annotation strategies are supported.
 *
 * # The `$inject` property
 *    ).toEqual(['$compile', '$rootScope']);
 * ```
 *
 * @param {Function|Array.<string|Function>} fn Function for which dependent service names need to
 * be retrieved as described above.
+*
+* @param {boolean=} [strictDi=false] Disallow argument name annotation inference.
 *
 * @returns {Array.<string>} The names of the services which the function requires.
 */
 constant: supportObject(constant),
 decorator: decorator
 }
 },
 providerInjector = (providerCache.$injector =
-createInternalInjector(providerCache, function() {
+createInternalInjector(providerCache, function(serviceName, caller) {
+if (angular.isString(caller)) {
+path.push(caller);
+}
 throw $injectorMinErr('unpr', "Unknown provider: {0}", path.join(' <- '));
 })),
 instanceCache = {},
 instanceInjector = (instanceCache.$injector =
-createInternalInjector(instanceCache, function(servicename) {
+createInternalInjector(instanceCache, function(serviceName, caller) {
-var provider = providerInjector.get(servicename + providerSuffix);
+var provider = providerInjector.get(serviceName + providerSuffix, caller);
-return instanceInjector.invoke(provider.$get, provider, undefined, servicename);
+return instanceInjector.invoke(provider.$get, provider, undefined, serviceName);
 }));
 forEach(loadModules(modulesToLoad), function(fn) { instanceInjector.invoke(fn || noop); });
 return providerCache[name + providerSuffix] = provider_;
 }
 function enforceReturnValue(name, factory) {
 return function enforcedReturnValue() {
-var result = instanceInjector.invoke(factory);
+var result = instanceInjector.invoke(factory, this);
 if (isUndefined(result)) {
 throw $injectorMinErr('undef', "Provider '{0}' must return a value from $get factory method.", name);
 }
 return result;
 };
 }
 ////////////////////////////////////
 // Module Loading
 ////////////////////////////////////
-function loadModules(modulesToLoad){
+function loadModules(modulesToLoad) {
 var runBlocks = [], moduleFn;
 forEach(modulesToLoad, function(module) {
 if (loadedModules.get(module)) return;
 loadedModules.put(module, true);
 function runInvokeQueue(queue) {
 var i, ii;
-for(i = 0, ii = queue.length; i < ii; i++) {
+for (i = 0, ii = queue.length; i < ii; i++) {
 var invokeArgs = queue[i],
 provider = providerInjector.get(invokeArgs[0]);
 provider[invokeArgs[1]].apply(provider, invokeArgs[2]);
 }
 // internal Injector
 ////////////////////////////////////
 function createInternalInjector(cache, factory) {
-function getService(serviceName) {
+function getService(serviceName, caller) {
 if (cache.hasOwnProperty(serviceName)) {
 if (cache[serviceName] === INSTANTIATING) {
 throw $injectorMinErr('cdep', 'Circular dependency found: {0}',
 serviceName + ' <- ' + path.join(' <- '));
 }
 return cache[serviceName];
 } else {
 try {
 path.unshift(serviceName);
 cache[serviceName] = INSTANTIATING;
-return cache[serviceName] = factory(serviceName);
+return cache[serviceName] = factory(serviceName, caller);
 } catch (err) {
 if (cache[serviceName] === INSTANTIATING) {
 delete cache[serviceName];
 }
 throw err;
 var args = [],
 $inject = annotate(fn, strictDi, serviceName),
 length, i,
 key;
-for(i = 0, length = $inject.length; i < length; i++) {
+for (i = 0, length = $inject.length; i < length; i++) {
 key = $inject[i];
 if (typeof key !== 'string') {
 throw $injectorMinErr('itkn',
 'Incorrect injection token! Expected service name as string, got {0}', key);
 }
 args.push(
 locals && locals.hasOwnProperty(key)
 ? locals[key]
-: getService(key)
+: getService(key, serviceName)
 );
 }
 if (isArray(fn)) {
 fn = fn[length];
 }
 // #5388
 return fn.apply(self, args);
 }
 function instantiate(Type, locals, serviceName) {
-var Constructor = function() {},
-instance, returnedValue;
 // Check if Type is annotated and use just the given function at n-1 as parameter
 // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
-Constructor.prototype = (isArray(Type) ? Type[Type.length - 1] : Type).prototype;
+// Object creation: http://jsperf.com/create-constructor/2
-instance = new Constructor();
+var instance = Object.create((isArray(Type) ? Type[Type.length - 1] : Type).prototype);
-returnedValue = invoke(Type, instance, locals, serviceName);
+var returnedValue = invoke(Type, instance, locals, serviceName);
 return isObject(returnedValue) || isFunction(returnedValue) ? returnedValue : instance;
 }
 return {
 }
 createInjector.$$annotate = annotate;
 /**
-* @ngdoc service
+* @ngdoc provider
-* @name $anchorScroll
+* @name $anchorScrollProvider
-* @kind function
-* @requires $window
-* @requires $location
-* @requires $rootScope
 *
 * @description
-* When called, it checks current value of `$location.hash()` and scrolls to the related element,
+* Use `$anchorScrollProvider` to disable automatic scrolling whenever
-* according to rules specified in
+* {@link ng.$location#hash $location.hash()} changes.
-* [Html5 spec](http://dev.w3.org/html5/spec/Overview.html#the-indicated-part-of-the-document).
-*
-* It also watches the `$location.hash()` and scrolls whenever it changes to match any anchor.
-* This can be disabled by calling `$anchorScrollProvider.disableAutoScrolling()`.
-*
-* @example
-<example module="anchorScrollExample">
-<file name="index.html">
-<div id="scrollArea" ng-controller="ScrollController">
-<a ng-click="gotoBottom()">Go to bottom</a>
-<a id="bottom"></a> You're at the bottom!
-</div>
-</file>
-<file name="script.js">
-angular.module('anchorScrollExample', [])
-.controller('ScrollController', ['$scope', '$location', '$anchorScroll',
-function ($scope, $location, $anchorScroll) {
-$scope.gotoBottom = function() {
-// set the location.hash to the id of
-// the element you wish to scroll to.
-$location.hash('bottom');
-// call $anchorScroll()
-$anchorScroll();
-};
-}]);
-</file>
-<file name="style.css">
-#scrollArea {
-height: 350px;
-overflow: auto;
-}
-#bottom {
-display: block;
-margin-top: 2000px;
-}
-</file>
-</example>
 */
 function $AnchorScrollProvider() {
 var autoScrollingEnabled = true;
+/**
+* @ngdoc method
+* @name $anchorScrollProvider#disableAutoScrolling
+*
+* @description
+* By default, {@link ng.$anchorScroll $anchorScroll()} will automatically detect changes to
+* {@link ng.$location#hash $location.hash()} and scroll to the element matching the new hash.<br />
+* Use this method to disable automatic scrolling.
+*
+* If automatic scrolling is disabled, one must explicitly call
+* {@link ng.$anchorScroll $anchorScroll()} in order to scroll to the element related to the
+* current hash.
+*/
 this.disableAutoScrolling = function() {
 autoScrollingEnabled = false;
 };
+/**
+* @ngdoc service
+* @name $anchorScroll
+* @kind function
+* @requires $window
+* @requires $location
+* @requires $rootScope
+*
+* @description
+* When called, it checks the current value of {@link ng.$location#hash $location.hash()} and
+* scrolls to the related element, according to the rules specified in the
+* [Html5 spec](http://dev.w3.org/html5/spec/Overview.html#the-indicated-part-of-the-document).
+*
+* It also watches the {@link ng.$location#hash $location.hash()} and automatically scrolls to
+* match any anchor whenever it changes. This can be disabled by calling
+* {@link ng.$anchorScrollProvider#disableAutoScrolling $anchorScrollProvider.disableAutoScrolling()}.
+*
+* Additionally, you can use its {@link ng.$anchorScroll#yOffset yOffset} property to specify a
+* vertical scroll-offset (either fixed or dynamic).
+*
+* @property {(number|function|jqLite)} yOffset
+* If set, specifies a vertical scroll-offset. This is often useful when there are fixed
+* positioned elements at the top of the page, such as navbars, headers etc.
+*
+* `yOffset` can be specified in various ways:
+* - **number**: A fixed number of pixels to be used as offset.<br /><br />
+* - **function**: A getter function called everytime `$anchorScroll()` is executed. Must return
+*   a number representing the offset (in pixels).<br /><br />
+* - **jqLite**: A jqLite/jQuery element to be used for specifying the offset. The distance from
+*   the top of the page to the element's bottom will be used as offset.<br />
+*   **Note**: The element will be taken into account only as long as its `position` is set to
+*   `fixed`. This option is useful, when dealing with responsive navbars/headers that adjust
+*   their height and/or positioning according to the viewport's size.
+*
+* <br />
+* <div class="alert alert-warning">
+* In order for `yOffset` to work properly, scrolling should take place on the document's root and
+* not some child element.
+* </div>
+*
+* @example
+<example module="anchorScrollExample">
+<file name="index.html">
+<div id="scrollArea" ng-controller="ScrollController">
+<a ng-click="gotoBottom()">Go to bottom</a>
+<a id="bottom"></a> You're at the bottom!
+</div>
+</file>
+<file name="script.js">
+angular.module('anchorScrollExample', [])
+.controller('ScrollController', ['$scope', '$location', '$anchorScroll',
+function ($scope, $location, $anchorScroll) {
+$scope.gotoBottom = function() {
+// set the location.hash to the id of
+// the element you wish to scroll to.
+$location.hash('bottom');
+// call $anchorScroll()
+$anchorScroll();
+};
+}]);
+</file>
+<file name="style.css">
+#scrollArea {
+height: 280px;
+overflow: auto;
+}
+#bottom {
+display: block;
+margin-top: 2000px;
+}
+</file>
+</example>
+*
+* <hr />
+* The example below illustrates the use of a vertical scroll-offset (specified as a fixed value).
+* See {@link ng.$anchorScroll#yOffset $anchorScroll.yOffset} for more details.
+*
+* @example
+<example module="anchorScrollOffsetExample">
+<file name="index.html">
+<div class="fixed-header" ng-controller="headerCtrl">
+<a href="" ng-click="gotoAnchor(x)" ng-repeat="x in [1,2,3,4,5]">
+Go to anchor {{x}}
+</a>
+</div>
+<div id="anchor{{x}}" class="anchor" ng-repeat="x in [1,2,3,4,5]">
+Anchor {{x}} of 5
+</div>
+</file>
+<file name="script.js">
+angular.module('anchorScrollOffsetExample', [])
+.run(['$anchorScroll', function($anchorScroll) {
+$anchorScroll.yOffset = 50;   // always scroll by 50 extra pixels
+}])
+.controller('headerCtrl', ['$anchorScroll', '$location', '$scope',
+function ($anchorScroll, $location, $scope) {
+$scope.gotoAnchor = function(x) {
+var newHash = 'anchor' + x;
+if ($location.hash() !== newHash) {
+// set the $location.hash to `newHash` and
+// $anchorScroll will automatically scroll to it
+$location.hash('anchor' + x);
+} else {
+// call $anchorScroll() explicitly,
+// since $location.hash hasn't changed
+$anchorScroll();
+}
+};
+}
+]);
+</file>
+<file name="style.css">
+body {
+padding-top: 50px;
+}
+.anchor {
+border: 2px dashed DarkOrchid;
+padding: 10px 10px 200px 10px;
+}
+.fixed-header {
+background-color: rgba(0, 0, 0, 0.2);
+height: 50px;
+position: fixed;
+top: 0; left: 0; right: 0;
+}
+.fixed-header > a {
+display: inline-block;
+margin: 5px 15px;
+}
+</file>
+</example>
+*/
 this.$get = ['$window', '$location', '$rootScope', function($window, $location, $rootScope) {
 var document = $window.document;
-// helper function to get first anchor from a NodeList
+// Helper function to get first anchor from a NodeList
-// can't use filter.filter, as it accepts only instances of Array
+// (using `Array#some()` instead of `angular#forEach()` since it's more performant
-// and IE can't convert NodeList to an array using [].slice
+//  and working in all supported browsers.)
-// TODO(vojta): use filter if we change it to accept lists as well
 function getFirstAnchor(list) {
 var result = null;
-forEach(list, function(element) {
+Array.prototype.some.call(list, function(element) {
-if (!result && nodeName_(element) === 'a') result = element;
+if (nodeName_(element) === 'a') {
+result = element;
+return true;
+}
 });
 return result;
 }
+function getYOffset() {
+var offset = scroll.yOffset;
+if (isFunction(offset)) {
+offset = offset();
+} else if (isElement(offset)) {
+var elem = offset[0];
+var style = $window.getComputedStyle(elem);
+if (style.position !== 'fixed') {
+offset = 0;
+} else {
+offset = elem.getBoundingClientRect().bottom;
+}
+} else if (!isNumber(offset)) {
+offset = 0;
+}
+return offset;
+}
+function scrollTo(elem) {
+if (elem) {
+elem.scrollIntoView();
+var offset = getYOffset();
+if (offset) {
+// `offset` is the number of pixels we should scroll UP in order to align `elem` properly.
+// This is true ONLY if the call to `elem.scrollIntoView()` initially aligns `elem` at the
+// top of the viewport.
+//
+// IF the number of pixels from the top of `elem` to the end of the page's content is less
+// than the height of the viewport, then `elem.scrollIntoView()` will align the `elem` some
+// way down the page.
+//
+// This is often the case for elements near the bottom of the page.
+//
+// In such cases we do not need to scroll the whole `offset` up, just the difference between
+// the top of the element and the offset, which is enough to align the top of `elem` at the
+// desired position.
+var elemTop = elem.getBoundingClientRect().top;
+$window.scrollBy(0, elemTop - offset);
+}
+} else {
+$window.scrollTo(0, 0);
+}
+}
 function scroll() {
 var hash = $location.hash(), elm;
 // empty hash, scroll to the top of the page
-if (!hash) $window.scrollTo(0, 0);
+if (!hash) scrollTo(null);
 // element with given id
-else if ((elm = document.getElementById(hash))) elm.scrollIntoView();
+else if ((elm = document.getElementById(hash))) scrollTo(elm);
 // first anchor with given name :-D
-else if ((elm = getFirstAnchor(document.getElementsByName(hash)))) elm.scrollIntoView();
+else if ((elm = getFirstAnchor(document.getElementsByName(hash)))) scrollTo(elm);
 // no element and hash == 'top', scroll to the top of the page
-else if (hash === 'top') $window.scrollTo(0, 0);
+else if (hash === 'top') scrollTo(null);
 }
 // 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(newVal, oldVal) {
 // skip the initial scroll if $location.hash is empty
 if (newVal === oldVal && newVal === '') return;
-$rootScope.$evalAsync(scroll);
+jqLiteDocumentLoaded(function() {
+$rootScope.$evalAsync(scroll);
+});
 });
 }
 return scroll;
 }];
 * for low-powered devices as well as applications containing a lot of structural operations.
 * @param {RegExp=} expression The className expression which will be checked against all animations
 * @return {RegExp} The current CSS className expression value. If null then there is no expression value
 */
 this.classNameFilter = function(expression) {
-if(arguments.length === 1) {
+if (arguments.length === 1) {
 this.$$classNameFilter = (expression instanceof RegExp) ? expression : null;
 }
 return this.$$classNameFilter;
 };
 });
 return defer.promise;
 }
-function resolveElementClasses(element, cache) {
+function resolveElementClasses(element, classes) {
 var toAdd = [], toRemove = [];
 var hasClasses = createMap();
 forEach((element.attr('class') || '').split(/\s+/), function(className) {
 hasClasses[className] = true;
 });
-forEach(cache.classes, function(status, className) {
+forEach(classes, function(status, className) {
 var hasClass = hasClasses[className];
 // If the most recent class manipulation (via $animate) was to remove the class, and the
 // element currently has the class, the class is scheduled for removal. Otherwise, if
 // the most recent class manipulation (via $animate) was to add the class, and the
 } else if (status === true && !hasClass) {
 toAdd.push(className);
 }
 });
-return (toAdd.length + toRemove.length) > 0 && [toAdd.length && toAdd, toRemove.length && toRemove];
+return (toAdd.length + toRemove.length) > 0 &&
+[toAdd.length ? toAdd : null, toRemove.length ? toRemove : null];
 }
 function cachedClassManipulation(cache, classes, op) {
 for (var i=0, ii = classes.length; i < ii; ++i) {
 var className = classes[i];
 currentDefer.resolve();
 currentDefer = null;
 });
 }
 return currentDefer.promise;
+}
+function applyStyles(element, options) {
+if (angular.isObject(options)) {
+var styles = extend(options.from || {}, options.to || {});
+element.css(styles);
+}
 }
 /**
 *
 * @ngdoc service
 * To learn more about enabling animation support, click here to visit the {@link ngAnimate
 * ngAnimate module page} as well as the {@link ngAnimate.$animate ngAnimate $animate service
 * page}.
 */
 return {
+animate: function(element, from, to) {
+applyStyles(element, { from: from, to: to });
+return asyncPromise();
+},
 /**
 *
 * @ngdoc method
 * @name $animate#enter
 * @param {DOMElement} element the element which will be inserted into the DOM
 * @param {DOMElement} parent the parent element which will append the element as
 *   a child (if the after element is not present)
 * @param {DOMElement} after the sibling element which will append the element
 *   after itself
+* @param {object=} options an optional collection of styles that will be applied to the element.
 * @return {Promise} the animation callback promise
 */
-enter : function(element, parent, after) {
+enter: function(element, parent, after, options) {
+applyStyles(element, options);
 after ? after.after(element)
 : parent.prepend(element);
 return asyncPromise();
 },
 * @name $animate#leave
 * @kind function
 * @description Removes the element from the DOM. When the function is called a promise
 * is returned that will be resolved at a later time.
 * @param {DOMElement} element the element which will be removed from the DOM
+* @param {object=} options an optional collection of options that will be applied to the element.
 * @return {Promise} the animation callback promise
 */
-leave : function(element) {
+leave: function(element, options) {
 element.remove();
 return asyncPromise();
 },
 /**
 *   DOM
 * @param {DOMElement} parent the parent element where the element will be
 *   inserted into (if the after element is not present)
 * @param {DOMElement} after the sibling element where the element will be
 *   positioned next to
+* @param {object=} options an optional collection of options that will be applied to the element.
 * @return {Promise} the animation callback promise
 */
-move : function(element, parent, after) {
+move: function(element, parent, after, options) {
 // Do not remove element before insert. Removing will cause data associated with the
 // element to be dropped. Insert will implicitly do the remove.
-return this.enter(element, parent, after);
+return this.enter(element, parent, after, options);
 },
 /**
 *
 * @ngdoc method
 * @description Adds the provided className CSS class value to the provided element.
 * When the function is called a promise is returned that will be resolved at a later time.
 * @param {DOMElement} element the element which will have the className value
 *   added to it
 * @param {string} className the CSS class which will be added to the element
+* @param {object=} options an optional collection of options that will be applied to the element.
 * @return {Promise} the animation callback promise
 */
-addClass : function(element, className) {
+addClass: function(element, className, options) {
-return this.setClass(element, className, []);
+return this.setClass(element, className, [], options);
 },
-$$addClassImmediately : function addClassImmediately(element, className) {
+$$addClassImmediately: function(element, className, options) {
 element = jqLite(element);
 className = !isString(className)
 ? (isArray(className) ? className.join(' ') : '')
 : className;
-forEach(element, function (element) {
+forEach(element, function(element) {
 jqLiteAddClass(element, className);
 });
+applyStyles(element, options);
+return asyncPromise();
 },
 /**
 *
 * @ngdoc method
 * @description Removes the provided className CSS class value from the provided element.
 * When the function is called a promise is returned that will be resolved at a later time.
 * @param {DOMElement} element the element which will have the className value
 *   removed from it
 * @param {string} className the CSS class which will be removed from the element
+* @param {object=} options an optional collection of options that will be applied to the element.
 * @return {Promise} the animation callback promise
 */
-removeClass : function(element, className) {
+removeClass: function(element, className, options) {
-return this.setClass(element, [], className);
+return this.setClass(element, [], className, options);
 },
-$$removeClassImmediately : function removeClassImmediately(element, className) {
+$$removeClassImmediately: function(element, className, options) {
 element = jqLite(element);
 className = !isString(className)
 ? (isArray(className) ? className.join(' ') : '')
 : className;
-forEach(element, function (element) {
+forEach(element, function(element) {
 jqLiteRemoveClass(element, className);
 });
+applyStyles(element, options);
 return asyncPromise();
 },
 /**
 *
 * When the function is called a promise is returned that will be resolved at a later time.
 * @param {DOMElement} element the element which will have its CSS classes changed
 *   removed from it
 * @param {string} add the CSS classes which will be added to the element
 * @param {string} remove the CSS class which will be removed from the element
+* @param {object=} options an optional collection of options that will be applied to the element.
 * @return {Promise} the animation callback promise
 */
-setClass : function(element, add, remove, runSynchronously) {
+setClass: function(element, add, remove, options) {
 var self = this;
 var STORAGE_KEY = '$$animateClasses';
 var createdCache = false;
 element = jqLite(element);
-if (runSynchronously) {
-// TODO(@caitp/@matsko): Remove undocumented `runSynchronously` parameter, and always
-// perform DOM manipulation asynchronously or in postDigest.
-self.$$addClassImmediately(element, add);
-self.$$removeClassImmediately(element, remove);
-return asyncPromise();
-}
 var cache = element.data(STORAGE_KEY);
 if (!cache) {
 cache = {
-classes: {}
+classes: {},
+options: options
 };
 createdCache = true;
+} else if (options && cache.options) {
+cache.options = angular.extend(cache.options || {}, options);
 }
 var classes = cache.classes;
 add = isArray(add) ? add : add.split(' ');
 if (createdCache) {
 cache.promise = runAnimationPostDigest(function(done) {
 var cache = element.data(STORAGE_KEY);
 element.removeData(STORAGE_KEY);
-var classes = cache && resolveElementClasses(element, cache);
+// in the event that the element is removed before postDigest
+// is run then the cache will be undefined and there will be
-if (classes) {
+// no need anymore to add or remove and of the element classes
-if (classes[0]) self.$$addClassImmediately(element, classes[0]);
+if (cache) {
-if (classes[1]) self.$$removeClassImmediately(element, classes[1]);
+var classes = resolveElementClasses(element, cache.classes);
+if (classes) {
+self.$$setClassImmediately(element, classes[0], classes[1], cache.options);
+}
 }
 done();
 });
 element.data(STORAGE_KEY, cache);
 }
 return cache.promise;
 },
-enabled : noop,
+$$setClassImmediately: function(element, add, remove, options) {
-cancel : noop
+add && this.$$addClassImmediately(element, add);
+remove && this.$$removeClassImmediately(element, remove);
+applyStyles(element, options);
+return asyncPromise();
+},
+enabled: noop,
+cancel: noop
 };
 }];
 }];
-function $$AsyncCallbackProvider(){
+function $$AsyncCallbackProvider() {
 this.$get = ['$$rAF', '$timeout', function($$rAF, $timeout) {
 return $$rAF.supported
 ? function(fn) { return $$rAF(fn); }
 : function(fn) {
 return $timeout(fn, 0, false);
 * 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 window.console or an object with the same interface.
-* @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],
 try {
 fn.apply(null, sliceArgs(arguments, 1));
 } finally {
 outstandingRequestCount--;
 if (outstandingRequestCount === 0) {
-while(outstandingRequestCallbacks.length) {
+while (outstandingRequestCallbacks.length) {
 try {
 outstandingRequestCallbacks.pop()();
 } catch (e) {
 $log.error(e);
 }
 }
 }
 }
+}
+function getHash(url) {
+var index = url.indexOf('#');
+return index === -1 ? '' : url.substr(index + 1);
 }
 /**
 * @private
 * Note: this method is used only by scenario runner
 */
 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(); });
+forEach(pollFns, function(pollFn) { pollFn(); });
 if (outstandingRequestCount === 0) {
 callback();
 } else {
 outstandingRequestCallbacks.push(callback);
 * 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(); });
+forEach(pollFns, function(pollFn) { pollFn(); });
 pollTimeout = setTimeout(check, interval);
 })();
 }
 //////////////////////////////////////////////////////////////
 // URL API
 //////////////////////////////////////////////////////////////
-var lastBrowserUrl = location.href,
+var cachedState, lastHistoryState,
-lastHistoryState = history.state,
+lastBrowserUrl = location.href,
 baseElement = document.find('base'),
 reloadLocation = null;
+cacheState();
+lastHistoryState = cachedState;
 /**
 * @name $browser#url
 *
 * @description
 if (location !== window.location) location = window.location;
 if (history !== window.history) history = window.history;
 // setter
 if (url) {
+var sameState = lastHistoryState === state;
 // Don't change anything if previous and current URLs and states match. This also prevents
 // IE<10 from getting into redirect loop when in LocationHashbangInHtml5Url mode.
 // See https://github.com/angular/angular.js/commit/ffb2701
-if (lastBrowserUrl === url && (!$sniffer.history || history.state === state)) {
+if (lastBrowserUrl === url && (!$sniffer.history || sameState)) {
-return;
+return self;
 }
 var sameBase = lastBrowserUrl && stripHash(lastBrowserUrl) === stripHash(url);
 lastBrowserUrl = url;
+lastHistoryState = state;
 // Don't use history API if only the hash changed
 // due to a bug in IE10/IE11 which leads
 // to not firing a `hashchange` nor `popstate` event
 // in some cases (see #9143).
-if ($sniffer.history && (!sameBase || history.state !== state)) {
+if ($sniffer.history && (!sameBase || !sameState)) {
 history[replace ? 'replaceState' : 'pushState'](state, '', url);
-lastHistoryState = history.state;
+cacheState();
+// Do the assignment again so that those two variables are referentially identical.
+lastHistoryState = cachedState;
 } else {
 if (!sameBase) {
 reloadLocation = url;
 }
 if (replace) {
 location.replace(url);
+} else if (!sameBase) {
+location.href = url;
 } else {
-location.href = url;
+location.hash = getHash(url);
 }
 }
 return self;
 // getter
 } else {
 * Return history.state or null if history.state is undefined.
 *
 * @returns {object} state
 */
 self.state = function() {
-return isUndefined(history.state) ? null : history.state;
+return cachedState;
 };
 var urlChangeListeners = [],
 urlChangeInit = false;
+function cacheStateAndFireUrlChange() {
+cacheState();
+fireUrlChange();
+}
+// This variable should be used *only* inside the cacheState function.
+var lastCachedState = null;
+function cacheState() {
+// This should be the only place in $browser where `history.state` is read.
+cachedState = window.history.state;
+cachedState = isUndefined(cachedState) ? null : cachedState;
+// Prevent callbacks fo fire twice if both hashchange & popstate were fired.
+if (equals(cachedState, lastCachedState)) {
+cachedState = lastCachedState;
+}
+lastCachedState = cachedState;
+}
 function fireUrlChange() {
-if (lastBrowserUrl === self.url() && lastHistoryState === history.state) {
+if (lastBrowserUrl === self.url() && lastHistoryState === cachedState) {
 return;
 }
 lastBrowserUrl = self.url();
+lastHistoryState = cachedState;
 forEach(urlChangeListeners, function(listener) {
-listener(self.url(), history.state);
+listener(self.url(), cachedState);
 });
 }
 /**
 * @name $browser#onUrlChange
 // 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).on('popstate', fireUrlChange);
+if ($sniffer.history) jqLite(window).on('popstate', cacheStateAndFireUrlChange);
 // hashchange event
-jqLite(window).on('hashchange', fireUrlChange);
+jqLite(window).on('hashchange', cacheStateAndFireUrlChange);
 urlChangeInit = true;
 }
 urlChangeListeners.push(callback);
 // Cookies API
 //////////////////////////////////////////////////////////////
 var lastCookies = {};
 var lastCookieString = '';
 var cookiePath = self.baseHref();
+function safeDecodeURIComponent(str) {
+try {
+return decodeURIComponent(str);
+} catch (e) {
+return str;
+}
+}
 /**
 * @name $browser#cookies
 *
 * @param {string=} name Cookie name
 // 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 +
+$log.warn("Cookie '" + name +
-"' possibly not set or overflowed because it was too large ("+
+"' possibly not set or overflowed because it was too large (" +
 cookieLength + " > 4096 bytes)!");
 }
 }
 }
 } else {
 for (i = 0; i < cookieArray.length; i++) {
 cookie = cookieArray[i];
 index = cookie.indexOf('=');
 if (index > 0) { //ignore nameless cookies
-name = decodeURIComponent(cookie.substring(0, index));
+name = safeDecodeURIComponent(cookie.substring(0, index));
 // the first value that is seen for a cookie is the most
 // specific one.  values for the same cookie name that
 // follow are for less specific paths.
 if (lastCookies[name] === undefined) {
-lastCookies[name] = decodeURIComponent(cookie.substring(index + 1));
+lastCookies[name] = safeDecodeURIComponent(cookie.substring(index + 1));
 }
 }
 }
 }
 return lastCookies;
 return false;
 };
 }
-function $BrowserProvider(){
+function $BrowserProvider() {
 this.$get = ['$window', '$log', '$sniffer', '$document',
-function( $window,   $log,   $sniffer,   $document){
+function($window, $log, $sniffer, $document) {
 return new Browser($window, $document, $log, $sniffer);
 }];
 }
 /**
 *     <p>This is the content of the template</p>
 *   </script>
 * ```
 *
 * **Note:** the `script` tag containing the template does not need to be included in the `head` of
-* the document, but it must be below the `ng-app` definition.
+* the document, but it must be a descendent of the {@link ng.$rootElement $rootElement} (IE,
+* element with ng-app attribute), otherwise the template will be ignored.
 *
 * Adding via the $templateCache service:
 *
 * ```js
 * var myApp = angular.module('myApp', []);
 *       template: '<div></div>', // or // function(tElement, tAttrs) { ... },
 *       // or
 *       // templateUrl: 'directive.html', // or // function(tElement, tAttrs) { ... },
 *       transclude: false,
 *       restrict: 'A',
+*       templateNamespace: 'html',
 *       scope: false,
 *       controller: function($scope, $element, $attrs, $transclude, otherInjectables) { ... },
 *       controllerAs: 'stringAlias',
 *       require: 'siblingDirectiveName', // or // ['^parentDirectiveName', '?optionalDirectiveName', '?^optionalParent'],
 *       compile: function compile(tElement, tAttrs, transclude) {
 * compiler}. The attributes are:
 *
 * #### `multiElement`
 * When this property is set to true, the HTML compiler will collect DOM nodes between
 * nodes with the attributes `directive-name-start` and `directive-name-end`, and group them
-* together as the directive elements. It is recomended that this feature be used on directives
+* together as the directive elements. It is recommended that this feature be used on directives
-* which are not strictly behavioural (such as {@link api/ng.directive:ngClick ngClick}), and which
+* which are not strictly behavioural (such as {@link ngClick}), and which
-* do not manipulate or replace child nodes (such as {@link api/ng.directive:ngInclude ngInclude}).
+* do not manipulate or replace child nodes (such as {@link ngInclude}).
 *
 * #### `priority`
 * When there are multiple directives defined on a single DOM element, sometimes it
 * is necessary to specify the order in which the directives are applied. The `priority` is used
 * to sort the directives before their `compile` functions get called. Priority is defined as a
 * of directives with the same priority is undefined. The default priority is `0`.
 *
 * #### `terminal`
 * If set to true then the current `priority` will be the last set of directives
 * which will execute (any directives at the current priority will still execute
-* as the order of execution on same `priority` is undefined).
+* as the order of execution on same `priority` is undefined). Note that expressions
+* and other directives used in the directive's template will also be excluded from execution.
 *
 * #### `scope`
 * **If set to `true`,** then a new scope will be created for this directive. If multiple directives on the
 * same element request a new scope, only one new scope is created. The new scope rule does not
 * apply for the root of the template since the root of the template always gets a new scope.
 *   Given `<widget my-attr="parentModel">` and widget definition of
 *   `scope: { localModel:'=myAttr' }`, then widget scope property `localModel` will reflect the
 *   value of `parentModel` on the parent scope. Any changes to `parentModel` will be reflected
 *   in `localModel` and any changes in `localModel` will reflect in `parentModel`. If the parent
 *   scope property doesn't exist, it will throw a NON_ASSIGNABLE_MODEL_EXPRESSION exception. You
-*   can avoid this behavior using `=?` or `=?attr` in order to flag the property as optional.
+*   can avoid this behavior using `=?` or `=?attr` in order to flag the property as optional. If
+*   you want to shallow watch for changes (i.e. $watchCollection instead of $watch) you can use
+*   `=*` or `=*attr` (`=*?` or `=*?attr` if the property is optional).
 *
 * * `&` or `&attr` - provides a way to execute an expression in the context of the parent scope.
 *   If no `attr` name is specified then the attribute name is assumed to be the same as the
 *   local name. Given `<widget my-attr="count = count + value">` and widget definition of
 *   `scope: { localFn:'&myAttr' }`, then isolate scope property `localFn` will point to
 *   For example, if the expression is `increment(amount)` then we can specify the amount value
 *   by calling the `localFn` as `localFn({amount: 22})`.
 *
 *
 * #### `bindToController`
-* When an isolate scope is used for a component (see above), and `controllerAs` is used, `bindToController` will
+* When an isolate scope is used for a component (see above), and `controllerAs` is used, `bindToController: true` will
 * allow a component to have its properties bound to the controller, rather than to scope. When the controller
 * is instantiated, the initial values of the isolate scope bindings are already available.
 *
 * #### `controller`
 * Controller constructor function. The controller is instantiated before the
 * Template loading is asynchronous even if the template has been preloaded into the {@link $templateCache}
 *
 * You can specify `templateUrl` as a string representing the URL or as a function which takes two
 * arguments `tElement` and `tAttrs` (described in the `compile` function api below) and returns
 * a string value representing the url.  In either case, the template URL is passed through {@link
-* api/ng.$sce#getTrustedResourceUrl $sce.getTrustedResourceUrl}.
+* $sce#getTrustedResourceUrl $sce.getTrustedResourceUrl}.
 *
 *
 * #### `replace` ([*DEPRECATED*!], will be removed in next major release - i.e. v2.0)
 * specify what the template should replace. Defaults to `false`.
 *
 * * `true` - the template will replace the directive's element.
 * * `false` - the template will replace the contents of the directive's element.
 *
 * The replacement process migrates all of the attributes / classes from the old element to the new
-* one. See the {@link guide/directive#creating-custom-directives_creating-directives_template-expanding-directive
+* one. See the {@link guide/directive#template-expanding-directive
 * Directives Guide} for an example.
 *
 * There are very few scenarios where element replacement is required for the application function,
 * the main one being reusable custom components that are used within SVG contexts
 * (because SVG doesn't work with custom elements in the DOM tree).
 *
 * If you want to manually control the insertion and removal of the transcluded content in your directive
 * then you must use this transclude function. When you call a transclude function it returns a a jqLite/JQuery
 * object that contains the compiled DOM, which is linked to the correct transclusion scope.
 *
-* When you call a transclusion function you can pass in a **clone attach function**. This function is accepts
+* When you call a transclusion function you can pass in a **clone attach function**. This function accepts
 * two parameters, `function(clone, scope) { ... }`, where the `clone` is a fresh compiled copy of your transcluded
 * content and the `scope` is the newly created transclusion scope, to which the clone is bound.
 *
 * <div class="alert alert-info">
 * **Best Practice**: Always provide a `cloneFn` (clone attach function) when you call a translude function
 </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 {function(angular.Scope, cloneAttachFn=)} transclude function available to directives - DEPRECATED.
+*
+* <div class="alert alert-error">
+* **Note:** Passing a `transclude` function to the $compile function is deprecated, as it
+*   e.g. will not use the right outer scope. Please pass the transclude function as a
+*   `parentBoundTranscludeFn` to the link function instead.
+* </div>
+*
 * @param {number} maxPriority only apply directives lower than given priority (Only effects the
 *                 root element(s), not their children)
-* @returns {function(scope, cloneAttachFn=)} a link function which is used to bind template
+* @returns {function(scope, cloneAttachFn=, options=)} 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.
+*
+*  * `options` - An optional object hash with linking options. If `options` is provided, then the following
+*  keys may be used to control linking behavior:
+*
+*      * `parentBoundTranscludeFn` - the transclude function made available to
+*        directives; if given, it will be passed through to the link functions of
+*        directives found in `element` during compilation.
+*      * `transcludeControllers` - an object hash with keys that map controller names
+*        to controller instances; if given, it will make the controllers
+*        available to directives.
+*      * `futureParentElement` - defines the parent to which the `cloneAttachFn` will add
+*        the cloned elements; only needed for transcludes that are allowed to contain non html
+*        elements (e.g. SVG elements). See also the directive.controller property.
 *
 * 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
 */
 $CompileProvider.$inject = ['$provide', '$$sanitizeUriProvider'];
 function $CompileProvider($provide, $$sanitizeUriProvider) {
 var hasDirectives = {},
 Suffix = 'Directive',
-COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\d\w_\-]+)\s+(.*)$/,
+COMMENT_DIRECTIVE_REGEXP = /^\s*directive\:\s*([\w\-]+)\s+(.*)$/,
-CLASS_DIRECTIVE_REGEXP = /(([\d\w_\-]+)(?:\:([^;]+))?;?)/,
+CLASS_DIRECTIVE_REGEXP = /(([\w\-]+)(?:\:([^;]+))?;?)/,
 ALL_OR_NOTHING_ATTRS = makeMap('ngSrc,ngSrcset,src,srcset'),
 REQUIRE_PREFIX_REGEXP = /^(?:(\^\^?)?(\?)?(\^\^?)?)?/;
 // Ref: http://developers.whatwg.org/webappapis.html#event-handler-idl-attributes
 // The assumption is that future DOM event attribute names will begin with
 // 'on' and be composed of only English letters.
 var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;
 function parseIsolateBindings(scope, directiveName) {
-var LOCAL_REGEXP = /^\s*([@=&])(\??)\s*(\w*)\s*$/;
+var LOCAL_REGEXP = /^\s*([@&]|=(\*?))(\??)\s*(\w*)\s*$/;
 var bindings = {};
 forEach(scope, function(definition, scopeName) {
 var match = definition.match(LOCAL_REGEXP);
 " Definition: {... {1}: '{2}' ...}",
 directiveName, scopeName, definition);
 }
 bindings[scopeName] = {
-attrName: match[3] || scopeName,
+mode: match[1][0],
-mode: match[1],
+collection: match[2] === '*',
-optional: match[2] === '?'
+optional: match[3] === '?',
+attrName: match[4] || scopeName
 };
 });
 return bindings;
 }
 *
 * @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.
+* The sanitization is a security measure aimed at preventing 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 `aHrefSanitizationWhitelist`
 * 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 is it written into the DOM.
 * binding information and a reference to the current scope on to DOM elements.
 * If enabled, the compiler will add the following to DOM elements that have been bound to the scope
 * * `ng-binding` CSS class
 * * `$binding` data property containing an array of the binding expressions
 *
-* You may want to use this in production for a significant performance boost. See
+* You may want to disable this in production for a significant performance boost. See
 * {@link guide/production#disabling-debug-data Disabling Debug Data} for more.
 *
 * The default value is true.
 */
 var debugInfoEnabled = true;
 this.debugInfoEnabled = function(enabled) {
-if(isDefined(enabled)) {
+if (isDefined(enabled)) {
 debugInfoEnabled = enabled;
 return this;
 }
 return debugInfoEnabled;
 };
 this.$$element = element;
 };
 Attributes.prototype = {
+/**
+* @ngdoc method
+* @name $compile.directive.Attributes#$normalize
+* @kind function
+*
+* @description
+* Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with `x-` or
+* `data-`) to its normalized, camelCase form.
+*
+* Also there is special case for Moz prefix starting with upper case letter.
+*
+* For further information check out the guide on {@link guide/directive#matching-directives Matching Directives}
+*
+* @param {string} name Name to normalize
+*/
 $normalize: directiveNormalize,
 /**
 * @ngdoc method
 * Adds the CSS class value specified by the classVal parameter to the element. If animations
 * are enabled then an animation will be triggered for the class addition.
 *
 * @param {string} classVal The className value that will be added to the element
 */
-$addClass : function(classVal) {
+$addClass: function(classVal) {
-if(classVal && classVal.length > 0) {
+if (classVal && classVal.length > 0) {
 $animate.addClass(this.$$element, classVal);
 }
 },
 /**
 * Removes the CSS class value specified by the classVal parameter from the element. If
 * animations are enabled then an animation will be triggered for the class removal.
 *
 * @param {string} classVal The className value that will be removed from the element
 */
-$removeClass : function(classVal) {
+$removeClass: function(classVal) {
-if(classVal && classVal.length > 0) {
+if (classVal && classVal.length > 0) {
 $animate.removeClass(this.$$element, classVal);
 }
 },
 /**
 * between the new and old CSS class values (specified as newClasses and oldClasses).
 *
 * @param {string} newClasses The current CSS className value
 * @param {string} oldClasses The former CSS className value
 */
-$updateClass : function(newClasses, oldClasses) {
+$updateClass: function(newClasses, oldClasses) {
 var toAdd = tokenDifference(newClasses, oldClasses);
 if (toAdd && toAdd.length) {
 $animate.addClass(this.$$element, toAdd);
 }
 var node = this.$$element[0],
 booleanKey = getBooleanAttrName(node, key),
 aliasedKey = getAliasedAttrName(node, key),
 observer = key,
-normalizedVal,
 nodeName;
 if (booleanKey) {
 this.$$element.prop(key, value);
 attrName = booleanKey;
-} else if(aliasedKey) {
+} else if (aliasedKey) {
 this[aliasedKey] = value;
 observer = aliasedKey;
 }
 this[key] = value;
 // split srcset into tuple of uri and descriptor except for the last item
 var rawUris = trimmedSrcset.split(pattern);
 // for each tuples
 var nbrUrisWith2parts = Math.floor(rawUris.length / 2);
-for (var i=0; i<nbrUrisWith2parts; i++) {
+for (var i = 0; i < nbrUrisWith2parts; i++) {
-var innerIdx = i*2;
+var innerIdx = i * 2;
 // sanitize the uri
-result += $$sanitizeUri(trim( rawUris[innerIdx]), true);
+result += $$sanitizeUri(trim(rawUris[innerIdx]), true);
 // add the descriptor
-result += ( " " + trim(rawUris[innerIdx+1]));
+result += (" " + trim(rawUris[innerIdx + 1]));
 }
 // split the last item into uri and descriptor
-var lastTuple = trim(rawUris[i*2]).split(/\s/);
+var lastTuple = trim(rawUris[i * 2]).split(/\s/);
 // sanitize the last uri
 result += $$sanitizeUri(trim(lastTuple[0]), true);
 // and add the last descriptor if any
-if( lastTuple.length === 2) {
+if (lastTuple.length === 2) {
 result += (" " + trim(lastTuple[1]));
 }
 this[key] = value = result;
 }
 * changes.
 *
 * @param {string} key Normalized key. (ie ngAttribute) .
 * @param {function(interpolatedValue)} fn Function that will be called whenever
 the interpolated value of the attribute changes.
-*        See {@link ng.$compile#attributes $compile} for more info.
+*        See the {@link guide/directive#text-and-attribute-bindings Directives} guide for more info.
 * @returns {function()} Returns a deregistration function for this observer.
 */
 $observe: function(key, fn) {
 var attrs = this,
-$$observers = (attrs.$$observers || (attrs.$$observers = Object.create(null))),
+$$observers = (attrs.$$observers || (attrs.$$observers = createMap())),
 listeners = ($$observers[key] || ($$observers[key] = []));
 listeners.push(fn);
 $rootScope.$evalAsync(function() {
-if (!listeners.$$inter) {
+if (!listeners.$$inter && attrs.hasOwnProperty(key)) {
 // no one registered attribute interpolation function, so lets call it manually
 fn(attrs[key]);
 }
 });
 function safeAddClass($element, className) {
 try {
 $element.addClass(className);
-} catch(e) {
+} catch (e) {
 // ignore, since it means that we are trying to set class on
 // SVG element, where class name is read-only.
 }
 }
 // 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){
+forEach($compileNodes, function(node, index) {
 if (node.nodeType == NODE_TYPE_TEXT && node.nodeValue.match(/\S+/) /* non-empty */ ) {
 $compileNodes[index] = jqLite(node).wrap('<span></span>').parent()[0];
 }
 });
 var compositeLinkFn =
 compileNodes($compileNodes, transcludeFn, $compileNodes,
 maxPriority, ignoreDirective, previousCompileContext);
 compile.$$addScopeClass($compileNodes);
 var namespace = null;
-return function publicLinkFn(scope, cloneConnectFn, transcludeControllers, parentBoundTranscludeFn, futureParentElement){
+return function publicLinkFn(scope, cloneConnectFn, options) {
 assertArg(scope, 'scope');
+options = options || {};
+var parentBoundTranscludeFn = options.parentBoundTranscludeFn,
+transcludeControllers = options.transcludeControllers,
+futureParentElement = options.futureParentElement;
+// When `parentBoundTranscludeFn` is passed, it is a
+// `controllersBoundTransclude` function (it was previously passed
+// as `transclude` to directive.link) so we must unwrap it to get
+// its `boundTranscludeFn`
+if (parentBoundTranscludeFn && parentBoundTranscludeFn.$$boundTransclude) {
+parentBoundTranscludeFn = parentBoundTranscludeFn.$$boundTransclude;
+}
 if (!namespace) {
 namespace = detectNamespaceForChildElements(futureParentElement);
 }
 var $linkNode;
 if (namespace !== 'html') {
 // TODO: Make this detect MathML as well...
 var node = parentElement && parentElement[0];
 if (!node) {
 return 'html';
 } else {
-return nodeName_(node) !== 'foreignobject' && node.toString().match(/SVG/) ? 'svg': 'html';
+return nodeName_(node) !== 'foreignobject' && node.toString().match(/SVG/) ? 'svg' : 'html';
 }
 }
 /**
 * Compile function matches each node in nodeList against the directives. Once all directives
 }
 } else {
 stableNodeList = nodeList;
 }
-for(i = 0, ii = linkFns.length; i < ii;) {
+for (i = 0, ii = linkFns.length; i < ii;) {
 node = stableNodeList[linkFns[i++]];
 nodeLinkFn = linkFns[i++];
 childLinkFn = linkFns[i++];
 if (nodeLinkFn) {
 compile.$$addScopeInfo(jqLite(node), childScope);
 } else {
 childScope = scope;
 }
-if ( nodeLinkFn.transcludeOnThisElement ) {
+if (nodeLinkFn.transcludeOnThisElement) {
 childBoundTranscludeFn = createBoundTranscludeFn(
 scope, nodeLinkFn.transclude, parentBoundTranscludeFn,
 nodeLinkFn.elementTranscludeOnThisElement);
 } else if (!nodeLinkFn.templateOnThisElement && parentBoundTranscludeFn) {
 if (!transcludedScope) {
 transcludedScope = scope.$new(false, containingScope);
 transcludedScope.$$transcluded = true;
 }
-return transcludeFn(transcludedScope, cloneFn, controllers, previousBoundTranscludeFn, futureParentElement);
+return transcludeFn(transcludedScope, cloneFn, {
+parentBoundTranscludeFn: previousBoundTranscludeFn,
+transcludeControllers: controllers,
+futureParentElement: futureParentElement
+});
 };
 return boundTranscludeFn;
 }
 var nodeType = node.nodeType,
 attrsMap = attrs.$attr,
 match,
 className;
-switch(nodeType) {
+switch (nodeType) {
 case NODE_TYPE_ELEMENT: /* Element */
 // use the node name: <directive>
 addDirective(directives,
 directiveNormalize(nodeName_(node)), 'E', maxPriority, ignoreDirective);
 value = trim(attr.value);
 // support ngAttr attribute binding
 ngAttrName = directiveNormalize(name);
 if (isNgAttr = NG_ATTR_BINDING.test(ngAttrName)) {
-name = snake_case(ngAttrName.substr(6), '-');
+name = name.replace(PREFIX_REGEXP, '')
+.substr(8).replace(/_(.)/g, function(match, letter) {
+return letter.toUpperCase();
+});
 }
 var directiveNName = ngAttrName.replace(/(Start|End)$/, '');
 if (directiveIsMultiElement(directiveNName)) {
 if (ngAttrName === directiveNName + 'Start') {
 */
 function groupScan(node, attrStart, attrEnd) {
 var nodes = [];
 var depth = 0;
 if (attrStart && node.hasAttribute && node.hasAttribute(attrStart)) {
-var startNode = node;
 do {
 if (!node) {
 throw $compileMinErr('uterdir',
 "Unterminated attribute, found '{0}' but no matching '{1}' found.",
 attrStart, attrEnd);
 childTranscludeFn = transcludeFn,
 linkFn,
 directiveValue;
 // executes all directives on the current element
-for(var i = 0, ii = directives.length; i < ii; i++) {
+for (var i = 0, ii = directives.length; i < ii; i++) {
 directive = directives[i];
 var attrStart = directive.$$start;
 var attrEnd = directive.$$end;
 // collect multiblock sections
 if (!value && !optional) {
 throw $compileMinErr('ctreq',
 "Controller '{0}', required by directive '{1}', can't be found!",
 require, directiveName);
 }
-return value;
+return value || null;
 } else if (isArray(require)) {
 value = [];
 forEach(require, function(require) {
 value.push(getControllers(directiveName, require, $element, elementControllers));
 });
 if (newIsolateScopeDirective) {
 isolateScope = scope.$new(true);
 }
-transcludeFn = boundTranscludeFn && controllersBoundTransclude;
+if (boundTranscludeFn) {
+// track `boundTranscludeFn` so it can be unwrapped if `transcludeFn`
+// is later passed as `parentBoundTranscludeFn` to `publicLinkFn`
+transcludeFn = controllersBoundTransclude;
+transcludeFn.$$boundTransclude = boundTranscludeFn;
+}
 if (controllerDirectives) {
 // TODO: merge `controllers` and `elementControllers` into single object.
 controllers = {};
 elementControllers = {};
 forEach(controllerDirectives, function(directive) {
 controllers[directive.name] = controllerInstance;
 });
 }
 if (newIsolateScopeDirective) {
-var LOCAL_REGEXP = /^\s*([@=&])(\??)\s*(\w*)\s*$/;
 compile.$$addScopeInfo($element, isolateScope, true, !(templateDirective && (templateDirective === newIsolateScopeDirective ||
 templateDirective === newIsolateScopeDirective.$$originalDirective)));
 compile.$$addScopeClass($element, true);
 var isolateScopeController = controllers && controllers[newIsolateScopeDirective.name];
 case '@':
 attrs.$observe(attrName, function(value) {
 isolateBindingContext[scopeName] = value;
 });
 attrs.$$observers[attrName].$$scope = scope;
-if( attrs[attrName] ) {
+if (attrs[attrName]) {
 // If the attribute has been provided then we trigger an interpolation to ensure
 // the value is there for use in the link fn
 isolateBindingContext[scopeName] = $interpolate(attrs[attrName])(scope);
 }
 break;
 }
 parentGet = $parse(attrs[attrName]);
 if (parentGet.literal) {
 compare = equals;
 } else {
-compare = function(a,b) { return a === b || (a !== a && b !== b); };
+compare = function(a, b) { return a === b || (a !== a && b !== b); };
 }
 parentSet = parentGet.assign || function() {
 // reset the change, or we will throw this exception on every $digest
 lastValue = isolateBindingContext[scopeName] = parentGet(scope);
 throw $compileMinErr('nonassign',
 }
 }
 return lastValue = parentValue;
 };
 parentValueWatch.$stateful = true;
-var unwatch = scope.$watch($parse(attrs[attrName], parentValueWatch), null, parentGet.literal);
+var unwatch;
+if (definition.collection) {
+unwatch = scope.$watchCollection(attrs[attrName], parentValueWatch);
+} else {
+unwatch = scope.$watch($parse(attrs[attrName], parentValueWatch), null, parentGet.literal);
+}
 isolateScope.$on('$destroy', unwatch);
 break;
 case '&':
 parentGet = $parse(attrs[attrName]);
 });
 controllers = null;
 }
 // PRELINKING
-for(i = 0, ii = preLinkFns.length; i < ii; i++) {
+for (i = 0, ii = preLinkFns.length; i < ii; i++) {
 linkFn = preLinkFns[i];
 invokeLinkFn(linkFn,
 linkFn.isolateScope ? isolateScope : scope,
 $element,
 attrs,
 scopeToChild = isolateScope;
 }
 childLinkFn && childLinkFn(scopeToChild, linkNode.childNodes, undefined, boundTranscludeFn);
 // POSTLINKING
-for(i = postLinkFns.length - 1; i >= 0; i--) {
+for (i = postLinkFns.length - 1; i >= 0; i--) {
 linkFn = postLinkFns[i];
 invokeLinkFn(linkFn,
 linkFn.isolateScope ? isolateScope : scope,
 $element,
 attrs,
 function addDirective(tDirectives, name, location, maxPriority, ignoreDirective, startAttrName,
 endAttrName) {
 if (name === ignoreDirective) return null;
 var match = null;
 if (hasDirectives.hasOwnProperty(name)) {
-for(var directive, directives = $injector.get(name + Suffix),
+for (var directive, directives = $injector.get(name + Suffix),
-i = 0, ii = directives.length; i<ii; i++) {
+i = 0, ii = directives.length; i < ii; i++) {
 try {
 directive = directives[i];
-if ( (maxPriority === undefined || maxPriority > directive.priority) &&
+if ((maxPriority === undefined || maxPriority > directive.priority) &&
 directive.restrict.indexOf(location) != -1) {
 if (startAttrName) {
 directive = inherit(directive, {$$start: startAttrName, $$end: endAttrName});
 }
 tDirectives.push(directive);
 match = directive;
 }
-} catch(e) { $exceptionHandler(e); }
+} catch (e) { $exceptionHandler(e); }
 }
 }
 return match;
 }
 * @param {string} name name of the directive to look up.
 * @returns true if directive was registered as multi-element.
 */
 function directiveIsMultiElement(name) {
 if (hasDirectives.hasOwnProperty(name)) {
-for(var directive, directives = $injector.get(name + Suffix),
+for (var directive, directives = $injector.get(name + Suffix),
-i = 0, ii = directives.length; i<ii; i++) {
+i = 0, ii = directives.length; i < ii; i++) {
 directive = directives[i];
 if (directive.multiElement) {
 return true;
 }
 }
 $rootElement[i] = $compileNode[0];
 }
 });
 afterTemplateChildLinkFn = compileNodes($compileNode[0].childNodes, childTranscludeFn);
-while(linkQueue.length) {
+while (linkQueue.length) {
 var scope = linkQueue.shift(),
 beforeTemplateLinkNode = linkQueue.shift(),
 linkRootElement = linkQueue.shift(),
 boundTranscludeFn = linkQueue.shift(),
 linkNode = $compileNode[0];
 return function delayedNodeLinkFn(ignoreChildLinkFn, scope, node, rootElement, boundTranscludeFn) {
 var childBoundTranscludeFn = boundTranscludeFn;
 if (scope.$$destroyed) return;
 if (linkQueue) {
-linkQueue.push(scope);
+linkQueue.push(scope,
-linkQueue.push(node);
+node,
-linkQueue.push(rootElement);
+rootElement,
-linkQueue.push(childBoundTranscludeFn);
+childBoundTranscludeFn);
 } else {
 if (afterTemplateNodeLinkFn.transcludeOnThisElement) {
 childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude, boundTranscludeFn);
 }
 afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, node, rootElement, childBoundTranscludeFn);
 }
 function wrapTemplate(type, template) {
 type = lowercase(type || 'html');
-switch(type) {
+switch (type) {
 case 'svg':
 case 'math':
 var wrapper = document.createElement('div');
-wrapper.innerHTML = '<'+type+'>'+template+'</'+type+'>';
+wrapper.innerHTML = '<' + type + '>' + template + '</' + type + '>';
 return wrapper.childNodes[0].childNodes;
 default:
 return template;
 }
 }
 }
 }
 function addAttrInterpolateDirective(node, directives, value, name, allOrNothing) {
-var interpolateFn = $interpolate(value, true);
+var trustedContext = getTrustedContext(node, name);
+allOrNothing = ALL_OR_NOTHING_ATTRS[name] || allOrNothing;
+var interpolateFn = $interpolate(value, true, trustedContext, allOrNothing);
 // no interpolation found -> ignore
 if (!interpolateFn) return;
 throw $compileMinErr('nodomevents',
 "Interpolations for HTML DOM event attributes are disallowed.  Please use the " +
 "ng- versions (such as ng-click instead of onclick) instead.");
 }
-// If the attribute was removed, then we are done
+// If the attribute has changed since last $interpolate()ed
-if (!attr[name]) {
+var newValue = attr[name];
-return;
+if (newValue !== value) {
+// we need to interpolate again since the attribute value has been updated
+// (e.g. by another directive's compile function)
+// ensure unset/empty values make interpolateFn falsy
+interpolateFn = newValue && $interpolate(newValue, true, trustedContext, allOrNothing);
+value = newValue;
 }
-// we need to interpolate again, in case the attribute value has been updated
-// (e.g. by another directive's compile function)
-interpolateFn = $interpolate(attr[name], true, getTrustedContext(node, name),
-ALL_OR_NOTHING_ATTRS[name] || allOrNothing);
 // if attribute was updated so that there is no interpolation going on we don't want to
 // register any observers
 if (!interpolateFn) return;
 //so that class changes can tap into the animation
 //hooks provided by the $animate service. Be sure to
 //skip animations when the first digest occurs (when
 //both the new and the old values are the same) since
 //the CSS classes are the non-interpolated values
-if(name === 'class' && newValue != oldValue) {
+if (name === 'class' && newValue != oldValue) {
 attr.$updateClass(newValue, oldValue);
 } else {
 attr.$set(name, newValue);
 }
 });
 removeCount = elementsToRemove.length,
 parent = firstElementToRemove.parentNode,
 i, ii;
 if ($rootElement) {
-for(i = 0, ii = $rootElement.length; i < ii; i++) {
+for (i = 0, ii = $rootElement.length; i < ii; i++) {
 if ($rootElement[i] == firstElementToRemove) {
 $rootElement[i++] = newNode;
 for (var j = i, j2 = j + removeCount - 1,
 jj = $rootElement.length;
 j < jj; j++, j2++) {
 function invokeLinkFn(linkFn, scope, $element, attrs, controllers, transcludeFn) {
 try {
 linkFn(scope, $element, attrs, controllers, transcludeFn);
-} catch(e) {
+} catch (e) {
 $exceptionHandler(e, startingTag($element));
 }
 }
 }];
 }
-var PREFIX_REGEXP = /^(x[\:\-_]|data[\:\-_])/i;
+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, ''));
 }
 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
-){}
+) {}
 function tokenDifference(str1, str2) {
 var values = '',
 tokens1 = str1.split(/\s+/),
 tokens2 = str2.split(/\s+/);
 outer:
-for(var i = 0; i < tokens1.length; i++) {
+for (var i = 0; i < tokens1.length; i++) {
 var token = tokens1[i];
-for(var j = 0; j < tokens2.length; j++) {
+for (var j = 0; j < tokens2.length; j++) {
-if(token == tokens2[j]) continue outer;
+if (token == tokens2[j]) continue outer;
 }
 values += (values.length > 0 ? ' ' : '') + token;
 }
 return values;
 }
 *
 *    * check if a controller with given name is registered via `$controllerProvider`
 *    * check if evaluating the string on the current scope returns a constructor
 *    * if $controllerProvider#allowGlobals, check `window[constructor]` on the global
 *      `window` object (not recommended)
+*
+*    The string can use the `controller as property` syntax, where the controller instance is published
+*    as the specified property on the `scope`; the `scope` must be injected into `locals` param for this
+*    to work correctly.
 *
 * @param {Object} locals Injection locals for Controller.
 * @return {Object} Instance of given controller.
 *
 * @description
 later = later === true;
 if (ident && isString(ident)) {
 identifier = ident;
 }
-if(isString(expression)) {
+if (isString(expression)) {
 match = expression.match(CNTRL_REG),
 constructor = match[1],
 identifier = identifier || match[3];
 expression = controllers.hasOwnProperty(constructor)
 ? controllers[constructor]
 // This allows properties to be added to the controller before the constructor is
 // invoked. Primarily, this is used for isolate scope bindings in $compile.
 //
 // This feature is not intended for use by applications, and is thus not documented
 // publicly.
-var Constructor = function() {};
+// Object creation: http://jsperf.com/create-constructor/2
-Constructor.prototype = (isArray(expression) ?
+var controllerPrototype = (isArray(expression) ?
 expression[expression.length - 1] : expression).prototype;
-instance = new Constructor();
+instance = Object.create(controllerPrototype);
 if (identifier) {
 addIdentifier(locals, identifier, instance, constructor || expression.name);
 }
 $scope.windowTitle = angular.element(window.document)[0].title;
 }]);
 </file>
 </example>
 */
-function $DocumentProvider(){
+function $DocumentProvider() {
-this.$get = ['$window', function(window){
+this.$get = ['$window', function(window) {
 return jqLite(window.document);
 }];
 }
 /**
 * {@link ngMock.$exceptionHandler mock $exceptionHandler} which aids in testing.
 *
 * ## Example:
 *
 * ```js
-*   angular.module('exceptionOverride', []).factory('$exceptionHandler', function () {
+*   angular.module('exceptionOverride', []).factory('$exceptionHandler', function() {
-*     return function (exception, cause) {
+*     return function(exception, cause) {
 *       exception.message += ' (caused by "' + cause + '")';
 *       throw exception;
 *     };
 *   });
 * ```
 *
 * This example will override the normal action of `$exceptionHandler`, to make angular
 * exceptions fail hard when they happen, instead of just logging to the console.
+*
+* <hr />
+* Note, that code executed in event-listeners (even those registered using jqLite's `on`/`bind`
+* methods) does not delegate exceptions to the {@link ng.$exceptionHandler $exceptionHandler}
+* (unless executed during a digest).
+*
+* If you wish, you can manually delegate exceptions, e.g.
+* `try { ... } catch(e) { $exceptionHandler(e); }`
 *
 * @param {Error} exception Exception associated with the error.
 * @param {string=} cause optional information about the context in which
 *       the error was thrown.
 *
 $log.error.apply($log, arguments);
 };
 }];
 }
+var APPLICATION_JSON = 'application/json';
+var CONTENT_TYPE_APPLICATION_JSON = {'Content-Type': APPLICATION_JSON + ';charset=utf-8'};
+var JSON_START = /^\[|^\{(?!\{)/;
+var JSON_ENDS = {
+'[': /]$/,
+'{': /}$/
+};
+var JSON_PROTECTION_PREFIX = /^\)\]\}',?\n/;
+function defaultHttpResponseTransform(data, headers) {
+if (isString(data)) {
+// Strip json vulnerability protection prefix and trim whitespace
+var tempData = data.replace(JSON_PROTECTION_PREFIX, '').trim();
+if (tempData) {
+var contentType = headers('Content-Type');
+if ((contentType && (contentType.indexOf(APPLICATION_JSON) === 0)) || isJsonLike(tempData)) {
+data = fromJson(tempData);
+}
+}
+}
+return data;
+}
+function isJsonLike(str) {
+var jsonStart = str.match(JSON_START);
+return jsonStart && JSON_ENDS[jsonStart[0]].test(str);
+}
 /**
 * 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;
+var parsed = createMap(), key, val, i;
 if (!headers) return parsed;
 forEach(headers.split('\n'), function(line) {
 i = line.indexOf(':');
 return function(name) {
 if (!headersObj) headersObj =  parseHeaders(headers);
 if (name) {
-return headersObj[lowercase(name)] || null;
+var value = headersObj[lowercase(name)];
+if (value === void 0) {
+value = null;
+}
+return value;
 }
 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(string=)} headers HTTP headers getter fn.
+* @param {number} status HTTP status code of the response.
 * @param {(Function|Array.<Function>)} fns Function or an array of functions.
 * @returns {*} Transformed data.
 */
-function transformData(data, headers, fns) {
+function transformData(data, headers, status, fns) {
 if (isFunction(fns))
-return fns(data, headers);
+return fns(data, headers, status);
 forEach(fns, function(fn) {
-data = fn(data, headers);
+data = fn(data, headers, status);
 });
 return data;
 }
 * @name $httpProvider
 * @description
 * Use `$httpProvider` to change the default behavior of the {@link ng.$http $http} service.
 * */
 function $HttpProvider() {
-var JSON_START = /^\s*(\[|\{[^\{])/,
-JSON_END = /[\}\]]\s*$/,
-PROTECTION_PREFIX = /^\)\]\}',?\n/,
-APPLICATION_JSON = 'application/json',
-CONTENT_TYPE_APPLICATION_JSON = {'Content-Type': APPLICATION_JSON + ';charset=utf-8'};
 /**
 * @ngdoc property
 * @name $httpProvider#defaults
 * @description
 *
 * Object containing default values for all {@link ng.$http $http} requests.
+*
+* - **`defaults.cache`** - {Object} - an object built with {@link ng.$cacheFactory `$cacheFactory`}
+* that will provide the cache for all requests who set their `cache` property to `true`.
+* If you set the `default.cache = false` then only requests that specify their own custom
+* cache object will be cached. See {@link $http#caching $http Caching} for more information.
 *
 * - **`defaults.xsrfCookieName`** - {string} - Name of cookie containing the XSRF token.
 * Defaults value is `'XSRF-TOKEN'`.
 *
 * - **`defaults.xsrfHeaderName`** - {string} - Name of HTTP header to populate with the
 * setting default headers.
 *     - **`defaults.headers.common`**
 *     - **`defaults.headers.post`**
 *     - **`defaults.headers.put`**
 *     - **`defaults.headers.patch`**
+*
 **/
 var defaults = this.defaults = {
 // transform incoming response data
-transformResponse: [function defaultHttpResponseTransform(data, headers) {
+transformResponse: [defaultHttpResponseTransform],
-if (isString(data)) {
-// strip json vulnerability protection prefix
-data = data.replace(PROTECTION_PREFIX, '');
-var contentType = headers('Content-Type');
-if ((contentType && contentType.indexOf(APPLICATION_JSON) === 0) ||
-(JSON_START.test(data) && JSON_END.test(data))) {
-data = fromJson(data);
-}
-}
-return data;
-}],
 // transform outgoing request data
 transformRequest: [function(d) {
-return isObject(d) && !isFile(d) && !isBlob(d) ? toJson(d) : d;
+return isObject(d) && !isFile(d) && !isBlob(d) && !isFormData(d) ? toJson(d) : d;
 }],
 // default headers
 headers: {
 common: {
 * @ngdoc method
 * @name $httpProvider#useApplyAsync
 * @description
 *
 * Configure $http service to combine processing of multiple http responses received at around
-* the same time via {@link ng.$rootScope#applyAsync $rootScope.$applyAsync}. This can result in
+* the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in
 * significant performance improvement for bigger applications that make many HTTP requests
 * concurrently (common during application bootstrap).
 *
 * Defaults to false. If no value is specifed, returns the current configured value.
 *
 }
 return useApplyAsync;
 };
 /**
-* Are ordered by request, i.e. they are applied in the same order as the
+* @ngdoc property
+* @name $httpProvider#interceptors
+* @description
+*
+* Array containing service factories for all synchronous or asynchronous {@link ng.$http $http}
+* pre-processing of request or postprocessing of responses.
+*
+* These service factories are ordered by request, i.e. they are applied in the same order as the
 * array, on request, but reverse order, on response.
-*/
+*
+* {@link ng.$http#interceptors Interceptors detailed info}
+**/
 var interceptorFactories = this.interceptors = [];
 this.$get = ['$httpBackend', '$browser', '$cacheFactory', '$rootScope', '$q', '$injector',
 function($httpBackend, $browser, $cacheFactory, $rootScope, $q, $injector) {
 * 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`.
 *
 * ```js
-*   $http({method: 'GET', url: '/someUrl'}).
+*   // Simple GET request example :
+*   $http.get('/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.
 *     });
 * ```
+*
+* ```js
+*   // Simple POST request example (passing data) :
+*   $http.post('/someUrl', {msg:'hello word!'}).
+*     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.
+*     });
+* ```
+*
 *
 * Since the returned value of calling the $http function is a `promise`, 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.
 * ```
 *
 * In addition, you can supply a `headers` property in the config object passed when
 * calling `$http(config)`, which overrides the defaults without changing them globally.
 *
+* To explicitly remove a header automatically added via $httpProvider.defaults.headers on a per request basis,
+* Use the `headers` property, setting the desired header to `undefined`. For example:
+*
+* ```js
+* var req = {
+*  method: 'POST',
+*  url: 'http://example.com',
+*  headers: {
+*    'Content-Type': undefined
+*  },
+*  data: { test: 'test' },
+* }
+*
+* $http(req).success(function(){...}).error(function(){...});
+* ```
 *
 * ## Transforming Requests and Responses
 *
 * Both requests and responses can be transformed using transformation functions: `transformRequest`
 * and `transformResponse`. These properties can be a single function that returns
-* the transformed value (`{function(data, headersGetter)`) or an array of such transformation functions,
+* the transformed value (`{function(data, headersGetter, status)`) or an array of such transformation functions,
 * which allows you to `push` or `unshift` a new transformation function into the transformation chain.
 *
 * ### Default Transformations
 *
 * The `$httpProvider` provider and `$http` service expose `defaults.transformRequest` and
 * 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 from the first request.
 *
 * You can change the default cache to a new object (built with
 * {@link ng.$cacheFactory `$cacheFactory`}) by updating the
-* {@link ng.$http#properties_defaults `$http.defaults.cache`} property. All requests who set
+* {@link ng.$http#defaults `$http.defaults.cache`} property. All requests who set
 * their `cache` property to `true` will now use this cache object.
 *
 * If you set the default cache to `false` then only requests that specify their own custom
 * cache object will be cached.
 *
 *    - **xsrfCookieName** – `{string}` – Name of cookie containing the XSRF token.
 *    - **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.
-*      See {@link #overriding-the-default-transformations-per-request Overriding the Default Transformations}
+*      See {@link ng.$http#overriding-the-default-transformations-per-request
+*      Overriding the Default Transformations}
 *    - **transformResponse** –
-*      `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
+*      `{function(data, headersGetter, status)|Array.<function(data, headersGetter, status)>}` –
 *      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.
+*      response body, headers and status and returns its transformed (typically deserialized) version.
-*      See {@link #overriding-the-default-transformations-per-request Overriding the Default Transformations}
+*      See {@link ng.$http#overriding-the-default-transformations-per-request
+*      Overriding the Default Transformations}
 *    - **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|Promise}` – timeout in milliseconds, or {@link ng.$q promise}
 });
 </file>
 </example>
 */
 function $http(requestConfig) {
-var config = {
+if (!angular.isObject(requestConfig)) {
+throw minErr('$http')('badreq', 'Http request configuration must be an object.  Received: {0}', requestConfig);
+}
+var config = extend({
 method: 'get',
 transformRequest: defaults.transformRequest,
 transformResponse: defaults.transformResponse
-};
+}, requestConfig);
-var headers = mergeHeaders(requestConfig);
+config.headers = mergeHeaders(requestConfig);
-extend(config, requestConfig);
-config.headers = headers;
 config.method = uppercase(config.method);
 var serverRequest = function(config) {
-headers = config.headers;
+var headers = config.headers;
-var reqData = transformData(config.data, headersGetter(headers), config.transformRequest);
+var reqData = transformData(config.data, headersGetter(headers), undefined, config.transformRequest);
 // strip content-type if data is undefined
 if (isUndefined(reqData)) {
 forEach(headers, function(value, header) {
 if (lowercase(header) === 'content-type') {
 if (isUndefined(config.withCredentials) && !isUndefined(defaults.withCredentials)) {
 config.withCredentials = defaults.withCredentials;
 }
 // send request
-return sendReq(config, reqData, headers).then(transformResponse, transformResponse);
+return sendReq(config, reqData).then(transformResponse, transformResponse);
 };
 var chain = [serverRequest, undefined];
 var promise = $q.when(config);
 if (interceptor.response || interceptor.responseError) {
 chain.push(interceptor.response, interceptor.responseError);
 }
 });
-while(chain.length) {
+while (chain.length) {
 var thenFn = chain.shift();
 var rejectFn = chain.shift();
 promise = promise.then(thenFn, rejectFn);
 }
 return promise;
 function transformResponse(response) {
 // make a copy since the response must be cacheable
-var resp = extend({}, response, {
+var resp = extend({}, response);
-data: transformData(response.data, response.headers, config.transformResponse)
+if (!response.data) {
-});
+resp.data = response.data;
+} else {
+resp.data = transformData(response.data, response.headers, response.status, config.transformResponse);
+}
 return (isSuccess(response.status))
 ? resp
 : $q.reject(resp);
+}
+function executeHeaderFns(headers) {
+var headerContent, processedHeaders = {};
+forEach(headers, function(headerFn, header) {
+if (isFunction(headerFn)) {
+headerContent = headerFn();
+if (headerContent != null) {
+processedHeaders[header] = headerContent;
+}
+} else {
+processedHeaders[header] = headerFn;
+}
+});
+return processedHeaders;
 }
 function mergeHeaders(config) {
 var defHeaders = defaults.headers,
 reqHeaders = extend({}, config.headers),
 reqHeaders[defHeaderName] = defHeaders[defHeaderName];
 }
 // execute if header value is a function for merged headers
-execHeaders(reqHeaders);
+return executeHeaderFns(reqHeaders);
-return reqHeaders;
-function execHeaders(headers) {
-var headerContent;
-forEach(headers, function(headerFn, header) {
-if (isFunction(headerFn)) {
-headerContent = headerFn();
-if (headerContent != null) {
-headers[header] = headerContent;
-} else {
-delete headers[header];
-}
-}
-});
-}
 }
 }
 $http.pendingRequests = [];
 * Makes the request.
 *
 * !!! ACCESSES CLOSURE VARS:
 * $httpBackend, defaults, $log, $rootScope, defaultCache, $http.pendingRequests
 */
-function sendReq(config, reqData, reqHeaders) {
+function sendReq(config, reqData) {
 var deferred = $q.defer(),
 promise = deferred.promise,
 cache,
 cachedResp,
+reqHeaders = config.headers,
 url = buildUrl(config.url, config.params);
 $http.pendingRequests.push(config);
 promise.then(removePendingReq, removePendingReq);
 if (cache) {
 cachedResp = cache.get(url);
 if (isDefined(cachedResp)) {
 if (isPromiseLike(cachedResp)) {
 // cached request has already been sent, but there is no response yet
-cachedResp.then(removePendingReq, removePendingReq);
+cachedResp.then(resolvePromiseWithResult, resolvePromiseWithResult);
-return cachedResp;
 } else {
 // serving from cache
 if (isArray(cachedResp)) {
 resolvePromise(cachedResp[1], cachedResp[0], shallowCopy(cachedResp[2]), cachedResp[3]);
 } else {
 (isSuccess(status) ? deferred.resolve : deferred.reject)({
 data: response,
 status: status,
 headers: headersGetter(headers),
 config: config,
-statusText : statusText
+statusText: statusText
 });
 }
+function resolvePromiseWithResult(result) {
+resolvePromise(result.data, result.status, shallowCopy(result.headers()), result.statusText);
+}
 function removePendingReq() {
 var idx = $http.pendingRequests.indexOf(config);
 if (idx !== -1) $http.pendingRequests.splice(idx, 1);
 }
 if (value === null || isUndefined(value)) return;
 if (!isArray(value)) value = [value];
 forEach(value, function(v) {
 if (isObject(v)) {
-if (isDate(v)){
+if (isDate(v)) {
 v = v.toISOString();
 } else {
 v = toJson(v);
 }
 }
 parts.push(encodeUriQuery(key) + '=' +
 encodeUriQuery(v));
 });
 });
-if(parts.length > 0) {
+if (parts.length > 0) {
 url += ((url.indexOf('?') == -1) ? '?' : '&') + parts.join('&');
 }
 return url;
 }
 }];
 response,
 xhr.getAllResponseHeaders(),
 statusText);
 };
-var requestError = function () {
+var requestError = function() {
 // The response is always empty
 // See https://xhr.spec.whatwg.org/#request-error-steps and https://fetch.spec.whatwg.org/#concept-network-error
 completeRequest(callback, -1, null, null, '');
 };
 xhr && xhr.abort();
 }
 function completeRequest(callback, status, response, headersString, statusText) {
 // cancel timeout and subsequent timeout promise resolution
-timeoutId && $browserDefer.cancel(timeoutId);
+if (timeoutId !== undefined) {
+$browserDefer.cancel(timeoutId);
+}
 jsonpDone = xhr = null;
 callback(status, response, headersString, statusText);
 $browser.$$completeOutstandingRequest(noop);
 }
 * 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){
+this.startSymbol = function(value) {
 if (value) {
 startSymbol = value;
 return this;
 } else {
 return startSymbol;
 * 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){
+this.endSymbol = function(value) {
 if (value) {
 endSymbol = value;
 return this;
 } else {
 return endSymbol;
 textLength = text.length,
 exp,
 concat = [],
 expressionPositions = [];
-while(index < textLength) {
+while (index < textLength) {
-if ( ((startIndex = text.indexOf(startSymbol, index)) != -1) &&
+if (((startIndex = text.indexOf(startSymbol, index)) != -1) &&
-((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) != -1) ) {
+((endIndex = text.indexOf(endSymbol, startIndex + startSymbolLength)) != -1)) {
 if (index !== startIndex) {
 concat.push(unescapeText(text.substring(index, startIndex)));
 }
 exp = text.substring(startIndex + startSymbolLength, endIndex);
 expressions.push(exp);
 "required.  See http://docs.angularjs.org/api/ng.$sce", text);
 }
 if (!mustHaveExpression || expressions.length) {
 var compute = function(values) {
-for(var i = 0, ii = expressions.length; i < ii; i++) {
+for (var i = 0, ii = expressions.length; i < ii; i++) {
 if (allOrNothing && isUndefined(values[i])) return;
 concat[expressionPositions[i]] = values[i];
 }
 return concat.join('');
 };
-var getValue = function (value) {
+var getValue = function(value) {
 return trustedContext ?
 $sce.getTrusted(trustedContext, value) :
 $sce.valueOf(value);
 };
-var stringify = function (value) {
+var stringify = function(value) {
 if (value == null) { // null || undefined
 return '';
 }
 switch (typeof value) {
-case 'string': {
+case 'string':
 break;
-}
+case 'number':
-case 'number': {
 value = '' + value;
 break;
-}
+default:
-default: {
 value = toJson(value);
-}
 }
 return value;
 };
 for (; i < ii; i++) {
 values[i] = parseFns[i](context);
 }
 return compute(values);
-} catch(err) {
+} catch (err) {
 var newErr = $interpolateMinErr('interr', "Can't interpolate: {0}\n{1}", text,
 err.toString());
 $exceptionHandler(newErr);
 }
 }, {
 // all of these properties are undocumented for now
 exp: text, //just for compatibility with regular watchers created via $watch
 expressions: expressions,
-$$watchDelegate: function (scope, listener, objectEquality) {
+$$watchDelegate: function(scope, listener, objectEquality) {
 var lastValue;
 return scope.$watchGroup(parseFns, function interpolateFnWatcher(values, oldValues) {
 var currValue = compute(values);
 if (isFunction(listener)) {
 listener.call(this, currValue, values !== oldValues ? lastValue : currValue, scope);
 replace(escapedEndRegexp, endSymbol);
 }
 function parseStringifyInterceptor(value) {
 try {
-return stringify(getValue(value));
+value = getValue(value);
-} catch(err) {
+return allOrNothing && !isDefined(value) ? value : stringify(value);
+} catch (err) {
 var newErr = $interpolateMinErr('interr', "Can't interpolate: {0}\n{1}", text,
 err.toString());
 $exceptionHandler(newErr);
 }
 }
 *           var stop;
 *           $scope.fight = function() {
 *             // Don't start a new fight if we are already fighting
 *             if ( angular.isDefined(stop) ) return;
 *
-*           stop = $interval(function() {
+*             stop = $interval(function() {
-*             if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
+*               if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
-*               $scope.blood_1 = $scope.blood_1 - 3;
+*                 $scope.blood_1 = $scope.blood_1 - 3;
-*               $scope.blood_2 = $scope.blood_2 - 4;
+*                 $scope.blood_2 = $scope.blood_2 - 4;
-*             } else {
+*               } else {
-*               $scope.stopFight();
+*                 $scope.stopFight();
+*               }
+*             }, 100);
+*           };
+*
+*           $scope.stopFight = function() {
+*             if (angular.isDefined(stop)) {
+*               $interval.cancel(stop);
+*               stop = undefined;
 *             }
-*           }, 100);
+*           };
-*         };
 *
-*         $scope.stopFight = function() {
+*           $scope.resetFight = function() {
-*           if (angular.isDefined(stop)) {
+*             $scope.blood_1 = 100;
-*             $interval.cancel(stop);
+*             $scope.blood_2 = 120;
-*             stop = undefined;
+*           };
-*           }
-*         };
 *
-*         $scope.resetFight = function() {
+*           $scope.$on('$destroy', function() {
-*           $scope.blood_1 = 100;
+*             // Make sure that the interval is destroyed too
-*           $scope.blood_2 = 120;
+*             $scope.stopFight();
-*         };
+*           });
-*
+*         }])
-*         $scope.$on('$destroy', function() {
-*           // Make sure that the interval is destroyed too
-*           $scope.stopFight();
-*         });
-*       }])
 *       // Register the 'myCurrentTime' directive factory method.
 *       // We inject $interval and dateFilter service since the factory method is DI.
 *       .directive('myCurrentTime', ['$interval', 'dateFilter',
 *         function($interval, dateFilter) {
 *           // return the directive link function. (compile function not needed)
 * $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(){
+function $LocaleProvider() {
 this.$get = function() {
 return {
 id: 'en-us',
 NUMBER_FORMATS: {
 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',
+'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',
 }
 return segments.join('/');
 }
-function parseAbsoluteUrl(absoluteUrl, locationObj, appBase) {
+function parseAbsoluteUrl(absoluteUrl, locationObj) {
-var parsedUrl = urlResolve(absoluteUrl, appBase);
+var parsedUrl = urlResolve(absoluteUrl);
 locationObj.$$protocol = parsedUrl.protocol;
 locationObj.$$host = parsedUrl.hostname;
 locationObj.$$port = int(parsedUrl.port) || DEFAULT_PORTS[parsedUrl.protocol] || null;
 }
-function parseAppUrl(relativeUrl, locationObj, appBase) {
+function parseAppUrl(relativeUrl, locationObj) {
 var prefixed = (relativeUrl.charAt(0) !== '/');
 if (prefixed) {
 relativeUrl = '/' + relativeUrl;
 }
-var match = urlResolve(relativeUrl, appBase);
+var match = urlResolve(relativeUrl);
 locationObj.$$path = decodeURIComponent(prefixed && match.pathname.charAt(0) === '/' ?
 match.pathname.substring(1) : match.pathname);
 locationObj.$$search = parseKeyValue(match.search);
 locationObj.$$hash = decodeURIComponent(match.hash);
 function stripHash(url) {
 var index = url.indexOf('#');
 return index == -1 ? url : url.substr(0, index);
 }
+function trimEmptyHash(url) {
+return url.replace(/(#.+)|#$/, '$1');
+}
 function stripFile(url) {
 return url.substr(0, stripHash(url).lastIndexOf('/') + 1);
 }
 */
 function LocationHtml5Url(appBase, basePrefix) {
 this.$$html5 = true;
 basePrefix = basePrefix || '';
 var appBaseNoFile = stripFile(appBase);
-parseAbsoluteUrl(appBase, this, appBase);
+parseAbsoluteUrl(appBase, this);
 /**
 * Parse given html5 (regular) url string into properties
-* @param {string} newAbsoluteUrl HTML5 url
+* @param {string} url HTML5 url
 * @private
 */
 this.$$parse = function(url) {
 var pathUrl = beginsWith(appBaseNoFile, url);
 if (!isString(pathUrl)) {
 throw $locationMinErr('ipthprfx', 'Invalid url "{0}", missing path prefix "{1}".', url,
 appBaseNoFile);
 }
-parseAppUrl(pathUrl, this, appBase);
+parseAppUrl(pathUrl, this);
 if (!this.$$path) {
 this.$$path = '/';
 }
 return true;
 }
 var appUrl, prevAppUrl;
 var rewrittenUrl;
-if ( (appUrl = beginsWith(appBase, url)) !== undefined ) {
+if ((appUrl = beginsWith(appBase, url)) !== undefined) {
 prevAppUrl = appUrl;
-if ( (appUrl = beginsWith(basePrefix, appUrl)) !== undefined ) {
+if ((appUrl = beginsWith(basePrefix, appUrl)) !== undefined) {
 rewrittenUrl = appBaseNoFile + (beginsWith('/', appUrl) || appUrl);
 } else {
 rewrittenUrl = appBase + prevAppUrl;
 }
-} else if ( (appUrl = beginsWith(appBaseNoFile, url)) !== undefined ) {
+} else if ((appUrl = beginsWith(appBaseNoFile, url)) !== undefined) {
 rewrittenUrl = appBaseNoFile + appUrl;
 } else if (appBaseNoFile == url + '/') {
 rewrittenUrl = appBaseNoFile;
 }
 if (rewrittenUrl) {
 * @param {string} hashPrefix hashbang prefix
 */
 function LocationHashbangUrl(appBase, hashPrefix) {
 var appBaseNoFile = stripFile(appBase);
-parseAbsoluteUrl(appBase, this, appBase);
+parseAbsoluteUrl(appBase, this);
 /**
 * Parse given hashbang url into properties
 * @param {string} url Hashbang url
 * @private
 */
 this.$$parse = function(url) {
 var withoutBaseUrl = beginsWith(appBase, url) || beginsWith(appBaseNoFile, url);
-var withoutHashUrl = withoutBaseUrl.charAt(0) == '#'
+var withoutHashUrl;
-? beginsWith(hashPrefix, withoutBaseUrl)
-: (this.$$html5)
+if (withoutBaseUrl.charAt(0) === '#') {
-? withoutBaseUrl
-: '';
+// The rest of the url starts with a hash so we have
+// got either a hashbang path or a plain hash fragment
-if (!isString(withoutHashUrl)) {
+withoutHashUrl = beginsWith(hashPrefix, withoutBaseUrl);
-throw $locationMinErr('ihshprfx', 'Invalid url "{0}", missing hash prefix "{1}".', url,
+if (isUndefined(withoutHashUrl)) {
-hashPrefix);
+// There was no hashbang prefix so we just have a hash fragment
-}
+withoutHashUrl = withoutBaseUrl;
-parseAppUrl(withoutHashUrl, this, appBase);
+}
+} else {
+// There was no hashbang path nor hash fragment:
+// If we are in HTML5 mode we use what is left as the path;
+// Otherwise we ignore what is left
+withoutHashUrl = this.$$html5 ? withoutBaseUrl : '';
+}
+parseAppUrl(withoutHashUrl, this);
 this.$$path = removeWindowsDriveName(this.$$path, withoutHashUrl, appBase);
 this.$$compose();
 *   * a.pathname === '/C:/foo' //true
 *
 * Inside of Angular, we're always using pathnames that
 * do not include drive names for routing.
 */
-function removeWindowsDriveName (path, url, base) {
+function removeWindowsDriveName(path, url, base) {
 /*
 Matches paths for file protocol on windows,
 such as /C:/foo/bar, and captures only /foo/bar.
 */
 var windowsFilePathExp = /^\/[A-Z]:(\/.*)/;
 this.$$url = encodePath(this.$$path) + (search ? '?' + search : '') + hash;
 this.$$absUrl = appBase + (this.$$url ? hashPrefix + this.$$url : '');
 };
 this.$$parseLinkUrl = function(url, relHref) {
-if(stripHash(appBase) == stripHash(url)) {
+if (stripHash(appBase) == stripHash(url)) {
 this.$$parse(url);
 return true;
 }
 return false;
 };
 }
 var rewrittenUrl;
 var appUrl;
-if ( appBase == stripHash(url) ) {
+if (appBase == stripHash(url)) {
 rewrittenUrl = url;
-} else if ( (appUrl = beginsWith(appBaseNoFile, url)) ) {
+} else if ((appUrl = beginsWith(appBaseNoFile, url))) {
 rewrittenUrl = appBase + hashPrefix + appUrl;
-} else if ( appBaseNoFile === url + '/') {
+} else if (appBaseNoFile === url + '/') {
 rewrittenUrl = appBaseNoFile;
 }
 if (rewrittenUrl) {
 this.$$parse(rewrittenUrl);
 }
 * @description
 * This method is getter only.
 *
 * Return full url representation with all segments encoded according to rules specified in
 * [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
+*
+*
+* ```js
+* // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+* var absUrl = $location.absUrl();
+* // => "http://example.com/#/some/path?foo=bar&baz=xoxo"
+* ```
 *
 * @return {string} full url
 */
 absUrl: locationGetter('$$absUrl'),
 *
 * 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`.
 *
+*
+* ```js
+* // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+* var url = $location.url();
+* // => "/some/path?foo=bar&baz=xoxo"
+* ```
+*
 * @param {string=} url New url without base prefix (e.g. `/path?a=b#hash`)
 * @return {string} url
 */
 url: function(url) {
 if (isUndefined(url))
 return this.$$url;
 var match = PATH_MATCH.exec(url);
-if (match[1]) this.path(decodeURIComponent(match[1]));
+if (match[1] || url === '') this.path(decodeURIComponent(match[1]));
-if (match[2] || match[1]) this.search(match[3] || '');
+if (match[2] || match[1] || url === '') this.search(match[3] || '');
 this.hash(match[5] || '');
 return this;
 },
 * @description
 * This method is getter only.
 *
 * Return protocol of current url.
 *
+*
+* ```js
+* // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+* var protocol = $location.protocol();
+* // => "http"
+* ```
+*
 * @return {string} protocol of current url
 */
 protocol: locationGetter('$$protocol'),
 /**
 * @description
 * This method is getter only.
 *
 * Return host of current url.
 *
+*
+* ```js
+* // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+* var host = $location.host();
+* // => "example.com"
+* ```
+*
 * @return {string} host of current url.
 */
 host: locationGetter('$$host'),
 /**
 *
 * @description
 * This method is getter only.
 *
 * Return port of current url.
+*
+*
+* ```js
+* // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+* var port = $location.port();
+* // => 80
+* ```
 *
 * @return {Number} port
 */
 port: locationGetter('$$port'),
 *
 * 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.
+*
+*
+* ```js
+* // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+* var path = $location.path();
+* // => "/some/path"
+* ```
 *
 * @param {(string|number)=} path New path
 * @return {string} path
 */
 path: locationGetterSetter('$$path', function(path) {
 * ```js
 * // given url http://example.com/#/some/path?foo=bar&baz=xoxo
 * var searchObject = $location.search();
 * // => {foo: 'bar', baz: 'xoxo'}
 *
-*
 * // set foo to 'yipee'
 * $location.search('foo', 'yipee');
-* // => $location
+* // $location.search() => {foo: 'yipee', baz: 'xoxo'}
 * ```
 *
 * @param {string|Object.<string>|Object.<Array.<string>>} search New search params - string or
 * hash object.
 *
 case 1:
 if (isString(search) || isNumber(search)) {
 search = search.toString();
 this.$$search = parseKeyValue(search);
 } else if (isObject(search)) {
+search = copy(search, {});
 // remove object undefined or null properties
 forEach(search, function(value, key) {
 if (value == null) delete search[key];
 });
 * This method is getter / setter.
 *
 * Return hash fragment when called without any parameter.
 *
 * Change hash fragment when called with parameter and return `$location`.
+*
+*
+* ```js
+* // given url http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue
+* var hash = $location.hash();
+* // => "hashValue"
+* ```
 *
 * @param {(string|number)=} hash New hash fragment
 * @return {string} hash
 */
 hash: locationGetterSetter('$$hash', function(hash) {
 this.$$replace = true;
 return this;
 }
 };
-forEach([LocationHashbangInHtml5Url, LocationHashbangUrl, LocationHtml5Url], function (Location) {
+forEach([LocationHashbangInHtml5Url, LocationHashbangUrl, LocationHtml5Url], function(Location) {
 Location.prototype = Object.create(locationPrototype);
 /**
 * @ngdoc method
 * @name $location#state
 * @ngdoc provider
 * @name $locationProvider
 * @description
 * Use the `$locationProvider` to configure how the application deep linking paths are stored.
 */
-function $LocationProvider(){
+function $LocationProvider() {
 var hashPrefix = '',
 html5Mode = {
 enabled: false,
 requireBase: true,
 rewriteLinks: true
 *     support `pushState`.
 *   - **requireBase** - `{boolean}` - (default: `true`) When html5Mode is enabled, specifies
 *     whether or not a <base> tag is required to be present. If `enabled` and `requireBase` are
 *     true, and a base tag is not present, an error will be thrown when `$location` is injected.
 *     See the {@link guide/$location $location guide for more information}
-*   - **rewriteLinks** - `{boolean}` - (default: `false`) When html5Mode is enabled, disables
+*   - **rewriteLinks** - `{boolean}` - (default: `true`) When html5Mode is enabled,
-*     url rewriting for relative linksTurns off url rewriting for relative links.
+*     enables/disables url rewriting for relative links.
 *
 * @returns {Object} html5Mode object if used as getter or itself (chaining) if used as setter
 */
 this.html5Mode = function(mode) {
 if (isBoolean(mode)) {
 html5Mode.enabled = mode;
 return this;
 } else if (isObject(mode)) {
 if (isBoolean(mode.enabled)) {
-html5Mode.enabled =  mode.enabled;
+html5Mode.enabled = mode.enabled;
 }
 if (isBoolean(mode.requireBase)) {
 html5Mode.requireBase = mode.requireBase;
 }
 if (isBoolean(mode.rewriteLinks)) {
-html5Mode.rewriteLinks =  mode.rewriteLinks;
+html5Mode.rewriteLinks = mode.rewriteLinks;
 }
 return this;
 } else {
 return html5Mode;
 * Broadcasted before a URL will change.
 *
 * This change can be prevented by calling
 * `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} for more
 * details about event object. Upon successful change
-* {@link ng.$location#events_$locationChangeSuccess $locationChangeSuccess} is fired.
+* {@link ng.$location#$locationChangeSuccess $locationChangeSuccess} is fired.
 *
 * The `newState` and `oldState` parameters may be defined only in HTML5 mode and when
 * the browser supports the HTML5 History API.
 *
 * @param {Object} angularEvent Synthetic event object.
 * @param {string=} oldUrl URL that was before it was changed.
 * @param {string=} newState New history state object
 * @param {string=} oldState History state object that was before it was changed.
 */
-this.$get = ['$rootScope', '$browser', '$sniffer', '$rootElement',
+this.$get = ['$rootScope', '$browser', '$sniffer', '$rootElement', '$window',
-function( $rootScope,   $browser,   $sniffer,   $rootElement) {
+function($rootScope, $browser, $sniffer, $rootElement, $window) {
 var $location,
 LocationMode,
 baseHref = $browser.baseHref(), // if base[href] is undefined, it defaults to ''
 initialUrl = $browser.url(),
 appBase;
 event.preventDefault();
 // update location manually
 if ($location.absUrl() != $browser.url()) {
 $rootScope.$apply();
 // hack to work around FF6 bug 684208 when scenario runner clicks on links
-window.angular['ff-684208-preventDefault'] = true;
+$window.angular['ff-684208-preventDefault'] = true;
 }
 }
 }
 });
 // update $location when $browser url changes
 $browser.onUrlChange(function(newUrl, newState) {
 $rootScope.$evalAsync(function() {
 var oldUrl = $location.absUrl();
 var oldState = $location.$$state;
+var defaultPrevented;
 $location.$$parse(newUrl);
 $location.$$state = newState;
-if ($rootScope.$broadcast('$locationChangeStart', newUrl, oldUrl,
-newState, oldState).defaultPrevented) {
+defaultPrevented = $rootScope.$broadcast('$locationChangeStart', newUrl, oldUrl,
+newState, oldState).defaultPrevented;
+// if the location was changed by a `$locationChangeStart` handler then stop
+// processing this location change
+if ($location.absUrl() !== newUrl) return;
+if (defaultPrevented) {
 $location.$$parse(oldUrl);
 $location.$$state = oldState;
 setBrowserUrlWithFallback(oldUrl, false, oldState);
 } else {
 initializing = false;
 if (!$rootScope.$$phase) $rootScope.$digest();
 });
 // update browser
 $rootScope.$watch(function $locationWatch() {
-var oldUrl = $browser.url();
+var oldUrl = trimEmptyHash($browser.url());
+var newUrl = trimEmptyHash($location.absUrl());
 var oldState = $browser.state();
 var currentReplace = $location.$$replace;
+var urlOrStateChanged = oldUrl !== newUrl ||
-if (initializing || oldUrl !== $location.absUrl() ||
+($location.$$html5 && $sniffer.history && oldState !== $location.$$state);
-($location.$$html5 && $sniffer.history && oldState !== $location.$$state)) {
+if (initializing || urlOrStateChanged) {
 initializing = false;
 $rootScope.$evalAsync(function() {
-if ($rootScope.$broadcast('$locationChangeStart', $location.absUrl(), oldUrl,
+var newUrl = $location.absUrl();
-$location.$$state, oldState).defaultPrevented) {
+var defaultPrevented = $rootScope.$broadcast('$locationChangeStart', newUrl, oldUrl,
+$location.$$state, oldState).defaultPrevented;
+// if the location was changed by a `$locationChangeStart` handler then stop
+// processing this location change
+if ($location.absUrl() !== newUrl) return;
+if (defaultPrevented) {
 $location.$$parse(oldUrl);
 $location.$$state = oldState;
 } else {
-setBrowserUrlWithFallback($location.absUrl(), currentReplace,
+if (urlOrStateChanged) {
-oldState === $location.$$state ? null : $location.$$state);
+setBrowserUrlWithFallback(newUrl, currentReplace,
+oldState === $location.$$state ? null : $location.$$state);
+}
 afterLocationChange(oldUrl, oldState);
 }
 });
 }
 * @ngdoc provider
 * @name $logProvider
 * @description
 * Use the `$logProvider` to configure how the application logs messages
 */
-function $LogProvider(){
+function $LogProvider() {
 var debug = true,
 self = this;
 /**
 * @ngdoc method
 } else {
 return debug;
 }
 };
-this.$get = ['$window', function($window){
+this.$get = ['$window', function($window) {
 return {
 /**
 * @ngdoc method
 * @name $log#log
 *
 * @name $log#debug
 *
 * @description
 * Write a debug message
 */
-debug: (function () {
+debug: (function() {
 var fn = consoleLog('debug');
 return function() {
 if (debug) {
 fn.apply(self, arguments);
 var $parseMinErr = minErr('$parse');
 // Sandboxing Angular Expressions
 // ------------------------------
 // Angular expressions are generally considered safe because these expressions only have direct
-// access to $scope and locals. However, one can obtain the ability to execute arbitrary JS code by
+// access to `$scope` and locals. However, one can obtain the ability to execute arbitrary JS code by
 // obtaining a reference to native JS functions such as the Function constructor.
 //
 // As an example, consider the following Angular expression:
 //
 //   {}.toString.constructor('alert("evil JS code")')
 //
 // This sandboxing technique is not perfect and doesn't aim to be. The goal is to prevent exploits
 // against the expression language, but not to prevent exploits that were enabled by exposing
-// sensitive JavaScript or browser apis on Scope. Exposing such objects on a Scope is never a good
+// sensitive JavaScript or browser APIs on Scope. Exposing such objects on a Scope is never a good
 // practice and therefore we are not even trying to protect against interaction with an object
 // explicitly exposed in this way.
 //
 // In general, it is not possible to access a Window object from an angular expression unless a
 // window or some DOM object that has a reference to window is published onto a Scope.
 // Similarly we prevent invocations of function known to be dangerous, as well as assignments to
 // native objects.
+//
+// See https://docs.angularjs.org/guide/security
 function ensureSafeMemberName(name, fullExpression) {
 if (name === "__defineGetter__" || name === "__defineSetter__"
 || name === "__lookupGetter__" || name === "__lookupSetter__"
 || name === "__proto__") {
 throw $parseMinErr('isecfld',
 'Attempting to access a disallowed field in Angular expressions! '
-+'Expression: {0}', fullExpression);
++ 'Expression: {0}', fullExpression);
 }
 return name;
 }
 function ensureSafeObject(obj, fullExpression) {
 CONSTANTS['this'].sharedGetter = true;
 //Operators - will be wrapped by binaryFn/unaryFn/assignment/filter
 var OPERATORS = extend(createMap(), {
-/* jshint bitwise : false */
+'+':function(self, locals, a, b) {
-'+':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;},
+return isDefined(b) ? b : undefined;},
-'-':function(self, locals, a,b){
+'-':function(self, locals, a, b) {
 a=a(self, locals); b=b(self, locals);
-return (isDefined(a)?a:0)-(isDefined(b)?b:0);
+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);},
-'%':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(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(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) {return !a(self, locals);},
-'&':function(self, locals, a,b){return a(self, locals)&b(self, locals);},
-'!':function(self, locals, a){return !a(self, locals);},
 //Tokenized as operators but parsed as assignment/filters
 '=':true,
 '|':true
 });
-/* jshint bitwise: true */
 var ESCAPE = {"n":"\n", "f":"\f", "r":"\r", "t":"\t", "v":"\v", "'":"'", '"':'"'};
 /////////////////////////////////////////
 /**
 * @constructor
 */
-var Lexer = function (options) {
+var Lexer = function(options) {
 this.options = options;
 };
 Lexer.prototype = {
 constructor: Lexer,
-lex: function (text) {
+lex: function(text) {
 this.text = text;
 this.index = 0;
-this.ch = undefined;
 this.tokens = [];
 while (this.index < this.text.length) {
-this.ch = this.text.charAt(this.index);
+var ch = this.text.charAt(this.index);
-if (this.is('"\'')) {
+if (ch === '"' || ch === "'") {
-this.readString(this.ch);
+this.readString(ch);
-} else if (this.isNumber(this.ch) || this.is('.') && this.isNumber(this.peek())) {
+} else if (this.isNumber(ch) || ch === '.' && this.isNumber(this.peek())) {
 this.readNumber();
-} else if (this.isIdent(this.ch)) {
+} else if (this.isIdent(ch)) {
 this.readIdent();
-} else if (this.is('(){}[].,;:?')) {
+} else if (this.is(ch, '(){}[].,;:?')) {
-this.tokens.push({
+this.tokens.push({index: this.index, text: ch});
-index: this.index,
-text: this.ch
-});
 this.index++;
-} else if (this.isWhitespace(this.ch)) {
+} else if (this.isWhitespace(ch)) {
 this.index++;
 } else {
-var ch2 = this.ch + this.peek();
+var ch2 = ch + this.peek();
 var ch3 = ch2 + this.peek(2);
-var fn = OPERATORS[this.ch];
+var op1 = OPERATORS[ch];
-var fn2 = OPERATORS[ch2];
+var op2 = OPERATORS[ch2];
-var fn3 = OPERATORS[ch3];
+var op3 = OPERATORS[ch3];
-if (fn3) {
+if (op1 || op2 || op3) {
-this.tokens.push({index: this.index, text: ch3, fn: fn3});
+var token = op3 ? ch3 : (op2 ? ch2 : ch);
-this.index += 3;
+this.tokens.push({index: this.index, text: token, operator: true});
-} else if (fn2) {
+this.index += token.length;
-this.tokens.push({index: this.index, text: ch2, fn: fn2});
-this.index += 2;
-} else if (fn) {
-this.tokens.push({
-index: this.index,
-text: this.ch,
-fn: fn
-});
-this.index += 1;
 } else {
 this.throwError('Unexpected next character ', this.index, this.index + 1);
 }
 }
 }
 return this.tokens;
 },
-is: function(chars) {
+is: function(ch, chars) {
-return chars.indexOf(this.ch) !== -1;
+return chars.indexOf(ch) !== -1;
 },
 peek: function(i) {
 var num = i || 1;
 return (this.index + num < this.text.length) ? this.text.charAt(this.index + num) : false;
 },
 isNumber: function(ch) {
-return ('0' <= ch && ch <= '9');
+return ('0' <= ch && ch <= '9') && typeof ch === "string";
 },
 isWhitespace: function(ch) {
 // IE treats non-breaking space as \u00A0
 return (ch === ' ' || ch === '\r' || ch === '\t' ||
 break;
 }
 }
 this.index++;
 }
-number = 1 * number;
 this.tokens.push({
 index: start,
 text: number,
 constant: true,
-fn: function() { return number; }
+value: Number(number)
 });
 },
 readIdent: function() {
-var expression = this.text;
-var ident = '';
 var start = this.index;
-var lastDot, peekIndex, methodName, ch;
 while (this.index < this.text.length) {
-ch = this.text.charAt(this.index);
+var ch = this.text.charAt(this.index);
-if (ch === '.' || this.isIdent(ch) || this.isNumber(ch)) {
+if (!(this.isIdent(ch) || this.isNumber(ch))) {
-if (ch === '.') lastDot = this.index;
-ident += ch;
-} else {
 break;
 }
 this.index++;
 }
-//check if the identifier ends with . and if so move back one char
-if (lastDot && ident[ident.length - 1] === '.') {
-this.index--;
-ident = ident.slice(0, -1);
-lastDot = ident.lastIndexOf('.');
-if (lastDot === -1) {
-lastDot = undefined;
-}
-}
-//check if this is not a method invocation and if it is back out to last dot
-if (lastDot) {
-peekIndex = this.index;
-while (peekIndex < this.text.length) {
-ch = this.text.charAt(peekIndex);
-if (ch === '(') {
-methodName = ident.substr(lastDot - start + 1);
-ident = ident.substr(0, lastDot - start);
-this.index = peekIndex;
-break;
-}
-if (this.isWhitespace(ch)) {
-peekIndex++;
-} else {
-break;
-}
-}
-}
 this.tokens.push({
 index: start,
-text: ident,
+text: this.text.slice(start, this.index),
-fn: CONSTANTS[ident] || getterFn(ident, this.options, expression)
+identifier: true
 });
-if (methodName) {
-this.tokens.push({
-index: lastDot,
-text: '.'
-});
-this.tokens.push({
-index: lastDot + 1,
-text: methodName
-});
-}
 },
 readString: function(quote) {
 var start = this.index;
 this.index++;
 } else if (ch === quote) {
 this.index++;
 this.tokens.push({
 index: start,
 text: rawString,
-string: string,
 constant: true,
-fn: function() { return string; }
+value: string
 });
 return;
 } else {
 string += ch;
 }
 }
 /**
 * @constructor
 */
-var Parser = function (lexer, $filter, options) {
+var Parser = function(lexer, $filter, options) {
 this.lexer = lexer;
 this.$filter = $filter;
 this.options = options;
 };
-Parser.ZERO = extend(function () {
+Parser.ZERO = extend(function() {
 return 0;
 }, {
 sharedGetter: true,
 constant: true
 });
 Parser.prototype = {
 constructor: Parser,
-parse: function (text) {
+parse: function(text) {
 this.text = text;
 this.tokens = this.lexer.lex(text);
 var value = this.statements();
 value.constant = !!value.constant;
 return value;
 },
-primary: function () {
+primary: function() {
 var primary;
 if (this.expect('(')) {
 primary = this.filterChain();
 this.consume(')');
 } else if (this.expect('[')) {
 primary = this.arrayDeclaration();
 } else if (this.expect('{')) {
 primary = this.object();
+} else if (this.peek().identifier && this.peek().text in CONSTANTS) {
+primary = CONSTANTS[this.consume().text];
+} else if (this.peek().identifier) {
+primary = this.identifier();
+} else if (this.peek().constant) {
+primary = this.constant();
 } else {
-var token = this.expect();
+this.throwError('not a primary expression', this.peek());
-primary = token.fn;
-if (!primary) {
-this.throwError('not a primary expression', token);
-}
-if (token.constant) {
-primary.constant = true;
-primary.literal = true;
-}
 }
 var next, context;
 while ((next = this.expect('(', '[', '.'))) {
 if (next.text === '(') {
 throw $parseMinErr('ueoe', 'Unexpected end of expression: {0}', this.text);
 return this.tokens[0];
 },
 peek: function(e1, e2, e3, e4) {
-if (this.tokens.length > 0) {
+return this.peekAhead(0, e1, e2, e3, e4);
-var token = this.tokens[0];
+},
+peekAhead: function(i, e1, e2, e3, e4) {
+if (this.tokens.length > i) {
+var token = this.tokens[i];
 var t = token.text;
 if (t === e1 || t === e2 || t === e3 || t === e4 ||
 (!e1 && !e2 && !e3 && !e4)) {
 return token;
 }
 }
 return false;
 },
-expect: function(e1, e2, e3, e4){
+expect: function(e1, e2, e3, e4) {
 var token = this.peek(e1, e2, e3, e4);
 if (token) {
 this.tokens.shift();
 return token;
 }
 return false;
 },
-consume: function(e1){
+consume: function(e1) {
-if (!this.expect(e1)) {
+if (this.tokens.length === 0) {
+throw $parseMinErr('ueoe', 'Unexpected end of expression: {0}', this.text);
+}
+var token = this.expect(e1);
+if (!token) {
 this.throwError('is unexpected, expecting [' + e1 + ']', this.peek());
 }
+return token;
 },
-unaryFn: function(fn, right) {
+unaryFn: function(op, right) {
+var fn = OPERATORS[op];
 return extend(function $parseUnaryFn(self, locals) {
 return fn(self, locals, right);
 }, {
 constant:right.constant,
 inputs: [right]
 });
 },
-binaryFn: function(left, fn, right, isBranching) {
+binaryFn: function(left, op, right, isBranching) {
+var fn = OPERATORS[op];
 return extend(function $parseBinaryFn(self, locals) {
 return fn(self, locals, left, right);
 }, {
 constant: left.constant && right.constant,
 inputs: !isBranching && [left, right]
+});
+},
+identifier: function() {
+var id = this.consume().text;
+//Continue reading each `.identifier` unless it is a method invocation
+while (this.peek('.') && this.peekAhead(1).identifier && !this.peekAhead(2, '(')) {
+id += this.consume().text + this.consume().text;
+}
+return getterFn(id, this.options, this.text);
+},
+constant: function() {
+var value = this.consume().value;
+return extend(function $parseConstant() {
+return value;
+}, {
+constant: true,
+literal: true
 });
 },
 statements: function() {
 var statements = [];
 }
 return left;
 },
 filter: function(inputFn) {
-var token = this.expect();
+var fn = this.$filter(this.consume().text);
-var fn = this.$filter(token.text);
 var argsFn;
 var args;
 if (this.peek(':')) {
 argsFn = [];
 var left = this.logicalOR();
 var middle;
 var token;
 if ((token = this.expect('?'))) {
 middle = this.assignment();
-if ((token = this.expect(':'))) {
+if (this.consume(':')) {
 var right = this.assignment();
-return extend(function $parseTernary(self, locals){
+return extend(function $parseTernary(self, locals) {
 return left(self, locals) ? middle(self, locals) : right(self, locals);
 }, {
 constant: left.constant && middle.constant && right.constant
 });
-} else {
-this.throwError('expected :', token);
 }
 }
 return left;
 },
 logicalOR: function() {
 var left = this.logicalAND();
 var token;
 while ((token = this.expect('||'))) {
-left = this.binaryFn(left, token.fn, this.logicalAND(), true);
+left = this.binaryFn(left, token.text, this.logicalAND(), true);
 }
 return left;
 },
 logicalAND: function() {
 var left = this.equality();
 var token;
-if ((token = this.expect('&&'))) {
+while ((token = this.expect('&&'))) {
-left = this.binaryFn(left, token.fn, this.logicalAND(), true);
+left = this.binaryFn(left, token.text, this.equality(), true);
 }
 return left;
 },
 equality: function() {
 var left = this.relational();
 var token;
-if ((token = this.expect('==','!=','===','!=='))) {
+while ((token = this.expect('==','!=','===','!=='))) {
-left = this.binaryFn(left, token.fn, this.equality());
+left = this.binaryFn(left, token.text, this.relational());
 }
 return left;
 },
 relational: function() {
 var left = this.additive();
 var token;
-if ((token = this.expect('<', '>', '<=', '>='))) {
+while ((token = this.expect('<', '>', '<=', '>='))) {
-left = this.binaryFn(left, token.fn, this.relational());
+left = this.binaryFn(left, token.text, this.additive());
 }
 return left;
 },
 additive: function() {
 var left = this.multiplicative();
 var token;
 while ((token = this.expect('+','-'))) {
-left = this.binaryFn(left, token.fn, this.multiplicative());
+left = this.binaryFn(left, token.text, this.multiplicative());
 }
 return left;
 },
 multiplicative: function() {
 var left = this.unary();
 var token;
 while ((token = this.expect('*','/','%'))) {
-left = this.binaryFn(left, token.fn, this.unary());
+left = this.binaryFn(left, token.text, this.unary());
 }
 return left;
 },
 unary: function() {
 var token;
 if (this.expect('+')) {
 return this.primary();
 } else if ((token = this.expect('-'))) {
-return this.binaryFn(Parser.ZERO, token.fn, this.unary());
+return this.binaryFn(Parser.ZERO, token.text, this.unary());
 } else if ((token = this.expect('!'))) {
-return this.unaryFn(token.fn, this.unary());
+return this.unaryFn(token.text, this.unary());
 } else {
 return this.primary();
 }
 },
 fieldAccess: function(object) {
-var expression = this.text;
+var getter = this.identifier();
-var field = this.expect().text;
-var getter = getterFn(field, this.options, expression);
 return extend(function $parseFieldAccess(scope, locals, self) {
-return getter(self || object(scope, locals));
+var o = self || object(scope, locals);
+return (o == null) ? undefined : getter(o);
 }, {
 assign: function(scope, value, locals) {
 var o = object(scope, locals);
 if (!o) object.assign(scope, o = {});
-return setter(o, field, value, expression);
+return getter.assign(o, value);
 }
 });
 },
 objectIndex: function(obj) {
 var expressionText = this.text;
 // we can safely reuse the array across invocations
 var args = argsFn.length ? [] : null;
 return function $parseFunctionCall(scope, locals) {
-var context = contextGetter ? contextGetter(scope, locals) : scope;
+var context = contextGetter ? contextGetter(scope, locals) : isDefined(contextGetter) ? undefined : scope;
 var fn = fnGetter(scope, locals, context) || noop;
 if (args) {
 var i = argsFn.length;
 while (i--) {
 }
 ensureSafeObject(context, expressionText);
 ensureSafeFunction(fn, expressionText);
-// IE stupidity! (IE doesn't have apply for some native functions)
+// IE doesn't have apply for some native functions
 var v = fn.apply
 ? fn.apply(context, args)
 : fn(args[0], args[1], args[2], args[3], args[4]);
 return ensureSafeObject(v, expressionText);
 };
 },
 // This is used with json array declaration
-arrayDeclaration: function () {
+arrayDeclaration: function() {
 var elementFns = [];
 if (this.peekToken().text !== ']') {
 do {
 if (this.peek(']')) {
 // Support trailing commas per ES5.1.
 break;
 }
-var elementFn = this.expression();
+elementFns.push(this.expression());
-elementFns.push(elementFn);
 } while (this.expect(','));
 }
 this.consume(']');
 return extend(function $parseArrayLiteral(self, locals) {
 constant: elementFns.every(isConstant),
 inputs: elementFns
 });
 },
-object: function () {
+object: function() {
 var keys = [], valueFns = [];
 if (this.peekToken().text !== '}') {
 do {
 if (this.peek('}')) {
 // Support trailing commas per ES5.1.
 break;
 }
-var token = this.expect();
+var token = this.consume();
-keys.push(token.string || token.text);
+if (token.constant) {
+keys.push(token.value);
+} else if (token.identifier) {
+keys.push(token.text);
+} else {
+this.throwError("invalid key", token);
+}
 this.consume(':');
-var value = this.expression();
+valueFns.push(this.expression());
-valueFns.push(value);
 } while (this.expect(','));
 }
 this.consume('}');
 return extend(function $parseObjectLiteral(self, locals) {
 ensureSafeObject(obj[key], fullExp);
 obj[key] = setValue;
 return setValue;
 }
-var getterFnCache = createMap();
+var getterFnCacheDefault = createMap();
+var getterFnCacheExpensive = createMap();
+function isPossiblyDangerousMemberName(name) {
+return name == 'constructor';
+}
 /**
 * 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, fullExp) {
+function cspSafeGetterFn(key0, key1, key2, key3, key4, fullExp, expensiveChecks) {
 ensureSafeMemberName(key0, fullExp);
 ensureSafeMemberName(key1, fullExp);
 ensureSafeMemberName(key2, fullExp);
 ensureSafeMemberName(key3, fullExp);
 ensureSafeMemberName(key4, fullExp);
+var eso = function(o) {
+return ensureSafeObject(o, fullExp);
+};
+var eso0 = (expensiveChecks || isPossiblyDangerousMemberName(key0)) ? eso : identity;
+var eso1 = (expensiveChecks || isPossiblyDangerousMemberName(key1)) ? eso : identity;
+var eso2 = (expensiveChecks || isPossiblyDangerousMemberName(key2)) ? eso : identity;
+var eso3 = (expensiveChecks || isPossiblyDangerousMemberName(key3)) ? eso : identity;
+var eso4 = (expensiveChecks || isPossiblyDangerousMemberName(key4)) ? eso : identity;
 return function cspSafeGetter(scope, locals) {
 var pathVal = (locals && locals.hasOwnProperty(key0)) ? locals : scope;
 if (pathVal == null) return pathVal;
-pathVal = pathVal[key0];
+pathVal = eso0(pathVal[key0]);
 if (!key1) return pathVal;
 if (pathVal == null) return undefined;
-pathVal = pathVal[key1];
+pathVal = eso1(pathVal[key1]);
 if (!key2) return pathVal;
 if (pathVal == null) return undefined;
-pathVal = pathVal[key2];
+pathVal = eso2(pathVal[key2]);
 if (!key3) return pathVal;
 if (pathVal == null) return undefined;
-pathVal = pathVal[key3];
+pathVal = eso3(pathVal[key3]);
 if (!key4) return pathVal;
 if (pathVal == null) return undefined;
-pathVal = pathVal[key4];
+pathVal = eso4(pathVal[key4]);
 return pathVal;
 };
 }
+function getterFnWithEnsureSafeObject(fn, fullExpression) {
+return function(s, l) {
+return fn(s, l, ensureSafeObject, fullExpression);
+};
+}
 function getterFn(path, options, fullExp) {
+var expensiveChecks = options.expensiveChecks;
+var getterFnCache = (expensiveChecks ? getterFnCacheExpensive : getterFnCacheDefault);
 var fn = getterFnCache[path];
 if (fn) return fn;
 var pathKeys = path.split('.'),
 pathKeysLength = pathKeys.length;
 // http://jsperf.com/angularjs-parse-getter/6
 if (options.csp) {
 if (pathKeysLength < 6) {
-fn = cspSafeGetterFn(pathKeys[0], pathKeys[1], pathKeys[2], pathKeys[3], pathKeys[4], fullExp);
+fn = cspSafeGetterFn(pathKeys[0], pathKeys[1], pathKeys[2], pathKeys[3], pathKeys[4], fullExp, expensiveChecks);
 } else {
 fn = function cspSafeGetter(scope, locals) {
 var i = 0, val;
 do {
 val = cspSafeGetterFn(pathKeys[i++], pathKeys[i++], pathKeys[i++], pathKeys[i++],
-pathKeys[i++], fullExp)(scope, locals);
+pathKeys[i++], fullExp, expensiveChecks)(scope, locals);
 locals = undefined; // clear after first iteration
 scope = val;
 } while (i < pathKeysLength);
 return val;
 };
 }
 } else {
 var code = '';
+if (expensiveChecks) {
+code += 's = eso(s, fe);\nl = eso(l, fe);\n';
+}
+var needsEnsureSafeObject = expensiveChecks;
 forEach(pathKeys, function(key, index) {
 ensureSafeMemberName(key, fullExp);
-code += 'if(s == null) return undefined;\n' +
+var lookupJs = (index
-'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
-: '((l&&l.hasOwnProperty("' + key + '"))?l:s)') + '.' + key + ';\n';
+: '((l&&l.hasOwnProperty("' + key + '"))?l:s)') + '.' + key;
+if (expensiveChecks || isPossiblyDangerousMemberName(key)) {
+lookupJs = 'eso(' + lookupJs + ', fe)';
+needsEnsureSafeObject = true;
+}
+code += 'if(s == null) return undefined;\n' +
+'s=' + lookupJs + ';\n';
 });
 code += 'return s;';
 /* jshint -W054 */
-var evaledFnGetter = new Function('s', 'l', code); // s=scope, l=locals
+var evaledFnGetter = new Function('s', 'l', 'eso', 'fe', code); // s=scope, l=locals, eso=ensureSafeObject
 /* jshint +W054 */
 evaledFnGetter.toString = valueFn(code);
+if (needsEnsureSafeObject) {
+evaledFnGetter = getterFnWithEnsureSafeObject(evaledFnGetter, fullExp);
+}
 fn = evaledFnGetter;
 }
 fn.sharedGetter = true;
 fn.assign = function(self, value) {
 };
 getterFnCache[path] = fn;
 return fn;
 }
+var objectValueOf = Object.prototype.valueOf;
+function getValueOf(value) {
+return isFunction(value.valueOf) ? value.valueOf() : objectValueOf.call(value);
+}
 ///////////////////////////////////
 /**
 * @ngdoc service
 * @name $parse
 * @description
 * `$parseProvider` can be used for configuring the default behavior of the {@link ng.$parse $parse}
 *  service.
 */
 function $ParseProvider() {
-var cache = createMap();
+var cacheDefault = createMap();
+var cacheExpensive = createMap();
-var $parseOptions = {
-csp: false
-};
 this.$get = ['$filter', '$sniffer', function($filter, $sniffer) {
-$parseOptions.csp = $sniffer.csp;
+var $parseOptions = {
+csp: $sniffer.csp,
+expensiveChecks: false
+},
+$parseOptionsExpensive = {
+csp: $sniffer.csp,
+expensiveChecks: true
+};
 function wrapSharedExpression(exp) {
 var wrapped = exp;
 if (exp.sharedGetter) {
 }
 return wrapped;
 }
-return function $parse(exp, interceptorFn) {
+return function $parse(exp, interceptorFn, expensiveChecks) {
 var parsedExpression, oneTime, cacheKey;
 switch (typeof exp) {
 case 'string':
 cacheKey = exp = exp.trim();
+var cache = (expensiveChecks ? cacheExpensive : cacheDefault);
 parsedExpression = cache[cacheKey];
 if (!parsedExpression) {
 if (exp.charAt(0) === ':' && exp.charAt(1) === ':') {
 oneTime = true;
 exp = exp.substring(2);
 }
-var lexer = new Lexer($parseOptions);
+var parseOptions = expensiveChecks ? $parseOptionsExpensive : $parseOptions;
-var parser = new Parser(lexer, $filter, $parseOptions);
+var lexer = new Lexer(parseOptions);
+var parser = new Parser(lexer, $filter, parseOptions);
 parsedExpression = parser.parse(exp);
 if (parsedExpression.constant) {
 parsedExpression.$$watchDelegate = constantWatchDelegate;
 } else if (oneTime) {
 if (typeof newValue === 'object') {
 // attempt to convert the value to a primitive type
 // TODO(docs): add a note to docs that by implementing valueOf even objects and arrays can
 //             be cheaply dirty-checked
-newValue = newValue.valueOf();
+newValue = getValueOf(newValue);
 if (typeof newValue === 'object') {
 // objects/arrays are not supported - deep-watching them would be too expensive
 return false;
 }
 inputExpressions = inputExpressions[0];
 return scope.$watch(function expressionInputWatch(scope) {
 var newInputValue = inputExpressions(scope);
 if (!expressionInputDirtyCheck(newInputValue, oldInputValue)) {
 lastResult = parsedExpression(scope);
-oldInputValue = newInputValue && newInputValue.valueOf();
+oldInputValue = newInputValue && getValueOf(newInputValue);
 }
 return lastResult;
 }, listener, objectEquality);
 }
 var changed = false;
 for (var i = 0, ii = inputExpressions.length; i < ii; i++) {
 var newInputValue = inputExpressions[i](scope);
 if (changed || (changed = !expressionInputDirtyCheck(newInputValue, oldInputValueOfValues[i]))) {
-oldInputValueOfValues[i] = newInputValue && newInputValue.valueOf();
+oldInputValueOfValues[i] = newInputValue && getValueOf(newInputValue);
 }
 }
 if (changed) {
 lastResult = parsedExpression(scope);
 lastValue = value;
 if (isFunction(listener)) {
 listener.apply(this, arguments);
 }
 if (isDefined(value)) {
-scope.$$postDigest(function () {
+scope.$$postDigest(function() {
 if (isDefined(lastValue)) {
 unwatch();
 }
 });
 }
 }, objectEquality);
 }
 function oneTimeLiteralWatchDelegate(scope, listener, objectEquality, parsedExpression) {
-var unwatch;
+var unwatch, lastValue;
 return unwatch = scope.$watch(function oneTimeWatch(scope) {
 return parsedExpression(scope);
 }, function oneTimeListener(value, old, scope) {
+lastValue = value;
 if (isFunction(listener)) {
 listener.call(this, value, old, scope);
 }
 if (isAllDefined(value)) {
-scope.$$postDigest(function () {
+scope.$$postDigest(function() {
-if(isAllDefined(value)) unwatch();
+if (isAllDefined(lastValue)) unwatch();
 });
 }
 }, objectEquality);
 function isAllDefined(value) {
 var allDefined = true;
-forEach(value, function (val) {
+forEach(value, function(val) {
 if (!isDefined(val)) allDefined = false;
 });
 return allDefined;
 }
 }
 }, objectEquality);
 }
 function addInterceptor(parsedExpression, interceptorFn) {
 if (!interceptorFn) return parsedExpression;
+var watchDelegate = parsedExpression.$$watchDelegate;
-var fn = function interceptedExpression(scope, locals) {
+var regularWatch =
+watchDelegate !== oneTimeLiteralWatchDelegate &&
+watchDelegate !== oneTimeWatchDelegate;
+var fn = regularWatch ? function regularInterceptedExpression(scope, locals) {
+var value = parsedExpression(scope, locals);
+return interceptorFn(value, scope, locals);
+} : function oneTimeInterceptedExpression(scope, locals) {
 var value = parsedExpression(scope, locals);
 var result = interceptorFn(value, scope, locals);
 // we only return the interceptor's result if the
 // initial value is defined (for bind-once)
 return isDefined(value) ? result : value;
 * @ngdoc service
 * @name $q
 * @requires $rootScope
 *
 * @description
-* A promise/deferred implementation inspired by [Kris Kowal's Q](https://github.com/kriskowal/q).
+* A service that helps you run functions asynchronously, and use their return values (or exceptions)
+* when they are done processing.
+*
+* This is an implementation of promises/deferred objects inspired by
+* [Kris Kowal's Q](https://github.com/kriskowal/q).
 *
 * $q can be used in two fashions --- one which is more similar to Kris Kowal's Q or jQuery's Deferred
 * implementations, and the other which resembles ES6 promises to some degree.
 *
 * # $q constructor
 * available yet.
 *
 * It can be used like so:
 *
 * ```js
-* return $q(function(resolve, reject) {
+*   // for the purpose of this example let's assume that variables `$q` and `okToGreet`
-*   // perform some asynchronous operation, resolve or reject the promise when appropriate.
+*   // are available in the current lexical scope (they could have been injected or passed in).
-*   setInterval(function() {
+*
-*     if (pollStatus > 0) {
+*   function asyncGreet(name) {
-*       resolve(polledValue);
+*     // perform some asynchronous operation, resolve or reject the promise when appropriate.
-*     } else if (pollStatus < 0) {
+*     return $q(function(resolve, reject) {
-*       reject(polledValue);
+*       setTimeout(function() {
-*     } else {
+*         if (okToGreet(name)) {
-*       pollStatus = pollAgain(function(value) {
+*           resolve('Hello, ' + name + '!');
-*         polledValue = value;
+*         } else {
-*       });
+*           reject('Greeting ' + name + ' is not allowed.');
-*     }
+*         }
-*   }, 10000);
+*       }, 1000);
-* }).
+*     });
-*   then(function(value) {
+*   }
-*     // handle success
+*
+*   var promise = asyncGreet('Robin Hood');
+*   promise.then(function(greeting) {
+*     alert('Success: ' + greeting);
 *   }, function(reason) {
-*     // handle failure
+*     alert('Failed: ' + reason);
 *   });
 * ```
 *
 * Note: progress/notify callbacks are not currently supported via the ES6-style interface.
 *
 *
 * 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.
 *
 * ```js
-*   // for the purpose of this example let's assume that variables `$q`, `scope` and `okToGreet`
+*   // for the purpose of this example let's assume that variables `$q` and `okToGreet`
 *   // are available in the current lexical scope (they could have been injected or passed in).
 *
 *   function asyncGreet(name) {
 *     var deferred = $q.defer();
 *
 *   `notifyCallback` method. The promise cannot be resolved or rejected from the notifyCallback
 *   method.
 *
 * - `catch(errorCallback)` – shorthand for `promise.then(null, errorCallback)`
 *
-* - `finally(callback)` – allows you to observe either the fulfillment or rejection of a promise,
+* - `finally(callback, notifyCallback)` – allows you to observe either the fulfillment or rejection of a promise,
 *   but to do so without modifying the final value. This is useful to release resources or do some
 *   clean-up that needs to be done whether the promise was rejected or resolved. See the [full
 *   specification](https://github.com/kriskowal/q/wiki/API-Reference#promisefinallycallback) for
 *   more information.
-*
-*   Because `finally` is a reserved word in JavaScript and reserved keywords are not supported as
-*   property names by ES3, you'll need to invoke the method like `promise['finally'](callback)` to
-*   make your code IE8 and Android 2.x compatible.
 *
 * # Chaining promises
 *
 * Because calling the `then` method of a promise returns a new derived promise, it is easily
 * possible to create a chain of promises:
 } else if (state.status === 1) {
 promise.resolve(state.value);
 } else {
 promise.reject(state.value);
 }
-} catch(e) {
+} catch (e) {
 promise.reject(e);
 exceptionHandler(e);
 }
 }
 }
 } else {
 this.promise.$$state.value = val;
 this.promise.$$state.status = 1;
 scheduleProcessQueue(this.promise.$$state);
 }
-} catch(e) {
+} catch (e) {
 fns[1](e);
 exceptionHandler(e);
 }
 },
 for (var i = 0, ii = callbacks.length; i < ii; i++) {
 result = callbacks[i][0];
 callback = callbacks[i][3];
 try {
 result.notify(isFunction(callback) ? callback(progress) : progress);
-} catch(e) {
+} catch (e) {
 exceptionHandler(e);
 }
 }
 });
 }
 var handleCallback = function handleCallback(value, isResolved, callback) {
 var callbackOutput = null;
 try {
 if (isFunction(callback)) callbackOutput = callback();
-} catch(e) {
+} catch (e) {
 return makePromise(e, false);
 }
 if (isPromiseLike(callbackOutput)) {
 return callbackOutput.then(function() {
 return makePromise(value, isResolved);
 $Q.all = all;
 return $Q;
 }
-function $$RAFProvider(){ //rAF
+function $$RAFProvider() { //rAF
 this.$get = ['$window', '$timeout', function($window, $timeout) {
 var requestAnimationFrame = $window.requestAnimationFrame ||
-$window.webkitRequestAnimationFrame ||
+$window.webkitRequestAnimationFrame;
-$window.mozRequestAnimationFrame;
 var cancelAnimationFrame = $window.cancelAnimationFrame ||
 $window.webkitCancelAnimationFrame ||
-$window.mozCancelAnimationFrame ||
 $window.webkitCancelRequestAnimationFrame;
 var rafSupported = !!requestAnimationFrame;
 var raf = rafSupported
 ? function(fn) {
 * All other scopes are descendant scopes of the root scope. Scopes provide separation
 * between the model and the view, via a mechanism for watching the model for changes.
 * They also provide an event emission/broadcast and subscription facility. See the
 * {@link guide/scope developer guide on scopes}.
 */
-function $RootScopeProvider(){
+function $RootScopeProvider() {
 var TTL = 10;
 var $rootScopeMinErr = minErr('$rootScope');
 var lastDirtyWatch = null;
 var applyAsyncId = null;
 }
 return TTL;
 };
 this.$get = ['$injector', '$exceptionHandler', '$parse', '$browser',
-function( $injector,   $exceptionHandler,   $parse,   $browser) {
+function($injector, $exceptionHandler, $parse, $browser) {
 /**
 * @ngdoc type
 * @name $rootScope.Scope
 *
 * ```js
 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');
 * ```
+*
+* When interacting with `Scope` in tests, additional helper methods are available on the
+* instances of `Scope` type. See {@link ngMock.$rootScope.Scope ngMock Scope} for additional
+* details.
 *
 *
 * @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
 var firstRun = true;
 if (!watchExpressions.length) {
 // No expressions means we call the listener ASAP
 var shouldCall = true;
-self.$evalAsync(function () {
+self.$evalAsync(function() {
 if (shouldCall) listener(newValues, newValues, self);
 });
 return function deregisterWatchGroup() {
 shouldCall = false;
 };
 oldValues[0] = oldValue;
 listener(newValues, (value === oldValue) ? newValues : oldValues, scope);
 });
 }
-forEach(watchExpressions, function (expr, i) {
+forEach(watchExpressions, function(expr, i) {
 var unwatchFn = self.$watch(expr, function watchGroupSubAction(value, oldValue) {
 newValues[i] = value;
 oldValues[i] = oldValue;
 if (!changeReactionScheduled) {
 changeReactionScheduled = true;
 function $watchCollectionInterceptor(_value) {
 newValue = _value;
 var newLength, key, bothNaN, newItem, oldItem;
+// If the new value is undefined, then return undefined as the watch may be a one-time watch
+if (isUndefined(newValue)) return;
 if (!isObject(newValue)) { // if primitive
 if (oldValue !== newValue) {
 oldValue = newValue;
 changeDetected++;
 }
 }
 }
 if (oldLength > newLength) {
 // we used to have more keys, need to find them and destroy them.
 changeDetected++;
-for(key in oldValue) {
+for (key in oldValue) {
 if (!newValue.hasOwnProperty(key)) {
 oldLength--;
 delete oldValue[key];
 }
 }
 do { // "while dirty" loop
 dirty = false;
 current = target;
-while(asyncQueue.length) {
+while (asyncQueue.length) {
 try {
 asyncTask = asyncQueue.shift();
-asyncTask.scope.$eval(asyncTask.expression);
+asyncTask.scope.$eval(asyncTask.expression, asyncTask.locals);
 } catch (e) {
 $exceptionHandler(e);
 }
 lastDirtyWatch = null;
 }
 watch.last = watch.eq ? copy(value, null) : value;
 watch.fn(value, ((last === initWatchVal) ? value : last), current);
 if (ttl < 5) {
 logIdx = 4 - ttl;
 if (!watchLog[logIdx]) watchLog[logIdx] = [];
-logMsg = (isFunction(watch.exp))
+watchLog[logIdx].push({
-? 'fn: ' + (watch.exp.name || watch.exp.toString())
+msg: isFunction(watch.exp) ? 'fn: ' + (watch.exp.name || watch.exp.toString()) : watch.exp,
-: watch.exp;
+newVal: value,
-logMsg += '; newVal: ' + toJson(value) + '; oldVal: ' + toJson(last);
+oldVal: last
-watchLog[logIdx].push(logMsg);
+});
 }
 } else if (watch === lastDirtyWatch) {
 // If the most recently dirty watcher is now clean, short circuit since the remaining watchers
 // have already been tested.
 dirty = false;
 // 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)) {
+while (current !== target && !(next = current.$$nextSibling)) {
 current = current.$parent;
 }
 }
 } while ((current = next));
 // `break traverseScopesLoop;` takes us to here
-if((dirty || asyncQueue.length) && !(ttl--)) {
+if ((dirty || asyncQueue.length) && !(ttl--)) {
 clearPhase();
 throw $rootScopeMinErr('infdig',
 '{0} $digest() iterations reached. Aborting!\n' +
 'Watchers fired in the last 5 iterations: {1}',
-TTL, toJson(watchLog));
+TTL, watchLog);
 }
 } while (dirty || asyncQueue.length);
 clearPhase();
-while(postDigestQueue.length) {
+while (postDigestQueue.length) {
 try {
 postDigestQueue.shift()();
 } catch (e) {
 $exceptionHandler(e);
 }
 * @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.
 *
+* @param {(object)=} locals Local variables object, useful for overriding values in scope.
 */
-$evalAsync: function(expr) {
+$evalAsync: function(expr, locals) {
 // if we are outside of an $digest loop and this is the first time we are scheduling async
 // task also schedule async auto-flush
 if (!$rootScope.$$phase && !asyncQueue.length) {
 $browser.defer(function() {
 if (asyncQueue.length) {
 $rootScope.$digest();
 }
 });
 }
-asyncQueue.push({scope: this, expression: expr});
+asyncQueue.push({scope: this, expression: expr, locals: locals});
 },
-$$postDigest : function(fn) {
+$$postDigest: function(fn) {
 postDigestQueue.push(fn);
 },
 /**
 * @ngdoc method
 current.$$listenerCount[name]++;
 } while ((current = current.$parent));
 var self = this;
 return function() {
-namedListeners[namedListeners.indexOf(listener)] = null;
+var indexOfListener = namedListeners.indexOf(listener);
-decrementListenerCount(self, 1, name);
+if (indexOfListener !== -1) {
+namedListeners[indexOfListener] = null;
+decrementListenerCount(self, 1, name);
+}
 };
 },
 /**
 i, length;
 do {
 namedListeners = scope.$$listeners[name] || empty;
 event.currentScope = scope;
-for (i=0, length=namedListeners.length; i<length; i++) {
+for (i = 0, length = namedListeners.length; i < length; i++) {
 // if listeners were deregistered, defragment the array
 if (!namedListeners[i]) {
 namedListeners.splice(i, 1);
 i--;
 //down while you can, then up and next sibling or up and next sibling until back at root
 while ((current = next)) {
 event.currentScope = current;
 listeners = current.$$listeners[name] || [];
-for (i=0, length = listeners.length; i<length; i++) {
+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) {
+} 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
 // (though it differs due to having the extra check for $$listenerCount)
 if (!(next = ((current.$$listenerCount[name] && current.$$childHead) ||
 (current !== target && current.$$nextSibling)))) {
-while(current !== target && !(next = current.$$nextSibling)) {
+while (current !== target && !(next = current.$$nextSibling)) {
 current = current.$parent;
 }
 }
 }
 function flushApplyAsync() {
 while (applyAsyncQueue.length) {
 try {
 applyAsyncQueue.shift()();
-} catch(e) {
+} catch (e) {
 $exceptionHandler(e);
 }
 }
 applyAsyncId = null;
 }
 return function sanitizeUri(uri, isImage) {
 var regex = isImage ? imgSrcSanitizationWhitelist : aHrefSanitizationWhitelist;
 var normalizedVal;
 normalizedVal = urlResolve(uri).href;
 if (normalizedVal !== '' && !normalizedVal.match(regex)) {
-return 'unsafe:'+normalizedVal;
+return 'unsafe:' + normalizedVal;
 }
 return uri;
 };
 };
 }
 RESOURCE_URL: 'resourceUrl',
 JS: 'js'
 };
 // Helper functions follow.
-// Copied from:
-// http://docs.closure-library.googlecode.com/git/closure_goog_string_string.js.source.html#line962
-// Prereq: s is a string.
-function escapeForRegexp(s) {
-return s.replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, '\\$1').
-replace(/\x08/g, '\\x08');
-}
 function adjustMatcher(matcher) {
 if (matcher === 'self') {
 return matcher;
 } else if (isString(matcher)) {
 * same origin resource requests.
 *
 * @description
 * Sets/Gets the whitelist of trusted resource URLs.
 */
-this.resourceUrlWhitelist = function (value) {
+this.resourceUrlWhitelist = function(value) {
 if (arguments.length) {
 resourceUrlWhitelist = adjustMatchers(value);
 }
 return resourceUrlWhitelist;
 };
 *
 * @description
 * Sets/Gets the blacklist of trusted resource URLs.
 */
-this.resourceUrlBlacklist = function (value) {
+this.resourceUrlBlacklist = function(value) {
 if (arguments.length) {
 resourceUrlBlacklist = adjustMatchers(value);
 }
 return resourceUrlBlacklist;
 };
 * such a context is binding arbitrary html controlled by the user via `ng-bind-html`.  We refer
 * to these contexts as privileged or SCE contexts.
 *
 * As of version 1.2, Angular ships with SCE enabled by default.
 *
-* Note:  When enabled (the default), IE8 in quirks mode is not supported.  In this mode, IE8 allows
+* Note:  When enabled (the default), IE<11 in quirks mode is not supported.  In this mode, IE<11 allow
 * one to execute arbitrary javascript by the use of the expression() syntax.  Refer
 * <http://blogs.msdn.com/b/ie/archive/2008/10/16/ending-expressions.aspx> to learn more about them.
 * You can ensure your document is in standards mode and not quirks mode by adding `<!doctype html>`
 * to the top of your HTML document.
 *
 *
 * ## How does it work?
 *
 * In privileged contexts, directives and code will bind to the result of {@link ng.$sce#getTrusted
 * $sce.getTrusted(context, value)} rather than to the value directly.  Directives use {@link
-* ng.$sce#parse $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs the
+* ng.$sce#parseAs $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs the
 * {@link ng.$sce#getTrusted $sce.getTrusted} behind the scenes on non-constant literals.
 *
 * As an example, {@link ng.directive:ngBindHtml ngBindHtml} uses {@link
 * ng.$sce#parseAsHtml $sce.parseAsHtml(binding expression)}.  Here's the actual code (slightly
 * simplified):
 * @return {boolean} true if SCE is enabled, false otherwise.
 *
 * @description
 * Enables/disables SCE and returns the current value.
 */
-this.enabled = function (value) {
+this.enabled = function(value) {
 if (arguments.length) {
 enabled = !!value;
 }
 return enabled;
 };
 * Inheritance happens to capture this in a natural way.  In some future, we
 * may not use inheritance anymore.  That is OK because no code outside of
 * sce.js and sceSpecs.js would need to be aware of this detail.
 */
-this.$get = ['$parse', '$sniffer', '$sceDelegate', function(
+this.$get = ['$parse', '$sceDelegate', function(
-$parse,   $sniffer,   $sceDelegate) {
+$parse,   $sceDelegate) {
-// Prereq: Ensure that we're not running in IE8 quirks mode.  In that mode, IE allows
+// Prereq: Ensure that we're not running in IE<11 quirks mode.  In that mode, IE < 11 allow
 // the "expression(javascript expression)" syntax which is insecure.
-if (enabled && $sniffer.msie && $sniffer.msieDocumentMode < 8) {
+if (enabled && msie < 8) {
 throw $sceMinErr('iequirks',
-'Strict Contextual Escaping does not support Internet Explorer version < 9 in quirks ' +
+'Strict Contextual Escaping does not support Internet Explorer version < 11 in quirks ' +
 'mode.  You can fix this by adding the text <!doctype html> to the top of your HTML ' +
 'document.  See http://docs.angularjs.org/api/ng.$sce for more information.');
 }
 var sce = shallowCopy(SCE_CONTEXTS);
 * have to do it at module config time on {@link ng.$sceProvider $sceProvider}.
 *
 * @description
 * Returns a boolean indicating if SCE is enabled.
 */
-sce.isEnabled = function () {
+sce.isEnabled = function() {
 return enabled;
 };
 sce.trustAs = $sceDelegate.trustAs;
 sce.getTrusted = $sceDelegate.getTrusted;
 sce.valueOf = $sceDelegate.valueOf;
 sce.parseAs = function sceParseAs(type, expr) {
 var parsed = $parse(expr);
 if (parsed.literal && parsed.constant) {
 return parsed;
 } else {
-return $parse(expr, function (value) {
+return $parse(expr, function(value) {
 return sce.getTrusted(type, value);
 });
 }
 };
 * @ngdoc method
 * @name $sce#parseAsHtml
 *
 * @description
 * Shorthand method.  `$sce.parseAsHtml(expression string)` →
-*     {@link ng.$sce#parse `$sce.parseAs($sce.HTML, value)`}
+*     {@link ng.$sce#parseAs `$sce.parseAs($sce.HTML, value)`}
 *
 * @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
 * @ngdoc method
 * @name $sce#parseAsCss
 *
 * @description
 * Shorthand method.  `$sce.parseAsCss(value)` →
-*     {@link ng.$sce#parse `$sce.parseAs($sce.CSS, value)`}
+*     {@link ng.$sce#parseAs `$sce.parseAs($sce.CSS, value)`}
 *
 * @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
 * @ngdoc method
 * @name $sce#parseAsUrl
 *
 * @description
 * Shorthand method.  `$sce.parseAsUrl(value)` →
-*     {@link ng.$sce#parse `$sce.parseAs($sce.URL, value)`}
+*     {@link ng.$sce#parseAs `$sce.parseAs($sce.URL, value)`}
 *
 * @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
 * @ngdoc method
 * @name $sce#parseAsResourceUrl
 *
 * @description
 * Shorthand method.  `$sce.parseAsResourceUrl(value)` →
-*     {@link ng.$sce#parse `$sce.parseAs($sce.RESOURCE_URL, value)`}
+*     {@link ng.$sce#parseAs `$sce.parseAs($sce.RESOURCE_URL, value)`}
 *
 * @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
 * @ngdoc method
 * @name $sce#parseAsJs
 *
 * @description
 * Shorthand method.  `$sce.parseAsJs(value)` →
-*     {@link ng.$sce#parse `$sce.parseAs($sce.JS, value)`}
+*     {@link ng.$sce#parseAs `$sce.parseAs($sce.JS, value)`}
 *
 * @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
 // Shorthand delegations.
 var parse = sce.parseAs,
 getTrusted = sce.getTrusted,
 trustAs = sce.trustAs;
-forEach(SCE_CONTEXTS, function (enumValue, name) {
+forEach(SCE_CONTEXTS, function(enumValue, name) {
 var lName = lowercase(name);
-sce[camelCase("parse_as_" + lName)] = function (expr) {
+sce[camelCase("parse_as_" + lName)] = function(expr) {
 return parse(enumValue, expr);
 };
-sce[camelCase("get_trusted_" + lName)] = function (value) {
+sce[camelCase("get_trusted_" + lName)] = function(value) {
 return getTrusted(enumValue, value);
 };
-sce[camelCase("trust_as_" + lName)] = function (value) {
+sce[camelCase("trust_as_" + lName)] = function(value) {
 return trustAs(enumValue, value);
 };
 });
 return sce;
 var eventSupport = {},
 android =
 int((/android (\d+)/.exec(lowercase(($window.navigator || {}).userAgent)) || [])[1]),
 boxee = /Boxee/i.test(($window.navigator || {}).userAgent),
 document = $document[0] || {},
-documentMode = document.documentMode,
 vendorPrefix,
-vendorRegex = /^(Moz|webkit|O|ms)(?=[A-Z])/,
+vendorRegex = /^(Moz|webkit|ms)(?=[A-Z])/,
 bodyStyle = document.body && document.body.style,
 transitions = false,
 animations = false,
 match;
 if (bodyStyle) {
-for(var prop in bodyStyle) {
+for (var prop in bodyStyle) {
-if(match = vendorRegex.exec(prop)) {
+if (match = vendorRegex.exec(prop)) {
 vendorPrefix = match[0];
 vendorPrefix = vendorPrefix.substr(0, 1).toUpperCase() + vendorPrefix.substr(1);
 break;
 }
 }
-if(!vendorPrefix) {
+if (!vendorPrefix) {
 vendorPrefix = ('WebkitOpacity' in bodyStyle) && 'webkit';
 }
 transitions = !!(('transition' in bodyStyle) || (vendorPrefix + 'Transition' in bodyStyle));
 animations  = !!(('animation' in bodyStyle) || (vendorPrefix + 'Animation' in bodyStyle));
-if (android && (!transitions||!animations)) {
+if (android && (!transitions ||  !animations)) {
 transitions = isString(document.body.style.webkitTransition);
 animations = isString(document.body.style.webkitAnimation);
 }
 }
 // jshint +W018
 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;
+// IE10+ implements 'input' event but it erroneously fires under various situations,
+// e.g. when placeholder changes, or a form is focused.
+if (event === 'input' && msie <= 11) return false;
 if (isUndefined(eventSupport[event])) {
 var divElm = document.createElement('div');
 eventSupport[event] = 'on' + event in divElm;
 }
 return eventSupport[event];
 },
 csp: csp(),
 vendorPrefix: vendorPrefix,
-transitions : transitions,
+transitions: transitions,
-animations : animations,
+animations: animations,
-android: android,
+android: android
-msie : msie,
-msieDocumentMode: documentMode
 };
 }];
 }
 var $compileMinErr = minErr('$compile');
 * @name $templateRequest
 *
 * @description
 * The `$templateRequest` service downloads the provided template using `$http` and, upon success,
 * stores the contents inside of `$templateCache`. If the HTTP request fails or the response data
-* of the HTTP request is empty then a `$compile` error will be thrown (the exception can be thwarted
+* of the HTTP request is empty, a `$compile` error will be thrown (the exception can be thwarted
 * by setting the 2nd parameter of the function to true).
 *
 * @param {string} tpl The HTTP request template URL
 * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
 *
 this.$get = ['$templateCache', '$http', '$q', function($templateCache, $http, $q) {
 function handleRequestFn(tpl, ignoreRequestError) {
 var self = handleRequestFn;
 self.totalPendingRequests++;
-return $http.get(tpl, { cache : $templateCache })
+var transformResponse = $http.defaults && $http.defaults.transformResponse;
+if (isArray(transformResponse)) {
+transformResponse = transformResponse.filter(function(transformer) {
+return transformer !== defaultHttpResponseTransform;
+});
+} else if (transformResponse === defaultHttpResponseTransform) {
+transformResponse = null;
+}
+var httpOptions = {
+cache: $templateCache,
+transformResponse: transformResponse
+};
+return $http.get(tpl, httpOptions)
 .then(function(response) {
-var html = response.data;
-if(!html || html.length === 0) {
-return handleError();
-}
 self.totalPendingRequests--;
-$templateCache.put(tpl, html);
+return response.data;
-return html;
 }, handleError);
-function handleError() {
+function handleError(resp) {
 self.totalPendingRequests--;
 if (!ignoreRequestError) {
 throw $compileMinErr('tpload', 'Failed to load template: {0}', tpl);
 }
-return $q.reject();
+return $q.reject(resp);
 }
 }
 handleRequestFn.totalPendingRequests = 0;
 forEach(bindings, function(binding) {
 var dataBinding = angular.element(binding).data('$binding');
 if (dataBinding) {
 forEach(dataBinding, function(bindingName) {
 if (opt_exactMatch) {
-var matcher = new RegExp('(^|\\s)' + expression + '(\\s|\\||$)');
+var matcher = new RegExp('(^|\\s)' + escapeForRegexp(expression) + '(\\s|\\||$)');
 if (matcher.test(bindingName)) {
 matches.push(binding);
 }
 } else {
 if (bindingName.indexOf(expression) != -1) {
 timeoutId;
 timeoutId = $browser.defer(function() {
 try {
 deferred.resolve(fn());
-} catch(e) {
+} catch (e) {
 deferred.reject(e);
 $exceptionHandler(e);
 }
 finally {
 delete deferreds[promise.$$timeoutId];
 // cause us to break tests.  In addition, when the browser resolves a URL for XHR, it
 // doesn't know about mocked locations and resolves URLs to the real document - which is
 // exactly the behavior needed here.  There is little value is mocking these out for this
 // service.
 var urlParsingNode = document.createElement("a");
-var originUrl = urlResolve(window.location.href, true);
+var originUrl = urlResolve(window.location.href);
 /**
 *
 * Implementation Notes for non-IE browsers
 *   | hostname      | The hostname
 *   | port          | The port, without ":"
 *   | pathname      | The pathname, beginning with "/"
 *
 */
-function urlResolve(url, base) {
+function urlResolve(url) {
 var href = url;
 if (msie) {
 // Normalize before parse.  Refer Implementation Notes on why this is
 // done in two steps on IE.
 * @example
 <example module="windowExample">
 <file name="index.html">
 <script>
 angular.module('windowExample', [])
-.controller('ExampleController', ['$scope', '$window', function ($scope, $window) {
+.controller('ExampleController', ['$scope', '$window', function($scope, $window) {
 $scope.greeting = 'Hello, World!';
 $scope.doGreeting = function(greeting) {
 $window.alert(greeting);
 };
 }]);
 // element(':button').click();
 });
 </file>
 </example>
 */
-function $WindowProvider(){
+function $WindowProvider() {
 this.$get = valueFn(window);
 }
 /* global currencyFilter: true,
 dateFilter: true,
 *    the keys are the filter names and the values are the filter factories.
 * @returns {Object} Registered filter instance, or if a map of filters was provided then a map
 *    of the registered filter instances.
 */
 function register(name, factory) {
-if(isObject(name)) {
+if (isObject(name)) {
 var filters = {};
 forEach(name, function(filter, key) {
 filters[key] = register(key, filter);
 });
 return filters;
 * @param {string|Object|function()} expression The predicate to be used for selecting items from
 *   `array`.
 *
 *   Can be one of:
 *
-*   - `string`: The string is evaluated as an expression and the resulting value is used for substring match against
+*   - `string`: The string is used for matching against the contents of the `array`. All strings or
-*     the contents of the `array`. All strings or objects with string properties in `array` that contain this string
+*     objects with string properties in `array` that match this string will be returned. This also
-*     will be returned. The predicate can be negated by prefixing the string with `!`.
+*     applies to nested object properties.
+*     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`
+*     property of the object or its nested object properties. That's equivalent to the simple
-*     as described above. The predicate can be negated by prefixing the string with `!`.
+*     substring match with a `string` as described above. The predicate can be negated by prefixing
-*     For Example `{name: "!M"}` predicate will return an array of items which have property `name`
+*     the string with `!`.
+*     For example `{name: "!M"}` predicate will return an array of items which have property `name`
 *     not containing "M".
+*
+*     Note that a named property will match properties on the same level only, while the special
+*     `$` property will match properties on the same level or deeper. E.g. an array item like
+*     `{name: {first: 'John', last: 'Doe'}}` will **not** be matched by `{name: 'John'}`, but
+*     **will** be matched by `{$: 'John'}`.
 *
 *   - `function(value, index)`: 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.
 *
 *
 *   Can be one of:
 *
 *   - `function(actual, expected)`:
 *     The function will be given the object value and the predicate value to compare and
-*     should return true if the item should be included in filtered result.
+*     should return true if both values should be considered equal.
 *
-*   - `true`: A shorthand for `function(actual, expected) { return angular.equals(expected, actual)}`.
+*   - `true`: A shorthand for `function(actual, expected) { return angular.equals(actual, expected)}`.
-*     this is essentially strict comparison of expected and actual.
+*     This is essentially strict comparison of expected and actual.
 *
 *   - `false|undefined`: A short hand for a function which will look for a substring match in case
 *     insensitive way.
 *
 * @example
 */
 function filterFilter() {
 return function(array, expression, comparator) {
 if (!isArray(array)) return array;
-var comparatorType = typeof(comparator),
+var predicateFn;
-predicates = [];
+var matchAgainstAnyProp;
-predicates.check = function(value, index) {
-for (var j = 0; j < predicates.length; j++) {
-if(!predicates[j](value, index)) {
-return false;
-}
-}
-return true;
-};
-if (comparatorType !== 'function') {
-if (comparatorType === 'boolean' && comparator) {
-comparator = function(obj, text) {
-return angular.equals(obj, text);
-};
-} else {
-comparator = function(obj, text) {
-if (obj && text && typeof obj === 'object' && typeof text === 'object') {
-for (var objKey in obj) {
-if (objKey.charAt(0) !== '$' && hasOwnProperty.call(obj, objKey) &&
-comparator(obj[objKey], text[objKey])) {
-return true;
-}
-}
-return false;
-}
-text = (''+text).toLowerCase();
-return (''+obj).toLowerCase().indexOf(text) > -1;
-};
-}
-}
-var search = function(obj, text){
-if (typeof text == 'string' && text.charAt(0) === '!') {
-return !search(obj, text.substr(1));
-}
-switch (typeof obj) {
-case "boolean":
-case "number":
-case "string":
-return comparator(obj, text);
-case "object":
-switch (typeof text) {
-case "object":
-return comparator(obj, text);
-default:
-for ( var objKey in obj) {
-if (objKey.charAt(0) !== '$' && search(obj[objKey], text)) {
-return true;
-}
-}
-break;
-}
-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 'function':
-case "number":
+predicateFn = expression;
-case "string":
-// Set up expression object and fall through
-expression = {$:expression};
-// jshint -W086
-case "object":
-// jshint +W086
-for (var key in expression) {
-(function(path) {
-if (typeof expression[path] === 'undefined') return;
-predicates.push(function(value) {
-return search(path == '$' ? value : (value && value[path]), expression[path]);
-});
-})(key);
-}
 break;
-case 'function':
+case 'boolean':
-predicates.push(expression);
+case 'number':
+case 'string':
+matchAgainstAnyProp = true;
+//jshint -W086
+case 'object':
+//jshint +W086
+predicateFn = createPredicateFn(expression, comparator, matchAgainstAnyProp);
 break;
 default:
 return array;
 }
-var filtered = [];
-for ( var j = 0; j < array.length; j++) {
+return array.filter(predicateFn);
-var value = array[j];
+};
-if (predicates.check(value, j)) {
+}
-filtered.push(value);
+// Helper functions for `filterFilter`
+function createPredicateFn(expression, comparator, matchAgainstAnyProp) {
+var shouldMatchPrimitives = isObject(expression) && ('$' in expression);
+var predicateFn;
+if (comparator === true) {
+comparator = equals;
+} else if (!isFunction(comparator)) {
+comparator = function(actual, expected) {
+if (isObject(actual) || isObject(expected)) {
+// Prevent an object to be considered equal to a string like `'[object'`
+return false;
 }
-}
-return filtered;
+actual = lowercase('' + actual);
+expected = lowercase('' + expected);
+return actual.indexOf(expected) !== -1;
+};
+}
+predicateFn = function(item) {
+if (shouldMatchPrimitives && !isObject(item)) {
+return deepCompare(item, expression.$, comparator, false);
+}
+return deepCompare(item, expression, comparator, matchAgainstAnyProp);
 };
+return predicateFn;
+}
+function deepCompare(actual, expected, comparator, matchAgainstAnyProp, dontMatchWholeObject) {
+var actualType = typeof actual;
+var expectedType = typeof expected;
+if ((expectedType === 'string') && (expected.charAt(0) === '!')) {
+return !deepCompare(actual, expected.substring(1), comparator, matchAgainstAnyProp);
+} else if (actualType === 'array') {
+// In case `actual` is an array, consider it a match
+// if ANY of it's items matches `expected`
+return actual.some(function(item) {
+return deepCompare(item, expected, comparator, matchAgainstAnyProp);
+});
+}
+switch (actualType) {
+case 'object':
+var key;
+if (matchAgainstAnyProp) {
+for (key in actual) {
+if ((key.charAt(0) !== '$') && deepCompare(actual[key], expected, comparator, true)) {
+return true;
+}
+}
+return dontMatchWholeObject ? false : deepCompare(actual, expected, comparator, false);
+} else if (expectedType === 'object') {
+for (key in expected) {
+var expectedVal = expected[key];
+if (isFunction(expectedVal)) {
+continue;
+}
+var matchAnyProperty = key === '$';
+var actualVal = matchAnyProperty ? actual : actual[key];
+if (!deepCompare(actualVal, expectedVal, comparator, matchAnyProperty, matchAnyProperty)) {
+return false;
+}
+}
+return true;
+} else {
+return comparator(actual, expected);
+}
+break;
+case 'function':
+return false;
+default:
+return comparator(actual, expected);
+}
 }
 /**
 * @ngdoc filter
 * @name currency
 * 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.
+* @param {number=} fractionSize Number of decimal places to round the amount to, defaults to default max fraction size for current locale
 * @returns {string} Formatted number.
 *
 *
 * @example
 <example module="currencyExample">
 }]);
 </script>
 <div ng-controller="ExampleController">
 <input type="number" ng-model="amount"> <br>
 default currency symbol ($): <span id="currency-default">{{amount | currency}}</span><br>
-custom currency identifier (USD$): <span>{{amount | currency:"USD$"}}</span>
+custom currency identifier (USD$): <span id="currency-custom">{{amount | currency:"USD$"}}</span>
+no fractions (0): <span id="currency-no-fractions">{{amount | currency:"USD$":0}}</span>
 </div>
 </file>
 <file name="protractor.js" type="protractor">
 it('should init with 1234.56', function() {
 expect(element(by.id('currency-default')).getText()).toBe('$1,234.56');
-expect(element(by.binding('amount | currency:"USD$"')).getText()).toBe('USD$1,234.56');
+expect(element(by.id('currency-custom')).getText()).toBe('USD$1,234.56');
+expect(element(by.id('currency-no-fractions')).getText()).toBe('USD$1,235');
 });
 it('should update', function() {
 if (browser.params.browser == 'safari') {
 // Safari does not understand the minus key. See
 // https://github.com/angular/protractor/issues/481
 return;
 }
 element(by.model('amount')).clear();
 element(by.model('amount')).sendKeys('-1234');
 expect(element(by.id('currency-default')).getText()).toBe('($1,234.00)');
-expect(element(by.binding('amount | currency:"USD$"')).getText()).toBe('(USD$1,234.00)');
+expect(element(by.id('currency-custom')).getText()).toBe('(USD$1,234.00)');
+expect(element(by.id('currency-no-fractions')).getText()).toBe('(USD$1,234)');
 });
 </file>
 </example>
 */
 currencyFilter.$inject = ['$locale'];
 function currencyFilter($locale) {
 var formats = $locale.NUMBER_FORMATS;
-return function(amount, currencySymbol){
+return function(amount, currencySymbol, fractionSize) {
-if (isUndefined(currencySymbol)) currencySymbol = formats.CURRENCY_SYM;
+if (isUndefined(currencySymbol)) {
+currencySymbol = formats.CURRENCY_SYM;
+}
+if (isUndefined(fractionSize)) {
+fractionSize = formats.PATTERNS[1].maxFrac;
+}
 // if null or undefined pass it through
 return (amount == null)
 ? amount
-: formatNumber(amount, formats.PATTERNS[1], formats.GROUP_SEP, formats.DECIMAL_SEP, 2).
+: formatNumber(amount, formats.PATTERNS[1], formats.GROUP_SEP, formats.DECIMAL_SEP, fractionSize).
 replace(/\u00A4/g, currencySymbol);
 };
 }
 /**
 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';
 number = 0;
 } else {
 formatedText = numStr;
 hasExponent = true;
 }
 // safely round numbers in JS without hitting imprecisions of floating-point arithmetics
 // inspired by:
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
 number = +(Math.round(+(number.toString() + 'e' + fractionSize)).toString() + 'e' + -fractionSize);
-if (number === 0) {
-isNegative = false;
-}
 var fraction = ('' + number).split(DECIMAL_SEP);
 var whole = fraction[0];
 fraction = fraction[1] || '';
 var i, pos = 0,
 group = pattern.gSize;
 if (whole.length >= (lgroup + group)) {
 pos = whole.length - lgroup;
 for (i = 0; i < pos; i++) {
-if ((pos - i)%group === 0 && i !== 0) {
+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) {
+if ((whole.length - i) % lgroup === 0 && i !== 0) {
 formatedText += groupSep;
 }
 formatedText += whole.charAt(i);
 }
 // format fraction part.
-while(fraction.length < fractionSize) {
+while (fraction.length < fractionSize) {
 fraction += '0';
 }
 if (fractionSize && fractionSize !== "0") formatedText += decimalSep + fraction.substr(0, fractionSize);
 } else {
+if (fractionSize > 0 && number < 1) {
-if (fractionSize > 0 && number > -1 && number < 1) {
 formatedText = number.toFixed(fractionSize);
+number = parseFloat(formatedText);
 }
 }
-parts.push(isNegative ? pattern.negPre : pattern.posPre);
+if (number === 0) {
-parts.push(formatedText);
+isNegative = false;
-parts.push(isNegative ? pattern.negSuf : pattern.posSuf);
+}
+parts.push(isNegative ? pattern.negPre : pattern.posPre,
+formatedText,
+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;
+while (num.length < digits) num = '0' + num;
 if (trim)
 num = num.substr(num.length - digits);
 return neg + num;
 }
 offset = offset || 0;
 return function(date) {
 var value = date['get' + name]();
 if (offset > 0 || value > -offset)
 value += offset;
-if (value === 0 && offset == -12 ) value = 12;
+if (value === 0 && offset == -12) value = 12;
 return padNumber(value, size, trim);
 };
 }
 function dateStrGetter(name, shortForm) {
 *   * `'ss'`: Second in minute, padded (00-59)
 *   * `'s'`: Second in minute (0-59)
 *   * `'.sss' or ',sss'`: Millisecond in second, padded (000-999)
 *   * `'a'`: AM/PM marker
 *   * `'Z'`: 4 digit (+sign) representation of the timezone offset (-1200-+1200)
-*   * `'ww'`: ISO-8601 week of year (00-53)
+*   * `'ww'`: Week of year, padded (00-53). Week 01 is the week with the first Thursday of the year
-*   * `'w'`: ISO-8601 week of year (0-53)
+*   * `'w'`: Week of year (0-53). Week 1 is the week with the first Thursday of the year
 *
 *   `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
 if (match[9]) {
 tzHour = int(match[9] + match[10]);
 tzMin = int(match[9] + match[11]);
 }
 dateSetter.call(date, int(match[1]), int(match[2]) - 1, int(match[3]));
-var h = int(match[4]||0) - tzHour;
+var h = int(match[4] || 0) - tzHour;
-var m = int(match[5]||0) - tzMin;
+var m = int(match[5] || 0) - tzMin;
-var s = int(match[6]||0);
+var s = int(match[6] || 0);
-var ms = Math.round(parseFloat('0.' + (match[7]||0)) * 1000);
+var ms = Math.round(parseFloat('0.' + (match[7] || 0)) * 1000);
 timeSetter.call(date, h, m, s, ms);
 return date;
 }
 return string;
 }
 if (!isDate(date)) {
 return date;
 }
-while(format) {
+while (format) {
 match = DATE_FORMATS_SPLIT.exec(format);
 if (match) {
 parts = concat(parts, match, 1);
 format = parts.pop();
 } else {
 if (timezone && timezone === 'UTC') {
 date = new Date(date.getTime());
 date.setMinutes(date.getMinutes() + date.getTimezoneOffset());
 }
-forEach(parts, function(value){
+forEach(parts, function(value) {
 fn = DATE_FORMATS[value];
 text += fn ? fn(date, $locale.DATETIME_FORMATS)
 : value.replace(/(^'|'$)/g, '').replace(/''/g, "'");
 });
 *
 *   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.
+* @param {number=} spacing The number of spaces to use per indentation, defaults to 2.
 * @returns {string} JSON string.
 *
 *
 * @example
 <example>
 <file name="index.html">
-<pre>{{ {'name':'value'} | json }}</pre>
+<pre id="default-spacing">{{ {'name':'value'} | json }}</pre>
+<pre id="custom-spacing">{{ {'name':'value'} | json:4 }}</pre>
 </file>
 <file name="protractor.js" type="protractor">
 it('should jsonify filtered objects', function() {
-expect(element(by.binding("{'name':'value'}")).getText()).toMatch(/\{\n  "name": ?"value"\n}/);
+expect(element(by.id('default-spacing')).getText()).toMatch(/\{\n  "name": ?"value"\n}/);
+expect(element(by.id('custom-spacing')).getText()).toMatch(/\{\n    "name": ?"value"\n}/);
 });
 </file>
 </example>
 *
 */
 function jsonFilter() {
-return function(object) {
+return function(object, spacing) {
-return toJson(object, true);
+if (isUndefined(spacing)) {
+spacing = 2;
+}
+return toJson(object, spacing);
 };
 }
 /**
 <div ng-controller="ExampleController">
 Limit {{numbers}} to: <input type="number" step="1" ng-model="numLimit">
 <p>Output numbers: {{ numbers | limitTo:numLimit }}</p>
 Limit {{letters}} to: <input type="number" step="1" ng-model="letterLimit">
 <p>Output letters: {{ letters | limitTo:letterLimit }}</p>
-Limit {{longNumber}} to: <input type="integer" ng-model="longNumberLimit">
+Limit {{longNumber}} to: <input type="number" step="1" ng-model="longNumberLimit">
 <p>Output long number: {{ longNumber | limitTo:longNumberLimit }}</p>
 </div>
 </file>
 <file name="protractor.js" type="protractor">
 var numLimitInput = element(by.model('numLimit'));
 expect(limitedLongNumber.getText()).toEqual('Output long number: 2345432342');
 });
 </file>
 </example>
 */
-function limitToFilter(){
+function limitToFilter() {
 return function(input, limit) {
 if (isNumber(input)) input = input.toString();
 if (!isArray(input) && !isString(input)) return input;
 if (Math.abs(Number(limit)) === Infinity) {
 } else {
 return "";
 }
 }
-var out = [],
+var i, n;
-i, n;
 // if abs(limit) exceeds maximum length, trim it
 if (limit > input.length)
 limit = input.length;
 else if (limit < -input.length)
 if (limit > 0) {
 i = 0;
 n = limit;
 } else {
+// zero and NaN check on limit - return empty array
+if (!limit) return [];
 i = input.length + limit;
 n = input.length;
 }
-for (; i<n; i++) {
+return input.slice(i, n);
-out.push(input[i]);
-}
-return out;
 };
 }
 /**
 * @ngdoc filter
 }]);
 </file>
 </example>
 */
 orderByFilter.$inject = ['$parse'];
-function orderByFilter($parse){
+function orderByFilter($parse) {
 return function(array, sortPredicate, reverseOrder) {
 if (!(isArrayLike(array))) return array;
-sortPredicate = isArray(sortPredicate) ? sortPredicate: [sortPredicate];
+sortPredicate = isArray(sortPredicate) ? sortPredicate : [sortPredicate];
 if (sortPredicate.length === 0) { sortPredicate = ['+']; }
-sortPredicate = sortPredicate.map(function(predicate){
+sortPredicate = sortPredicate.map(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);
 }
-if ( predicate === '' ) {
+if (predicate === '') {
 // Effectively no predicate was passed so we compare identity
-return reverseComparator(function(a,b) {
+return reverseComparator(compare, descending);
-return compare(a, b);
-}, descending);
 }
 get = $parse(predicate);
 if (get.constant) {
 var key = get();
-return reverseComparator(function(a,b) {
+return reverseComparator(function(a, b) {
 return compare(a[key], b[key]);
 }, descending);
 }
 }
-return reverseComparator(function(a,b){
+return reverseComparator(function(a, b) {
 return compare(get(a),get(b));
 }, descending);
 });
-var arrayCopy = [];
+return slice.call(array).sort(reverseComparator(comparator, reverseOrder));
-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++) {
-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 descending
-? function(a,b){return comp(b,a);}
+? function(a, b) {return comp(b,a);}
 : comp;
 }
-function compare(v1, v2){
+function isPrimitive(value) {
+switch (typeof value) {
+case 'number': /* falls through */
+case 'boolean': /* falls through */
+case 'string':
+return true;
+default:
+return false;
+}
+}
+function objectToString(value) {
+if (value === null) return 'null';
+if (typeof value.valueOf === 'function') {
+value = value.valueOf();
+if (isPrimitive(value)) return value;
+}
+if (typeof value.toString === 'function') {
+value = value.toString();
+if (isPrimitive(value)) return value;
+}
+return '';
+}
+function compare(v1, v2) {
 var t1 = typeof v1;
 var t2 = typeof v2;
-if (t1 == t2) {
+if (t1 === t2 && t1 === "object") {
-if (isDate(v1) && isDate(v2)) {
+v1 = objectToString(v1);
-v1 = v1.valueOf();
+v2 = objectToString(v2);
-v2 = v2.valueOf();
+}
-}
+if (t1 === t2) {
-if (t1 == "string") {
+if (t1 === "string") {
 v1 = v1.toLowerCase();
 v2 = v2.toLowerCase();
 }
 if (v1 === v2) return 0;
 return v1 < v2 ? -1 : 1;
 if (!attr.href && !attr.xlinkHref && !attr.name) {
 return function(scope, element) {
 // SVGAElement does not use the href attribute, but rather the 'xlinkHref' attribute.
 var href = toString.call(element.prop('href')) === '[object SVGAnimatedString]' ?
 'xlink:href' : 'href';
-element.on('click', function(event){
+element.on('click', function(event) {
 // if we have no href url, then don't navigate anywhere.
 if (!element.attr(href)) {
 event.preventDefault();
 }
 });
 * @description
 * Using Angular markup like `{{hash}}` in an href attribute will
 * make the link go to the wrong URL if the user clicks it before
 * Angular has a chance to replace the `{{hash}}` markup with its
 * value. Until Angular replaces the markup the link will be broken
-* and will most likely return a 404 error.
+* and will most likely return a 404 error. The `ngHref` directive
-*
+* solves this problem.
-* The `ngHref` directive solves this problem.
 *
 * The wrong way to write it:
 * ```html
 * <a href="http://www.gravatar.com/avatar/{{hash}}">link1</a>
 * ```
 *  - `minlength`
 *  - `number`
 *  - `pattern`
 *  - `required`
 *  - `url`
+*  - `date`
+*  - `datetimelocal`
+*  - `time`
+*  - `week`
+*  - `month`
 *
 * @description
 * `FormController` keeps track of all its controls and nested forms as well as the state of them,
 * such as being valid/invalid or dirty/pristine.
 *
 * in this form.
 *
 * Setting a form back to a pristine state is often useful when we want to 'reuse' a form after
 * saving or resetting it.
 */
-form.$setPristine = function () {
+form.$setPristine = function() {
 $animate.setClass(element, PRISTINE_CLASS, DIRTY_CLASS + ' ' + SUBMITTED_CLASS);
 form.$dirty = false;
 form.$pristine = true;
 form.$submitted = false;
 forEach(controls, function(control) {
 * untouched state (ng-untouched class).
 *
 * Setting a form controls back to their untouched state is often useful when setting the form
 * back to its pristine state.
 */
-form.$setUntouched = function () {
+form.$setUntouched = function() {
 forEach(controls, function(control) {
 control.$setUntouched();
 });
 };
 * @name form.FormController#$setSubmitted
 *
 * @description
 * Sets the form to its submitted state.
 */
-form.$setSubmitted = function () {
+form.$setSubmitted = function() {
 $animate.addClass(element, SUBMITTED_CLASS);
 form.$submitted = true;
 parentForm.$setSubmitted();
 };
 }
 scope.$apply(function() {
 controller.$commitViewValue();
 controller.$setSubmitted();
 });
-event.preventDefault
+event.preventDefault();
-? event.preventDefault()
-: event.returnValue = false; // IE
 };
 addEventListenerFn(formElement[0], 'submit', handleFormSubmission);
 // unregister the preventDefault listener so that we don't not leak memory but in a
 alias = newValue;
 setter(scope, alias, controller, alias);
 parentFormCtrl.$$renameControl(controller, alias);
 });
 }
-if (parentFormCtrl !== nullFormCtrl) {
+formElement.on('$destroy', function() {
-formElement.on('$destroy', function() {
+parentFormCtrl.$removeControl(controller);
-parentFormCtrl.$removeControl(controller);
+if (alias) {
-if (alias) {
+setter(scope, alias, undefined, alias);
-setter(scope, alias, undefined, alias);
+}
-}
+extend(controller, nullFormCtrl); //stop propagating child destruction handlers upwards
-extend(controller, nullFormCtrl); //stop propagating child destruction handlers upwards
+});
-});
-}
 }
 };
 }
 };
 * @name input[text]
 *
 * @description
 * Standard HTML text input with angular data binding, inherited by most of the `input` elements.
 *
-* *NOTE* Not every feature offered is available for all input types.
 *
 * @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.
+*    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
-* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
+*    any length.
-*    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
+* @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
-*    patterns defined as scope expressions.
+*    that contains the regular expression body that will be converted to a regular expression
+*    as in the ngPattern directive.
+* @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match
+*    a RegExp found by evaluating the Angular expression given in the attribute value.
+*    If the expression evaluates to a RegExp object then this is used directly.
+*    If the expression is a string then it will be converted to a RegExp after wrapping it in `^` and `$`
+*    characters. For instance, `"abc"` will be converted to `new RegExp('^abc$')`.
 * @param {string=} ngChange Angular expression to be executed when input changes due to user
 *    interaction with the input element.
 * @param {boolean=} [ngTrim=true] If set to false Angular will not automatically trim the input.
 *    This parameter is ignored for input[type=password] controls, which will never trim the
 *    input.
 * @description
 * Input with date validation and transformation. In browsers that do not yet support
 * the HTML5 date input, a text element will be used. In that case, text must be entered in a valid ISO-8601
 * date format (yyyy-MM-dd), for example: `2009-01-06`. Since many
 * modern browsers do not yet support this input type, it is important to provide cues to users on the
-* expected input format via a placeholder or label. The model must always be a Date object.
+* expected input format via a placeholder or label.
+*
+* The model must always be a Date object, otherwise Angular will throw an error.
+* Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
 *
 * The timezone to be used to read/write the `Date` instance in the model can be defined using
 * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 createDateParser(DATE_REGEXP, ['yyyy', 'MM', 'dd']),
 'yyyy-MM-dd'),
 /**
 * @ngdoc input
-* @name input[dateTimeLocal]
+* @name input[datetime-local]
 *
 * @description
 * Input with datetime validation and transformation. In browsers that do not yet support
 * the HTML5 date input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
-* local datetime format (yyyy-MM-ddTHH:mm:ss), for example: `2010-12-28T14:57:00`. The model must be a Date object.
+* local datetime format (yyyy-MM-ddTHH:mm:ss), for example: `2010-12-28T14:57:00`.
+*
+* The model must always be a Date object, otherwise Angular will throw an error.
+* Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
 *
 * The timezone to be used to read/write the `Date` instance in the model can be defined using
 * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 * Input with time validation and transformation. In browsers that do not yet support
 * the HTML5 date input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
 * local time format (HH:mm:ss), for example: `14:57:00`. Model must be a Date object. This binding will always output a
 * Date object to the model of January 1, 1970, or local date `new Date(1970, 0, 1, HH, mm, ss)`.
 *
+* The model must always be a Date object, otherwise Angular will throw an error.
+* Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
+*
 * The timezone to be used to read/write the `Date` instance in the model can be defined using
 * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 * @param {string=} name Property name of the form under which the control is published.
 * @name input[week]
 *
 * @description
 * Input with week-of-the-year validation and transformation to Date. In browsers that do not yet support
 * the HTML5 week input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
-* week format (yyyy-W##), for example: `2013-W02`. The model must always be a Date object.
+* week format (yyyy-W##), for example: `2013-W02`.
+*
+* The model must always be a Date object, otherwise Angular will throw an error.
+* Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
 *
 * The timezone to be used to read/write the `Date` instance in the model can be defined using
 * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 * @name input[month]
 *
 * @description
 * Input with month validation and transformation. In browsers that do not yet support
 * the HTML5 month input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
-* month format (yyyy-MM), for example: `2009-01`. The model must always be a Date object. In the event the model is
+* month format (yyyy-MM), for example: `2009-01`.
-* not set to the first of the month, the first of that model's month is assumed.
+*
+* The model must always be a Date object, otherwise Angular will throw an error.
+* Invalid `Date` objects (dates whose `getTime()` is `NaN`) will be rendered as an empty string.
+* If the model is not set to the first of the month, the next view to model update will set it
+* to the first of the month.
 *
 * The timezone to be used to read/write the `Date` instance in the model can be defined using
 * {@link ng.directive:ngModelOptions ngModelOptions}. By default, this is the timezone of the browser.
 *
 * @param {string} ngModel Assignable angular expression to data-bind to.
 *
 * @description
 * Text input with number validation and transformation. Sets the `number` validation
 * error if not a valid number.
 *
+* The model must always be a number, otherwise Angular will throw an error.
+*
 * @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 than `min`.
 * @param {string=} max Sets the `max` validation error key if the value entered is greater than `max`.
 * @param {string=} required Sets `required` validation error key if the value is not entered.
 *    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.
+*    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
-* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
+*    any length.
-*    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
+* @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
-*    patterns defined as scope expressions.
+*    that contains the regular expression body that will be converted to a regular expression
+*    as in the ngPattern directive.
+* @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match
+*    a RegExp found by evaluating the Angular expression given in the attribute value.
+*    If the expression evaluates to a RegExp object then this is used directly.
+*    If the expression is a string then it will be converted to a RegExp after wrapping it in `^` and `$`
+*    characters. For instance, `"abc"` will be converted to `new RegExp('^abc$')`.
 * @param {string=} ngChange Angular expression to be executed when input changes due to user
 *    interaction with the input element.
 *
 * @example
 <example name="number-input-directive" module="numberExample">
 *
 * @description
 * Text input with URL validation. Sets the `url` validation error key if the content is not a
 * valid URL.
 *
+* <div class="alert alert-warning">
+* **Note:** `input[url]` uses a regex to validate urls that is derived from the regex
+* used in Chromium. If you need stricter validation, you can use `ng-pattern` or modify
+* the built-in validators (see the {@link guide/forms Forms guide})
+* </div>
+*
 * @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.
+*    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
-* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
+*    any length.
-*    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
+* @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
-*    patterns defined as scope expressions.
+*    that contains the regular expression body that will be converted to a regular expression
+*    as in the ngPattern directive.
+* @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match
+*    a RegExp found by evaluating the Angular expression given in the attribute value.
+*    If the expression evaluates to a RegExp object then this is used directly.
+*    If the expression is a string then it will be converted to a RegExp after wrapping it in `^` and `$`
+*    characters. For instance, `"abc"` will be converted to `new RegExp('^abc$')`.
 * @param {string=} ngChange Angular expression to be executed when input changes due to user
 *    interaction with the input element.
 *
 * @example
 <example name="url-input-directive" module="urlExample">
 *
 * @description
 * Text input with email validation. Sets the `email` validation error key if not a valid email
 * address.
 *
+* <div class="alert alert-warning">
+* **Note:** `input[email]` uses a regex to validate email addresses that is derived from the regex
+* used in Chromium. If you need stricter validation (e.g. requiring a top-level domain), you can
+* use `ng-pattern` or modify the built-in validators (see the {@link guide/forms Forms guide})
+* </div>
+*
 * @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.
+*    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
-* @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
+*    any length.
-*    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
+* @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
-*    patterns defined as scope expressions.
+*    that contains the regular expression body that will be converted to a regular expression
+*    as in the ngPattern directive.
+* @param {string=} ngPattern Sets `pattern` validation error key if the ngModel value does not match
+*    a RegExp found by evaluating the Angular expression given in the attribute value.
+*    If the expression evaluates to a RegExp object then this is used directly.
+*    If the expression is a string then it will be converted to a RegExp after wrapping it in `^` and `$`
+*    characters. For instance, `"abc"` will be converted to `new RegExp('^abc$')`.
 * @param {string=} ngChange Angular expression to be executed when input changes due to user
 *    interaction with the input element.
 *
 * @example
 <example name="email-input-directive" module="emailExample">
 'submit': noop,
 'reset': noop,
 'file': noop
 };
-function testFlags(validity, flags) {
-var i, flag;
-if (flags) {
-for (i=0; i<flags.length; ++i) {
-flag = flags[i];
-if (validity[flag]) {
-return true;
-}
-}
-}
-return false;
-}
 function stringBasedInputType(ctrl) {
 ctrl.$formatters.push(function(value) {
 return ctrl.$isEmpty(value) ? value : value.toString();
 });
 }
 baseInputType(scope, element, attr, ctrl, $sniffer, $browser);
 stringBasedInputType(ctrl);
 }
 function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
-var validity = element.prop(VALIDITY_STATE_PROPERTY);
-var placeholder = element[0].placeholder, noevent = {};
 var type = lowercase(element[0].type);
 // In composition mode, users are still inputing intermediate text buffer,
 // hold the listener until composition is done.
 // More about composition events: https://developer.mozilla.org/en-US/docs/Web/API/CompositionEvent
 listener();
 });
 }
 var listener = function(ev) {
+if (timeout) {
+$browser.defer.cancel(timeout);
+timeout = null;
+}
 if (composing) return;
 var value = element.val(),
 event = ev && ev.type;
-// IE (11 and under) seem to emit an 'input' event if the placeholder value changes.
-// We don't want to dirty the value when this happens, so we abort here. Unfortunately,
-// IE also sends input events for other non-input-related things, (such as focusing on a
-// form control), so this change is not entirely enough to solve this.
-if (msie && (ev || noevent).type === 'input' && element[0].placeholder !== placeholder) {
-placeholder = element[0].placeholder;
-return;
-}
 // By default we will trim the value
 // If the attribute ng-trim exists we will avoid trimming
 // If input type is 'password', the value is never trimmed
 if (type !== 'password' && (!attr.ngTrim || attr.ngTrim !== 'false')) {
 if ($sniffer.hasEvent('input')) {
 element.on('input', listener);
 } else {
 var timeout;
-var deferListener = function(ev) {
+var deferListener = function(ev, input, origValue) {
 if (!timeout) {
 timeout = $browser.defer(function() {
-listener(ev);
 timeout = null;
+if (!input || input.value !== origValue) {
+listener(ev);
+}
 });
 }
 };
 element.on('keydown', function(event) {
 // ignore
 //    command            modifiers                   arrows
 if (key === 91 || (15 < key && key < 19) || (37 <= key && key <= 40)) return;
-deferListener(event);
+deferListener(event, this, this.value);
 });
 // if user modifies input value using context menu in IE, we need "paste" and "cut" events to catch it
 if ($sniffer.hasEvent('paste')) {
 element.on('paste cut', deferListener);
 // if user paste into input using mouse on older browser
 // or form autocomplete on newer browser, we need "change" event to catch it
 element.on('change', listener);
 ctrl.$render = function() {
-element.val(ctrl.$isEmpty(ctrl.$modelValue) ? '' : ctrl.$viewValue);
+element.val(ctrl.$isEmpty(ctrl.$viewValue) ? '' : ctrl.$viewValue);
 };
 }
 function weekParser(isoWeek, existingDate) {
 if (isDate(isoWeek)) {
 if (isString(iso)) {
 // When a date is JSON'ified to wraps itself inside of an extra
 // set of double quotes. This makes the date parsing code unable
 // to match the date string and parse it as a date.
-if (iso.charAt(0) == '"' && iso.charAt(iso.length-1) == '"') {
+if (iso.charAt(0) == '"' && iso.charAt(iso.length - 1) == '"') {
-iso = iso.substring(1, iso.length-1);
+iso = iso.substring(1, iso.length - 1);
 }
 if (ISO_DATE_REGEXP.test(iso)) {
 return new Date(iso);
 }
 regexp.lastIndex = 0;
 }
 return undefined;
 });
 ctrl.$formatters.push(function(value) {
-if (!ctrl.$isEmpty(value)) {
+if (value && !isDate(value)) {
-if (!isDate(value)) {
+throw $ngModelMinErr('datefmt', 'Expected `{0}` to be a date', value);
-throw $ngModelMinErr('datefmt', 'Expected `{0}` to be a date', value);
+}
-}
+if (isValidDate(value)) {
 previousDate = value;
 if (previousDate && timezone === 'UTC') {
 var timezoneOffset = 60000 * previousDate.getTimezoneOffset();
 previousDate = new Date(previousDate.getTime() + timezoneOffset);
 }
 return $filter('date')(value, format, timezone);
 } else {
 previousDate = null;
+return '';
 }
-return '';
 });
 if (isDefined(attr.min) || attr.ngMin) {
 var minVal;
 ctrl.$validators.min = function(value) {
-return ctrl.$isEmpty(value) || isUndefined(minVal) || parseDate(value) >= minVal;
+return !isValidDate(value) || isUndefined(minVal) || parseDate(value) >= minVal;
 };
 attr.$observe('min', function(val) {
 minVal = parseObservedDateValue(val);
 ctrl.$validate();
 });
 }
 if (isDefined(attr.max) || attr.ngMax) {
 var maxVal;
 ctrl.$validators.max = function(value) {
-return ctrl.$isEmpty(value) || isUndefined(maxVal) || parseDate(value) <= maxVal;
+return !isValidDate(value) || isUndefined(maxVal) || parseDate(value) <= maxVal;
 };
 attr.$observe('max', function(val) {
 maxVal = parseObservedDateValue(val);
 ctrl.$validate();
 });
 }
-// Override the standard $isEmpty to detect invalid dates as well
-ctrl.$isEmpty = function(value) {
+function isValidDate(value) {
 // Invalid Date: getTime() returns NaN
-return !value || (value.getTime && value.getTime() !== value.getTime());
+return value && !(value.getTime && value.getTime() !== value.getTime());
-};
+}
 function parseObservedDateValue(val) {
 return isDefined(val) ? (isDate(val) ? val : parseDate(val)) : undefined;
 }
 };
 // in browsers, i.e. we can always read out input.value even if it is not valid!
 baseInputType(scope, element, attr, ctrl, $sniffer, $browser);
 stringBasedInputType(ctrl);
 ctrl.$$parserName = 'url';
-ctrl.$validators.url = function(value) {
+ctrl.$validators.url = function(modelValue, viewValue) {
+var value = modelValue || viewValue;
 return ctrl.$isEmpty(value) || URL_REGEXP.test(value);
 };
 }
 function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) {
 // in browsers, i.e. we can always read out input.value even if it is not valid!
 baseInputType(scope, element, attr, ctrl, $sniffer, $browser);
 stringBasedInputType(ctrl);
 ctrl.$$parserName = 'email';
-ctrl.$validators.email = function(value) {
+ctrl.$validators.email = function(modelValue, viewValue) {
+var value = modelValue || viewValue;
 return ctrl.$isEmpty(value) || EMAIL_REGEXP.test(value);
 };
 }
 function radioInputType(scope, element, attr, ctrl) {
 ctrl.$render = function() {
 element[0].checked = ctrl.$viewValue;
 };
-// Override the standard `$isEmpty` because an empty checkbox is never equal to the trueValue
+// Override the standard `$isEmpty` because the $viewValue of an empty checkbox is always set to `false`
+// This is because of the parser below, which compares the `$modelValue` with `trueValue` to convert
+// it to a boolean.
 ctrl.$isEmpty = function(value) {
-return value !== trueValue;
+return value === false;
 };
 ctrl.$formatters.push(function(value) {
 return equals(value, trueValue);
 });
 *    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.
+*    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any
+*    length.
 * @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 input
 * @restrict E
 *
 * @description
-* HTML input element control with angular data-binding. Input control follows HTML5 input types
+* HTML input element control. When used together with {@link ngModel `ngModel`}, it provides data-binding,
-* and polyfills the HTML5 validation behavior for older browsers.
+* input state control, and validation.
-*
+* Input control follows HTML5 input types and polyfills the HTML5 validation behavior for older browsers.
-* *NOTE* Not every feature offered is available for all input types.
+*
+* <div class="alert alert-warning">
+* **Note:** Not every feature offered is available for all input types.
+* Specifically, data binding and event handling via `ng-model` is unsupported for `input[file]`.
+* </div>
 *
 * @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.
+*    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any
+*    length.
 * @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 type
 * @name 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 {*} $modelValue The value in the model that the control is bound to.
 * @property {Array.<Function>} $parsers Array of functions to execute, as a pipeline, whenever
-the control reads value from the DOM.  Each function is called, in turn, passing the value
+the control reads value from the DOM. The functions are called in array order, each passing
-through to the next. The last return value is used to populate the model.
+its return value through to the next. The last return value is forwarded to the
-Used to sanitize / convert the value as well as validation. For validation,
+{@link ngModel.NgModelController#$validators `$validators`} collection.
-the parsers should update the validity state using
-{@link ngModel.NgModelController#$setValidity $setValidity()},
+Parsers are used to sanitize / convert the {@link ngModel.NgModelController#$viewValue
-and return `undefined` for invalid values.
+`$viewValue`}.
+Returning `undefined` from a parser means a parse error occurred. In that case,
+no {@link ngModel.NgModelController#$validators `$validators`} will run and the `ngModel`
+will be set to `undefined` unless {@link ngModelOptions `ngModelOptions.allowInvalid`}
+is set to `true`. The parse error is stored in `ngModel.$error.parse`.
 *
 * @property {Array.<Function>} $formatters Array of functions to execute, as a pipeline, whenever
-the model value changes. Each function is called, in turn, passing the value through to the
+the model value changes. The functions are called in reverse array order, each passing the value through to the
-next. Used to format / convert values for display in the control and validation.
+next. The last return value is used as the actual DOM value.
+Used to format / convert values for display in the control.
 * ```js
 * function formatter(value) {
 *   if (value) {
 *     return value.toUpperCase();
 *   }
 * @property {Object.<string, function>} $asyncValidators A collection of validations that are expected to
 *      perform an asynchronous validation (e.g. a HTTP request). The validation function that is provided
 *      is expected to return a promise when it is run during the model validation process. Once the promise
 *      is delivered then the validation status will be set to true when fulfilled and false when rejected.
 *      When the asynchronous validators are triggered, each of the validators will run in parallel and the model
-*      value will only be updated once all validators have been fulfilled. Also, keep in mind that all
+*      value will only be updated once all validators have been fulfilled. As long as an asynchronous validator
-*      asynchronous validators will only run once all synchronous validators have passed.
+*      is unfulfilled, its key will be added to the controllers `$pending` property. Also, all asynchronous validators
+*      will only run once all synchronous validators have passed.
 *
 * Please note that if $http is used then it is important that the server returns a success HTTP response code
 * in order to fulfill the validation and a status level of `4xx` in order to reject the validation.
 *
 * ```js
 *        return true;
 *      });
 * };
 * ```
 *
-* @param {string} name The name of the validator.
-* @param {Function} validationFn The validation function that will be run.
-*
 * @property {Array.<Function>} $viewChangeListeners Array of functions to execute whenever the
 *     view value has changed. It is called with no arguments, and its return value is ignored.
 *     This can be used in place of additional $watches against the model value.
 *
 * @property {Object} $error An object hash with all failing validator ids as keys.
 * @property {boolean} $touched True if control has lost focus.
 * @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.
+* @property {string} $name The name attribute of the control.
 *
 * @description
 *
-* `NgModelController` provides API for the `ng-model` directive. The controller contains
+* `NgModelController` provides API for the {@link ngModel `ngModel`} directive.
-* services for data-binding, validation, CSS updates, and value formatting and parsing. It
+* The controller contains services for data-binding, validation, CSS updates, and value formatting
-* purposefully does not contain any logic which deals with DOM rendering or listening to
+* and parsing. It purposefully does not contain any logic which deals with DOM rendering or
-* DOM events. Such DOM related logic should be provided by other directives which make use of
+* listening to DOM events.
-* `NgModelController` for data-binding.
+* Such DOM related logic should be provided by other directives which make use of
-*
+* `NgModelController` for data-binding to control elements.
-* ## Custom Control Example
+* Angular provides this DOM logic for most {@link input `input`} elements.
+* At the end of this page you can find a {@link ngModel.NgModelController#custom-control-example
+* custom control example} that uses `ngModelController` to bind to `contenteditable` elements.
+*
+* @example
+* ### Custom Control Example
 * 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.
 *
 * Note that `contenteditable` is an HTML5 attribute, which tells the browser to let the element
 * contents be edited in place by the user.  This will not work on older browsers.
 *
 * We are using the {@link ng.service:$sce $sce} service here and include the {@link ngSanitize $sanitize}
 * module to automatically remove "bad" content like inline event listener (e.g. `<span onclick="...">`).
-* However, as we are using `$sce` the model can still decide to to provide unsafe content if it marks
+* However, as we are using `$sce` the model can still decide to provide unsafe content if it marks
 * that content using the `$sce` service.
 *
 * <example name="NgModelController" module="customControl" deps="angular-sanitize.js">
 <file name="style.css">
 [contenteditable] {
 element.html($sce.getTrustedHtml(ngModel.$viewValue || ''));
 };
 // Listen for change events to enable binding
 element.on('blur keyup change', function() {
-scope.$apply(read);
+scope.$evalAsync(read);
 });
 read(); // initialize
 // Write data to the model
 function read() {
 */
 var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$parse', '$animate', '$timeout', '$rootScope', '$q', '$interpolate',
 function($scope, $exceptionHandler, $attr, $element, $parse, $animate, $timeout, $rootScope, $q, $interpolate) {
 this.$viewValue = Number.NaN;
 this.$modelValue = Number.NaN;
+this.$$rawModelValue = undefined; // stores the parsed modelValue / model set from scope regardless of validity.
 this.$validators = {};
 this.$asyncValidators = {};
 this.$parsers = [];
 this.$formatters = [];
 this.$viewChangeListeners = [];
 this.$pending = undefined; // keep pending keys here
 this.$name = $interpolate($attr.name || '', false)($scope);
 var parsedNgModel = $parse($attr.ngModel),
+parsedNgModelAssign = parsedNgModel.assign,
+ngModelGet = parsedNgModel,
+ngModelSet = parsedNgModelAssign,
 pendingDebounce = null,
 ctrl = this;
-var ngModelGet = function ngModelGet() {
-var modelValue = parsedNgModel($scope);
-if (ctrl.$options && ctrl.$options.getterSetter && isFunction(modelValue)) {
-modelValue = modelValue();
-}
-return modelValue;
-};
-var ngModelSet = function ngModelSet(newValue) {
-var getterSetter;
-if (ctrl.$options && ctrl.$options.getterSetter &&
-isFunction(getterSetter = parsedNgModel($scope))) {
-getterSetter(ctrl.$modelValue);
-} else {
-parsedNgModel.assign($scope, ctrl.$modelValue);
-}
-};
 this.$$setOptions = function(options) {
 ctrl.$options = options;
+if (options && options.getterSetter) {
-if (!parsedNgModel.assign && (!options || !options.getterSetter)) {
+var invokeModelGetter = $parse($attr.ngModel + '()'),
+invokeModelSetter = $parse($attr.ngModel + '($$$p)');
+ngModelGet = function($scope) {
+var modelValue = parsedNgModel($scope);
+if (isFunction(modelValue)) {
+modelValue = invokeModelGetter($scope);
+}
+return modelValue;
+};
+ngModelSet = function($scope, newValue) {
+if (isFunction(parsedNgModel($scope))) {
+invokeModelSetter($scope, {$$$p: ctrl.$modelValue});
+} else {
+parsedNgModelAssign($scope, ctrl.$modelValue);
+}
+};
+} else if (!parsedNgModel.assign) {
 throw $ngModelMinErr('nonassign', "Expression '{0}' is non-assignable. Element: {1}",
 $attr.ngModel, startingTag($element));
 }
 };
 /**
 * @ngdoc method
 * @name ngModel.NgModelController#$isEmpty
 *
 * @description
-* This is called when we need to determine if the value of the input is empty.
+* This is called when we need to determine if the value of an input is empty.
 *
 * For instance, the required directive does this to work out if the input has data or not.
+*
 * The default `$isEmpty` function checks whether the value is `undefined`, `''`, `null` or `NaN`.
 *
 * You can override this for input directives whose concept of being empty is different to the
 * default. The `checkboxInputType` directive does this because in its case a value of `false`
 * implies empty.
 *
-* @param {*} value Model value to check.
+* @param {*} value The value of the input to check for emptiness.
-* @returns {boolean} True if `value` is empty.
+* @returns {boolean} True if `value` is "empty".
 */
 this.$isEmpty = function(value) {
 return isUndefined(value) || value === '' || value === null || value !== value;
 };
 /**
 * @ngdoc method
 * @name ngModel.NgModelController#$setValidity
 *
 * @description
-* Change the validity state, and notifies the form.
+* Change the validity state, and notify the form.
 *
-* This method can be called within $parsers/$formatters. However, if possible, please use the
+* This method can be called within $parsers/$formatters or a custom validation implementation.
-*        `ngModel.$validators` pipeline which is designed to call this method automatically.
+* However, in most cases it should be sufficient to use the `ngModel.$validators` and
+* `ngModel.$asyncValidators` collections which will call `$setValidity` automatically.
 *
-* @param {string} validationErrorKey Name of the validator. the `validationErrorKey` will assign
+* @param {string} validationErrorKey Name of the validator. The `validationErrorKey` will be assigned
-*        to `$error[validationErrorKey]` and `$pending[validationErrorKey]`
+*        to either `$error[validationErrorKey]` or `$pending[validationErrorKey]`
-*        so that it is available for data-binding.
+*        (for unfulfilled `$asyncValidators`), 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), invalid (false), pending (undefined),
-*                          or skipped (null).
+*                          or skipped (null). Pending is used for unfulfilled `$asyncValidators`.
+*                          Skipped is used by Angular when validators do not run because of parse errors and
+*                          when `$asyncValidators` do not run because any of the `$validators` failed.
 */
 addSetValidityMethod({
 ctrl: this,
 $element: $element,
 set: function(object, property) {
 * @name ngModel.NgModelController#$setPristine
 *
 * @description
 * Sets the control to its pristine state.
 *
-* This method can be called to remove the 'ng-dirty' class and set the control to its pristine
+* This method can be called to remove the `ng-dirty` class and set the control to its pristine
-* state (ng-pristine class). A model is considered to be pristine when the model has not been changed
+* state (`ng-pristine` class). A model is considered to be pristine when the control
-* from when first compiled within then form.
+* has not been changed from when first compiled.
 */
-this.$setPristine = function () {
+this.$setPristine = function() {
 ctrl.$dirty = false;
 ctrl.$pristine = true;
 $animate.removeClass($element, DIRTY_CLASS);
 $animate.addClass($element, PRISTINE_CLASS);
+};
+/**
+* @ngdoc method
+* @name ngModel.NgModelController#$setDirty
+*
+* @description
+* Sets the control to its dirty state.
+*
+* This method can be called to remove the `ng-pristine` class and set the control to its dirty
+* state (`ng-dirty` class). A model is considered to be dirty when the control has been changed
+* from when first compiled.
+*/
+this.$setDirty = function() {
+ctrl.$dirty = true;
+ctrl.$pristine = false;
+$animate.removeClass($element, PRISTINE_CLASS);
+$animate.addClass($element, DIRTY_CLASS);
+parentForm.$setDirty();
 };
 /**
 * @ngdoc method
 * @name ngModel.NgModelController#$setUntouched
 *
 * @description
 * Sets the control to its untouched state.
 *
-* This method can be called to remove the 'ng-touched' class and set the control to its
+* This method can be called to remove the `ng-touched` class and set the control to its
-* untouched state (ng-untouched class). Upon compilation, a model is set as untouched
+* untouched state (`ng-untouched` class). Upon compilation, a model is set as untouched
 * by default, however this function can be used to restore that state if the model has
 * already been touched by the user.
 */
 this.$setUntouched = function() {
 ctrl.$touched = false;
 * @name ngModel.NgModelController#$setTouched
 *
 * @description
 * Sets the control to its touched state.
 *
-* This method can be called to remove the 'ng-untouched' class and set the control to its
+* This method can be called to remove the `ng-untouched` class and set the control to its
-* touched state (ng-touched class). A model is considered to be touched when the user has
+* touched state (`ng-touched` class). A model is considered to be touched when the user has
-* first interacted (focussed) on the model input element and then shifted focus away (blurred)
+* first focused the control element and then shifted focus away from the control (blur event).
-* from the input element.
 */
 this.$setTouched = function() {
 ctrl.$touched = true;
 ctrl.$untouched = false;
 $animate.setClass($element, TOUCHED_CLASS, UNTOUCHED_CLASS);
 * <example name="ng-model-cancel-update" module="cancel-update-example">
 *   <file name="app.js">
 *     angular.module('cancel-update-example', [])
 *
 *     .controller('CancelUpdateController', ['$scope', function($scope) {
-*       $scope.resetWithCancel = function (e) {
+*       $scope.resetWithCancel = function(e) {
 *         if (e.keyCode == 27) {
 *           $scope.myForm.myInput1.$rollbackViewValue();
 *           $scope.myValue = '';
 *         }
 *       };
-*       $scope.resetWithoutCancel = function (e) {
+*       $scope.resetWithoutCancel = function(e) {
 *         if (e.keyCode == 27) {
 *           $scope.myValue = '';
 *         }
 *       };
 *     }]);
 /**
 * @ngdoc method
 * @name ngModel.NgModelController#$validate
 *
 * @description
-* Runs each of the registered validators (first synchronous validators and then asynchronous validators).
+* Runs each of the registered validators (first synchronous validators and then
+* asynchronous validators).
+* If the validity changes to invalid, the model will be set to `undefined`,
+* unless {@link ngModelOptions `ngModelOptions.allowInvalid`} is `true`.
+* If the validity changes to valid, it will set the model to the last available valid
+* modelValue, i.e. either the last parsed value or the last value set from the scope.
 */
 this.$validate = function() {
 // ignore $validate before model is initialized
 if (isNumber(ctrl.$modelValue) && isNaN(ctrl.$modelValue)) {
 return;
 }
-this.$$parseAndValidate();
+var viewValue = ctrl.$$lastCommittedViewValue;
+// Note: we use the $$rawModelValue as $modelValue might have been
+// set to undefined during a view -> model update that found validation
+// errors. We can't parse the view here, since that could change
+// the model although neither viewValue nor the model on the scope changed
+var modelValue = ctrl.$$rawModelValue;
+// Check if the there's a parse error, so we don't unset it accidentially
+var parserName = ctrl.$$parserName || 'parse';
+var parserValid = ctrl.$error[parserName] ? false : undefined;
+var prevValid = ctrl.$valid;
+var prevModelValue = ctrl.$modelValue;
+var allowInvalid = ctrl.$options && ctrl.$options.allowInvalid;
+ctrl.$$runValidators(parserValid, modelValue, viewValue, function(allValid) {
+// If there was no change in validity, don't update the model
+// This prevents changing an invalid modelValue to undefined
+if (!allowInvalid && prevValid !== allValid) {
+// Note: Don't check ctrl.$valid here, as we could have
+// external validators (e.g. calculated on the server),
+// that just call $setValidity and need the model value
+// to calculate their validity.
+ctrl.$modelValue = allValid ? modelValue : undefined;
+if (ctrl.$modelValue !== prevModelValue) {
+ctrl.$$writeModelToScope();
+}
+}
+});
 };
 this.$$runValidators = function(parseValid, modelValue, viewValue, doneCallback) {
 currentValidationRunId++;
 var localValidationRunId = currentValidationRunId;
 }
 ctrl.$$lastCommittedViewValue = viewValue;
 // change to dirty
 if (ctrl.$pristine) {
-ctrl.$dirty = true;
+this.$setDirty();
-ctrl.$pristine = false;
-$animate.removeClass($element, PRISTINE_CLASS);
-$animate.addClass($element, DIRTY_CLASS);
-parentForm.$setDirty();
 }
 this.$$parseAndValidate();
 };
 this.$$parseAndValidate = function() {
 var viewValue = ctrl.$$lastCommittedViewValue;
 var modelValue = viewValue;
 var parserValid = isUndefined(modelValue) ? undefined : true;
 if (parserValid) {
-for(var i = 0; i < ctrl.$parsers.length; i++) {
+for (var i = 0; i < ctrl.$parsers.length; i++) {
 modelValue = ctrl.$parsers[i](modelValue);
 if (isUndefined(modelValue)) {
 parserValid = false;
 break;
 }
 }
 }
 if (isNumber(ctrl.$modelValue) && isNaN(ctrl.$modelValue)) {
 // ctrl.$modelValue has not been touched yet...
-ctrl.$modelValue = ngModelGet();
+ctrl.$modelValue = ngModelGet($scope);
 }
 var prevModelValue = ctrl.$modelValue;
 var allowInvalid = ctrl.$options && ctrl.$options.allowInvalid;
+ctrl.$$rawModelValue = modelValue;
 if (allowInvalid) {
 ctrl.$modelValue = modelValue;
 writeToModelIfNeeded();
 }
-ctrl.$$runValidators(parserValid, modelValue, viewValue, function(allValid) {
+// Pass the $$lastCommittedViewValue here, because the cached viewValue might be out of date.
+// This can happen if e.g. $setViewValue is called from inside a parser
+ctrl.$$runValidators(parserValid, modelValue, ctrl.$$lastCommittedViewValue, function(allValid) {
 if (!allowInvalid) {
 // Note: Don't check ctrl.$valid here, as we could have
 // external validators (e.g. calculated on the server),
 // that just call $setValidity and need the model value
 // to calculate their validity.
 }
 }
 };
 this.$$writeModelToScope = function() {
-ngModelSet(ctrl.$modelValue);
+ngModelSet($scope, ctrl.$modelValue);
 forEach(ctrl.$viewChangeListeners, function(listener) {
 try {
 listener();
-} catch(e) {
+} catch (e) {
 $exceptionHandler(e);
 }
 });
 };
 // 3. ng-change kicks in and reverts scope value to 'a'
 //    -> scope value did not change since the last digest as
 //       ng-change executes in apply phase
 // 4. view should be changed back to 'a'
 $scope.$watch(function ngModelWatch() {
-var modelValue = ngModelGet();
+var modelValue = ngModelGet($scope);
 // if scope model value and ngModel value are out of sync
 // TODO(perf): why not move this to the action fn?
 if (modelValue !== ctrl.$modelValue) {
-ctrl.$modelValue = modelValue;
+ctrl.$modelValue = ctrl.$$rawModelValue = modelValue;
 var formatters = ctrl.$formatters,
 idx = formatters.length;
 var viewValue = modelValue;
-while(idx--) {
+while (idx--) {
 viewValue = formatters[idx](viewValue);
 }
 if (ctrl.$viewValue !== viewValue) {
 ctrl.$viewValue = ctrl.$$lastCommittedViewValue = viewValue;
 ctrl.$render();
 /**
 * @ngdoc directive
 * @name ngModel
 *
 * @element input
+* @priority 1
 *
 * @description
 * The `ngModel` directive binds an `input`,`select`, `textarea` (or custom form control) to a
 * property on the scope using {@link ngModel.NgModelController NgModelController},
 * which is created and exposed by this directive.
 * current scope. If the property doesn't already exist on this scope, it will be created
 * implicitly and added to the scope.
 *
 * For best practices on using `ngModel`, see:
 *
-*  - [https://github.com/angular/angular.js/wiki/Understanding-Scopes]
+*  - [Understanding Scopes](https://github.com/angular/angular.js/wiki/Understanding-Scopes)
 *
 * For basic examples, how to use `ngModel`, see:
 *
 *  - {@link ng.directive:input input}
 *    - {@link input[text] text}
 *    - {@link input[radio] radio}
 *    - {@link input[number] number}
 *    - {@link input[email] email}
 *    - {@link input[url] url}
 *    - {@link input[date] date}
-*    - {@link input[dateTimeLocal] dateTimeLocal}
+*    - {@link input[datetime-local] datetime-local}
 *    - {@link input[time] time}
 *    - {@link input[month] month}
 *    - {@link input[week] week}
 *  - {@link ng.directive:select select}
 *  - {@link ng.directive:textarea textarea}
 *
 * # CSS classes
 * The following CSS classes are added and removed on the associated input/select/textarea element
 * depending on the validity of the model.
 *
-*  - `ng-valid` is set if the model is valid.
+*  - `ng-valid`: the model is valid
-*  - `ng-invalid` is set if the model is invalid.
+*  - `ng-invalid`: the model is invalid
-*  - `ng-pristine` is set if the model is pristine.
+*  - `ng-valid-[key]`: for each valid key added by `$setValidity`
-*  - `ng-dirty` is set if the model is dirty.
+*  - `ng-invalid-[key]`: for each invalid key added by `$setValidity`
+*  - `ng-pristine`: the control hasn't been interacted with yet
+*  - `ng-dirty`: the control has been interacted with
+*  - `ng-touched`: the control has been blurred
+*  - `ng-untouched`: the control hasn't been blurred
+*  - `ng-pending`: any `$asyncValidators` are unfulfilled
 *
 * Keep in mind that ngAnimate can detect each of these classes when added and removed.
 *
 * ## Animation Hooks
 *
 <file name="app.js">
 angular.module('getterSetterExample', [])
 .controller('ExampleController', ['$scope', function($scope) {
 var _name = 'Brian';
 $scope.user = {
-name: function (newName) {
+name: function(newName) {
 if (angular.isDefined(newName)) {
 _name = newName;
 }
 return _name;
 }
 };
 }]);
 </file>
 * </example>
 */
-var ngModelDirective = function() {
+var ngModelDirective = ['$rootScope', function($rootScope) {
 return {
 restrict: 'A',
 require: ['ngModel', '^?form', '^?ngModelOptions'],
 controller: NgModelController,
 // Prelink needs to run before any input directive
 }
 element.on('blur', function(ev) {
 if (modelCtrl.$touched) return;
-scope.$apply(function() {
+if ($rootScope.$$phase) {
-modelCtrl.$setTouched();
+scope.$evalAsync(modelCtrl.$setTouched);
-});
+} else {
+scope.$apply(modelCtrl.$setTouched);
+}
 });
 }
 };
 }
 };
-};
+}];
 /**
 * @ngdoc directive
 * @name ngChange
 require: '?ngModel',
 link: function(scope, elm, attr, ctrl) {
 if (!ctrl) return;
 attr.required = true; // force truthy in case we are on non input element
-ctrl.$validators.required = function(value) {
+ctrl.$validators.required = function(modelValue, viewValue) {
-return !attr.required || !ctrl.$isEmpty(value);
+return !attr.required || !ctrl.$isEmpty(viewValue);
 };
 attr.$observe('required', function() {
 ctrl.$validate();
 });
 if (!ctrl) return;
 var regexp, patternExp = attr.ngPattern || attr.pattern;
 attr.$observe('pattern', function(regex) {
 if (isString(regex) && regex.length > 0) {
-regex = new RegExp(regex);
+regex = new RegExp('^' + regex + '$');
 }
 if (regex && !regex.test) {
 throw minErr('ngPattern')('noregexp',
 'Expected {0} to be a RegExp but was {1}. Element: {2}', patternExp,
 restrict: 'A',
 require: '?ngModel',
 link: function(scope, elm, attr, ctrl) {
 if (!ctrl) return;
-var maxlength = 0;
+var maxlength = -1;
 attr.$observe('maxlength', function(value) {
-maxlength = int(value) || 0;
+var intVal = int(value);
+maxlength = isNaN(intVal) ? -1 : intVal;
 ctrl.$validate();
 });
 ctrl.$validators.maxlength = function(modelValue, viewValue) {
-return ctrl.$isEmpty(modelValue) || viewValue.length <= maxlength;
+return (maxlength < 0) || ctrl.$isEmpty(modelValue) || (viewValue.length <= maxlength);
 };
 }
 };
 };
 attr.$observe('minlength', function(value) {
 minlength = int(value) || 0;
 ctrl.$validate();
 });
 ctrl.$validators.minlength = function(modelValue, viewValue) {
-return ctrl.$isEmpty(modelValue) || viewValue.length >= minlength;
+return ctrl.$isEmpty(viewValue) || viewValue.length >= minlength;
 };
 }
 };
 };
 /**
 * @ngdoc directive
 * @name ngValue
 *
 * @description
-* Binds the given expression to the value of `input[select]` or `input[radio]`, so
+* Binds the given expression to the value of `<option>` or {@link input[radio] `input[radio]`},
-* that when the element is selected, the `ngModel` of that element is set to the
+* so that when the element is selected, the {@link ngModel `ngModel`} of that element is set to
-* bound value.
+* the bound value.
 *
-* `ngValue` is useful when dynamically generating lists of radio buttons using `ng-repeat`, as
+* `ngValue` is useful when dynamically generating lists of radio buttons using
-* shown below.
+* {@link ngRepeat `ngRepeat`}, as shown below.
+*
+* Likewise, `ngValue` can be used to generate `<option>` elements for
+* the {@link select `select`} element. In that case however, only strings are supported
+* for the `value `attribute, so the resulting `ngModel` will always be a string.
+* Support for `select` models with non-string values is available via `ngOptions`.
 *
 * @element input
 * @param {string=} ngValue angular expression, whose value will be bound to the `value` attribute
 *   of the `input` element
 *
 * to have access to the updated model.
 *
 * `ngModelOptions` has an effect on the element it's declared on and its descendants.
 *
 * @param {Object} ngModelOptions options to apply to the current model. Valid keys are:
-*   - `updateOn`: string specifying which event should be the input bound to. You can set several
+*   - `updateOn`: string specifying which event should the input be bound to. You can set several
 *     events using an space delimited list. There is a special event called `default` that
 *     matches the default events belonging of the control.
 *   - `debounce`: integer value which contains the debounce model update value in milliseconds. A
 *     value of 0 triggers an immediate update. If an object is supplied instead, you can specify a
 *     custom value for each event. For example:
 <file name="app.js">
 angular.module('optionsExample', [])
 .controller('ExampleController', ['$scope', function($scope) {
 $scope.user = { name: 'say', data: '' };
-$scope.cancel = function (e) {
+$scope.cancel = function(e) {
 if (e.keyCode == 27) {
 $scope.userForm.userName.$rollbackViewValue();
 }
 };
 }]);
 <file name="app.js">
 angular.module('getterSetterExample', [])
 .controller('ExampleController', ['$scope', function($scope) {
 var _name = 'Brian';
 $scope.user = {
-name: function (newName) {
+name: function(newName) {
 return angular.isDefined(newName) ? (_name = newName) : _name;
 }
 };
 }]);
 </file>
 * Try it here: enter text in text box and watch the greeting change.
 <example module="bindExample">
 <file name="index.html">
 <script>
 angular.module('bindExample', [])
-.controller('ExampleController', ['$scope', function ($scope) {
+.controller('ExampleController', ['$scope', function($scope) {
 $scope.salutation = 'Hello';
 $scope.name = 'World';
 }]);
 </script>
 <div ng-controller="ExampleController">
 /**
 * @ngdoc directive
 * @name ngBindHtml
 *
 * @description
-* Creates a binding that will innerHTML the result of evaluating the `expression` into the current
+* Evaluates the expression and inserts the resulting HTML into the element in a secure way. By default,
-* element in a secure way.  By default, the innerHTML-ed content will be sanitized using the {@link
+* the resulting HTML content will be sanitized using the {@link ngSanitize.$sanitize $sanitize} service.
-* ngSanitize.$sanitize $sanitize} service.  To utilize this functionality, ensure that `$sanitize`
+* To utilize this functionality, ensure that `$sanitize` is available, for example, by including {@link
-* is available, for example, by including {@link ngSanitize} in your module's dependencies (not in
+* ngSanitize} in your module's dependencies (not in core Angular). In order to use {@link ngSanitize}
-* core Angular). In order to use {@link ngSanitize} in your module's dependencies, you need to
+* in your module's dependencies, you need to include "angular-sanitize.js" in your application.
-* include "angular-sanitize.js" in your application.
 *
 * You may also bypass sanitization for values you know are safe. To do so, bind to
 * an explicitly trusted value via {@link ng.$sce#trustAsHtml $sce.trustAsHtml}.  See the example
-* under {@link ng.$sce#Example Strict Contextual Escaping (SCE)}.
+* under {@link ng.$sce#show-me-an-example-using-sce- Strict Contextual Escaping (SCE)}.
 *
 * Note: If a `$sanitize` service is unavailable and the bound value isn't explicitly trusted, you
 * will have an exception (instead of an exploit.)
 *
 * @element ANY
 function removeClasses(classes) {
 var newClasses = digestClassCounts(classes, -1);
 attr.$removeClass(newClasses);
 }
-function digestClassCounts (classes, count) {
+function digestClassCounts(classes, count) {
 var classCounts = element.data('$classCounts') || {};
 var classesToUpdate = [];
-forEach(classes, function (className) {
+forEach(classes, function(className) {
 if (count > 0 || classCounts[className]) {
 classCounts[className] = (classCounts[className] || 0) + count;
 if (classCounts[className] === +(count > 0)) {
 classesToUpdate.push(className);
 }
 });
 element.data('$classCounts', classCounts);
 return classesToUpdate.join(' ');
 }
-function updateClasses (oldClasses, newClasses) {
+function updateClasses(oldClasses, newClasses) {
 var toAdd = arrayDifference(newClasses, oldClasses);
 var toRemove = arrayDifference(oldClasses, newClasses);
 toAdd = digestClassCounts(toAdd, 1);
 toRemove = digestClassCounts(toRemove, -1);
 if (toAdd && toAdd.length) {
 function arrayDifference(tokens1, tokens2) {
 var values = [];
 outer:
-for(var i = 0; i < tokens1.length; i++) {
+for (var i = 0; i < tokens1.length; i++) {
 var token = tokens1[i];
-for(var j = 0; j < tokens2.length; j++) {
+for (var j = 0; j < tokens2.length; j++) {
-if(token == tokens2[j]) continue outer;
+if (token == tokens2[j]) continue outer;
 }
 values.push(token);
 }
 return values;
 }
-function arrayClasses (classVal) {
+function arrayClasses(classVal) {
 if (isArray(classVal)) {
 return classVal;
 } else if (isString(classVal)) {
 return classVal.split(' ');
 } else if (isObject(classVal)) {
-var classes = [], i = 0;
+var classes = [];
 forEach(classVal, function(v, k) {
 if (v) {
 classes = classes.concat(k.split(' '));
 }
 });
 ## ngClass and pre-existing CSS3 Transitions/Animations
 The ngClass directive still supports CSS3 Transitions/Animations even if they do not follow the ngAnimate CSS naming structure.
 Upon animation ngAnimate will apply supplementary CSS classes to track the start and end of an animation, but this will not hinder
 any pre-existing CSS transitions already on the element. To get an idea of what happens during a class-based animation, be sure
-to view the step by step details of {@link ngAnimate.$animate#addclass $animate.addClass} and
+to view the step by step details of {@link ng.$animate#addClass $animate.addClass} and
-{@link ngAnimate.$animate#removeclass $animate.removeClass}.
+{@link ng.$animate#removeClass $animate.removeClass}.
 */
 var ngClassDirective = classDirective('', true);
 /**
 * @ngdoc directive
 *
 * @element html
 * @description
 * Enables [CSP (Content Security Policy)](https://developer.mozilla.org/en/Security/CSP) support.
 *
-* This is necessary when developing things like Google Chrome Extensions.
+* This is necessary when developing things like Google Chrome Extensions or Universal Windows Apps.
 *
 * CSP forbids apps to use `eval` or `Function(string)` generated functions (among other things).
 * For Angular to be CSP compatible there are only two things that we need to do differently:
 *
 * - don't use `Function` constructor to generate optimized value getters
 });
 </file>
 </example>
 */
 /*
-* A directive that allows creation of custom onclick handlers that are defined as angular
+* A collection of directives that allows creation of custom event handlers that are defined as
-* expressions and are compiled and executed within the current scope.
+* 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 = {};
 // For events that might fire synchronously during DOM manipulation
 // we need to execute their event handlers asynchronously using $evalAsync,
 var directiveName = directiveNormalize('ng-' + eventName);
 ngEventDirectives[directiveName] = ['$parse', '$rootScope', function($parse, $rootScope) {
 return {
 restrict: 'A',
 compile: function($element, attr) {
-var fn = $parse(attr[directiveName]);
+// We expose the powerful $event object on the scope that provides access to the Window,
+// etc. that isn't protected by the fast paths in $parse.  We explicitly request better
+// checks at the cost of speed since event handler expressions are not executed as
+// frequently as regular change detection.
+var fn = $parse(attr[directiveName], /* interceptorFn */ null, /* expensiveChecks */ true);
 return function ngEventHandler(scope, element) {
 element.on(eventName, function(event) {
 var callback = function() {
 fn(scope, {$event:event});
 };
 <example module="ngAnimate" deps="angular-animate.js" animations="true">
 <file name="index.html">
 Click me: <input type="checkbox" ng-model="checked" ng-init="checked=true" /><br/>
 Show when checked:
 <span ng-if="checked" class="animate-if">
-I'm removed when the checkbox is unchecked.
+This is removed when the checkbox is unchecked.
 </span>
 </file>
 <file name="animations.css">
 .animate-if {
 background:white;
 transclude: 'element',
 priority: 600,
 terminal: true,
 restrict: 'A',
 $$tlb: true,
-link: function ($scope, $element, $attr, ctrl, $transclude) {
+link: function($scope, $element, $attr, ctrl, $transclude) {
 var block, childScope, previousElements;
 $scope.$watch($attr.ngIf, function ngIfWatchAction(value) {
 if (value) {
 if (!childScope) {
-$transclude(function (clone, newScope) {
+$transclude(function(clone, newScope) {
 childScope = newScope;
 clone[clone.length++] = document.createComment(' end ngIf: ' + $attr.ngIf + ' ');
 // Note: We only need the first/last node of the cloned nodes.
 // However, we need to keep the reference to the jqlite wrapper as it might be changed later
 // by a directive with templateUrl when its template arrives.
 };
 $animate.enter(clone, $element.parent(), $element);
 });
 }
 } else {
-if(previousElements) {
+if (previousElements) {
 previousElements.remove();
 previousElements = null;
 }
-if(childScope) {
+if (childScope) {
 childScope.$destroy();
 childScope = null;
 }
-if(block) {
+if (block) {
 previousElements = getBlockNodes(block.clone);
 $animate.leave(previousElements).then(function() {
 previousElements = null;
 });
 block = null;
 *
 * @description
 * Fetches, compiles and includes an external HTML fragment.
 *
 * By default, the template URL is restricted to the same domain and protocol as the
-* application document. This is done by calling {@link ng.$sce#getTrustedResourceUrl
+* application document. This is done by calling {@link $sce#getTrustedResourceUrl
 * $sce.getTrustedResourceUrl} on it. To load templates from other domains or protocols
 * you may either {@link ng.$sceDelegateProvider#resourceUrlWhitelist whitelist them} or
-* [wrap them](ng.$sce#trustAsResourceUrl) as trusted values. Refer to Angular's {@link
+* {@link $sce#trustAsResourceUrl wrap them} as trusted values. Refer to Angular's {@link
 * ng.$sce Strict Contextual Escaping}.
 *
 * In addition, the browser's
 * [Same Origin Policy](https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest)
 * and [Cross-Origin Resource Sharing (CORS)](http://www.w3.org/TR/cors/)
 currentScope,
 previousElement,
 currentElement;
 var cleanupLastIncludeContent = function() {
-if(previousElement) {
+if (previousElement) {
 previousElement.remove();
 previousElement = null;
 }
-if(currentScope) {
+if (currentScope) {
 currentScope.$destroy();
 currentScope = null;
 }
-if(currentElement) {
+if (currentElement) {
 $animate.leave(currentElement).then(function() {
 previousElement = null;
 });
 previousElement = currentElement;
 currentElement = null;
 // specially.
 $element.empty();
 $compile(jqLiteBuildFragment(ctrl.template, document).childNodes)(scope,
 function namespaceAdaptedClone(clone) {
 $element.append(clone);
-}, undefined, undefined, $element);
+}, {futureParentElement: $element});
 return;
 }
 $element.html(ctrl.template);
 $compile($element.contents())(scope);
 });
 </file>
 </example>
 */
 var ngPluralizeDirective = ['$locale', '$interpolate', function($locale, $interpolate) {
-var BRACE = /{}/g;
+var BRACE = /{}/g,
+IS_WHEN = /^when(Minus)?(.+)$/;
 return {
 restrict: 'EA',
 link: function(scope, element, attr) {
 var numberExp = attr.count,
 whenExp = attr.$attr.when && element.attr(attr.$attr.when), // we have {{}} in attrs
 offset = attr.offset || 0,
 whens = scope.$eval(whenExp) || {},
 whensExpFns = {},
 startSymbol = $interpolate.startSymbol(),
 endSymbol = $interpolate.endSymbol(),
-isWhen = /^when(Minus)?(.+)$/;
+braceReplacement = startSymbol + numberExp + '-' + offset + endSymbol,
+watchRemover = angular.noop,
+lastCount;
 forEach(attr, function(expression, attributeName) {
-if (isWhen.test(attributeName)) {
+var tmpMatch = IS_WHEN.exec(attributeName);
-whens[lowercase(attributeName.replace('when', '').replace('Minus', '-'))] =
+if (tmpMatch) {
-element.attr(attr.$attr[attributeName]);
+var whenKey = (tmpMatch[1] ? '-' : '') + lowercase(tmpMatch[2]);
+whens[whenKey] = element.attr(attr.$attr[attributeName]);
 }
 });
 forEach(whens, function(expression, key) {
-whensExpFns[key] =
+whensExpFns[key] = $interpolate(expression.replace(BRACE, braceReplacement));
-$interpolate(expression.replace(BRACE, startSymbol + numberExp + '-' +
-offset + endSymbol));
 });
-scope.$watch(function ngPluralizeWatch() {
+scope.$watch(numberExp, function ngPluralizeWatchAction(newVal) {
-var value = parseFloat(scope.$eval(numberExp));
+var count = parseFloat(newVal);
+var countIsNaN = isNaN(count);
-if (!isNaN(value)) {
-//if explicit number rule such as 1, 2, 3... is defined, just use it. Otherwise,
+if (!countIsNaN && !(count in whens)) {
-//check it against pluralization rules in $locale service
+// If an explicit number rule such as 1, 2, 3... is defined, just use it.
-if (!(value in whens)) value = $locale.pluralCat(value - offset);
+// Otherwise, check it against pluralization rules in $locale service.
-return whensExpFns[value](scope);
+count = $locale.pluralCat(count - offset);
-} else {
-return '';
 }
-}, function ngPluralizeWatchAction(newVal) {
-element.text(newVal);
+// If both `count` and `lastCount` are NaN, we don't need to re-register a watch.
+// In JS `NaN !== NaN`, so we have to exlicitly check.
+if ((count !== lastCount) && !(countIsNaN && isNaN(lastCount))) {
+watchRemover();
+watchRemover = scope.$watch(whensExpFns[count], updateElementText);
+lastCount = count;
+}
 });
+function updateElementText(newText) {
+element.text(newText || '');
+}
 }
 };
 }];
 /**
 *     before specifying a tracking expression.
 *
 *     For example: `item in items` is equivalent to `item in items track by $id(item)`. This implies that the DOM elements
 *     will be associated by item identity in the array.
 *
-*   * `variable in expression as alias_expression` – You can also provide an optional alias expression which will then store the
-*     intermediate results of the repeater after the filters have been applied. Typically this is used to render a special message
-*     when a filter is active on the repeater, but the filtered result set is empty.
-*
-*     For example: `item in items | filter:x as results` will store the fragment of the repeated items as `results`, but only after
-*     the items have been processed through the filter.
-*
 *     For example: `item in items track by $id(item)`. A built in `$id()` function can be used to assign a unique
 *     `$$hashKey` property to each item in the array. This property is then used as a key to associated DOM elements
 *     with the corresponding item in the array by identity. Moving the same object in array would move the DOM
 *     element in the same way in the DOM.
 *
 *     case the object identity does not matter. Two objects are considered equivalent as long as their `id`
 *     property is same.
 *
 *     For example: `item in items | filter:searchText track by item.id` is a pattern that might be used to apply a filter
 *     to items in conjunction with a tracking expression.
+*
+*   * `variable in expression as alias_expression` – You can also provide an optional alias expression which will then store the
+*     intermediate results of the repeater after the filters have been applied. Typically this is used to render a special message
+*     when a filter is active on the repeater, but the filtered result set is empty.
+*
+*     For example: `item in items | filter:x as results` will store the fragment of the repeated items as `results`, but only after
+*     the items have been processed through the filter.
 *
 * @example
 * This example initializes the scope to a list of names and
 * then uses `ngRepeat` to display every person:
 <example module="ngAnimate" deps="angular-animate.js" animations="true">
 var lhs = match[1];
 var rhs = match[2];
 var aliasAs = match[3];
 var trackByExp = match[4];
-match = lhs.match(/^(?:([\$\w]+)|\(([\$\w]+)\s*,\s*([\$\w]+)\))$/);
+match = lhs.match(/^(?:(\s*[\$\w]+)|\(\s*([\$\w]+)\s*,\s*([\$\w]+)\s*\))$/);
 if (!match) {
 throw ngRepeatMinErr('iidexp', "'_item_' in '_item_ in _collection_' should be an identifier or '(_key_, _value_)' expression, but got '{0}'.",
 lhs);
 }
 var hashFnLocals = {$id: hashKey};
 if (trackByExp) {
 trackByExpGetter = $parse(trackByExp);
 } else {
-trackByIdArrayFn = function (key, value) {
+trackByIdArrayFn = function(key, value) {
 return hashKey(value);
 };
-trackByIdObjFn = function (key) {
+trackByIdObjFn = function(key) {
 return key;
 };
 }
 return function ngRepeatLink($scope, $element, $attr, ctrl, $transclude) {
 delete lastBlockMap[trackById];
 nextBlockMap[trackById] = block;
 nextBlockOrder[index] = block;
 } else if (nextBlockMap[trackById]) {
 // if collision detected. restore lastBlockMap and throw an error
-forEach(nextBlockOrder, function (block) {
+forEach(nextBlockOrder, function(block) {
 if (block && block.scope) lastBlockMap[block.id] = block;
 });
 throw ngRepeatMinErr('dupes',
 "Duplicates in a repeater are not allowed. Use 'track by' expression to specify unique keys. Repeater: {0}, Duplicate key: {1}, Duplicate value: {2}",
-expression, trackById, toJson(value));
+expression, trackById, value);
 } else {
 // new never before seen block
 nextBlockOrder[index] = {id: trackById, scope: undefined, clone: undefined};
 nextBlockMap[trackById] = true;
 }
 * specificity (when !important isn't used with any conflicting styles). If a developer chooses to override the
 * styling to change how to hide an element then it is just a matter of using !important in their own CSS code.
 *
 * ### Overriding `.ng-hide`
 *
-* By default, the `.ng-hide` class will style the element with `display:none!important`. If you wish to change
+* By default, the `.ng-hide` class will style the element with `display: none!important`. If you wish to change
 * the hide behavior with ngShow/ngHide then this can be achieved by restating the styles for the `.ng-hide`
 * class in CSS:
 *
 * ```css
 * .ng-hide {
 *   /&#42; this is just another form of hiding an element &#42;/
-*   display:block!important;
+*   display: block!important;
-*   position:absolute;
+*   position: absolute;
-*   top:-9999px;
+*   top: -9999px;
-*   left:-9999px;
+*   left: -9999px;
 * }
 * ```
 *
 * By default you don't need to override in CSS anything and the animations will work around the display style.
 *
 * //a working example can be found at the bottom of this page
 * //
 * .my-element.ng-hide-add, .my-element.ng-hide-remove {
 *   /&#42; this is required as of 1.3x to properly
 *      apply all styling in a show/hide animation &#42;/
-*   transition:0s linear all;
+*   transition: 0s linear all;
 * }
 *
 * .my-element.ng-hide-add-active,
 * .my-element.ng-hide-remove-active {
 *   /&#42; the transition is defined in the active class &#42;/
-*   transition:1s linear all;
+*   transition: 1s linear all;
 * }
 *
 * .my-element.ng-hide-add { ... }
 * .my-element.ng-hide-add.ng-hide-add-active { ... }
 * .my-element.ng-hide-remove { ... }
 <span class="glyphicon glyphicon-thumbs-down"></span> I hide when your checkbox is checked.
 </div>
 </div>
 </file>
 <file name="glyphicons.css">
-@import url(//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap-glyphicons.css);
+@import url(../../components/bootstrap-3.1.1/css/bootstrap.css);
 </file>
 <file name="animations.css">
 .animate-show {
-line-height:20px;
+line-height: 20px;
-opacity:1;
+opacity: 1;
-padding:10px;
+padding: 10px;
-border:1px solid black;
+border: 1px solid black;
-background:white;
+background: white;
 }
 .animate-show.ng-hide-add.ng-hide-add-active,
 .animate-show.ng-hide-remove.ng-hide-remove-active {
--webkit-transition:all linear 0.5s;
+-webkit-transition: all linear 0.5s;
-transition:all linear 0.5s;
+transition: all linear 0.5s;
 }
 .animate-show.ng-hide {
-line-height:0;
+line-height: 0;
-opacity:0;
+opacity: 0;
-padding:0 10px;
+padding: 0 10px;
 }
 .check-element {
-padding:10px;
+padding: 10px;
-border:1px solid black;
+border: 1px solid black;
-background:white;
+background: white;
 }
 </file>
 <file name="protractor.js" type="protractor">
 var thumbsUp = element(by.css('span.glyphicon-thumbs-up'));
 var thumbsDown = element(by.css('span.glyphicon-thumbs-down'));
 var ngShowDirective = ['$animate', function($animate) {
 return {
 restrict: 'A',
 multiElement: true,
 link: function(scope, element, attr) {
-scope.$watch(attr.ngShow, function ngShowWatchAction(value){
+scope.$watch(attr.ngShow, function ngShowWatchAction(value) {
 // we're adding a temporary, animation-specific class for ng-hide since this way
 // we can control when the element is actually displayed on screen without having
 // to have a global/greedy CSS selector that breaks when other animations are run.
 // Read: https://github.com/angular/angular.js/issues/9103#issuecomment-58335845
-$animate[value ? 'removeClass' : 'addClass'](element, NG_HIDE_CLASS, NG_HIDE_IN_PROGRESS_CLASS);
+$animate[value ? 'removeClass' : 'addClass'](element, NG_HIDE_CLASS, {
+tempClasses: NG_HIDE_IN_PROGRESS_CLASS
+});
 });
 }
 };
 }];
 * specificity (when !important isn't used with any conflicting styles). If a developer chooses to override the
 * styling to change how to hide an element then it is just a matter of using !important in their own CSS code.
 *
 * ### Overriding `.ng-hide`
 *
-* By default, the `.ng-hide` class will style the element with `display:none!important`. If you wish to change
+* By default, the `.ng-hide` class will style the element with `display: none!important`. If you wish to change
 * the hide behavior with ngShow/ngHide then this can be achieved by restating the styles for the `.ng-hide`
 * class in CSS:
 *
 * ```css
 * .ng-hide {
 *   /&#42; this is just another form of hiding an element &#42;/
-*   display:block!important;
+*   display: block!important;
-*   position:absolute;
+*   position: absolute;
-*   top:-9999px;
+*   top: -9999px;
-*   left:-9999px;
+*   left: -9999px;
 * }
 * ```
 *
 * By default you don't need to override in CSS anything and the animations will work around the display style.
 *
 * ```css
 * //
 * //a working example can be found at the bottom of this page
 * //
 * .my-element.ng-hide-add, .my-element.ng-hide-remove {
-*   transition:0.5s linear all;
+*   transition: 0.5s linear all;
 * }
 *
 * .my-element.ng-hide-add { ... }
 * .my-element.ng-hide-add.ng-hide-add-active { ... }
 * .my-element.ng-hide-remove { ... }
 <span class="glyphicon glyphicon-thumbs-down"></span> I hide when your checkbox is checked.
 </div>
 </div>
 </file>
 <file name="glyphicons.css">
-@import url(//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap-glyphicons.css);
+@import url(../../components/bootstrap-3.1.1/css/bootstrap.css);
 </file>
 <file name="animations.css">
 .animate-hide {
--webkit-transition:all linear 0.5s;
+-webkit-transition: all linear 0.5s;
-transition:all linear 0.5s;
+transition: all linear 0.5s;
-line-height:20px;
+line-height: 20px;
-opacity:1;
+opacity: 1;
-padding:10px;
+padding: 10px;
-border:1px solid black;
+border: 1px solid black;
-background:white;
+background: white;
 }
 .animate-hide.ng-hide {
-line-height:0;
+line-height: 0;
-opacity:0;
+opacity: 0;
-padding:0 10px;
+padding: 0 10px;
 }
 .check-element {
-padding:10px;
+padding: 10px;
-border:1px solid black;
+border: 1px solid black;
-background:white;
+background: white;
 }
 </file>
 <file name="protractor.js" type="protractor">
 var thumbsUp = element(by.css('span.glyphicon-thumbs-up'));
 var thumbsDown = element(by.css('span.glyphicon-thumbs-down'));
 var ngHideDirective = ['$animate', function($animate) {
 return {
 restrict: 'A',
 multiElement: true,
 link: function(scope, element, attr) {
-scope.$watch(attr.ngHide, function ngHideWatchAction(value){
+scope.$watch(attr.ngHide, function ngHideWatchAction(value) {
 // The comment inside of the ngShowDirective explains why we add and
 // remove a temporary class for the show/hide animation
-$animate[value ? 'addClass' : 'removeClass'](element,NG_HIDE_CLASS, NG_HIDE_IN_PROGRESS_CLASS);
+$animate[value ? 'addClass' : 'removeClass'](element,NG_HIDE_CLASS, {
+tempClasses: NG_HIDE_IN_PROGRESS_CLASS
+});
 });
 }
 };
 }];
 $scope.title = 'Lorem Ipsum';
 $scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...';
 }]);
 </script>
 <div ng-controller="ExampleController">
-<input ng-model="title"><br>
+<input ng-model="title"> <br/>
 <textarea ng-model="text"></textarea> <br/>
 <pane title="{{title}}">{{text}}</pane>
 </div>
 </file>
 <file name="protractor.js" type="protractor">
 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);
 }
 }
 *
 * # `ngOptions`
 *
 * The `ngOptions` attribute can be used to dynamically generate a list of `<option>`
 * elements for the `<select>` element using the array or object obtained by evaluating the
-* `ngOptions` comprehension_expression.
+* `ngOptions` comprehension expression.
+*
+* In many cases, `ngRepeat` can be used on `<option>` elements instead of `ngOptions` to achieve a
+* similar result. However, `ngOptions` provides some benefits such as reducing memory and
+* increasing speed by not creating a new scope for each repeated instance, as well as providing
+* more flexibility in how the `<select>`'s model is assigned via the `select` **`as`** part of the
+* comprehension expression. `ngOptions` should be used when the `<select>` model needs to be bound
+*  to a non-string value. This is because an option element can only be bound to string values at
+* present.
 *
 * When an item in the `<select>` menu is selected, the array element or object property
 * represented by the selected option will be bound to the model identified by the `ngModel`
 * directive.
+*
+* 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 the `null` or "not selected"
+* option. See example below for demonstration.
 *
 * <div class="alert alert-warning">
 * **Note:** `ngModel` compares by reference, not value. This is important when binding to an
 * array of objects. See an example [in this jsfiddle](http://jsfiddle.net/qWzTb/).
 * </div>
 *
-* Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
+* ## `select` **`as`**
-* be nested into the `<select>` element. This element will then represent the `null` or "not selected"
+*
-* option. See example below for demonstration.
+* Using `select` **`as`** will bind the result of the `select` expression to the model, but
+* the value of the `<select>` and `<option>` html elements will be either the index (for array data sources)
+* or property name (for object data sources) of the value within the collection. If a **`track by`** expression
+* is used, the result of that expression will be set as the value of the `option` and `select` elements.
+*
+*
+* ### `select` **`as`** and **`track by`**
 *
 * <div class="alert alert-warning">
-* **Note:** `ngOptions` provides an iterator facility for the `<option>` element which should be used instead
+* Do not use `select` **`as`** and **`track by`** in the same expression. They are not designed to work together.
-* 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 only
-* be bound to string values at present.
 * </div>
 *
-* <div class="alert alert-info">
+* Consider the following example:
-* **Note:** Using `select as` will bind the result of the `select as` expression to the model, but
+*
-* the value of the `<select>` and `<option>` html elements will be either the index (for array data sources)
+* ```html
-* or property name (for object data sources) of the value  within the collection.
+* <select ng-options="item.subItem as item.label for item in values track by item.id" ng-model="selected">
-* </div>
+* ```
+*
+* ```js
+* $scope.values = [{
+*   id: 1,
+*   label: 'aLabel',
+*   subItem: { name: 'aSubItem' }
+* }, {
+*   id: 2,
+*   label: 'bLabel',
+*   subItem: { name: 'bSubItem' }
+* }];
+*
+* $scope.selected = { name: 'aSubItem' };
+* ```
+*
+* With the purpose of preserving the selection, the **`track by`** expression is always applied to the element
+* of the data source (to `item` in this example). To calculate whether an element is selected, we do the
+* following:
+*
+* 1. Apply **`track by`** to the elements in the array. In the example: `[1, 2]`
+* 2. Apply **`track by`** to the already selected value in `ngModel`.
+*    In the example: this is not possible as **`track by`** refers to `item.id`, but the selected
+*    value from `ngModel` is `{name: 'aSubItem'}`, so the **`track by`** expression is applied to
+*    a wrong object, the selected element can't be found, `<select>` is always reset to the "not
+*    selected" option.
+*
 *
 * @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 The control is considered valid only if value is entered.
 * @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
 * @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`
+*     * `label` **`group by`** `group` **`for`** `value` **`in`** `array`
-*     * `select` **`as`** `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
+*     * `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
+*     * `label` **`for`** `value` **`in`** `array` | orderBy:`orderexpr` **`track by`** `trackexpr`
+*        (for including a filter with `track by`)
 *   * 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`
 *      DOM element.
 *   * `trackexpr`: Used when working with an array of objects. The result of this expression will be
 *      used to identify the objects in the array. The `trackexpr` will most likely refer to the
 *     `value` variable (e.g. `value.propertyName`). With this the selection is preserved
 *      even when the options are recreated (e.g. reloaded from the server).
-* <div class="alert alert-info">
-* **Note:** Using `select as` together with `trackexpr` is not possible (and will throw).
-* Reasoning:
-* - Example: <select ng-options="item.subItem as item.label for item in values track by item.id" ng-model="selected">
-*   values: [{id: 1, label: 'aLabel', subItem: {name: 'aSubItem'}}, {id: 2, label: 'bLabel', subItem: {name: 'bSubItemß'}}],
-*   $scope.selected = {name: 'aSubItem'};
-* - track by is always applied to `value`, with purpose to preserve the selection,
-*   (to `item` in this case)
-* - to calculate whether an item is selected we do the following:
-*   1. apply `track by` to the values in the array, e.g.
-*      In the example: [1,2]
-*   2. apply `track by` to the already selected value in `ngModel`:
-*      In the example: this is not possible, as `track by` refers to `item.id`, but the selected
-*      value from `ngModel` is `{name: aSubItem}`.
-*
-* </div>
 *
 * @example
 <example module="selectExample">
 <file name="index.html">
 <script>
 if (unknownOption.parent()) unknownOption.remove();
 }
 // Workaround for https://code.google.com/p/chromium/issues/detail?id=381459
 // Adding an <option selected="selected"> element to a <select required="required"> should
 // automatically select the new element
-if (element[0].hasAttribute('selected')) {
+if (element && element[0].hasAttribute('selected')) {
 element[0].selected = true;
 }
 };
 self.removeOption = function(value) {
 if (this.hasOption(value)) {
 delete optionsMap[value];
-if (ngModelCtrl.$viewValue == value) {
+if (ngModelCtrl.$viewValue === value) {
 this.renderUnknownOption(value);
 }
 }
 };
 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++) {
+for (var i = 0, children = element.children(), ii = children.length; i < ii; i++) {
 if (children[i].value === '') {
 emptyOption = nullOption = children.eq(i);
 break;
 }
 }
 groupByFn = $parse(match[3] || ''),
 valueFn = $parse(match[2] ? match[1] : valueName),
 valuesFn = $parse(match[7]),
 track = match[8],
 trackFn = track ? $parse(match[8]) : null,
+trackKeysCache = {},
 // 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:''}]],
 //re-usable object to represent option's locals
 locals = {};
-if (trackFn && selectAsFn) {
-throw ngOptionsMinErr('trkslct',
-"Comprehension expression cannot contain both selectAs '{0}' " +
-"and trackBy '{1}' expressions.",
-selectAs, track);
-}
 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
 return exprFn(scope, locals);
 }
 function selectionChanged() {
 scope.$apply(function() {
-var optionGroup,
+var collection = valuesFn(scope) || [];
-collection = valuesFn(scope) || [],
-key, value, optionElement, index, groupIndex, length, groupLength, trackIndex;
 var viewValue;
 if (multiple) {
 viewValue = [];
 forEach(selectElement.val(), function(selectedKey) {
+selectedKey = trackFn ? trackKeysCache[selectedKey] : selectedKey;
 viewValue.push(getViewValue(selectedKey, collection[selectedKey]));
 });
 } else {
-var selectedKey = selectElement.val();
+var selectedKey = trackFn ? trackKeysCache[selectElement.val()] : selectElement.val();
 viewValue = getViewValue(selectedKey, collection[selectedKey]);
 }
 ctrl.$setViewValue(viewValue);
 render();
 });
 }
 function createIsSelectedFn(viewValue) {
 var selectedSet;
 if (multiple) {
-if (!selectAs && trackFn && isArray(viewValue)) {
+if (trackFn && isArray(viewValue)) {
 selectedSet = new HashMap([]);
 for (var trackIndex = 0; trackIndex < viewValue.length; trackIndex++) {
 // tracking by key
 selectedSet.put(callExpression(trackFn, null, viewValue[trackIndex]), true);
 }
 } else {
 selectedSet = new HashMap(viewValue);
 }
-} else if (!selectAsFn && trackFn) {
+} else if (trackFn) {
 viewValue = callExpression(trackFn, null, viewValue);
 }
 return function isSelected(key, value) {
 var compareValueFn;
-if (selectAsFn) {
+if (trackFn) {
+compareValueFn = trackFn;
+} else if (selectAsFn) {
 compareValueFn = selectAsFn;
-} else if (trackFn) {
-compareValueFn = trackFn;
 } else {
 compareValueFn = valueFn;
 }
 if (multiple) {
 return isDefined(selectedSet.remove(callExpression(compareValueFn, key, value)));
 } else {
-return viewValue == callExpression(compareValueFn, key, value);
+return viewValue === callExpression(compareValueFn, key, value);
 }
 };
 }
 function scheduleRendering() {
 if (!renderScheduled) {
 scope.$$postDigest(render);
 renderScheduled = true;
 }
+}
+/**
+* A new labelMap is created with each render.
+* This function is called for each existing option with added=false,
+* and each new option with added=true.
+* - Labels that are passed to this method twice,
+* (once with added=true and once with added=false) will end up with a value of 0, and
+* will cause no change to happen to the corresponding option.
+* - Labels that are passed to this method only once with added=false will end up with a
+* value of -1 and will eventually be passed to selectCtrl.removeOption()
+* - Labels that are passed to this method only once with added=true will end up with a
+* value of 1 and will eventually be passed to selectCtrl.addOption()
+*/
+function updateLabelMap(labelMap, label, added) {
+labelMap[label] = labelMap[label] || 0;
+labelMap[label] += (added ? 1 : -1);
 }
 function render() {
 renderScheduled = false;
 keys = keyName ? sortedKeys(values) : values,
 key,
 value,
 groupLength, length,
 groupIndex, index,
+labelMap = {},
 selected,
 isSelected = createIsSelectedFn(viewValue),
 anySelected = false,
 lastElement,
 element,
-label;
+label,
+optionId;
+trackKeysCache = {};
 // We now build up the list of options we need (we merge later)
 for (index = 0; length = keys.length, index < length; index++) {
 key = index;
 if (keyName) {
 key = keys[index];
-if ( key.charAt(0) === '$' ) continue;
+if (key.charAt(0) === '$') continue;
 }
 value = values[key];
 optionGroupName = callExpression(groupByFn, key, value) || '';
 if (!(optionGroup = optionGroups[optionGroupName])) {
 label = callExpression(displayFn, key, value); // what will be seen by the user
 // doing displayFn(scope, locals) || '' overwrites zero values
 label = isDefined(label) ? label : '';
+optionId = trackFn ? trackFn(scope, locals) : (keyName ? keys[index] : index);
+if (trackFn) {
+trackKeysCache[optionId] = key;
+}
 optionGroup.push({
 // either the index into array or key from object
-id: (keyName ? keys[index] : index),
+id: optionId,
 label: label,
 selected: selected                   // determine if we should be selected
 });
 }
 if (!multiple) {
 existingParent.element.attr('label', existingParent.label = optionGroupName);
 }
 }
 lastElement = null;  // start at the beginning
-for(index = 0, length = optionGroup.length; index < length; index++) {
+for (index = 0, length = optionGroup.length; index < length; index++) {
 option = optionGroup[index];
-if ((existingOption = existingOptions[index+1])) {
+if ((existingOption = existingOptions[index + 1])) {
 // reuse elements
 lastElement = existingOption.element;
 if (existingOption.label !== option.label) {
+updateLabelMap(labelMap, existingOption.label, false);
+updateLabelMap(labelMap, option.label, true);
 lastElement.text(existingOption.label = option.label);
+lastElement.prop('label', existingOption.label);
 }
 if (existingOption.id !== option.id) {
 lastElement.val(existingOption.id = option.id);
 }
 // lastElement.prop('selected') provided by jQuery has side-effects
 // rather then the element.
 (element = optionTemplate.clone())
 .val(option.id)
 .prop('selected', option.selected)
 .attr('selected', option.selected)
+.prop('label', option.label)
 .text(option.label);
 }
 existingOptions.push(existingOption = {
 element: element,
 label: option.label,
 id: option.id,
 selected: option.selected
 });
-selectCtrl.addOption(option.label, element);
+updateLabelMap(labelMap, option.label, true);
 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) {
+while (existingOptions.length > index) {
 option = existingOptions.pop();
-selectCtrl.removeOption(option.label);
+updateLabelMap(labelMap, option.label, false);
 option.element.remove();
 }
 }
 // remove any excessive OPTGROUPs from select
-while(optionGroupsCache.length > groupIndex) {
+while (optionGroupsCache.length > groupIndex) {
-optionGroupsCache.pop()[0].element.remove();
+// remove all the labels in the option group
+optionGroup = optionGroupsCache.pop();
+for (index = 1; index < optionGroup.length; ++index) {
+updateLabelMap(labelMap, optionGroup[index].label, false);
+}
+optionGroup[0].element.remove();
 }
+forEach(labelMap, function(count, label) {
+if (count > 0) {
+selectCtrl.addOption(label);
+} else if (count < 0) {
+selectCtrl.removeOption(label);
+}
+});
 }
 }
 }
 };
 }];
 if (!interpolateFn) {
 attr.$set('value', element.text());
 }
 }
-return function (scope, element, attr) {
+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
 "</ul>\n" +
 "");
 }]);
 /**
-* @license AngularJS v1.3.0-rc.5
+* @license AngularJS v1.3.8
 * (c) 2010-2014 Google, Inc. http://angularjs.org
 * License: MIT
 */
 (function(window, angular, undefined) {'use strict';
 * Create a shallow copy of an object and clear other fields from the destination
 */
 function shallowClearAndCopy(src, dst) {
 dst = dst || {};
-angular.forEach(dst, function(value, key){
+angular.forEach(dst, function(value, key) {
 delete dst[key];
 });
 for (var key in src) {
 if (src.hasOwnProperty(key) && !(key.charAt(0) === '$' && key.charAt(1) === '$')) {
 * which can pose problems with server backends that do not expect that
 * behavior.  This can be disabled by configuring the `$resourceProvider` like
 * this:
 *
 * ```js
-app.config(['$resourceProvider', function ($resourceProvider) {
+app.config(['$resourceProvider', function($resourceProvider) {
 // Don't strip trailing slashes from calculated URLs
 $resourceProvider.defaults.stripTrailingSlashes = false;
 }]);
 * ```
 *
 *   If the parameter value is prefixed with `@` then the value for that parameter will be extracted
 *   from the corresponding property on the `data` object (provided when calling an action method).  For
 *   example, if the `defaultParam` object is `{someParam: '@someProp'}` then the value of `someParam`
 *   will be `data.someProp`.
 *
-* @param {Object.<Object>=} actions Hash with declaration of custom action that should extend
+* @param {Object.<Object>=} actions Hash with declaration of custom actions that should extend
 *   the default set of resource actions. The declaration should be created in the format of {@link
-*   ng.$http#usage_parameters $http.config}:
+*   ng.$http#usage $http.config}:
 *
 *       {action1: {method:?, params:?, isArray:?, headers:?, ...},
 *        action2: {method:?, params:?, isArray:?, headers:?, ...},
 *        ...}
 *
 *    // This will PUT /notes/ID with the note object in the request payload
 *    }]);
 * ```
 */
 angular.module('ngResource', ['ng']).
-provider('$resource', function () {
+provider('$resource', function() {
 var provider = this;
 this.defaults = {
 // Strip slashes by default
 stripTrailingSlashes: true,
 'remove': {method: 'DELETE'},
 'delete': {method: 'DELETE'}
 }
 };
-this.$get = ['$http', '$q', function ($http, $q) {
+this.$get = ['$http', '$q', function($http, $q) {
 var noop = angular.noop,
 forEach = angular.forEach,
 extend = angular.extend,
 copy = angular.copy,
 this.defaults = extend({}, provider.defaults, defaults);
 this.urlParams = {};
 }
 Route.prototype = {
-setUrlParams: function (config, params, actionUrl) {
+setUrlParams: function(config, params, actionUrl) {
 var self = this,
 url = actionUrl || self.template,
 val,
 encodedVal;
 var urlParams = self.urlParams = {};
-forEach(url.split(/\W/), function (param) {
+forEach(url.split(/\W/), function(param) {
 if (param === 'hasOwnProperty') {
 throw $resourceMinErr('badname', "hasOwnProperty is not a valid parameter name.");
 }
 if (!(new RegExp("^\\d+$").test(param)) && param &&
 (new RegExp("(^|[^\\\\]):" + param + "(\\W|$)").test(url))) {
 }
 });
 url = url.replace(/\\:/g, ':');
 params = params || {};
-forEach(self.urlParams, function (_, urlParam) {
+forEach(self.urlParams, function(_, urlParam) {
 val = params.hasOwnProperty(urlParam) ? params[urlParam] : self.defaults[urlParam];
 if (angular.isDefined(val) && val !== null) {
 encodedVal = encodeUriSegment(val);
-url = url.replace(new RegExp(":" + urlParam + "(\\W|$)", "g"), function (match, p1) {
+url = url.replace(new RegExp(":" + urlParam + "(\\W|$)", "g"), function(match, p1) {
 return encodedVal + p1;
 });
 } else {
-url = url.replace(new RegExp("(\/?):" + urlParam + "(\\W|$)", "g"), function (match,
+url = url.replace(new RegExp("(\/?):" + urlParam + "(\\W|$)", "g"), function(match,
 leadingSlashes, tail) {
 if (tail.charAt(0) == '/') {
 return tail;
 } else {
 return leadingSlashes + tail;
 // replace escaped `/\.` with `/.`
 config.url = url.replace(/\/\\\./, '/.');
 // set params - delegate param encoding to $http
-forEach(params, function (value, key) {
+forEach(params, function(value, key) {
 if (!self.urlParams[key]) {
 config.params = config.params || {};
 config.params[key] = value;
 }
 });
 actions = extend({}, provider.defaults.actions, actions);
 function extractParams(data, actionParams) {
 var ids = {};
 actionParams = extend({}, paramDefaults, actionParams);
-forEach(actionParams, function (value, key) {
+forEach(actionParams, function(value, key) {
 if (isFunction(value)) { value = value(); }
 ids[key] = value && value.charAt && value.charAt(0) == '@' ?
 lookupDottedPath(data, value.substr(1)) : value;
 });
 return ids;
 function Resource(value) {
 shallowClearAndCopy(value || {}, this);
 }
-Resource.prototype.toJSON = function () {
+Resource.prototype.toJSON = function() {
 var data = extend({}, this);
 delete data.$promise;
 delete data.$resolved;
 return data;
 };
-forEach(actions, function (action, name) {
+forEach(actions, function(action, name) {
 var hasBody = /^(POST|PUT|PATCH)$/i.test(action.method);
-Resource[name] = function (a1, a2, a3, a4) {
+Resource[name] = function(a1, a2, a3, a4) {
 var params = {}, data, success, error;
 /* jshint -W086 */ /* (purposefully fall through case statements) */
 switch (arguments.length) {
 case 4:
 var responseInterceptor = action.interceptor && action.interceptor.response ||
 defaultResponseInterceptor;
 var responseErrorInterceptor = action.interceptor && action.interceptor.responseError ||
 undefined;
-forEach(action, function (value, key) {
+forEach(action, function(value, key) {
 if (key != 'params' && key != 'isArray' && key != 'interceptor') {
 httpConfig[key] = copy(value);
 }
 });
 if (hasBody) httpConfig.data = data;
 route.setUrlParams(httpConfig,
 extend({}, extractParams(data, action.params || {}), params),
 action.url);
-var promise = $http(httpConfig).then(function (response) {
+var promise = $http(httpConfig).then(function(response) {
 var data = response.data,
 promise = value.$promise;
 if (data) {
 // Need to convert action.isArray to boolean in case it is undefined
 angular.isArray(data) ? 'array' : 'object');
 }
 // jshint +W018
 if (action.isArray) {
 value.length = 0;
-forEach(data, function (item) {
+forEach(data, function(item) {
 if (typeof item === "object") {
 value.push(new Resource(item));
 } else {
 // Valid JSON values may be string literals, and these should not be converted
 // into objects. These items will not have access to the Resource prototype
 value.$resolved = true;
 response.resource = value;
 return response;
-}, function (response) {
+}, function(response) {
 value.$resolved = true;
 (error || noop)(response);
 return $q.reject(response);
 });
 promise = promise.then(
-function (response) {
+function(response) {
 var value = responseInterceptor(response);
 (success || noop)(value, response.headers);
 return value;
 },
 responseErrorInterceptor);
 // instance call
 return promise;
 };
-Resource.prototype['$' + name] = function (params, success, error) {
+Resource.prototype['$' + name] = function(params, success, error) {
 if (isFunction(params)) {
 error = success; success = params; params = {};
 }
 var result = Resource[name].call(this, params, this, success, error);
 return result.$promise || result;
 };
 });
-Resource.bind = function (additionalParamDefaults) {
+Resource.bind = function(additionalParamDefaults) {
 return resourceFactory(url, extend({}, paramDefaults, additionalParamDefaults), actions);
 };
 return Resource;
 }
 })(window, window.angular);
 /**
-* @license AngularJS v1.3.0-rc.5
+* @license AngularJS v1.3.8
 * (c) 2010-2014 Google, Inc. http://angularjs.org
 * License: MIT
 */
 (function(window, angular, undefined) {'use strict';
 * See {@link ngRoute.$route#example $route} for an example of configuring and using `ngRoute`.
 *
 * ## Dependencies
 * Requires the {@link ngRoute `ngRoute`} module to be installed.
 */
-function $RouteProvider(){
+function $RouteProvider() {
 function inherit(parent, extra) {
-return angular.extend(new (angular.extend(function() {}, {prototype:parent}))(), extra);
+return angular.extend(Object.create(parent), extra);
 }
 var routes = {};
 /**
 *
 * @description
 * Adds a new route definition to the `$route` service.
 */
 this.when = function(path, route) {
+//copy original route object to preserve params inherited from proto chain
+var routeCopy = angular.copy(route);
+if (angular.isUndefined(routeCopy.reloadOnSearch)) {
+routeCopy.reloadOnSearch = true;
+}
+if (angular.isUndefined(routeCopy.caseInsensitiveMatch)) {
+routeCopy.caseInsensitiveMatch = this.caseInsensitiveMatch;
+}
 routes[path] = angular.extend(
-{reloadOnSearch: true},
+routeCopy,
-route,
+path && pathRegExp(path, routeCopy)
-path && pathRegExp(path, route)
 );
 // create redirection for trailing slashes
 if (path) {
-var redirectPath = (path[path.length-1] == '/')
+var redirectPath = (path[path.length - 1] == '/')
-? path.substr(0, path.length-1)
+? path.substr(0, path.length - 1)
-: path +'/';
+: path + '/';
 routes[redirectPath] = angular.extend(
 {redirectTo: path},
-pathRegExp(redirectPath, route)
+pathRegExp(redirectPath, routeCopy)
 );
 }
 return this;
 };
+/**
+* @ngdoc property
+* @name $routeProvider#caseInsensitiveMatch
+* @description
+*
+* A boolean property indicating if routes defined
+* using this provider should be matched using a case insensitive
+* algorithm. Defaults to `false`.
+*/
+this.caseInsensitiveMatch = false;
 /**
 * @param path {string} path
 * @param opts {Object} options
 * @return {?Object}
 },
 keys = ret.keys = [];
 path = path
 .replace(/([().])/g, '\\$1')
-.replace(/(\/)?:(\w+)([\?\*])?/g, function(_, slash, key, option){
+.replace(/(\/)?:(\w+)([\?\*])?/g, function(_, slash, key, option) {
 var optional = option === '?' ? option : null;
 var star = option === '*' ? option : null;
 keys.push({ name: key, optional: !!optional });
 slash = slash || '';
 return ''
 * @description
 * Causes `$route` service to reload the current route even if
 * {@link ng.$location $location} hasn't changed.
 *
 * As a result of that, {@link ngRoute.directive:ngView ngView}
-* creates new scope, reinstantiates the controller.
+* creates new scope and reinstantiates the controller.
 */
 reload: function() {
 forceReload = true;
 $rootScope.$evalAsync(function() {
 // Don't support cancellation of a reload for now...
 /**
 * @returns {string} interpolation of the redirect path with the parameters
 */
 function interpolate(string, params) {
 var result = [];
-angular.forEach((string||'').split(':'), function(segment, i) {
+angular.forEach((string || '').split(':'), function(segment, i) {
 if (i === 0) {
 result.push(segment);
 } else {
-var segmentMatch = segment.match(/(\w+)(.*)/);
+var segmentMatch = segment.match(/(\w+)(?:[?*])?(.*)/);
 var key = segmentMatch[1];
 result.push(params[key]);
 result.push(segmentMatch[2] || '');
 delete params[key];
 }
 <file name="animations.css">
 .view-animate-container {
 position:relative;
 height:100px!important;
-position:relative;
 background:white;
 border:1px solid black;
 height:40px;
 overflow:hidden;
 }
 * @eventType emit on the current ngView scope
 * @description
 * Emitted every time the ngView content is reloaded.
 */
 ngViewFactory.$inject = ['$route', '$anchorScroll', '$animate'];
-function ngViewFactory(   $route,   $anchorScroll,   $animate) {
+function ngViewFactory($route, $anchorScroll, $animate) {
 return {
 restrict: 'ECA',
 terminal: true,
 priority: 400,
 transclude: 'element',
 scope.$on('$routeChangeSuccess', update);
 update();
 function cleanupLastView() {
-if(previousLeaveAnimation) {
+if (previousLeaveAnimation) {
 $animate.cancel(previousLeaveAnimation);
 previousLeaveAnimation = null;
 }
-if(currentScope) {
+if (currentScope) {
 currentScope.$destroy();
 currentScope = null;
 }
-if(currentElement) {
+if (currentElement) {
 previousLeaveAnimation = $animate.leave(currentElement);
 previousLeaveAnimation.then(function() {
 previousLeaveAnimation = null;
 });
 currentElement = null;
 // However, using ng-view on an element with additional content does not make sense...
 // Note: We can't remove them in the cloneAttchFn of $transclude as that
 // function is called before linking the content, which would apply child
 // directives to non existing elements.
 var clone = $transclude(newScope, function(clone) {
-$animate.enter(clone, null, currentElement || $element).then(function onNgViewEnter () {
+$animate.enter(clone, null, currentElement || $element).then(function onNgViewEnter() {
 if (angular.isDefined(autoScrollExp)
 && (!autoScrollExp || scope.$eval(autoScrollExp))) {
 $anchorScroll();
 }
 });
 },
 controller: ['$scope', function($scope){
 // the index of the suggestions that's currently selected
 $scope.selectedIndex = -1;
+$scope.initLock = true;
 // set new index
 $scope.setIndex = function(i){
 $scope.selectedIndex = parseInt(i);
 };
 $scope.completing = false;
 // starts autocompleting on typing in something
 $scope.$watch('searchParam', function(newValue, oldValue){
-if (oldValue === newValue || !oldValue) {
+if (oldValue === newValue || (!oldValue && $scope.initLock)) {
 return;
 }
 if(watching && typeof $scope.searchParam !== 'undefined' && $scope.searchParam !== null) {
 $scope.completing = true;
 }],
 link: function(scope, element, attrs){
+setTimeout(function() {
+scope.initLock = false;
+scope.$apply();
+}, 250);
 var attr = '';
 // Default atts
 scope.attrs = {
 "placeholder": "start typing...",
 }
 if (attrs.clickActivation) {
 element[0].onclick = function(e){
 if(!scope.searchParam){
-scope.completing = true;
+setTimeout(function() {
-scope.$apply();
+scope.completing = true;
+scope.$apply();
+}, 200);
 }
 };
 }
 var key = {left: 37, up: 38, right: 39, down: 40 , enter: 13, esc: 27, tab: 9};
 // we do a timeout to prevent hiding it before a click event is registered
 setTimeout(function() {
 scope.select();
 scope.setIndex(-1);
 scope.$apply();
-}, 200);
+}, 150);
 }, true);
 element[0].addEventListener("keydown",function (e){
 var keycode = e.keyCode || e.which;
 var l = angular.element(this).find('li').length;
+// this allows submitting forms by pressing Enter in the autocompleted field
+if(!scope.completing || l == 0) return;
 // implementation of the up and down movement in the list of suggestions
 switch (keycode){
 case key.up:
 */
 !(function() {
 "use strict";
-var VERSION = '2.1.0';
+var VERSION = '3.0.0';
 var ENTITIES = {};
 // from http://semplicewebsites.com/removing-accents-javascript
 var latin_map={"Á":"A","Ă":"A","Ắ":"A","Ặ":"A","Ằ":"A","Ẳ":"A","Ẵ":"A","Ǎ":"A","Â":"A","Ấ":"A","Ậ":"A","Ầ":"A","Ẩ":"A","Ẫ":"A","Ä":"A","Ǟ":"A","Ȧ":"A","Ǡ":"A","Ạ":"A","Ȁ":"A","À":"A","Ả":"A","Ȃ":"A","Ā":"A","Ą":"A","Å":"A","Ǻ":"A","Ḁ":"A","Ⱥ":"A","Ã":"A","Ꜳ":"AA","Æ":"AE","Ǽ":"AE","Ǣ":"AE","Ꜵ":"AO","Ꜷ":"AU","Ꜹ":"AV","Ꜻ":"AV","Ꜽ":"AY","Ḃ":"B","Ḅ":"B","Ɓ":"B","Ḇ":"B","Ƀ":"B","Ƃ":"B","Ć":"C","Č":"C","Ç":"C","Ḉ":"C","Ĉ":"C","Ċ":"C","Ƈ":"C","Ȼ":"C","Ď":"D","Ḑ":"D","Ḓ":"D","Ḋ":"D","Ḍ":"D","Ɗ":"D","Ḏ":"D","ǲ":"D","ǅ":"D","Đ":"D","Ƌ":"D","Ǳ":"DZ","Ǆ":"DZ","É":"E","Ĕ":"E","Ě":"E","Ȩ":"E","Ḝ":"E","Ê":"E","Ế":"E","Ệ":"E","Ề":"E","Ể":"E","Ễ":"E","Ḙ":"E","Ë":"E","Ė":"E","Ẹ":"E","Ȅ":"E","È":"E","Ẻ":"E","Ȇ":"E","Ē":"E","Ḗ":"E","Ḕ":"E","Ę":"E","Ɇ":"E","Ẽ":"E","Ḛ":"E","Ꝫ":"ET","Ḟ":"F","Ƒ":"F","Ǵ":"G","Ğ":"G","Ǧ":"G","Ģ":"G","Ĝ":"G","Ġ":"G","Ɠ":"G","Ḡ":"G","Ǥ":"G","Ḫ":"H","Ȟ":"H","Ḩ":"H","Ĥ":"H","Ⱨ":"H","Ḧ":"H","Ḣ":"H","Ḥ":"H","Ħ":"H","Í":"I","Ĭ":"I","Ǐ":"I","Î":"I","Ï":"I","Ḯ":"I","İ":"I","Ị":"I","Ȉ":"I","Ì":"I","Ỉ":"I","Ȋ":"I","Ī":"I","Į":"I","Ɨ":"I","Ĩ":"I","Ḭ":"I","Ꝺ":"D","Ꝼ":"F","Ᵹ":"G","Ꞃ":"R","Ꞅ":"S","Ꞇ":"T","Ꝭ":"IS","Ĵ":"J","Ɉ":"J","Ḱ":"K","Ǩ":"K","Ķ":"K","Ⱪ":"K","Ꝃ":"K","Ḳ":"K","Ƙ":"K","Ḵ":"K","Ꝁ":"K","Ꝅ":"K","Ĺ":"L","Ƚ":"L","Ľ":"L","Ļ":"L","Ḽ":"L","Ḷ":"L","Ḹ":"L","Ⱡ":"L","Ꝉ":"L","Ḻ":"L","Ŀ":"L","Ɫ":"L","ǈ":"L","Ł":"L","Ǉ":"LJ","Ḿ":"M","Ṁ":"M","Ṃ":"M","Ɱ":"M","Ń":"N","Ň":"N","Ņ":"N","Ṋ":"N","Ṅ":"N","Ṇ":"N","Ǹ":"N","Ɲ":"N","Ṉ":"N","Ƞ":"N","ǋ":"N","Ñ":"N","Ǌ":"NJ","Ó":"O","Ŏ":"O","Ǒ":"O","Ô":"O","Ố":"O","Ộ":"O","Ồ":"O","Ổ":"O","Ỗ":"O","Ö":"O","Ȫ":"O","Ȯ":"O","Ȱ":"O","Ọ":"O","Ő":"O","Ȍ":"O","Ò":"O","Ỏ":"O","Ơ":"O","Ớ":"O","Ợ":"O","Ờ":"O","Ở":"O","Ỡ":"O","Ȏ":"O","Ꝋ":"O","Ꝍ":"O","Ō":"O","Ṓ":"O","Ṑ":"O","Ɵ":"O","Ǫ":"O","Ǭ":"O","Ø":"O","Ǿ":"O","Õ":"O","Ṍ":"O","Ṏ":"O","Ȭ":"O","Ƣ":"OI","Ꝏ":"OO","Ɛ":"E","Ɔ":"O","Ȣ":"OU","Ṕ":"P","Ṗ":"P","Ꝓ":"P","Ƥ":"P","Ꝕ":"P","Ᵽ":"P","Ꝑ":"P","Ꝙ":"Q","Ꝗ":"Q","Ŕ":"R","Ř":"R","Ŗ":"R","Ṙ":"R","Ṛ":"R","Ṝ":"R","Ȑ":"R","Ȓ":"R","Ṟ":"R","Ɍ":"R","Ɽ":"R","Ꜿ":"C","Ǝ":"E","Ś":"S","Ṥ":"S","Š":"S","Ṧ":"S","Ş":"S","Ŝ":"S","Ș":"S","Ṡ":"S","Ṣ":"S","Ṩ":"S","ẞ":"SS","Ť":"T","Ţ":"T","Ṱ":"T","Ț":"T","Ⱦ":"T","Ṫ":"T","Ṭ":"T","Ƭ":"T","Ṯ":"T","Ʈ":"T","Ŧ":"T","Ɐ":"A","Ꞁ":"L","Ɯ":"M","Ʌ":"V","Ꜩ":"TZ","Ú":"U","Ŭ":"U","Ǔ":"U","Û":"U","Ṷ":"U","Ü":"U","Ǘ":"U","Ǚ":"U","Ǜ":"U","Ǖ":"U","Ṳ":"U","Ụ":"U","Ű":"U","Ȕ":"U","Ù":"U","Ủ":"U","Ư":"U","Ứ":"U","Ự":"U","Ừ":"U","Ử":"U","Ữ":"U","Ȗ":"U","Ū":"U","Ṻ":"U","Ų":"U","Ů":"U","Ũ":"U","Ṹ":"U","Ṵ":"U","Ꝟ":"V","Ṿ":"V","Ʋ":"V","Ṽ":"V","Ꝡ":"VY","Ẃ":"W","Ŵ":"W","Ẅ":"W","Ẇ":"W","Ẉ":"W","Ẁ":"W","Ⱳ":"W","Ẍ":"X","Ẋ":"X","Ý":"Y","Ŷ":"Y","Ÿ":"Y","Ẏ":"Y","Ỵ":"Y","Ỳ":"Y","Ƴ":"Y","Ỷ":"Y","Ỿ":"Y","Ȳ":"Y","Ɏ":"Y","Ỹ":"Y","Ź":"Z","Ž":"Z","Ẑ":"Z","Ⱬ":"Z","Ż":"Z","Ẓ":"Z","Ȥ":"Z","Ẕ":"Z","Ƶ":"Z","Ĳ":"IJ","Œ":"OE","ᴀ":"A","ᴁ":"AE","ʙ":"B","ᴃ":"B","ᴄ":"C","ᴅ":"D","ᴇ":"E","ꜰ":"F","ɢ":"G","ʛ":"G","ʜ":"H","ɪ":"I","ʁ":"R","ᴊ":"J","ᴋ":"K","ʟ":"L","ᴌ":"L","ᴍ":"M","ɴ":"N","ᴏ":"O","ɶ":"OE","ᴐ":"O","ᴕ":"OU","ᴘ":"P","ʀ":"R","ᴎ":"N","ᴙ":"R","ꜱ":"S","ᴛ":"T","ⱻ":"E","ᴚ":"R","ᴜ":"U","ᴠ":"V","ᴡ":"W","ʏ":"Y","ᴢ":"Z","á":"a","ă":"a","ắ":"a","ặ":"a","ằ":"a","ẳ":"a","ẵ":"a","ǎ":"a","â":"a","ấ":"a","ậ":"a","ầ":"a","ẩ":"a","ẫ":"a","ä":"a","ǟ":"a","ȧ":"a","ǡ":"a","ạ":"a","ȁ":"a","à":"a","ả":"a","ȃ":"a","ā":"a","ą":"a","ᶏ":"a","ẚ":"a","å":"a","ǻ":"a","ḁ":"a","ⱥ":"a","ã":"a","ꜳ":"aa","æ":"ae","ǽ":"ae","ǣ":"ae","ꜵ":"ao","ꜷ":"au","ꜹ":"av","ꜻ":"av","ꜽ":"ay","ḃ":"b","ḅ":"b","ɓ":"b","ḇ":"b","ᵬ":"b","ᶀ":"b","ƀ":"b","ƃ":"b","ɵ":"o","ć":"c","č":"c","ç":"c","ḉ":"c","ĉ":"c","ɕ":"c","ċ":"c","ƈ":"c","ȼ":"c","ď":"d","ḑ":"d","ḓ":"d","ȡ":"d","ḋ":"d","ḍ":"d","ɗ":"d","ᶑ":"d","ḏ":"d","ᵭ":"d","ᶁ":"d","đ":"d","ɖ":"d","ƌ":"d","ı":"i","ȷ":"j","ɟ":"j","ʄ":"j","ǳ":"dz","ǆ":"dz","é":"e","ĕ":"e","ě":"e","ȩ":"e","ḝ":"e","ê":"e","ế":"e","ệ":"e","ề":"e","ể":"e","ễ":"e","ḙ":"e","ë":"e","ė":"e","ẹ":"e","ȅ":"e","è":"e","ẻ":"e","ȇ":"e","ē":"e","ḗ":"e","ḕ":"e","ⱸ":"e","ę":"e","ᶒ":"e","ɇ":"e","ẽ":"e","ḛ":"e","ꝫ":"et","ḟ":"f","ƒ":"f","ᵮ":"f","ᶂ":"f","ǵ":"g","ğ":"g","ǧ":"g","ģ":"g","ĝ":"g","ġ":"g","ɠ":"g","ḡ":"g","ᶃ":"g","ǥ":"g","ḫ":"h","ȟ":"h","ḩ":"h","ĥ":"h","ⱨ":"h","ḧ":"h","ḣ":"h","ḥ":"h","ɦ":"h","ẖ":"h","ħ":"h","ƕ":"hv","í":"i","ĭ":"i","ǐ":"i","î":"i","ï":"i","ḯ":"i","ị":"i","ȉ":"i","ì":"i","ỉ":"i","ȋ":"i","ī":"i","į":"i","ᶖ":"i","ɨ":"i","ĩ":"i","ḭ":"i","ꝺ":"d","ꝼ":"f","ᵹ":"g","ꞃ":"r","ꞅ":"s","ꞇ":"t","ꝭ":"is","ǰ":"j","ĵ":"j","ʝ":"j","ɉ":"j","ḱ":"k","ǩ":"k","ķ":"k","ⱪ":"k","ꝃ":"k","ḳ":"k","ƙ":"k","ḵ":"k","ᶄ":"k","ꝁ":"k","ꝅ":"k","ĺ":"l","ƚ":"l","ɬ":"l","ľ":"l","ļ":"l","ḽ":"l","ȴ":"l","ḷ":"l","ḹ":"l","ⱡ":"l","ꝉ":"l","ḻ":"l","ŀ":"l","ɫ":"l","ᶅ":"l","ɭ":"l","ł":"l","ǉ":"lj","ſ":"s","ẜ":"s","ẛ":"s","ẝ":"s","ḿ":"m","ṁ":"m","ṃ":"m","ɱ":"m","ᵯ":"m","ᶆ":"m","ń":"n","ň":"n","ņ":"n","ṋ":"n","ȵ":"n","ṅ":"n","ṇ":"n","ǹ":"n","ɲ":"n","ṉ":"n","ƞ":"n","ᵰ":"n","ᶇ":"n","ɳ":"n","ñ":"n","ǌ":"nj","ó":"o","ŏ":"o","ǒ":"o","ô":"o","ố":"o","ộ":"o","ồ":"o","ổ":"o","ỗ":"o","ö":"o","ȫ":"o","ȯ":"o","ȱ":"o","ọ":"o","ő":"o","ȍ":"o","ò":"o","ỏ":"o","ơ":"o","ớ":"o","ợ":"o","ờ":"o","ở":"o","ỡ":"o","ȏ":"o","ꝋ":"o","ꝍ":"o","ⱺ":"o","ō":"o","ṓ":"o","ṑ":"o","ǫ":"o","ǭ":"o","ø":"o","ǿ":"o","õ":"o","ṍ":"o","ṏ":"o","ȭ":"o","ƣ":"oi","ꝏ":"oo","ɛ":"e","ᶓ":"e","ɔ":"o","ᶗ":"o","ȣ":"ou","ṕ":"p","ṗ":"p","ꝓ":"p","ƥ":"p","ᵱ":"p","ᶈ":"p","ꝕ":"p","ᵽ":"p","ꝑ":"p","ꝙ":"q","ʠ":"q","ɋ":"q","ꝗ":"q","ŕ":"r","ř":"r","ŗ":"r","ṙ":"r","ṛ":"r","ṝ":"r","ȑ":"r","ɾ":"r","ᵳ":"r","ȓ":"r","ṟ":"r","ɼ":"r","ᵲ":"r","ᶉ":"r","ɍ":"r","ɽ":"r","ↄ":"c","ꜿ":"c","ɘ":"e","ɿ":"r","ś":"s","ṥ":"s","š":"s","ṧ":"s","ş":"s","ŝ":"s","ș":"s","ṡ":"s","ṣ":"s","ṩ":"s","ʂ":"s","ᵴ":"s","ᶊ":"s","ȿ":"s","ɡ":"g","ß":"ss","ᴑ":"o","ᴓ":"o","ᴝ":"u","ť":"t","ţ":"t","ṱ":"t","ț":"t","ȶ":"t","ẗ":"t","ⱦ":"t","ṫ":"t","ṭ":"t","ƭ":"t","ṯ":"t","ᵵ":"t","ƫ":"t","ʈ":"t","ŧ":"t","ᵺ":"th","ɐ":"a","ᴂ":"ae","ǝ":"e","ᵷ":"g","ɥ":"h","ʮ":"h","ʯ":"h","ᴉ":"i","ʞ":"k","ꞁ":"l","ɯ":"m","ɰ":"m","ᴔ":"oe","ɹ":"r","ɻ":"r","ɺ":"r","ⱹ":"r","ʇ":"t","ʌ":"v","ʍ":"w","ʎ":"y","ꜩ":"tz","ú":"u","ŭ":"u","ǔ":"u","û":"u","ṷ":"u","ü":"u","ǘ":"u","ǚ":"u","ǜ":"u","ǖ":"u","ṳ":"u","ụ":"u","ű":"u","ȕ":"u","ù":"u","ủ":"u","ư":"u","ứ":"u","ự":"u","ừ":"u","ử":"u","ữ":"u","ȗ":"u","ū":"u","ṻ":"u","ų":"u","ᶙ":"u","ů":"u","ũ":"u","ṹ":"u","ṵ":"u","ᵫ":"ue","ꝸ":"um","ⱴ":"v","ꝟ":"v","ṿ":"v","ʋ":"v","ᶌ":"v","ⱱ":"v","ṽ":"v","ꝡ":"vy","ẃ":"w","ŵ":"w","ẅ":"w","ẇ":"w","ẉ":"w","ẁ":"w","ⱳ":"w","ẘ":"w","ẍ":"x","ẋ":"x","ᶍ":"x","ý":"y","ŷ":"y","ÿ":"y","ẏ":"y","ỵ":"y","ỳ":"y","ƴ":"y","ỷ":"y","ỿ":"y","ȳ":"y","ẙ":"y","ɏ":"y","ỹ":"y","ź":"z","ž":"z","ẑ":"z","ʑ":"z","ⱬ":"z","ż":"z","ẓ":"z","ȥ":"z","ẕ":"z","ᵶ":"z","ᶎ":"z","ʐ":"z","ƶ":"z","ɀ":"z","ﬀ":"ff","ﬃ":"ffi","ﬄ":"ffl","ﬁ":"fi","ﬂ":"fl","ĳ":"ij","œ":"oe","ﬆ":"st","ₐ":"a","ₑ":"e","ᵢ":"i","ⱼ":"j","ₒ":"o","ᵣ":"r","ᵤ":"u","ᵥ":"v","ₓ":"x"};
 })
 return new this.constructor(s);
 },
-endsWith: function(suffix) {
+endsWith: function() {
-var l  = this.s.length - suffix.length;
+var suffixes = Array.prototype.slice.call(arguments, 0);
-return l >= 0 && this.s.indexOf(suffix, l) === l;
+for (var i = 0; i < suffixes.length; ++i) {
+var l  = this.s.length - suffixes[i].length;
+if (l >= 0 && this.s.indexOf(suffixes[i], l) === l) return true;
+}
+return false;
 },
 escapeHTML: function() { //from underscore.string
 return new this.constructor(this.s.replace(/[&<>"']/g, function(m){ return '&' + reversedEscapeChars[m] + ';'; }));
 },
 if (sl.charAt(0) === '-')
 sl = sl.substr(1);
 return new this.constructor(sl);
 },
-startsWith: function(prefix) {
+startsWith: function() {
-return this.s.lastIndexOf(prefix, 0) === 0;
+var prefixes = Array.prototype.slice.call(arguments, 0);
+for (var i = 0; i < prefixes.length; ++i) {
+if (this.s.lastIndexOf(prefixes[i], 0) === 0) return true;
+}
+return false;
 },
 stripPunctuation: function() {
 //return new this.constructor(this.s.replace(/[\.,-\/#!$%\^&\*;:{}=\-_`~()]/g,""));
 return new this.constructor(this.s.replace(/[^\w\s]|_/g, "").replace(/\s+/g, " "));
 var r = new RegExp(open + '(.+?)' + close, 'g')
 //, r = /\{\{(.+?)\}\}/g
 var matches = s.match(r) || [];
 matches.forEach(function(match) {
-var key = match.substring(opening.length, match.length - closing.length);//chop {{ and }}
+var key = match.substring(opening.length, match.length - closing.length).trim();//chop {{ and }}
-if (typeof values[key] != 'undefined')
+var value = typeof values[key] == 'undefined' ? '' : values[key];
-s = s.replace(match, values[key]);
+s = s.replace(match, value);
 });
 return new this.constructor(s);
 },
 times: function(n) {
 },
 //#modified from https://github.com/epeli/underscore.string
 underscore: function() {
 var s = this.trim().s.replace(/([a-z\d])([A-Z]+)/g, '$1_$2').replace(/[-\s]+/g, '_').toLowerCase();
-if ((new S(this.s.charAt(0))).isUpper()) {
-s = '_' + s;
-}
 return new this.constructor(s);
 },
 unescapeHTML: function() { //from underscore.string
 return new this.constructor(this.s.replace(/\&([^;]+);/g, function(entity, entityCode){

mons