feat(ngAria): add option to disable role=button

Closes #11580 Closes #12234
revert: "fix($compile): do not write @-bound properties if attribute is not present"
2015-07-02 14:36:49 +03:00 · 2015-07-01 22:12:03 -07:00 · 2015-07-01 12:15:00 -07:00 · 2015-07-01 12:15:00 -07:00 · 2015-07-01 12:14:42 -07:00 · 2015-06-30 13:19:52 +01:00
966 changed files with 35091 additions and 16242 deletions
@@ -0,0 +1,5 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# JS files must always use LF for tools to work
+*.js eol=lf
@@ -1,4 +1,5 @@
 language: node_js
+sudo: false
 node_js:
  - '0.10'

@@ -1,3 +1,74 @@
+<a name="1.4.1"></a>
+# 1.4.1 hyperionic-illumination (2015-06-16)
+
+
+## Bug Fixes
+
+- **$compile:**
+  - workaround for IE11 MutationObserver
+  ([f3b1d0b7](https://github.com/angular/angular.js/commit/f3b1d0b723298a5f8ea21d0704405649cce1b5fc),
+   [#11781](https://github.com/angular/angular.js/issues/11781))
+  - prevent exception when using `watch` as isolated scope binding property in Firefox
+  ([a6339d30](https://github.com/angular/angular.js/commit/a6339d30d1379689da5eec9647a953f64821f8b0),
+   [#11627](https://github.com/angular/angular.js/issues/11627))
+  - assign controller return values correctly for multiple directives
+  ([8caf1802](https://github.com/angular/angular.js/commit/8caf1802e0e93389dec626ef35e04a302aa6c39d),
+   [#12029](https://github.com/angular/angular.js/issues/12029), [#12036](https://github.com/angular/angular.js/issues/12036))
+- **$location:** do not get caught in infinite digest in IE9 when redirecting in `$locationChangeSuccess`
+  ([91b60226](https://github.com/angular/angular.js/commit/91b602263b96b6fce1331208462e18eb647f4d60),
+   [#11439](https://github.com/angular/angular.js/issues/11439), [#11675](https://github.com/angular/angular.js/issues/11675), [#11935](https://github.com/angular/angular.js/issues/11935), [#12083](https://github.com/angular/angular.js/issues/12083))
+- **$parse:** set null reference properties to `undefined`
+  ([71fc3f4f](https://github.com/angular/angular.js/commit/71fc3f4fa0cd12eff335d57efed7c033554749f4),
+   [#12099](https://github.com/angular/angular.js/issues/12099))
+  ([d19504a1](https://github.com/angular/angular.js/commit/d19504a179355d7801d59a8db0285a1322e04601),
+   [#11959](https://github.com/angular/angular.js/issues/11959))
+- **$sanitize:** do not remove `tabindex` attribute
+  ([799353c7](https://github.com/angular/angular.js/commit/799353c75de28e6fbf52dac6e0721e85b578575a),
+   [#8371](https://github.com/angular/angular.js/issues/8371), [#5853](https://github.com/angular/angular.js/issues/5853))
+- **copy:** do not copy the same object twice
+  ([0e622f7b](https://github.com/angular/angular.js/commit/0e622f7b5bc3d5d0ab0fbc1a1bc69404bd7216d5))
+- **forms:** parse exponential notation in `numberInputType` directive
+  ([ebd0fbba](https://github.com/angular/angular.js/commit/ebd0fbba8ff90bee0cd016d574643d56a7f81ed0),
+   [#12121](https://github.com/angular/angular.js/issues/12121), [#12122](https://github.com/angular/angular.js/issues/12122))
+- **linky:** allow case insensitive scheme detection
+  ([8dc09e6d](https://github.com/angular/angular.js/commit/8dc09e6dabb84c2c611cdc9e40adfac989648200),
+   [#12073](https://github.com/angular/angular.js/issues/12073), [#12073](https://github.com/angular/angular.js/issues/12073))
+- **ngAria:**
+  - update `aria-valuemin/max` when `min/max` change
+  ([ebaa0f59](https://github.com/angular/angular.js/commit/ebaa0f598501702ae64d59ada0ae492eaf0e2db6),
+   [#11770](https://github.com/angular/angular.js/issues/11770), [#11774](https://github.com/angular/angular.js/issues/11774))
+  - ensure boolean values for aria-hidden and aria-disabled
+  ([59273354](https://github.com/angular/angular.js/commit/59273354b57dd8d1ad2cd2f4740ffa8923e480f9),
+   [#11365](https://github.com/angular/angular.js/issues/11365))
+- **ngModel:** ignore Object.prototype properties on the form validation object
+  ([0934b76b](https://github.com/angular/angular.js/commit/0934b76b72cec86093414834ac4cb7f0946b651d),
+   [#12066](https://github.com/angular/angular.js/issues/12066))
+- **ngOptions:**
+  - do not watch properties starting with $
+  ([34a6da24](https://github.com/angular/angular.js/commit/34a6da24c17356d4ffc70aec3f621a140a9a61ab),
+   [#11930](https://github.com/angular/angular.js/issues/11930), [#12010](https://github.com/angular/angular.js/issues/12010))
+  - use reference check only when not using trackBy
+  ([d7dc14dc](https://github.com/angular/angular.js/commit/d7dc14dc0cdeb9c187d227e19acc8aca7df9d740),
+   [#11936](https://github.com/angular/angular.js/issues/11936), [#11996](https://github.com/angular/angular.js/issues/11996))
+
+
+## Features
+
+- **$compile:** show module name during `multidir` error
+  ([351fe4b7](https://github.com/angular/angular.js/commit/351fe4b79c50a45a11af2fcd2aa7b6fd3b70058d),
+   [#11775](https://github.com/angular/angular.js/issues/11775))
+- **$q:** $q.resolve as an alias for $q.when
+  ([3ef52980](https://github.com/angular/angular.js/commit/3ef529806fef28b41ca4af86a330f39a95699cf6),
+   [#11944](https://github.com/angular/angular.js/issues/11944), [#11987](https://github.com/angular/angular.js/issues/11987))
+
+
+## Performance Improvements
+
+- **$compile:** avoid jquery data calls when there is no data
+  ([9efb0d5e](https://github.com/angular/angular.js/commit/9efb0d5ee961b57c8fc144a3138a15955e4010e2))
+
+
+
 <a name="1.3.16"></a>
 # 1.3.16 cookie-oatmealification (2015-06-05)

@@ -289,6 +360,220 @@ To get the desired behaviour you need to iterate using the object form of the `n



+
+<a name="v1.4.0-rc.1"></a>
+# v1.4.0-rc.1 sartorial-chronography (2015-04-24)
+
+
+## Bug Fixes
+
+- **$animate:**
+  - ensure that from styles are applied for class-based animations
+  ([8f819d2c](https://github.com/angular/angular.js/commit/8f819d2cb5c8025b25534529a6e897dc8805885b))
+  - make sure the JS animation lookup is an object lookup
+  ([103a39ca](https://github.com/angular/angular.js/commit/103a39ca8dad0300bead15c358aad846510b2229),
+   [#11619](https://github.com/angular/angular.js/issues/11619))
+- **$animateCss:** ensure that rAF waiting loop doesn't ignore pending items during a flush
+  ([90e424b2](https://github.com/angular/angular.js/commit/90e424b206239e261024e8ef7fcac762236cd8b7))
+- **$http:** stop coercing falsy HTTP request bodies to null / empty body
+  ([e04a887c](https://github.com/angular/angular.js/commit/e04a887c9b506de18516600310fe6e529d9d2ca3),
+   [#11552](https://github.com/angular/angular.js/issues/11552), [#11593](https://github.com/angular/angular.js/issues/11593))
+- **ngAnimate:**
+  - close parent animations only when there are classes to resolve
+  ([1459be17](https://github.com/angular/angular.js/commit/1459be170dabfca40501dcf219dfced5ba513169))
+  - ensure ngClass-based classes are always resolved for CSS-enabled animations
+  ([89f081e4](https://github.com/angular/angular.js/commit/89f081e452e9a75c2d3bf86bfef8b7f9bd1f2b0e))
+  - do not abort animation if only `ng-anchor-in` is used
+  ([3333a5c3](https://github.com/angular/angular.js/commit/3333a5c380f830cba8efec5825cb6648f930f206))
+  - ensure that a filtered-out leave animation always runs its DOM operation
+  ([6dd64ab5](https://github.com/angular/angular.js/commit/6dd64ab5f34fa19db8f90e6eabc810843089ba14),
+   [#11555](https://github.com/angular/angular.js/issues/11555))
+  - ensure that animations work when the app is bootstrapped on the document node
+  ([bee14ed1](https://github.com/angular/angular.js/commit/bee14ed1e7b77ea7dc62326611380da36dec297e),
+   [#11574](https://github.com/angular/angular.js/issues/11574))
+  - ensure SVG classes are properly removed
+  ([fa0bbded](https://github.com/angular/angular.js/commit/fa0bbded1ea040fbfdb1a4339e4a374fe9717a82))
+- **ngAria:** change accessibility keypress event to use event.which if it is provided
+  ([249f9b81](https://github.com/angular/angular.js/commit/249f9b81cbad5c57cf978a47842744aadd85cdb4),
+   [#11340](https://github.com/angular/angular.js/issues/11340))
+- **ngMessageFormat:**
+  - ensure bindings are valid for Protractor
+  ([992114f7](https://github.com/angular/angular.js/commit/992114f7a7f5f39778753e0c49458f14b6290ffc),
+   [#11644](https://github.com/angular/angular.js/issues/11644), [#11649](https://github.com/angular/angular.js/issues/11649))
+  - minified symbol and nested required expression
+  ([8a45064f](https://github.com/angular/angular.js/commit/8a45064f2bdec13ba3de5b0a0785df76188ab172),
+   [#11414](https://github.com/angular/angular.js/issues/11414), [#11592](https://github.com/angular/angular.js/issues/11592))
+- **select:** allow empty option to be added dynamically by ng-repeat
+  ([abf59c28](https://github.com/angular/angular.js/commit/abf59c285c3ff6af20dbf4236eba5204ae735abb),
+   [#11470](https://github.com/angular/angular.js/issues/11470), [#11512](https://github.com/angular/angular.js/issues/11512))
+
+
+## Features
+
+- **$animate:** provide support for animations on elements outside of $rootElement
+  ([e41faaa2](https://github.com/angular/angular.js/commit/e41faaa2a155a42bcc66952497a6f33866878508))
+
+
+
+
+<a name="v1.4.0-rc.0"></a>
+# v1.4.0-rc.0 smooth-unwinding (2015-04-10)
+
+
+## Bug Fixes
+
+- **$compile:**
+  - throw error on invalid directive name
+  ([170ff9a3](https://github.com/angular/angular.js/commit/170ff9a37dea8772dda7c89e84176ac1a8992878),
+   [#11281](https://github.com/angular/angular.js/issues/11281), [#11109](https://github.com/angular/angular.js/issues/11109))
+  - update data() when controller returns custom value
+  ([9900610e](https://github.com/angular/angular.js/commit/9900610eea4ece87b063f2aa9d82c75c369927df),
+   [#11147](https://github.com/angular/angular.js/issues/11147), [#11326](https://github.com/angular/angular.js/issues/11326))
+- **$http:** throw error if `success` and `error` methods do not receive a function
+  ([1af563d4](https://github.com/angular/angular.js/commit/1af563d43e74cb7be53e815b66fd91dd93986ed6),
+   [#11330](https://github.com/angular/angular.js/issues/11330), [#11333](https://github.com/angular/angular.js/issues/11333))
+- **$parse:** fix parse errors on older Android WebViews which choke with reserved keywords
+  ([10ae33b2](https://github.com/angular/angular.js/commit/10ae33b2d88b04df76f519edc50a47fa30f83e96),
+   [#11455](https://github.com/angular/angular.js/issues/11455))
+- **$rootScope:** allow destroying a root scope
+  ([f8c8cf69](https://github.com/angular/angular.js/commit/f8c8cf698aa23640249d79fd405605694478e4f7),
+   [#11241](https://github.com/angular/angular.js/issues/11241), [#10895](https://github.com/angular/angular.js/issues/10895))
+- **cookieReader:** safely access $document so it can be mocked
+  ([a057e089](https://github.com/angular/angular.js/commit/a057e0896a7fe2fdaba50b2515555b86e4f4be27),
+   [#11373](https://github.com/angular/angular.js/issues/11373), [#11388](https://github.com/angular/angular.js/issues/11388))
+- **filterFilter:** fix matching against `null`/`undefined`
+  ([b5002ab6](https://github.com/angular/angular.js/commit/b5002ab62ad6e13f4339e20106e1fdece14912a2),
+   [#11432](https://github.com/angular/angular.js/issues/11432), [#11445](https://github.com/angular/angular.js/issues/11445))
+- **ngAnimate:** ensure that minified repaint code isn't removed
+  ([c55a4944](https://github.com/angular/angular.js/commit/c55a494433e619aad0c7ef9fddadc0b3fdf53915),
+   [#9936](https://github.com/angular/angular.js/issues/9936))
+- **ngAria:** handle elements with role="checkbox/menuitemcheckbox"
+  ([44337f63](https://github.com/angular/angular.js/commit/44337f63fa94116795e83e3a764a6ba6782809c7),
+   [#11317](https://github.com/angular/angular.js/issues/11317), [#11321](https://github.com/angular/angular.js/issues/11321))
+- **ngModel:** allow setting model to NaN when asyncValidator is present
+  ([948120ec](https://github.com/angular/angular.js/commit/948120ecdbc4dd07880c0107564c50c7675b8a93),
+   [#11315](https://github.com/angular/angular.js/issues/11315), [#11411](https://github.com/angular/angular.js/issues/11411))
+- **ngTouch:** register touches properly when jQuery is used
+  ([06a9f0a9](https://github.com/angular/angular.js/commit/06a9f0a95f0e72fa2e9879fe8a49e9bf69986a5f),
+   [#4001](https://github.com/angular/angular.js/issues/4001), [#8584](https://github.com/angular/angular.js/issues/8584), [#10797](https://github.com/angular/angular.js/issues/10797), [#11488](https://github.com/angular/angular.js/issues/11488))
+- **select:** don't call $render twice if $viewValue ref changes
+  ([7e5c447f](https://github.com/angular/angular.js/commit/7e5c447fa9ad7d81cc818d6e79392c3e4a6b23a0),
+   [#11329](https://github.com/angular/angular.js/issues/11329), [#11412](https://github.com/angular/angular.js/issues/11412))
+
+
+## Features
+
+- **$anchorScroll:** allow scrolling to a specified element
+  ([731c8b5e](https://github.com/angular/angular.js/commit/731c8b5e2d01a44aa91f967f1a6acbadb8005a8b),
+   [#4568](https://github.com/angular/angular.js/issues/4568), [#9596](https://github.com/angular/angular.js/issues/9596))
+- **$animate:** complete refactor of internal animation code
+  ([c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef))
+- **$http:** support custom params serializers
+  ([6c8464ad](https://github.com/angular/angular.js/commit/6c8464ad14dd308349f632245c1a064c9aae242a),
+   [#3740](https://github.com/angular/angular.js/issues/3740), [#7429](https://github.com/angular/angular.js/issues/7429), [#9224](https://github.com/angular/angular.js/issues/9224), [#11461](https://github.com/angular/angular.js/issues/11461))
+- **$interpolate:** extend interpolation with MessageFormat like syntax
+  ([1e58488a](https://github.com/angular/angular.js/commit/1e58488ad65abf7031bab5813523bb9d86dbd28c),
+   [#11152](https://github.com/angular/angular.js/issues/11152))
+- **angular.Module:** add `decorator` method
+  ([e57138d7](https://github.com/angular/angular.js/commit/e57138d7eff1210f99238c475fff57530bf0ab19),
+   [#11305](https://github.com/angular/angular.js/issues/11305), [#11300](https://github.com/angular/angular.js/issues/11300))
+- **ngClass:** add support for conditional map within an array.
+  ([4588e627](https://github.com/angular/angular.js/commit/4588e627bb7238b2113241919b948d0e5166c76d),
+   [#4807](https://github.com/angular/angular.js/issues/4807))
+- **travis:** run unit tests on iOS 8
+  ([2cdb2016](https://github.com/angular/angular.js/commit/2cdb2016b9d89abfb5ab988b67d5f26f3bf21908),
+   [#11479](https://github.com/angular/angular.js/issues/11479))
+
+
+## Performance Improvements
+
+- **$rootScope:** remove history event handler when app is torn down
+  ([d996305b](https://github.com/angular/angular.js/commit/d996305b4470f80fbb1cbddf54b7d10ffbb6ab47),
+   [#9897](https://github.com/angular/angular.js/issues/9897), [#9905](https://github.com/angular/angular.js/issues/9905))
+- **benchmark:** add ngmodel benchmarks to largetable-bp
+  ([b8dbdb0c](https://github.com/angular/angular.js/commit/b8dbdb0c5e2cd176c6d94d60f781cfc02e646592),
+   [#11082](https://github.com/angular/angular.js/issues/11082))
+- **ngOptions:** only perform deep equality check on ngModel if using track by
+  ([171b9f7f](https://github.com/angular/angular.js/commit/171b9f7f2339ef9047b8526b2c3f36bb58d14feb),
+   [#11448](https://github.com/angular/angular.js/issues/11448), [#11447](https://github.com/angular/angular.js/issues/11447))
+
+
+## Breaking Changes
+
+- **$animate:** due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+  JavaScript and CSS animations can no longer be run in
+parallel. With earlier versions of ngAnimate, both CSS and JS animations
+would be run together when multiple animations were detected. This
+feature has now been removed, however, the same effect, with even more
+possibilities, can be achieved by injecting `$animateCss` into a
+JavaScript-defined animation and creating custom CSS-based animations
+from there. Read the ngAnimate docs for more info.
+
+- **$animate:** due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+  The function params for `$animate.enabled()` when an
+element is used are now flipped. This fix allows the function to act as
+a getter when a single element param is provided.
+
+```js
+// < 1.4
+$animate.enabled(false, element);
+
+// 1.4+
+$animate.enabled(element, false);
+```
+
+- **$animate:** due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+  In addition to disabling the children of the element,
+`$animate.enabled(element, false)` will now also disable animations on
+the element itself.
+
+- **$animate:** due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+  Animation-related callbacks are now fired on
+`$animate.on` instead of directly being on the element.
+
+```js
+// < 1.4
+element.on('$animate:before', function(e, data) {
+  if (data.event === 'enter') { ... }
+});
+element.off('$animate:before', fn);
+
+// 1.4+
+$animate.on(element, 'enter', function(data) {
+  //...
+});
+$animate.off(element, 'enter', fn);
+```
+
+- **$animate:** due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+  There is no need to call `$scope.$apply` or
+`$scope.$digest` inside of an animation promise callback anymore
+since the promise is resolved within a digest automatically (but a
+digest is not run unless the promise is chained).
+
+```js
+// < 1.4
+$animate.enter(element).then(function() {
+  $scope.$apply(function() {
+    $scope.explode = true;
+  });
+});
+
+// 1.4+
+$animate.enter(element).then(function() {
+  $scope.explode = true;
+});
+```
+
+- **$animate:** due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+  When an enter, leave or move animation is triggered then it
+will always end any pending or active parent class based animations
+(animations triggered via ngClass) in order to ensure that any CSS
+styles are resolved in time.
+
+
+
+
 <a name="1.4.0-beta.6"></a>
 # 1.4.0-beta.6 cookie-liberation (2015-03-17)

@@ -454,6 +739,7 @@ mechanism.
   [#10864](https://github.com/angular/angular.js/issues/10864))


+
 <a name="1.4.0-beta.5"></a>
 # 1.4.0-beta.5 karmic-stabilization (2015-02-24)

@@ -539,6 +825,35 @@ end of the container containing the ngMessages directive).
 </div>
 ```

+- **$http:** due to [5da1256](https://github.com/angular/angular.js/commit/5da1256fc2812d5b28fb0af0de81256054856369),
+
+`transformRequest` functions can no longer modify request headers.
+
+Before this commit `transformRequest` could modify request headers, ex.:
+
+```javascript
+function requestTransform(data, headers) {
+    headers = angular.extend(headers(), {
+      'X-MY_HEADER': 'abcd'
+    });
+  }
+  return angular.toJson(data);
+}
+```
+
+This behavior was unintended and undocumented, so the change should affect very few applications. If one
+needs to dynamically add / remove headers it should be done in a header function, for example:
+
+```javascript
+$http.get(url, {
+  headers: {
+    'X-MY_HEADER': function(config) {
+      return 'abcd'; //you've got access to a request config object to specify header value dynamically
+    }
+  }
+})
+```
+
 <a name="1.3.14"></a>
 # 1.3.14 instantaneous-browserification (2015-02-24)

@@ -613,6 +928,8 @@ end of the container containing the ngMessages directive).



+
+
 <a name="1.4.0-beta.3"></a>
 # 1.4.0-beta.3 substance-mimicry (2015-02-02)

@@ -963,7 +1280,33 @@ But in practice this is not what people want and so this change iterates over pr
 in the order they are returned by Object.keys(obj), which is almost always the order
 in which the properties were defined.

+- **select:** due to [7fda214c](https://github.com/angular/angular.js/commit/7fda214c4f65a6a06b25cf5d5aff013a364e9cef),

+the `select` directive will now use strict comparison of the `ngModel` scope value against `option`
+values to determine which option is selected. This means `Number` scope values will not be matched
+against numeric option strings.
+In Angular 1.3.x, setting `scope.x = 200` would select the `option` with the value 200 in the following `select`:
+
+```
+<select ng-model="x">
+  <option value="100">100</option>
+  <option value="200">200</option>
+</select>
+```
+
+In Angular 1.4.x, the 'unknown option' will be selected.
+To remedy this, you can simply initialize the model as a string: `scope.x = '200'`, or if you want to
+keep the model as a `Number`, you can do the conversion via `$formatters` and `$parsers` on `ngModel`:
+
+```js
+ngModelCtrl.$parsers.push(function(value) {
+  return parseInt(value, 10); // Convert option value to number
+});
+
+ngModelCtrl.$formatters.push(function(value) {
+  return value.toString(); // Convert scope value to string
+});
+```

 <a name="1.3.9"></a>
 # 1.3.9 multidimensional-awareness (2015-01-13)
@@ -126,6 +126,9 @@ module.exports = function(grunt) {
      ngLocale: {
        files: { src: 'src/ngLocale/**/*.js' },
      },
+      ngMessageFormat: {
+        files: { src: 'src/ngMessageFormat/**/*.js' },
+      },
      ngMessages: {
        files: { src: 'src/ngMessages/**/*.js' },
      },
@@ -200,6 +203,10 @@ module.exports = function(grunt) {
        dest: 'build/angular-resource.js',
        src: util.wrap(files['angularModules']['ngResource'], 'module')
      },
+      messageformat: {
+        dest: 'build/angular-message-format.js',
+        src: util.wrap(files['angularModules']['ngMessageFormat'], 'module')
+      },
      messages: {
        dest: 'build/angular-messages.js',
        src: util.wrap(files['angularModules']['ngMessages'], 'module')
@@ -232,6 +239,7 @@ module.exports = function(grunt) {
      animate: 'build/angular-animate.js',
      cookies: 'build/angular-cookies.js',
      loader: 'build/angular-loader.js',
+      messageformat: 'build/angular-message-format.js',
      messages: 'build/angular-messages.js',
      touch: 'build/angular-touch.js',
      resource: 'build/angular-resource.js',
@@ -1,6 +1,6 @@
 The MIT License

-Copyright (c) 2010-2014 Google, Inc. http://angularjs.org
+Copyright (c) 2010-2015 Google, Inc. http://angularjs.org

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -40,6 +40,7 @@ var angularFiles = {
    'src/ng/timeout.js',
    'src/ng/urlUtils.js',
    'src/ng/window.js',
+    'src/ng/cookieReader.js',

    'src/ng/filter.js',
    'src/ng/filter/filter.js',
@@ -65,6 +66,7 @@ var angularFiles = {
    'src/ng/directive/ngList.js',
    'src/ng/directive/ngModel.js',
    'src/ng/directive/ngNonBindable.js',
+    'src/ng/directive/ngOptions.js',
    'src/ng/directive/ngPluralize.js',
    'src/ng/directive/ngRepeat.js',
    'src/ng/directive/ngShowHide.js',
@@ -85,10 +87,29 @@ var angularFiles = {

  'angularModules': {
    'ngAnimate': [
-      'src/ngAnimate/animate.js'
+      'src/ngAnimate/shared.js',
+      'src/ngAnimate/rafScheduler.js',
+      'src/ngAnimate/animateChildrenDirective.js',
+      'src/ngAnimate/animateCss.js',
+      'src/ngAnimate/animateCssDriver.js',
+      'src/ngAnimate/animateJs.js',
+      'src/ngAnimate/animateJsDriver.js',
+      'src/ngAnimate/animateQueue.js',
+      'src/ngAnimate/animateRunner.js',
+      'src/ngAnimate/animation.js',
+      'src/ngAnimate/module.js'
    ],
    'ngCookies': [
-      'src/ngCookies/cookies.js'
+      'src/ngCookies/cookies.js',
+      'src/ngCookies/cookieStore.js',
+      'src/ngCookies/cookieWriter.js'
+    ],
+    'ngMessageFormat': [
+      'src/ngMessageFormat/messageFormatCommon.js',
+      'src/ngMessageFormat/messageFormatSelector.js',
+      'src/ngMessageFormat/messageFormatInterpolationParts.js',
+      'src/ngMessageFormat/messageFormatParser.js',
+      'src/ngMessageFormat/messageFormatService.js'
    ],
    'ngMessages': [
      'src/ngMessages/messages.js'
@@ -161,7 +182,7 @@ var angularFiles = {
    'src/publishExternalApis.js',
    '@angularSrcModules',
    '@angularScenario',
-    '@angularTest',
+    '@angularTest'
  ],

  'karmaExclude': [
@@ -180,6 +201,7 @@ var angularFiles = {
    '@angularSrcModules',
    'src/ngScenario/browserTrigger.js',
    'test/helpers/*.js',
+    'test/ngMessageFormat/*.js',
    'test/ngMock/*.js',
    'test/ngCookies/*.js',
    'test/ngRoute/**/*.js',
@@ -196,7 +218,7 @@ var angularFiles = {
    'src/publishExternalApis.js',
    '@angularSrcModules',
    '@angularScenario',
-    '@angularTest',
+    '@angularTest'
  ],

  'karmaJqueryExclude': [
@@ -208,6 +230,7 @@ var angularFiles = {

 angularFiles['angularSrcModules'] = [].concat(
  angularFiles['angularModules']['ngAnimate'],
+  angularFiles['angularModules']['ngMessageFormat'],
  angularFiles['angularModules']['ngMessages'],
  angularFiles['angularModules']['ngCookies'],
  angularFiles['angularModules']['ngResource'],
@@ -14,11 +14,14 @@
      <div>ngBind: <input type="radio" ng-model="benchmarkType" value="ngBind"></div>
      <div>ngBindOnce: <input type="radio" ng-model="benchmarkType" value="ngBindOnce"></div>
      <div>interpolation: <input type="radio" ng-model="benchmarkType" value="interpolation"></div>
+      <div>interpolation + bind-once: <input type="radio" ng-model="benchmarkType" value="bindOnceInterpolation"></div>
      <div>attribute interpolation: <input type="radio" ng-model="benchmarkType" value="interpolationAttr"></div>
      <div>ngBind + fnInvocation: <input type="radio" ng-model="benchmarkType" value="ngBindFn"></div>
      <div>interpolation + fnInvocation: <input type="radio" ng-model="benchmarkType" value="interpolationFn"></div>
      <div>ngBind + filter: <input type="radio" ng-model="benchmarkType" value="ngBindFilter"></div>
      <div>interpolation + filter: <input type="radio" ng-model="benchmarkType" value="interpolationFilter"></div>
+      <div>ngModel (const name): <input type="radio" ng-model="benchmarkType" value="ngModelConstName"></div>
+      <div>ngModel (interp name): <input type="radio" ng-model="benchmarkType" value="ngModelInterpName"></div>

      <ng-switch on="benchmarkType">
        <baseline-binding-table ng-switch-when="baselineBinding">
@@ -35,7 +38,7 @@
        </div>
        <div ng-switch-when="ngBindOnce">
          <h2>baseline binding once</h2>
-          <div ng-repeat="row in data">
+          <div ng-repeat="row in ::data">
            <span ng-repeat="column in ::row">
              <span ng-bind="::column.i"></span>:<span ng-bind="::column.j"></span>|
            </span>
@@ -47,6 +50,12 @@
            <span ng-repeat="column in row">{{column.i}}:{{column.j}}|</span>
          </div>
        </div>
+        <div ng-switch-when="bindOnceInterpolation">
+          <h2>baseline one-time interpolation</h2>
+          <div ng-repeat="row in ::data">
+            <span ng-repeat="column in ::row">{{::column.i}}:{{::column.j}}|</span>
+          </div>
+        </div>
        <div ng-switch-when="interpolationAttr">
          <h2>attribute interpolation</h2>
          <div ng-repeat="row in data">
@@ -77,6 +86,20 @@
            <span ng-repeat="column in row">{{column.i | noop}}:{{column.j | noop}}|</span>
          </div>
        </div>
+        <div ng-switch-when="ngModelConstName">
+          <h2>ngModel (const name)</h2>
+          <div ng-repeat="row in data">
+            <input type="text" ng-model="row.i" name="constName" />
+            <input type="text" ng-model="row.j" />
+          </div>
+        </div>
+        <div ng-switch-when="ngModelInterpName">
+          <h2>ngModel (interp name)</h2>
+          <div ng-repeat="(rowIdx, row) in data">
+            <input type="text" ng-model="row.i" name="input-{{rowIdx}}" />
+            <input type="text" ng-model="row.j" name="input2-{{rowIdx}}" />
+          </div>
+        </div>
      </ng-switch>
    </div>
  </div>
@@ -0,0 +1,95 @@
+"use strict";
+
+/* globals angular, benchmarkSteps */
+
+var app = angular.module('ngOptionsBenchmark', []);
+
+app.config(function($compileProvider) {
+  if ($compileProvider.debugInfoEnabled) {
+    $compileProvider.debugInfoEnabled(false);
+  }
+});
+
+
+
+app.controller('DataController', function($scope, $element) {
+  $scope.items = [];
+  $scope.count = 10000;
+
+  function changeOptions() {
+    $scope.items = [];
+    for (var i = 0; i < $scope.count; ++i) {
+      $scope.items.push({
+        id: i,
+        label: 'item-' + i,
+        group: 'group-' + i % 100
+      });
+    }
+  }
+
+  var selectElement = $element.find('select');
+  console.log(selectElement);
+
+
+  benchmarkSteps.push({
+    name: 'add-options',
+    fn: function() {
+      $scope.$apply(function() {
+        $scope.count = 10000;
+        changeOptions();
+      });
+    }
+  });
+
+  benchmarkSteps.push({
+    name: 'set-model-1',
+    fn: function() {
+      $scope.$apply(function() {
+        $scope.x = $scope.items[1000];
+      });
+    }
+  });
+
+  benchmarkSteps.push({
+    name: 'set-model-2',
+    fn: function() {
+      $scope.$apply(function() {
+        $scope.x = $scope.items[10];
+      });
+    }
+  });
+
+  benchmarkSteps.push({
+    name: 'remove-options',
+    fn: function() {
+      $scope.count = 100;
+      changeOptions();
+    }
+  });
+
+  benchmarkSteps.push({
+    name: 'add-options',
+    fn: function() {
+      $scope.$apply(function() {
+        $scope.count = 10000;
+        changeOptions();
+      });
+    }
+  });
+
+  benchmarkSteps.push({
+    name: 'set-view-1',
+    fn: function() {
+      selectElement.val('2000');
+      selectElement.triggerHandler('change');
+    }
+  });
+
+  benchmarkSteps.push({
+    name: 'set-view-2',
+    fn: function() {
+      selectElement.val('1000');
+      selectElement.triggerHandler('change');
+    }
+  });
+});
@@ -0,0 +1,11 @@
+module.exports = function(config) {
+  config.set({
+    scripts: [    {
+      id: 'angular',
+      src: '/build/angular.js'
+    },
+    {
+      src: 'app.js',
+    }]
+  });
+};
@@ -0,0 +1,10 @@
+<div ng-app="ngOptionsBenchmark" ng-cloak>
+  <div ng-controller="DataController">
+    <div class="container-fluid">
+      <p>
+        Tests the execution of ng-options for rendering during model and option updates.
+      </p>
+      <select ng-model="x" ng-options="a as a.label group by a.group for a in items track by a.id"></select>
+    </div>
+  </div>
+</div>
@@ -103,10 +103,10 @@ then(function (tags) {
    sort(semver.rcompare);
 }).
 then(function (tags) {
-  var major = tags[0].split('.')[0] + '.x';
+  var major = tags[0].split('.')[0];
  return tags.
    filter(function (ver) {
-      return semver.satisfies(ver, major);
+      return semver(ver).major == major;
    });
 }).
 then(function (tags) {
@@ -9,3 +9,11 @@
 ng\:form {
  display: block;
 }
+
+.ng-animate-shim {
+  visibility:hidden;
+}
+
+.ng-anchor {
+  position:absolute;
+}
@@ -701,3 +701,7 @@ ul.events > li {
    padding-bottom:0px;
  }
 }
+
+iframe[name="example-anchoringExample"] {
+  height:400px;
+}
@@ -35,7 +35,7 @@ angular.module('tutorials', [])
      'step': '@docTutorialReset'
    },
    template:
-      '<p><a href="" ng-click="show=!show;$event.stopPropagation()">Workspace Reset Instructions  ➤</a></p>\n' +
+      '<p><button class="btn" ng-click="show=!show">Workspace Reset Instructions  ➤</button></p>\n' +
      '<div class="alert alert-info" ng-show="show">\n' +
      '  <p>Reset the workspace to step {{step}}.</p>' +
      '  <p><pre>git checkout -f step-{{step}}</pre></p>\n' +
@@ -43,7 +43,7 @@ angular.module('tutorials', [])
          '<a href="http://angular.github.io/angular-phonecat/step-{{step}}/app">Step {{step}} Live Demo</a>.</p>\n' +
      '</div>\n' +
      '<p>The most important changes are listed below. You can see the full diff on ' +
-        '<a ng-href="https://github.com/angular/angular-phonecat/compare/step-{{step ? (step - 1): \'0~1\'}}...step-{{step}}">GitHub</a>\n' +
+        '<a ng-href="https://github.com/angular/angular-phonecat/compare/step-{{step ? (step - 1): \'0~1\'}}...step-{{step}}" title="See diff on Github">GitHub</a>\n' +
      '</p>'
  };
 });
@@ -21,11 +21,13 @@ angular.module('versions', [])
  };

  $scope.jumpToDocsVersion = function(version) {
-    var currentPagePath = $location.path().replace(/\/$/, '');
-
-    // TODO: We need to do some munging of the path for different versions of the API...
-
-
-    $window.location = version.docsUrl + currentPagePath;
+    var currentPagePath = $location.path().replace(/\/$/, ''),
+        url = '';
+    if (version.isOldDocsUrl) {
+      url = version.docsUrl;
+    }else{
+      url = version.docsUrl + currentPagePath;
+    }
+    $window.location = url;
  };
 }]);
@@ -10,14 +10,14 @@ var Package = require('dgeni').Package;
 module.exports = new Package('angularjs', [
  require('dgeni-packages/ngdoc'),
  require('dgeni-packages/nunjucks'),
-  require('dgeni-packages/examples')
+  require('dgeni-packages/examples'),
+  require('dgeni-packages/git')
 ])


 .factory(require('./services/errorNamespaceMap'))
 .factory(require('./services/getMinerrInfo'))
 .factory(require('./services/getVersion'))
-.factory(require('./services/gitData'))

 .factory(require('./services/deployments/debug'))
 .factory(require('./services/deployments/default'))
@@ -26,7 +26,6 @@ module.exports = new Package('angularjs', [

 .factory(require('./inline-tag-defs/type'))

-
 .processor(require('./processors/error-docs'))
 .processor(require('./processors/index-page'))
 .processor(require('./processors/keywords'))
@@ -1,16 +0,0 @@
-"use strict";
-
-var versionInfo = require('../../../lib/versions/version-info');
-
-/**
- * @dgService gitData
- * @description
- * Information from the local git repository
- */
-module.exports = function gitData() {
-  return {
-    version: versionInfo.currentVersion,
-    versions: versionInfo.previousVersions,
-    info: versionInfo.gitRepoInfo
-  };
-};
@@ -3,7 +3,7 @@
 <head>
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta charset="utf-8">
-  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="Description"
        content="AngularJS is what HTML would have been, had it been designed for building web-apps.
                 Declarative templates with data-binding, MVC, dependency injection and great
@@ -76,7 +76,7 @@
          <div class="row">
            <div class="col-md-9 header-branding">
              <a class="brand navbar-brand" href="http://angularjs.org">
-                <img width="117" height="30" class="logo" ng-src="img/angularjs-for-header-only.svg">
+                <img width="117" height="30" class="logo" alt="Link to Angular JS Homepage" ng-src="img/angularjs-for-header-only.svg">
              </a>
              <ul class="nav navbar-nav">
                <li class="divider-vertical"></li>
@@ -220,10 +220,10 @@
        <p class="pull-right"><a back-to-top>Back to top</a></p>

        <p>
-          Super-powered by Google  ©2010-2014
+          Super-powered by Google  ©2010-2015
          ( <a id="version"
               ng-href="https://github.com/angular/angular.js/blob/master/CHANGELOG.md#{{versionNumber}}"
-               ng-bind-template="v{{version}}">
+               ng-bind-template="v{{version}}" title="Changelog of this version of Angular JS">
            </a>
          )
        </p>
@@ -0,0 +1,60 @@
+{% macro typeList(types) -%}
+{% for typeName in types %}<a href="" class="{$ typeName | typeClass $}">{$ typeName | escape $}</a>{% endfor %}
+{%- endmacro -%}
+
+{%- macro paramTable(params) %}
+<table class="variables-matrix input-arguments">
+  <thead>
+    <tr>
+      <th>Param</th>
+      <th>Type</th>
+      <th>Details</th>
+    </tr>
+  </thead>
+  <tbody>
+    {% for param in params %}
+    <tr>
+      <td>
+        {$ param.name $}
+        {% if param.alias %}| {$ param.alias $}{% endif %}
+        {% if param.optional %}<div><em>(optional)</em></div>{% endif %}
+      </td>
+      <td>
+        {$ typeList(param.typeList) $}
+      </td>
+      <td>
+        {$ param.description | marked $}
+        {% if param.defaultValue %}<p><em>(default: {$ param.defaultValue $})</em></p>{% endif %}
+      </td>
+    </tr>
+    {% endfor %}
+  </tbody>
+</table>
+{% endmacro -%}
+
+
+{%- macro directiveParam(name, type, join, sep) %}
+  {%- if type.optional %}[{% endif -%}
+  {$ name | dashCase $}{$ join $}{$ type.name $}{$ sep $}
+  {%- if type.optional %}]{% endif -%}
+{% endmacro -%}
+
+{%- macro functionSyntax(fn) %}
+  {%- set sep = joiner(', ') -%}
+  {% marked -%}
+    `{$ fn.name $}({%- for param in fn.params %}{$ sep() $}
+    {%- if param.type.optional %}[{% endif -%}
+    {$ param.name $}
+    {%- if param.type.optional %}]{% endif -%}
+    {% endfor %});`
+  {%- endmarked %}
+{% endmacro -%}
+
+{%- macro typeInfo(fn) -%}
+<table class="variables-matrix return-arguments">
+  <tr>
+    <td>{$ typeList(fn.typeList) $}</td>
+    <td>{$ fn.description | marked $}</td>
+  </tr>
+</table>
+{%- endmacro -%}
@@ -140,7 +140,7 @@ or JavaScript callbacks.
      {@link ngAnimate#service Services / Factories}
    </td>
    <td>
-      Use {@link ngAnimate.$animate $animate} to trigger animation operations within your directive code.
+      Use {@link ng.$animate $animate} to trigger animation operations within your directive code.
    </td>
  </tr>
  <tr>
@@ -5,4 +5,4 @@

 This error occurs when the name of a directive is not valid.

-Directives must start with a lowercase character.
+Directives must start with a lowercase character and must not contain leading or trailing whitespaces.
@@ -0,0 +1,12 @@
+@ngdoc error
+@name $compile:noctrl
+@fullName Controller is required.
+@description
+
+When using the `bindToController` feature of AngularJS, a directive is required
+to have a Controller. A controller may be specified by adding a "controller"
+property to the directive definition object. Its value should be either a
+string, or an invokable object (a function, or an array whose last element is a
+function).
+
+For more information, see the {@link guide/directive directives guide}.
@@ -0,0 +1,71 @@
+@ngdoc error
+@name $compile:noident
+@fullName Controller identifier is required.
+@description
+
+When using the `bindToController` feature of AngularJS, a directive is required
+to have a Controller identifier, which is initialized in scope with the value of
+the controller instance. This can be supplied using the "controllerAs" property
+of the directive object, or alternatively by adding " as IDENTIFIER" to the controller
+name.
+
+For example, the following directives are valid:
+
+```js
+// OKAY, because controller is a string with an identifier component.
+directive("okay", function() {
+  return {
+    bindToController: true,
+    controller: "myCtrl as $ctrl"
+    scope: {
+      text: "@text"
+    }
+  };
+});
+
+
+// OKAY, because the directive uses the controllerAs property to override
+// the controller identifier.
+directive("okay2", function() {
+  return {
+    bindToController: true,
+    controllerAs: "$ctrl",
+    controller: function() {
+
+    },
+    scope: {
+      text: "@text"
+    }
+  };
+});
+```
+
+While the following are invalid:
+
+```js
+// BAD, because the controller property is a string with no identifier.
+directive("bad", function() {
+  return {
+    bindToController: true,
+    controller: "noIdentCtrl",
+    scope: {
+      text: "@text"
+    }
+  };
+});
+
+
+// BAD because the controller is not a string (therefore has no identifier),
+// and there is no controllerAs property.
+directive("bad2", function() {
+  return {
+    bindToController: true,
+    controller: function noControllerAs() {
+
+    },
+    scope: {
+      text: "@text"
+    }
+  };
+});
+```
@@ -36,9 +36,25 @@ Following are invalid uses of this directive:
 ```


-To resolve this error, always use path expressions with scope properties that are two-way data-bound:
+To resolve this error, do one of the following options:
+
+- use path expressions with scope properties that are two-way data-bound like so:
+
 ```
 <my-directive bind="some.property">
 <my-directive bind="some[3]['property']">
 ```

+- Make the binding optional
+
+```
+myModule.directive('myDirective', function factory() {
+  return {
+    ...
+    scope: {
+      localValue: '=?bind' // <-- the '?' makes it optional
+    }
+    ...
+  }
+});
+```
@@ -69,3 +69,15 @@ angular.module('myModule', [])
 ```

 Use the `$controller` service if you want to instantiate controllers yourself.
+
+Attempting to inject a scope object into anything that's not a controller or a directive,
+for example a service, will also throw an `Unknown provider: $scopeProvider <- $scope` error.
+This might happen if one mistakenly registers a controller as a service, ex.:
+
+```
+angular.module('myModule', [])
+  .service('MyController', ['$scope', function($scope) {
+    // This controller throws an unknown provider error because
+    // a scope object cannot be injected into a service.
+  }]);
+```
@@ -0,0 +1,6 @@
+@ngdoc error
+@name $interpolate:badexpr
+@fullName Expecting end operator
+@description
+
+The Angular expression is missing the corresponding closing operator.
@@ -0,0 +1,11 @@
+@ngdoc error
+@name $interpolate:dupvalue
+@fullName Duplicate choice in plural/select
+@description
+
+You have repeated a match selection for your plural or select MessageFormat
+extension in your interpolation expression.  The different choices have to be unique.
+
+For more information about the MessageFormat syntax in interpolation
+expressions, please refer to MessageFormat extensions section at
+{@link guide/i18n#MessageFormat Angular i18n MessageFormat}
@@ -0,0 +1,12 @@
+@ngdoc error
+@name $interpolate:logicbug
+@fullName Bug in ngMessageFormat module
+@description
+
+You've just hit a bug in the ngMessageFormat module provided by angular-message-format.min.js.
+Please file a github issue for this and provide the interpolation text that caused you to hit this
+bug mentioning the exact version of AngularJS used and we will fix it!
+
+For more information about the MessageFormat syntax in interpolation
+expressions, please refer to MessageFormat extensions section at
+{@link guide/i18n#MessageFormat Angular i18n MessageFormat}
@@ -0,0 +1,17 @@
+@ngdoc error
+@name $interpolate:nochgmustache
+@fullName Redefinition of start/endSymbol incompatible with MessageFormat extensions
+@description
+
+You have redefined `$interpolate.startSymbol`/`$interpolate.endSymbol` and also
+loaded the `ngMessageFormat` module (provided by angular-message-format.min.js)
+while creating your injector.
+
+`ngMessageFormat` currently does not support redefinition of the
+startSymbol/endSymbol used by `$interpolate`.  If this is affecting you, please
+file an issue and mention @chirayuk on it.  This is intended to be fixed in a
+future commit and the github issue will help gauge urgency.
+
+For more information about the MessageFormat syntax in interpolation
+expressions, please refer to MessageFormat extensions section at
+{@link guide/i18n#MessageFormat Angular i18n MessageFormat}
@@ -0,0 +1,12 @@
+@ngdoc error
+@name $interpolate:reqarg
+@fullName Missing required argument for MessageFormat
+@description
+
+You must specify the MessageFormat function that you're using right after the
+comma following the Angular expression.  Currently, the supported functions are
+"plural" and "select" (for gender selections.)
+
+For more information about the MessageFormat syntax in interpolation
+expressions, please refer to MessageFormat extensions section at
+{@link guide/i18n#MessageFormat Angular i18n MessageFormat}
@@ -0,0 +1,11 @@
+@ngdoc error
+@name $interpolate:reqcomma
+@fullName Missing comma following MessageFormat plural/select keyword
+@description
+
+The MessageFormat syntax requires a comma following the "plural" or "select"
+extension keyword in the extended interpolation syntax.
+
+For more information about the MessageFormat syntax in interpolation
+expressions, please refer to MessageFormat extensions section at
+{@link guide/i18n#MessageFormat Angular i18n MessageFormat}
@@ -0,0 +1,11 @@
+@ngdoc error
+@name $interpolate:reqendbrace
+@fullName Unterminated message for plural/select value
+@description
+
+The plural or select message for a value or keyword choice has no matching end
+brace to mark the end of the message.
+
+For more information about the MessageFormat syntax in interpolation
+expressions, please refer to MessageFormat extensions section at
+{@link guide/i18n#MessageFormat Angular i18n MessageFormat}
@@ -0,0 +1,6 @@
+@ngdoc error
+@name $interpolate:reqendinterp
+@fullName Unterminated interpolation
+@description
+
+The interpolation text does not have an ending `endSymbol` ("}}" by default) and is unterminated.
@@ -0,0 +1,12 @@
+@ngdoc error
+@name $interpolate:reqopenbrace
+@fullName An opening brace was expected but not found
+@description
+
+The plural or select extension keyword or values (such as "other", "male",
+"female", "=0", "one", "many", etc.) MUST be followed by a message enclosed in
+braces.
+
+For more information about the MessageFormat syntax in interpolation
+expressions, please refer to MessageFormat extensions section at
+{@link guide/i18n#MessageFormat Angular i18n MessageFormat}
@@ -0,0 +1,13 @@
+@ngdoc error
+@name $interpolate:reqother
+@fullName Required choice "other" for select/plural in MessageFormat
+@description
+
+Your interpolation expression with a MessageFormat extension for either
+"plural" or "select" (typically used for gender selection) does not contain a
+message for the choice "other".  Using either select or plural MessageFormat
+extensions require that you provide a message for the selection "other".
+
+For more information about the MessageFormat syntax in interpolation
+expressions, please refer to MessageFormat extensions section at
+{@link guide/i18n#MessageFormat Angular i18n MessageFormat}
@@ -0,0 +1,12 @@
+@ngdoc error
+@name $interpolate:unknarg
+@fullName Unrecognized MessageFormat extension
+@description
+
+The MessageFormat extensions provided by `ngMessageFormat` are currently
+limited to "plural" and "select".  The extension that you have used is either
+unsupported or invalid.
+
+For more information about the MessageFormat syntax in interpolation
+expressions, please refer to MessageFormat extensions section at
+{@link guide/i18n#MessageFormat Angular i18n MessageFormat}
@@ -0,0 +1,10 @@
+@ngdoc error
+@name $interpolate:unsafe
+@fullName MessageFormat extensions not allowed in secure context
+@description
+
+You have attempted to use a MessageFormat extension in your interpolation expression that is marked as a secure context.  For security purposes, this is not supported.
+
+Read more about secure contexts at {@link ng.$sce Strict Contextual Escaping
+(SCE)} and about the MessageFormat extensions at {@link
+guide/i18n#MessageFormat Angular i18n MessageFormat}.
@@ -0,0 +1,6 @@
+@ngdoc error
+@name $interpolate:untermstr
+@fullName Unterminated string literal
+@description
+
+The string literal was not terminated in your Angular expression.
@@ -0,0 +1,8 @@
+@ngdoc error
+@name $interpolate:wantstring
+@fullName Expected the beginning of a string
+@description
+
+We expected to see the beginning of a string (either a single quote or a double
+quote character) in the expression but it was not found.  The expression is
+invalid.  If this is incorrect, please file an issue on github.
@@ -35,7 +35,7 @@ URL of the subcontext:

 ```html
 <head>
-  <base href="/subapp">
+  <base href="/subapp/">
  ...
 </head>
 ```
@@ -0,0 +1,51 @@
+@ngdoc error
+@name filter:notarray
+@fullName Not an array
+@description
+
+This error occurs when {@link ng.filter filter} is not used with an array:
+```html
+<input ng-model="search">
+<div ng-repeat="(key, value) in myObj | filter:search">
+  {{ key }} : {{ value }}
+</div>
+```
+
+Filter must be used with an array so a subset of items can be returned.
+The array can be initialized asynchronously and therefore null or undefined won't throw this error.
+
+To filter an object by the value of its properties you can create your own custom filter:
+```js
+angular.module('customFilter',[])
+  .filter('custom', function() {
+    return function(input, search) {
+      if (!input) return input;
+      if (!search) return input;
+      var expected = ('' + search).toLowerCase();
+      var result = {};
+      angular.forEach(input, function(value, key) {
+        var actual = ('' + value).toLowerCase();
+        if (actual.indexOf(expected) !== -1) {
+          result[key] = value;
+        }
+      });
+      return result;
+    }
+  });
+```
+That can be used as:
+```html
+<input ng-model="search">
+<div ng-repeat="(key, value) in myObj | custom:search">
+  {{ key }} : {{ value }}
+</div>
+```
+
+You could as well convert the object to an array using a filter such as
+[toArrayFilter](https://github.com/petebacondarwin/angular-toArrayFilter):
+```html
+<input ng-model="search">
+<div ng-repeat="item in myObj | toArray:false | filter:search">
+  {{ item }}
+</div>
+```
@@ -0,0 +1,7 @@
+@ngdoc error
+@name ng:cpta
+@fullName Copying TypedArray
+@description
+
+Copying TypedArray's with a destination is not supported because TypedArray
+objects can not be mutated, they are fixed length.
@@ -165,7 +165,7 @@ encoded.

 `$location` service has two configuration modes which control the format of the URL in the browser
 address bar: **Hashbang mode** (the default) and the **HTML5 mode** which is based on using the
-HTML5 [History API](http://www.w3.org/TR/html5/introduction.html#history-0). Applications use the same API in
+[HTML5 History API](https://html.spec.whatwg.org/multipage/browsers.html#the-history-interface). Applications use the same API in
 both modes and the `$location` service will work with appropriate URL segments and browser APIs to
 facilitate the browser URL change and history management.

@@ -693,7 +693,7 @@ A path should always begin with forward slash (`/`); the `$location.path()` sett
 forward slash if it is missing.

 Note that the `!` prefix in the hashbang mode is not part of `$location.path()`; it is actually
-hashPrefix.
+`hashPrefix`.

 ## Crawling your app

@@ -43,7 +43,7 @@ Currently, ngAria interfaces with the following directives:

 Most of ngAria's heavy lifting happens in the {@link ngModel ngModel}
 directive.  For elements using ngModel, special attention is paid by ngAria if that element also
-has a a role or type of `checkbox`, `radio`, `range` or `textbox`.
+has a role or type of `checkbox`, `radio`, `range` or `textbox`.

 For those elements using ngModel, ngAria will dynamically bind and update the following ARIA
 attributes (if they have not been explicitly specified by the developer):
@@ -253,7 +253,7 @@ The table below explains in detail which animation events are triggered
 | {@link ng.directive:ngClass#animations ngClass or &#123;&#123;class&#125;&#125;}    | add and remove                           |
 | {@link ng.directive:ngShow#animations ngShow & ngHide}                              | add and remove (the ng-hide class value) |

-For a full breakdown of the steps involved during each animation event, refer to the {@link ngAnimate.$animate API docs}.
+For a full breakdown of the steps involved during each animation event, refer to the {@link ng.$animate API docs}.

 ## How do I use animations in my own directives?

@@ -276,6 +276,6 @@ myModule.directive('my-directive', ['$animate', function($animate) {

 ## More about animations

-For a full breakdown of each method available on `$animate`, see the {@link ngAnimate.$animate API documentation}.
+For a full breakdown of each method available on `$animate`, see the {@link ng.$animate API documentation}.

 To see a complete demo, see the {@link tutorial/step_12 animation step within the AngularJS phonecat tutorial}.
@@ -55,11 +55,11 @@ Try out the Live Preview above, and then let's walk through the example and desc
 <img class="pull-right" style="padding-left: 3em; padding-bottom: 1em;" src="img/guide/concepts-databinding1.png">

 This looks like normal HTML, with some new markup. In Angular, a file like this is called a
-<a name="template">"{@link templates template}"</a>. When Angular starts your application, it parses and
-processes this new markup from the template using the so-called <a name="compiler">"{@link compiler compiler}"</a>.
-The loaded, transformed and rendered DOM is then called the <a name="view">"view"</a>.
+<a name="template">{@link templates template}</a>. When Angular starts your application, it parses and
+processes this new markup from the template using the <a name="compiler">{@link compiler compiler}</a>.
+The loaded, transformed and rendered DOM is then called the <a name="view"></a>*view*.

-The first kind of new markup are the so-called <a name="directive">"{@link directive directives}"</a>.
+The first kind of new markup are the <a name="directive">{@link directive directives}</a>.
 They apply special behavior to attributes or elements in the HTML. In the example above we use the
 {@link ng.directive:ngApp `ng-app`} attribute, which is linked to a directive that automatically
 initializes our application. Angular also defines a directive for the {@link ng.directive:input `input`}
@@ -75,16 +75,16 @@ stores/updates the value of the input field into/from a variable.

 The second kind of new markup are the double curly braces `{{ expression | filter }}`:
 When the compiler encounters this markup, it will replace it with the evaluated value of the markup.
-An <a name="expression">"{@link expression expression}"</a> in a template is a JavaScript-like code snippet that allows
+An <a name="expression">{@link expression expression}</a> in a template is a JavaScript-like code snippet that allows
 to read and write variables. Note that those variables are not global variables.
 Just like variables in a JavaScript function live in a scope,
-Angular provides a <a name="scope">"{@link scope scope}"</a> for the variables accessible to expressions.
-The values that are stored in variables on the scope are referred to as the <a name="model">"model"</a>
+Angular provides a <a name="scope">{@link scope scope}</a> for the variables accessible to expressions.
+The values that are stored in variables on the scope are referred to as the <a name="model"></a>*model*
 in the rest of the documentation.
 Applied to the example above, the markup directs Angular to "take the data we got from the input widgets
 and multiply them together".

-The example above also contains a <a name="filter">"{@link guide/filter filter}"</a>.
+The example above also contains a <a name="filter">{@link guide/filter filter}</a>.
 A filter formats the value of an expression for display to the user.
 In the example above, the filter {@link ng.filter:currency `currency`} formats a number
 into an output that looks like money.
@@ -92,7 +92,7 @@ into an output that looks like money.
 The important thing in the example is that Angular provides _live_ bindings:
 Whenever the input values change, the value of the expressions are automatically
 recalculated and the DOM is updated with their values.
-The concept behind this is <a name="databinding">"{@link databinding two-way data binding}"</a>.
+The concept behind this is <a name="databinding">{@link databinding two-way data binding}</a>.


 ## Adding UI logic: Controllers
@@ -150,7 +150,7 @@ different currencies and also pay the invoice.

 What changed?

-First, there is a new JavaScript file that contains a so-called <a name="controller">"{@link controller controller}"</a>.
+First, there is a new JavaScript file that contains a <a name="controller">{@link controller controller}</a>.
 More exactly, the file contains a constructor function that creates the actual controller instance.
 The purpose of controllers is to expose variables and functionality to expressions and directives.

@@ -255,15 +255,15 @@ We moved the `convertCurrency` function and the definition of the existing curre
 into the new file `finance2.js`. But how does the controller
 get a hold of the now separated function?

-This is where <a name="di">"{@link di Dependency Injection}"</a> comes into play.
+This is where <a name="di">{@link di Dependency Injection}</a> comes into play.
 Dependency Injection (DI) is a software design pattern that
 deals with how objects and functions get created and how they get a hold of their dependencies.
 Everything within Angular (directives, filters, controllers,
 services, ...) is created and wired using dependency injection. Within Angular,
-the DI container is called the <a name="injector">"{@link di injector}"</a>.
+the DI container is called the <a name="injector">{@link di injector}</a>.

 To use DI, there needs to be a place where all the things that should work together are registered.
-In Angular, this is the purpose of the so-called <a name="module">"{@link module modules}"</a>.
+In Angular, this is the purpose of the <a name="module">{@link module modules}</a>.
 When Angular starts, it will use the configuration of the module with the name defined by the `ng-app` directive,
 including the configuration of all modules that this module depends on.

@@ -30,12 +30,12 @@ Do not use controllers to:
 services} instead.
 - Manage the life-cycle of other components (for example, to create service instances).

-# Setting up the initial state of a `$scope` object
+## Setting up the initial state of a `$scope` object

 Typically, when you create an application you need to set up the initial state for the Angular
 `$scope`. You set up the initial state of a scope by attaching properties to the `$scope` object.
 The properties contain the **view model** (the model that will be presented by the view).  All the
-`$scope` properties will be available to the template at the point in the DOM where the Controller
+`$scope` properties will be available to the {@link templates template} at the point in the DOM where the Controller
 is registered.

 The following example demonstrates creating a `GreetingController`, which attaches a `greeting`
@@ -69,13 +69,13 @@ now be data-bound to the template:
 ```


-# Adding Behavior to a Scope Object
+## Adding Behavior to a Scope Object

 In order to react to events or execute computation in the view we must provide behavior to the
 scope. We add behavior to the scope by attaching methods to the `$scope` object.  These methods are
 then available to be called from the template/view.

-The following example uses a Controller to add a method to the scope, which doubles a number:
+The following example uses a Controller to add a method, which doubles a number, to the scope:

 ```js
 var myApp = angular.module('myApp',[]);
@@ -99,7 +99,7 @@ objects (or primitives) assigned to the scope become model properties. Any metho
 the scope are available in the template/view, and can be invoked via angular expressions
 and `ng` event handler directives (e.g. {@link ng.directive:ngClick ngClick}).

-# Using Controllers Correctly
+## Using Controllers Correctly

 In general, a Controller shouldn't try to do too much. It should contain only the business logic
 needed for a single view.
@@ -125,7 +125,7 @@ following components:
 - A model consisting of a string named `spice`
 - A Controller with two functions that set the value of `spice`

-The message in our template contains a binding to the `spice` model, which by default is set to the
+The message in our template contains a binding to the `spice` model which, by default, is set to the
 string "very". Depending on which button is clicked, the `spice` model is set to `chili` or
 `jalapeño`, and the message is automatically updated by data-binding.

@@ -259,7 +259,7 @@ Inheritance works with methods in the same way as it does with properties. So in
 examples, all of the properties could be replaced with methods that return string values.


-## Testing Controllers
+# Testing Controllers

 Although there are many ways to test a Controller, one of the best conventions, shown below,
 involves injecting the {@link ng.$rootScope $rootScope} and {@link ng.$controller $controller}:
@@ -3,6 +3,8 @@
@sortOrder 210
@description

+# Data Binding
+
 Data-binding in Angular apps is the automatic synchronization of data between the model and view
 components.  The way that Angular implements data-binding lets you treat the model as the
 single-source-of-truth in your application.  The view is a projection of the model at all times.
@@ -297,9 +297,9 @@ then the expression is not fulfilled and will remain watched.
  2. If V is not undefined, mark the result of the expression as stable and schedule a task
     to deregister the watch for this expression when we exit the digest loop
  3. Process the digest loop as normal
-  4. When digest loop is done and all the values have settled process the queue of watch
-     deregistration tasks. For each watch to be deregistered check if it still evaluates
-     to value that is not `undefined`. If that's the case, deregister the watch. Otherwise
+  4. When digest loop is done and all the values have settled, process the queue of watch
+     deregistration tasks. For each watch to be deregistered, check if it still evaluates
+     to a value that is not `undefined`. If that's the case, deregister the watch. Otherwise,
     keep dirty-checking the watch in the future digest loops by following the same
     algorithm starting from step 1

@@ -316,10 +316,10 @@ Here are three example cases.
 When interpolating text or attributes:

 ```html
-  <div name="attr: {{::color}}">text: {{::name}}</div>
+  <div name="attr: {{::color}}">text: {{::name | uppercase}}</div>
 ```

-When using a directive with bidirectional binding and the parameters will not change:
+When using a directive with bidirectional binding and parameters that will not change:

 ```js
 someModule.directive('someDirective', function() {
@@ -342,7 +342,6 @@ When using a directive that takes an expression:

 ```html
 <ul>
-  <li ng-repeat="item in ::items">{{item.name}};</li>
+  <li ng-repeat="item in ::items | orderBy:'name'">{{item.name}};</li>
 </ul>
-```
-
+```
@@ -3,6 +3,8 @@
@sortOrder 290
@description

+# Forms
+
 Controls (`input`, `select`, `textarea`) are ways for a user to enter data.
 A Form is a collection of controls for the purpose of grouping related controls together.

@@ -14,7 +16,7 @@ be circumvented and thus can not be trusted. Server-side validation is still nec
 secure application.


-# Simple form
+## Simple form
 The key directive in understanding two-way data-binding is {@link ng.directive:ngModel ngModel}.
 The `ngModel` directive provides the two-way data-binding by synchronizing the model to the view,
 as well as view to the model. In addition it provides an {@link ngModel.NgModelController API}
@@ -62,7 +64,7 @@ For example: inputs of type `email` must have a value in the form of `user@domai



-# Using CSS classes
+## Using CSS classes

 To allow styling of form as well as controls, `ngModel`  adds these CSS classes:

@@ -126,7 +128,7 @@ and failing to satisfy its validity.



-# Binding to form and control state
+## Binding to form and control state

 A form is an instance of {@link form.FormController FormController}.
 The form instance can optionally be published into the scope using the `name` attribute.
@@ -208,7 +210,7 @@ didn't interact with a control



-# Custom model update triggers
+## Custom model update triggers

 By default, any change to the content will trigger a model update and form validation. You can
 override this behavior using the {@link ng.directive:ngModelOptions ngModelOptions} directive to
@@ -249,7 +251,7 @@ will update the model only when the control loses focus (blur event).



-# Non-immediate (debounced) model updates
+## Non-immediate (debounced) model updates

 You can delay the model update/validation by using the `debounce` key with the
 {@link ng.directive:ngModelOptions ngModelOptions} directive. This delay will also apply to
@@ -290,7 +292,7 @@ after last change.
  </file>
 </example>

-# Custom Validation
+## Custom Validation

 Angular provides basic implementation for most common HTML5 {@link ng.directive:input input}
 types: ({@link input[text] text}, {@link input[number] number}, {@link input[url] url},
@@ -407,7 +409,7 @@ In the following example we create two directives:
  </file>
 </example>

-# Modifying built-in validators
+## Modifying built-in validators

 Since Angular itself uses `$validators`, you can easily replace or remove built-in validators,
 should you find it necessary. The following example shows you how to overwrite the email validator
@@ -452,7 +454,7 @@ Note that you can alternatively use `ng-pattern` to further restrict the validat
 </example>


-# Implementing custom form controls (using `ngModel`)
+## Implementing custom form controls (using `ngModel`)
 Angular implements all of the basic HTML form controls ({@link ng.directive:input input},
 {@link ng.directive:select select}, {@link ng.directive:textarea textarea}),
 which should be sufficient for most cases. However, if you need more flexibility,
@@ -489,9 +491,7 @@ The following example shows how to add two-way data-binding to contentEditable e
        link: function(scope, elm, attrs, ctrl) {
          // view -> model
          elm.on('blur', function() {
-            scope.$apply(function() {
-              ctrl.$setViewValue(elm.html());
-            });
+            ctrl.$setViewValue(elm.html());
          });

          // model -> view
@@ -18,8 +18,10 @@ application means providing translations and localized formats for the abstracte
 Angular supports i18n/l10n for {@link ng.filter:date date}, {@link ng.filter:number number} and
 {@link ng.filter:currency currency} filters.

-Additionally, Angular supports localizable pluralization support through the {@link
-ng.directive:ngPluralize `ngPluralize` directive}.
+Localizable pluralization is supported via the {@link ng.directive:ngPluralize `ngPluralize`
+directive}.  Additionally, you can use {@link guide/i18n#messageformat-extensions MessageFormat extensions} to
+`$interpolate` for localizable pluralization and gender support in all interpolations via the
+`ngMessageFormat` module.

 All localizable Angular components depend on locale-specific rule sets managed by the {@link
 ng.$locale `$locale` service}.
@@ -137,3 +139,242 @@ The Angular datetime filter uses the time zone settings of the browser. The same
 application will show different time information depending on the time zone settings of the
 computer that the application is running on. Neither JavaScript nor Angular currently supports
 displaying the date with a timezone specified by the developer.
+
+
+<a name="MessageFormat"></a>
+## MessageFormat extensions
+
+You can write localizable plural and gender based messages in Angular interpolation expressions and
+`$interpolate` calls.
+
+This syntax extension is provided by way of the `ngMessageFormat` module that your application can
+depend upon (shipped separately as `angular-message-format.min.js` and `angular-message-format.js`.)
+A current limitation of the `ngMessageFormat` module, is that it does not support redefining the
+`$interpolate` start and end symbols. Only the default `{{` and `}}` are allowed.
+
+The syntax extension is based on a subset of the ICU MessageFormat syntax that covers plurals and
+gender selections.  Please refer to the links in the “Further Reading” section at the bottom of this
+section.
+
+You may find it helpful to play with our [Plnkr Example](http://plnkr.co/edit/QBVRQ70dvKZDWmHW9RyR?p=preview)
+as you read the examples below.
+
+### Plural Syntax
+
+The syntax for plural based message selection looks like the following:
+
+```text
+{{NUMERIC_EXPRESSION, plural,
+    =0 {MESSAGE_WHEN_VALUE_IS_0}
+    =1 {MESSAGE_WHEN_VALUE_IS_1}
+    =2 {MESSAGE_WHEN_VALUE_IS_2}
+    =3 {MESSAGE_WHEN_VALUE_IS_3}
+    ...
+    zero {MESSAGE_WHEN_PLURAL_CATEGORY_IS_ZERO}
+    one {MESSAGE_WHEN_PLURAL_CATEGORY_IS_ONE}
+    two {MESSAGE_WHEN_PLURAL_CATEGORY_IS_TWO}
+    few {MESSAGE_WHEN_PLURAL_CATEGORY_IS_FEW}
+    many {MESSAGE_WHEN_PLURAL_CATEGORY_IS_MANY}
+    other {MESSAGE_WHEN_THERE_IS_NO_MATCH}
+}}
+```
+
+Please note that whitespace (including newline) is generally insignificant except as part of the
+actual message text that occurs in curly braces.  Whitespace is generally used to aid readability.
+
+Here, `NUMERIC_EXPRESSION` is an expression that evaluates to a numeric value based on which the
+displayed message should change based on pluralization rules.
+
+Following the Angular expression, you would denote the plural extension syntax by the `, plural,`
+syntax element.  The spaces there are optional.
+
+This is followed by a list of selection keyword and corresponding message pairs.  The "other"
+keyword and corresponding message are **required** but you may have as few or as many of the other
+categories as you need.
+
+#### Selection Keywords
+
+The selection keywords can be either exact matches or language dependent [plural
+categories](http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html).
+
+Exact matches are written as the equal sign followed by the exact value. `=0`, `=1`, `=2` and
+`=123` are all examples of exact matches.  Note that there should be no space between the equal sign
+and the numeric value.
+
+Plural category matches are single words corresponding to the [plural
+categories](http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html) of
+the CLDR plural category spec.  These categories vary by locale.  The "en" (English) locale, for
+example, defines just "one" and "other" while the "ga" (Irish) locale defines "one", "two", "few",
+"many" and "other".  Typically, you would just write the categories for your language.  During
+translation, the translators will add or remove more categories depending on the target locale.
+
+Exact matches always win over keyword matches.  Therefore, if you define both `=0` and `zero`, when
+the value of the expression is zero, the `=0` message is the one that will be selected.  (The
+duplicate keyword categories are helpful when used with the optional `offset` syntax described
+later.)
+
+
+#### Messages
+
+Messages immediately follow a selection keyword and are optionally preceded by whitespace.  They are
+written in single curly braces (`{}`).  They may contain Angular interpolation syntax inside them.
+In addition, the `#` symbol is a placeholder for the actual numeric value of the expression.
+
+### Simple plural example
+
+```text
+{{numMessages, plural,
+      =0 {You have no new messages}
+      =1 {You have one new message}
+   other {You have # new messages}
+}}
+```
+
+Because these messages can themselves contain Angular expressions, you could also write this as
+follows:
+
+```text
+{{numMessages, plural,
+      =0 {You have no new messages}
+      =1 {You have one new message}
+   other {You have {{numMessages}} new messages}
+}}
+```
+
+
+### Plural syntax with optional `offset`
+
+The plural syntax supports an optional `offset` syntax that is used in matching.  It's simpler to
+explain this with an example.
+
+```text
+{{recipients.length, plural, offset:1
+    =0    {You gave no gifts}
+    =1    {You gave {{recipients[0].name}} a gift}
+    one   {You gave {{recipients[0].name}} and one other person a gift}
+    other {You gave {{recipients[0].name}} and # other people a gift}
+}}
+```
+
+When an `offset` is specified, the matching works as follows.  First, the exact value of the Angular
+expression is matched against the exact matches (i.e. `=N` selectors) to find a match.  If there is
+one, that message is used.  If there was no match, then the offset value is subtracted from the
+value of the expression and locale specific pluralization rules are applied to this new value to
+obtain its plural category (such as “one”, “few”, “many”, etc.) and a match is attempted against the
+keyword selectors and the matching message is used.  If there was no match, then the “other”
+category (required) is used.  The value of the `#` character inside a message is the value of
+original expression reduced by the offset value that was specified.
+
+### Escaping / Quoting
+
+You will need to escape curly braces or the `#` character inside message texts if you want them to
+be treated literally with no special meaning.  You may quote/escape any character in your message
+text by preceding it with a `\` (backslash) character.  The backslash character removes any special
+meaning to the character that immediately follows it.  Therefore, you can escape or quote the
+backslash itself by preceding it with another backslash character.
+
+
+### Gender (aka select) Syntax
+
+The gender support is provided by the more generic "select" syntax that is more akin to a switch
+statement.  It is general enough to support use for gender based messages.
+
+The syntax for gender based message selection looks like the following:
+
+```text
+{{EXPRESSION, select,
+    male {MESSAGE_WHEN_EXPRESSION_IS_MALE}
+    female {MESSAGE_WHEN_EXPRESSION_IS_FEMALE}
+    ...
+    other {MESSAGE_WHEN_THERE_IS_NO_GENDER_MATCH}
+}}
+```
+
+Please note that whitespace (including newline) is generally insignificant except as part of the
+actual message text that occurs in curly braces.  Whitespace is generally used to aid readability.
+
+Here, `EXPRESSION` is an Angular expression that evaluates to the gender of the person that
+is used to select the message that should be displayed.
+
+The Angular expression is followed by `, select,` where the spaces are optional.
+
+This is followed by a list of selection keyword and corresponding message pairs.  The "other"
+keyword and corresponding message are **required** but you may have as few or as many of the other
+gender values as you need (i.e. it isn't restricted to male/female.)  Note however, that the
+matching is **case-sensitive**.
+
+#### Selection Keywords
+
+Selection keywords are simple words like "male" and "female".  The keyword, "other", and its
+corresponding message are required while others are optional.  It is used when the Angular
+expression does not match (case-insensitively) any of the other keywords specified.
+
+#### Messages
+
+Messages immediately follow a selection keyword and are optionally preceded by whitespace.  They are
+written in single curly braces (`{}`).  They may contain Angular interpolation syntax inside them.
+
+### Simple gender example
+
+```text
+{{friendGender, select,
+       male {Invite him}
+     female {Invite her}
+      other {Invite them}
+}}
+```
+
+### Nesting
+
+As mentioned in the syntax for plural and select, the embedded messages can contain Angular
+interpolation syntax.  Since you can use MessageFormat extensions in Angular interpolation, this
+allows you to nest plural and gender expressions in any order.
+
+Please note that if these are intended to reach a translator and be translated, it is recommended
+that the messages appear as a whole and not be split up.
+
+### More complex example that demonstrates nesting
+
+This is taken from the [plunker example](http://plnkr.co/edit/QBVRQ70dvKZDWmHW9RyR?p=preview) linked to earlier.
+
+```text
+{{recipients.length, plural, offset:1
+    =0 {You ({{sender.name}}) gave no gifts}
+    =1 { {{ recipients[0].gender, select,
+              male {You ({{sender.name}}) gave him ({{recipients[0].name}}) a gift.}
+              female {You ({{sender.name}}) gave her ({{recipients[0].name}}) a gift.}
+              other {You ({{sender.name}}) gave them ({{recipients[0].name}}) a gift.}
+          }}
+       }
+    one { {{ recipients[0].gender, select,
+              male {You ({{sender.name}}) gave him ({{recipients[0].name}}) and one other person a gift.}
+              female {You ({{sender.name}}) gave her ({{recipients[0].name}}) and one other person a gift.}
+              other {You ({{sender.name}}) gave them ({{recipients[0].name}}) and one other person a gift.}
+          }}
+       }
+    other {You ({{sender.name}}) gave {{recipients.length}} people gifts. }
+}}
+```
+
+### Differences from the ICU MessageFormat syntax
+
+This section is useful to you if you're already familiar with the ICU MessageFormat syntax.
+
+This syntax extension, while based on MessageFormat, has been designed to be backwards compatible
+with existing AngularJS interpolation expressions.  The key rule is simply this: **All
+interpolations are done inside double curlies.** The top level comma operator after an expression
+inside the double curlies causes MessageFormat extensions to be recognized.  Such a top level comma
+is otherwise illegal in an Angular expression and is used by MessageFormat to specify the function
+(such as plural/select) and it's related syntax.
+
+To understand the extension, take a look at the ICU MessageFormat syntax as specified by the ICU
+documentation.  Anywhere in that MessageFormat that you have regular message text and you want to
+substitute an expression, just put it in double curlies instead of single curlies that MessageFormat
+dictates.  This has a huge advantage.  **You are no longer limited to simple identifiers for
+substitutions**.  Because you are using double curlies, you can stick in any arbitrary interpolation
+syntax there, including nesting more MessageFormat expressions!
+
+### Further Reading
+For more details, please refer to our [design doc](https://docs.google.com/a/google.com/document/d/1pbtW2yvtmFBikfRrJd8VAsabiFkKezmYZ_PbgdjQOVU/edit).
+You can read more about the ICU MessageFormat syntax at
+[Formatting Messages | ICU User Guide](http://userguide.icu-project.org/formatparse/messages#TOC-MessageFormat).
@@ -13,6 +13,335 @@ which drives many of these changes.
 * Several new features, especially animations, would not be possible without a few changes.
 * Finally, some outstanding bugs were best fixed by changing an existing API.

+# Migrating from 1.3 to 1.4
+
+Angular 1.4 fixes major animation issues and introduces a new API for `ngCookies`. Further, there
+are changes to `ngMessages`, `$compile`, `ngRepeat`, `ngOptions `and some fixes to core filters:
+`limitTo` and `filter`.
+
+The reason for the ngAnimate refactor was to fix timing issues and to expose new APIs to allow
+for developers to construct more versatile animations.  We now have access to `$animateCss`
+and the many timing-oriented bugs were fixed which results in smoother animations.
+If animation is something of interest, then please read over the breaking changes below for animations when
+`ngAnimate` is used.
+
+`ngMessages` has been upgraded to allow for dynamic message resolution. This handy feature allows for developers
+to render error messages with ngMessages that are listed with a directive such as ngRepeat. A great usecase for this
+involves pulling error message data from a server and then displaying that data via the mechanics of ngMessages. Be
+sure to read the breaking change involved with `ngMessagesInclude` to upgrade your template code.
+
+Other changes, such as the ordering of elements with ngRepeat and ngOptions, may also affect the behavior of your
+application. And be sure to also read up on the changes to `$cookies`. The migration jump from 1.3 to 1.4 should be
+relatively straightforward otherwise.
+
+
+
+
+## Animation (`ngAnimate`)
+
+Animations in 1.4 have been refactored internally, but the API has stayed much the same. There are, however,
+some breaking changes that need to be addressed when upgrading to 1.4.
+
+Due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+JavaScript and CSS animations can no longer be run in
+parallel. With earlier versions of ngAnimate, both CSS and JS animations
+would be run together when multiple animations were detected. This
+feature has been removed, however, the same effect, with even more
+possibilities, can be achieved by injecting `$animateCss` into a
+JavaScript-defined animation and creating custom CSS-based animations
+from there.
+
+By using `$animateCss` inside of a JavaScript animation in Angular 1.4, we can trigger custom CSS-based animations
+directly from our JavaScript code.
+
+```js
+ngModule.animation('.slide-animation', ['$animateCss', function($animateCss) {
+  return {
+    enter: function(element, doneFn) {
+      // this will trigger a `.ng-enter` and `.ng-enter-active` CSS animation
+      var animation = $animateCss(element, {
+        event: 'enter'
+        // any other CSS-related properties
+        //   addClass: 'some-class',
+        //   removeClass: 'some-other-class',
+        //   from: {},
+        //   to: {}
+      });
+
+      // make sure to read the ngAnimate docs to understand how this works
+      animation.start().done(doneFn);
+    }
+  }
+}]);
+```
+
+{@link ngAnimate.$animateCss Click here to learn how to use $animateCss in your animation code}
+
+Due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+animation-related callbacks are now fired on `$animate.on` instead of directly being on the element.
+
+```js
+// < 1.4
+element.on('$animate:before', function(e, data) {
+  if (data.event === 'enter') { ... }
+});
+element.off('$animate:before', fn);
+
+// 1.4+
+$animate.on('enter', element, function(data) {
+  //...
+});
+$animate.off('enter', element, fn);
+```
+
+Due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+the function params for `$animate.enabled()` when an element is used are now flipped. This fix allows
+the function to act as a getter when a single element param is provided.
+
+```js
+// < 1.4
+$animate.enabled(false, element);
+
+// 1.4+
+$animate.enabled(element, false);
+```
+
+Due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+in addition to disabling the children of the element, `$animate.enabled(element, false)` will now also
+disable animations on the element itself.
+
+Due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+there is no need to call `$scope.$apply` or `$scope.$digest` inside of a animation promise callback anymore
+since the promise is resolved within a digest automatically. (Not to worry, any extra digests will not be
+run unless the promise is used.)
+
+```js
+// < 1.4
+$animate.enter(element).then(function() {
+  $scope.$apply(function() {
+    $scope.explode = true;
+  });
+});
+
+// 1.4+
+$animate.enter(element).then(function() {
+  $scope.explode = true;
+});
+```
+
+Due to [c8700f04](https://github.com/angular/angular.js/commit/c8700f04fb6fb5dc21ac24de8665c0476d6db5ef),
+when an enter, leave or move animation is triggered then it will always end any pending or active parent
+class based animations (animations triggered via ngClass) in order to ensure that any CSS styles are resolved in time.
+
+
+
+
+## Forms (`ngMessages`, `ngOptions`, `select`)
+
+### ngMessages
+The ngMessages module has also been subject to an internal refactor to allow it to be more flexible
+and compatible with dynamic message data. The `ngMessage` directive now supports a new attribute
+called `ng-message-exp` which will evaluate an expression and will keep track of that expression
+as it changes in order to re-evaluate the listed messages.
+
+[Click here to learn more about dynamic ng-messages](https://docs.angularjs.org/api/ngMessages#dynamic-messaging)
+
+There is only one breaking change. Please consider the following when including remote
+message templates via `ng-messages-include`:
+
+Due to [c9a4421f](https://github.com/angular/angular.js/commit/c9a4421fc3c97448527eadef1f42eb2f487ec2e0),
+the `ngMessagesInclude` attribute has now been removed and cannot be used in the same element containing
+the `ngMessages` directive. Instead, `ngMessagesInclude` is to be used on its own element inline with
+other inline messages situated as children within the `ngMessages` container directive.
+
+```html
+<!-- AngularJS 1.3.x -->
+<div ng-messages="model.$error" ng-messages-include="remote.html">
+  <div ng-message="required">Your message is required</div>
+</div>
+
+<!-- AngularJS 1.4.x -->
+<div ng-messages="model.$error">
+  <div ng-message="required">Your message is required</div>
+  <div ng-messages-include="remote.html"></div>
+</div>
+```
+
+Depending on where the `ngMessagesInclude` directive is placed it will be prioritized inline with the other messages
+before and after it.
+
+### ngOptions
+
+The `ngOptions` directive has also been refactored and as a result some long-standing bugs
+have been fixed. The breaking changes are comparatively minor and should not affect most applications.
+
+Due to [7fda214c](https://github.com/angular/angular.js/commit/7fda214c4f65a6a06b25cf5d5aff013a364e9cef),
+when `ngOptions` renders the option values within the DOM, the resulting HTML code is different.
+Normally this should not affect your application at all, however, if your code relies on inspecting
+the value property of `<option>` elements (that `ngOptions` generates) then be sure
+to [read the details](https://github.com/angular/angular.js/commit/7fda214c4f65a6a06b25cf5d5aff013a364e9cef).
+
+Due to [7fda214c](https://github.com/angular/angular.js/commit/7fda214c4f65a6a06b25cf5d5aff013a364e9cef),
+when iterating over an object's properties using the `(key, value) in obj` syntax
+the order of the elements used to be sorted alphabetically. This was an artificial
+attempt to create a deterministic ordering since browsers don't guarantee the order.
+But in practice this is not what people want and so this change iterates over properties
+in the order they are returned by Object.keys(obj), which is almost always the order
+in which the properties were defined.
+
+
+### select
+
+Due to [7fda214c](https://github.com/angular/angular.js/commit/7fda214c4f65a6a06b25cf5d5aff013a364e9cef),
+the `select` directive will now use strict comparison of the `ngModel` scope value against `option`
+values to determine which option is selected. This means `Number` scope values will not be matched
+against numeric option strings.
+In Angular 1.3.x, setting `scope.x = 200` would select the option with the value 200 in the following `select`:
+
+```
+<select ng-model="x">
+  <option value="100">100</option>
+  <option value="200">200</option>
+</select>
+```
+
+In Angular 1.4.x, the 'unknown option' will be selected.
+To remedy this, you can simply initialize the model as a string: `scope.x = '200'`, or if you want to
+keep the model as a `Number`, you can do the conversion via `$formatters` and `$parsers` on `ngModel`:
+
+```js
+ngModelCtrl.$parsers.push(function(value) {
+  return parseInt(value, 10); // Convert option value to number
+});
+
+ngModelCtrl.$formatters.push(function(value) {
+  return value.toString(); // Convert scope value to string
+});
+```
+
+## Templating (`ngRepeat`, `$compile`)
+
+### ngRepeat
+
+Due to [c260e738](https://github.com/angular/angular.js/commit/c260e7386391877625eda086480de73e8a0ba921),
+previously, the order of items when using ngRepeat to iterate over object properties was guaranteed to be consistent
+by sorting the keys into alphabetic order.
+
+Now, the order of the items is browser dependent based on the order returned
+from iterating over the object using the `for key in obj` syntax.
+
+It seems that browsers generally follow the strategy of providing
+keys in the order in which they were defined, although there are exceptions
+when keys are deleted and reinstated. See
+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete#Cross-browser_issues
+
+The best approach is to convert Objects into Arrays by a filter such as
+https://github.com/petebacondarwin/angular-toArrayFilter
+or some other mechanism, and then sort them manually in the order you need.
+
+
+### $compile
+
+Due to [6a38dbfd](https://github.com/angular/angular.js/commit/6a38dbfd3c34c8f9efff503d17eb3cbeb666d422),
+previously, '&' expressions would always set up a function in the isolate scope. Now, if the binding
+is marked as optional and the attribute is not specified, no function will be added to the isolate scope.
+
+Due to [62d514b](https://github.com/angular/angular.js/commit/62d514b06937cc7dd86e973ea11165c88343b42d),
+returning an object from a controller constructor function will now override the scope. Views that use the
+controllerAs method will no longer get the this reference, but the returned object. 
+
+
+## Cookies (`ngCookies`)
+
+Due to [38fbe3ee](https://github.com/angular/angular.js/commit/38fbe3ee8370fc449b82d80df07b5c2ed2cd5fbe),
+`$cookies` will no longer expose properties that represent the current browser cookie
+values. `$cookies` no longer polls the browser for changes to the cookies and ***no longer copies
+cookie values onto the `$cookies` object***.
+
+This was changed because the polling is expensive and caused issues with the `$cookies` properties
+not synchronizing correctly with the actual browser cookie values (The reason the polling
+was originally added was to allow communication between different tabs,
+but there are better ways to do this today, for example `localStorage`.)
+
+The new API on `$cookies` is as follows:
+
+ * `get`
+ * `put`
+ * `getObject`
+ * `putObject`
+ * `getAll`
+ * `remove`
+
+You must explictly use the methods above in order to access cookie data. This also means that
+you can no longer watch the properties on `$cookies` to detect changes
+that occur on the browsers cookies.
+
+This feature is generally only needed if a 3rd party library was programmatically
+changing the cookies at runtime. If you rely on this then you must either write code that
+can react to the 3rd party library making the changes to cookies or implement your own polling
+mechanism.
+
+**DEPRECATION NOTICE**
+
+`$cookieStore` is now deprecated as all the useful logic
+has been moved to `$cookies`, to which `$cookieStore` now simply
+delegates calls.
+
+
+
+
+## Server Requests (`$http`)
+
+Due to [5da1256](https://github.com/angular/angular.js/commit/5da1256fc2812d5b28fb0af0de81256054856369),
+`transformRequest` functions can no longer modify request headers.
+
+Before this commit `transformRequest` could modify request headers, ex.:
+
+```javascript
+function requestTransform(data, headers) {
+    headers = angular.extend(headers(), {
+      'X-MY_HEADER': 'abcd'
+    });
+  }
+  return angular.toJson(data);
+}
+```
+
+This behavior was unintended and undocumented, so the change should affect very few applications. If one
+needs to dynamically add / remove headers it should be done in a header function, for example:
+
+```javascript
+$http.get(url, {
+  headers: {
+    'X-MY_HEADER': function(config) {
+      return 'abcd'; //you've got access to a request config object to specify header value dynamically
+    }
+  }
+})
+```
+
+
+
+
+## Filters (`filter`, `limitTo`)
+
+### `filter` filter
+Due to [cea8e751](https://github.com/angular/angular.js/commit/cea8e75144e6910b806b63a6ec2a6d118316fddd),
+the `filter` filter will throw an error when used with a non-array. Beforehand it would silently
+return an empty array.
+
+If necessary, this can be worked around by converting an object to an array,
+using a filter such as https://github.com/petebacondarwin/angular-toArrayFilter.
+
+### `limitTo` filter
+Due to [a3c3bf33](https://github.com/angular/angular.js/commit/a3c3bf3332e5685dc319c46faef882cb6ac246e1),
+the limitTo filter has changed behavior when the provided limit value is invalid.
+Now, instead of returning empty object/array, it returns unchanged input.
+
+
+
+
+
 # Migrating from 1.2 to 1.3

 ## Controllers
@@ -140,7 +140,7 @@ The above is a suggestion. Tailor it to your needs.
 # Module Loading & Dependencies

 A module is a collection of configuration and run blocks which get applied to the application
-during the bootstrap process. In its simplest form the module consist of a collection of two kinds
+during the bootstrap process. In its simplest form the module consists of a collection of two kinds
 of blocks:

  1. **Configuration blocks** - get executed during the provider registrations and configuration
@@ -197,14 +197,14 @@ Then Angular applies configuration blocks in the same order they were registered
 ## Run Blocks

 Run blocks are the closest thing in Angular to the main method. A run block is the code which
-needs to run to kickstart the application. It is executed after all of the service have been
+needs to run to kickstart the application. It is executed after all of the services have been
 configured and the injector has been created. Run blocks typically contain code which is hard
 to unit-test, and for this reason should be declared in isolated modules, so that they can be
 ignored in the unit-tests.

 ## Dependencies

-Modules can list other modules as their dependencies. Depending on a module implies that required
+Modules can list other modules as their dependencies. Depending on a module implies that the required
 module needs to be loaded before the requiring module is loaded. In other words the configuration
 blocks of the required modules execute before the configuration blocks of the requiring module.
 The same is true for the run blocks. Each module can only be loaded once, even if multiple other
@@ -39,7 +39,7 @@ In general, we recommend against this because it can create unintended XSS vecto

 However, it's ok to mix server-side templating in the bootstrap template (`index.html`) as long
 as user input cannot be used on the server to output html that would then be processed by Angular
-in a way that would cause allow for arbitrary code execution.
+in a way that would allow for arbitrary code execution.

 For instance, you can use server-side templating to dynamically generate CSS, URLs, etc, but not
 for generating templates that are bootstrapped/compiled by Angular.
@@ -82,7 +82,7 @@ on the service.
 ### Registering Services

 Services are registered to modules via the {@link angular.Module Module API}.
-Typically you use the {@link angular.module Module#factory} API to register a service:
+Typically you use the {@link angular.Module#factory Module factory} API to register a service:

 ```js
 var myModule = angular.module('myModule', []);
@@ -181,7 +181,7 @@ of a real browser alert.

 ```js
 var mock, notify;
-
+beforeEach(module('myServiceModule'));
 beforeEach(function() {
  mock = {alert: jasmine.createSpy()};

@@ -261,8 +261,10 @@ myModule.filter('length', function() {

 describe('length filter', function() {

+  var $filter;
+
  beforeEach(inject(function(_$filter_){
-    $filter= _$filter_;
+    $filter = _$filter_;
  }));

  it('returns 0 when given null', function() {
@@ -20,6 +20,42 @@ AngularJS is 100% JavaScript, 100% client-side and compatible with both desktop
 So it's definitely not a plugin or some other native browser extension.


+### What is the AngularJS versioning strategy?
+
+In Angular 1 we do not allow intentional breaking changes to appear in versions where only the "patch"
+number changes. For example between 1.3.12 and 1.3.13 there can be no breaking changes. We do allow
+breaking changes happen between "minor" number changes. For example between 1.3.15 and 1.4.0 there
+will be a number of breaking changes. We also allow breaking changes between beta releases of Angular.
+For example between 1.4.0-beta.4 and 1.4.0-beta.5 there may be breaking changes. We try hard to minimize
+these kinds of change only to those where there is a strong use case such as a strongly requested feature
+improvement, a considerable simplification of the code or a measurable performance improvement.
+
+When adding new code to branches of Angular, have a very stringent commit policy:
+
+- Every commit must contain tests and documentation updates alongside the code changes and that all the
+tests must pass;
+- Commit messages must be written in a specific manner that allows us to parse them and extract the changes
+for release notes.
+
+The Angular code base has a very large set of unit tests (over 4000) and end to end tests, which are pretty
+comprehensive. This means that a breaking change will require one or more tests to be changed to allow the
+tests to pass. So when a commit includes tests that are being removed or modified, this is a flag that the
+code might include a breaking change. When reviewing the commit we can then decide whether there really is
+a breaking change and if it is appropriate for the branch to which it is being merged. If so, then we
+require that the commit message contains an appropriate breaking change message.
+
+Additionally, when a commit lands in our master repository it is synced to Google where we test it against
+over 2000 applications using the test suites of these applications. This allows us to catch regressions
+quickly before a release. We've had a pretty good experience with this setup. Only bugs that affect features
+not used at Google or without sufficient test coverage, have a chance of making it through.
+
+Lastly, when we are making a release we generate updates to the changelog directly from the commits. This
+generated update contains a highlighted section that contains all the breaking changes that have been
+extracted from the commits. We can quickly see in the new changelog exactly what commits contain breaking
+changes and so can application developers when they are deciding whether to update to a new version of
+Angular.
+
+
 ### Is AngularJS a templating system?

 At the highest level, Angular does look like just another templating system. But there is one
@@ -33,7 +69,7 @@ templating systems.
 ### Do I need to worry about security holes in AngularJS?

 Like any other technology, AngularJS is not impervious to attack. Angular does, however, provide
-built-in protection from basic security holes including cross-site scripting and HTML injection
+built-in protection from basic security holes, including cross-site scripting and HTML injection
 attacks. AngularJS does round-trip escaping on all strings for you and even offers XSRF protection
 for server-side communication.

@@ -52,7 +88,7 @@ Yes. See instructions in {@link downloading}.

 We run our extensive test suite against the following browsers: Safari, Chrome, Firefox, Opera 15,
 IE9 and mobile browsers (Android, Chrome Mobile, iOS Safari). See {@link guide/ie Internet
-Explorer Compatibility} for more details in supporting legacy IE browsers.
+Explorer Compatibility} for more details on supporting legacy IE browsers.


 ### What's Angular's performance like?
@@ -61,8 +97,8 @@ The startup time heavily depends on your network connection, state of the cache,
 available hardware, but typically we measure bootstrap time in tens or hundreds of milliseconds.

 The runtime performance will vary depending on the number and complexity of bindings on the page
-as well as the speed of your backend (for apps that fetch data from the backend). Just for an
-illustration we typically build snappy apps with hundreds or thousands of active bindings.
+as well as the speed of your backend (for apps that fetch data from the backend). For an
+illustration, we typically build snappy apps with hundreds or thousands of active bindings.


 ### How big is the angular.js file that I need to include?
@@ -88,7 +124,7 @@ but we don't guarantee that.

 ### What is testability like in Angular?

-Very testable and designed this way from ground up. It has an integrated dependency injection
+Very testable and designed this way from the ground up. It has an integrated dependency injection
 framework, provides mocks for many heavy dependencies (server-side communication). See
 {@link ngMock} for details.

@@ -158,7 +194,7 @@ Conditionally showing and hiding things using jQuery is a common pattern in othe
 `ng-show` (and `ng-hide`) conditionally show and hide elements based on boolean expressions.
 Describe the conditions for showing and hiding an element in terms of `$scope` variables:

-    <div ng-show="!loggedIn">Click <a href="#/login">here</a> to log in</div>
+    <div ng-show="!loggedIn"><a href="#/login">Click here to log in</a></div>

 Note also the counterpart `ng-hide` and similar `ng-disabled`.
 Note especially the powerful `ng-switch` that should be used instead of several mutually exclusive `ng-show`s.
@@ -189,7 +225,7 @@ Then whenever a value on a scope changes, all `$watch`es observing that element

 Sometimes, usually when you're writing a custom directive, you will have to define your own `$watch` on a scope value to make the directive react to changes.

-On the flip side, sometimes you change a scope value in some code but the app doesn't react to it.
+On the flip side, sometimes you change a scope value in some code, but the app doesn't react to it.
 Angular checks for scope variable changes after pieces of your code have finished running; for example, when `ng-click` calls a function on your scope, Angular will check for changes and react.
 However, some code is outside of Angular and you'll have to call `scope.$apply()` yourself to trigger the update.
 This is most commonly seen in event handlers in custom directives.
@@ -129,7 +129,8 @@ Once you have Node.js installed on your machine you can download the tool depend
 npm install
 ```

-This command will download the following tools, into the `node_modules` directory:
+This command reads angular-phonecat's `package.json` file and downloads the following tools
+into the `node_modules` directory:

 - [Bower][bower] - client-side code package manager
 - [Http-Server][http-server] - simple local static web server
@@ -198,7 +199,7 @@ http://localhost:8000/app/index.html

 <div class="alert alert-info">
 To serve the web app on a different ip address or port, edit the "start" script within package.json.
-You can `-a` to set the address and `-p` to set the port.
+You can use `-a` to set the address and `-p` to set the port.
 </div>

 ### Running Unit Tests
@@ -270,6 +271,7 @@ It is good to run the end to end tests whenever you make changes to the HTML vie
 that the application as a whole is executing correctly.  It is very common to run End to End tests
 before pushing a new commit of changes to a remote repository.

+Now that you have set up your local machine, let's get started with the tutorial: {@link step_00 Step 0 - Bootstrapping}

 [git]: http://git-scm.com/
 [node]: http://nodejs.org/
@@ -31,7 +31,7 @@ npm install

 To see the app running in a browser, open a *separate* terminal/command line tab or window, then
 run `npm start` to start the web server. Now, open a browser window for the app and navigate to
-<a href="http://localhost:8000/app/" target="_blank">`http://localhost:8000/app/`</a>
+<a href="http://localhost:8000/app/" target="_blank" title="Open app on localhost">`http://localhost:8000/app/`</a>

 Note that if you already ran the master branch app prior to checking out step-0, you may see the cached
 master version of the app in your browser window at this point. Just hit refresh to re-load the page.
@@ -91,22 +91,22 @@ being the element on which the `ngApp` directive was defined.

          Nothing here {{'yet' + '!'}}

-  This line demonstrates two core features of Angular's templating capabilities:
+This line demonstrates two core features of Angular's templating capabilities:

-    * a binding, denoted by double-curlies `{{ }}`
-    * a simple expression `'yet' + '!'` used in this binding.
+  * a binding, denoted by double-curlies `{{ }}`
+  * a simple expression `'yet' + '!'` used in this binding.

-  The binding tells Angular that it should evaluate an expression and insert the result into the
-  DOM in place of the binding. Rather than a one-time insert, as we'll see in the next steps, a
-  binding will result in efficient continuous updates whenever the result of the expression
-  evaluation changes.
+The binding tells Angular that it should evaluate an expression and insert the result into the
+DOM in place of the binding. Rather than a one-time insert, as we'll see in the next steps, a
+binding will result in efficient continuous updates whenever the result of the expression
+evaluation changes.

-  {@link guide/expression Angular expression} is a JavaScript-like code snippet that is
-  evaluated by Angular in the context of the current model scope, rather than within the scope of
-  the global context (`window`).
+{@link guide/expression Angular expression} is a JavaScript-like code snippet that is
+evaluated by Angular in the context of the current model scope, rather than within the scope of
+the global context (`window`).

-  As expected, once this template is processed by Angular, the html page contains the text:
-  "Nothing here yet!".
+As expected, once this template is processed by Angular, the html page contains the text:
+"Nothing here yet!".

 ## Bootstrapping AngularJS apps

@@ -11,7 +11,7 @@ multiple views by adding routing, using an Angular module called 'ngRoute'.

 * When you now navigate to `app/index.html`, you are redirected to `app/index.html/#/phones`
  and the phone list appears in the browser.
-* When you click on a phone link the url changes to one specific to that phone and the stub of a
+* When you click on a phone link, the url changes to that specific phone and the stub of a
  phone detail page is displayed.

 <div doc-tutorial-reset="7"></div>
@@ -225,7 +225,7 @@ inserted into and removed from the list:
  * The `ng-leave` class is applied when they're removed from the list.

 The phone listing items are added and removed depending on the data passed to the `ng-repeat` attribute.
-For example, if the filter data changes the items will be animated in and out of the repeat list.
+For example, if the filter data changes, the items will be animated in and out of the repeat list.

 Something important to note is that when an animation occurs, two sets of CSS classes
 are added to the element:
@@ -233,7 +233,7 @@ are added to the element:
  1. a "starting" class that represents the style at the beginning of the animation
  2. an "active" class that represents the style at the end of the animation

-The name of the starting class is the name of event that is fired (like `enter`, `move` or `leave`) prefixed with
+The name of the starting class is the name of the event that is fired (like `enter`, `move` or `leave`) prefixed with
 `ng-`. So an `enter` event will result in a class called `ng-enter`.

 The active class name is the same as the starting class's but with an `-active` suffix.
@@ -184,6 +184,8 @@ describe("extractDateTimeSymbols", function() {
                      'nov.', 'déc.'],
                  DAY: ['dimanche', 'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi'],
                  SHORTDAY: ['dim.', 'lun.', 'mar.', 'mer.', 'jeu.', 'ven.', 'sam.'],
+                  FIRSTDAYOFWEEK: 6,
+                  WEEKENDRANGE: [5, 6],
                  AMPMS: ['AM', 'PM'],
                  ERAS: ['av. J.-C.', 'ap. J.-C.'],
                  ERANAMES: ['avant Jésus-Christ', 'après Jésus-Christ'],
@@ -42,6 +42,8 @@ function convertDatetimeData(dataObj) {
  datetimeFormats.DAY = dataObj.WEEKDAYS;
  datetimeFormats.SHORTDAY = dataObj.SHORTWEEKDAYS;
  datetimeFormats.AMPMS = dataObj.AMPMS;
+  datetimeFormats.FIRSTDAYOFWEEK = dataObj.FIRSTDAYOFWEEK;
+  datetimeFormats.WEEKENDRANGE = dataObj.WEEKENDRANGE;
  datetimeFormats.ERAS = dataObj.ERAS;
  datetimeFormats.ERANAMES = dataObj.ERANAMES;

@@ -185,14 +185,16 @@ module.exports = {
    var mapFileName = mapFile.match(/[^\/]+$/)[0];
    var errorFileName = file.replace(/\.js$/, '-errors.json');
    var versionNumber = grunt.config('NG_VERSION').full;
+    var compilationLevel = (file === 'build/angular-message-format.js') ?
+        'ADVANCED_OPTIMIZATIONS' : 'SIMPLE_OPTIMIZATIONS';
    shell.exec(
        'java ' +
            this.java32flags() + ' ' +
-            '-Xmx2g ' +
+            this.memoryRequirement() + ' ' +
            '-cp bower_components/closure-compiler/compiler.jar' + classPathSep +
            'bower_components/ng-closure-runner/ngcompiler.jar ' +
            'org.angularjs.closurerunner.NgClosureRunner ' +
-            '--compilation_level SIMPLE_OPTIMIZATIONS ' +
+            '--compilation_level ' + compilationLevel + ' ' +
            '--language_in ECMASCRIPT5_STRICT ' +
            '--minerr_pass ' +
            '--minerr_errors ' + errorFileName + ' ' +
@@ -215,6 +217,10 @@ module.exports = {
    }.bind(this));
  },

+  memoryRequirement: function() {
+    return (process.platform === 'win32') ? '' : '-Xmx2g';
+  },
+

  //returns the 32-bit mode force flags for java compiler if supported, this makes the build much faster
  java32flags: function(){
@@ -16,9 +16,9 @@ var currentPackage, previousVersions, cdnVersion, gitRepoInfo;
 var getPackage = function() {
  // Search up the folder hierarchy for the first package.json
  var packageFolder = path.resolve('.');
-  while ( !fs.existsSync(path.join(packageFolder, 'package.json')) ) {
+  while (!fs.existsSync(path.join(packageFolder, 'package.json'))) {
    var parent = path.dirname(packageFolder);
-    if ( parent === packageFolder) { break; }
+    if (parent === packageFolder) { break; }
    packageFolder = parent;
  }
  return JSON.parse(fs.readFileSync(path.join(packageFolder,'package.json'), 'UTF-8'));
@@ -48,11 +48,11 @@ var getGitRepoInfo = function() {
 * @return {String}         The codename if found, otherwise null/undefined
 */
 var getCodeName = function(tagName) {
-  var gitCatOutput = shell.exec('git cat-file -p '+ tagName, {silent:true}).output;
+  var gitCatOutput = shell.exec('git cat-file -p ' + tagName, {silent:true}).output;
  var tagMessage = gitCatOutput.match(/^.*codename.*$/mg)[0];
  var codeName = tagMessage && tagMessage.match(/codename\((.*)\)/)[1];
  if (!codeName) {
-    throw new Error("Could not extract release code name. The message of tag "+tagName+
+    throw new Error("Could not extract release code name. The message of tag " + tagName +
      " must match '*codename(some release name)*'");
  }
  return codeName;
@@ -65,7 +65,7 @@ var getCodeName = function(tagName) {
 */
 function getBuild() {
  var hash = shell.exec('git rev-parse --short HEAD', {silent: true}).output.replace('\n', '');
-  return 'sha.'+hash;
+  return 'sha.' + hash;
 }


@@ -76,14 +76,14 @@ function getBuild() {
 var getTaggedVersion = function() {
  var gitTagResult = shell.exec('git describe --exact-match', {silent:true});

-  if ( gitTagResult.code === 0 ) {
+  if (gitTagResult.code === 0) {
    var tag = gitTagResult.output.trim();
    var version = semver.parse(tag);

-    if ( version && semver.satisfies(version, currentPackage.branchVersion)) {
+    if (version && semver.satisfies(version, currentPackage.branchVersion)) {
      version.codeName = getCodeName(tag);
      version.full = version.version;
-      version.branch = 'v' + currentPackage.branchVersion.replace('*', 'x');
+      version.branch = 'v' + currentPackage.branchPattern.replace('*', 'x');
      return version;
    }
  }
@@ -102,7 +102,7 @@ var getPreviousVersions =  function() {
  var repo_url = currentPackage.repository.url;
  var tagResults = shell.exec('git ls-remote --tags ' + repo_url,
                              {silent: true});
-  if ( tagResults.code === 0 ) {
+  if (tagResults.code === 0) {
    return _(tagResults.output.match(/v[0-9].*[0-9]$/mg))
      .map(function(tag) {
        var version = semver.parse(tag);
@@ -110,10 +110,16 @@ var getPreviousVersions =  function() {
      })
      .filter()
      .map(function(version) {
+        // angular.js didn't follow semantic version until 1.20rc1
+        if ((version.major === 1 && version.minor === 0 && version.prerelease.length > 0) || (version.major === 1 && version.minor === 2 && version.prerelease[0] === 'rc1')) {
+          version.version = [version.major, version.minor, version.patch].join('.') + version.prerelease.join('');
+          version.raw = 'v' + version.version;
+        }
        version.docsUrl = 'http://code.angularjs.org/' + version.version + '/docs';
        // Versions before 1.0.2 had a different docs folder name
-        if ( version.major < 1 || (version.major === 1 && version.minor === 0 && version.dot < 2 ) ) {
+        if (version.major < 1 || (version.major === 1 && version.minor === 0 && version.patch < 2)) {
          version.docsUrl += '-' + version.version;
+          version.isOldDocsUrl = true;
        }
        return version;
      })
@@ -134,10 +140,10 @@ var getCdnVersion = function() {
      if (!cdnVersion) {
        // Note: need to use shell.exec and curl here
        // as version-infos returns its result synchronously...
-        var cdnResult = shell.exec('curl http://ajax.googleapis.com/ajax/libs/angularjs/'+version+'/angular.min.js '+
+        var cdnResult = shell.exec('curl http://ajax.googleapis.com/ajax/libs/angularjs/' + version + '/angular.min.js ' +
                  '--head --write-out "%{http_code}" -o /dev/null -silent',
                                    {silent: true});
-        if ( cdnResult.code === 0 ) {
+        if (cdnResult.code === 0) {
          var statusCode = cdnResult.output.trim();
          if (statusCode === '200') {
            cdnVersion = version;
@@ -159,9 +165,9 @@ var getSnapshotVersion = function() {
    })
    .last();

-  if ( !version ) {
+  if (!version) {
    // a snapshot version before the first tag on the branch
-    version = semver(currentPackage.branchVersion.replace('*','0-beta.1'));
+    version = semver(currentPackage.branchPattern.replace('*','0-beta.1'));
  }

  // We need to clone to ensure that we are not modifying another version
@@ -207,7 +207,7 @@
          "dependencies": {
            "traceur": {
              "version": "0.0.33",
-              "resolved": "git+https://github.com/vojtajina/traceur-compiler#d90b1e34c799bf61cd1aafdc33db0a554fa9e617",
+              "resolved": "git://github.com/vojtajina/traceur-compiler.git#d90b1e34c799bf61cd1aafdc33db0a554fa9e617",
              "dependencies": {
                "commander": {
                  "version": "2.7.1",
@@ -2385,10 +2385,10 @@
      }
    },
    "dgeni-packages": {
-      "version": "0.10.13",
+      "version": "0.10.17",
      "dependencies": {
        "catharsis": {
-          "version": "0.8.6",
+          "version": "0.8.7",
          "dependencies": {
            "underscore-contrib": {
              "version": "0.3.0",
@@ -2404,10 +2404,10 @@
          "version": "2.3.0",
          "dependencies": {
            "camel-case": {
-              "version": "1.1.1"
+              "version": "1.1.2"
            },
            "constant-case": {
-              "version": "1.1.0"
+              "version": "1.1.1"
            },
            "dot-case": {
              "version": "1.1.1"
@@ -2428,7 +2428,7 @@
              "version": "1.1.1"
            },
            "pascal-case": {
-              "version": "1.1.0"
+              "version": "1.1.1"
            },
            "path-case": {
              "version": "1.1.1"
@@ -2440,10 +2440,10 @@
              "version": "1.1.1"
            },
            "swap-case": {
-              "version": "1.1.0"
+              "version": "1.1.1"
            },
            "title-case": {
-              "version": "1.1.0"
+              "version": "1.1.1"
            },
            "upper-case": {
              "version": "1.1.2"
@@ -2468,7 +2468,7 @@
          }
        },
        "htmlparser2": {
-          "version": "3.8.2",
+          "version": "3.8.3",
          "dependencies": {
            "domhandler": {
              "version": "2.3.0"
@@ -2518,21 +2518,21 @@
          "version": "0.3.0",
          "dependencies": {
            "lru-cache": {
-              "version": "2.5.0"
+              "version": "2.6.4"
            },
            "sigmund": {
-              "version": "1.0.0"
+              "version": "1.0.1"
            }
          }
        },
        "nunjucks": {
-          "version": "1.2.0",
+          "version": "1.3.4",
          "dependencies": {
            "optimist": {
              "version": "0.6.1",
              "dependencies": {
                "wordwrap": {
-                  "version": "0.0.2"
+                  "version": "0.0.3"
                },
                "minimist": {
                  "version": "0.0.10"
@@ -2552,10 +2552,10 @@
                      "version": "0.2.14",
                      "dependencies": {
                        "lru-cache": {
-                          "version": "2.5.0"
+                          "version": "2.6.4"
                        },
                        "sigmund": {
-                          "version": "1.0.0"
+                          "version": "1.0.1"
                        }
                      }
                    },
@@ -2582,10 +2582,10 @@
                  "version": "0.1.6"
                },
                "fsevents": {
-                  "version": "0.3.5",
+                  "version": "0.3.6",
                  "dependencies": {
                    "nan": {
-                      "version": "1.5.3"
+                      "version": "1.8.4"
                    }
                  }
                }
@@ -2621,6 +2621,12 @@
            }
          }
        },
+        "semver": {
+          "version": "4.3.6"
+        },
+        "shelljs": {
+          "version": "0.5.1"
+        },
        "winston": {
          "version": "0.7.3",
          "dependencies": {
@@ -6499,7 +6505,7 @@
      }
    },
    "protractor": {
-      "version": "2.0.0",
+      "version": "2.1.0",
      "dependencies": {
        "request": {
          "version": "2.36.0",
@@ -6508,7 +6514,7 @@
              "version": "0.6.6"
            },
            "json-stringify-safe": {
-              "version": "5.0.0"
+              "version": "5.0.1"
            },
            "mime": {
              "version": "1.2.11"
@@ -6520,12 +6526,7 @@
              "version": "1.4.3"
            },
            "tough-cookie": {
-              "version": "0.12.1",
-              "dependencies": {
-                "punycode": {
-                  "version": "1.3.2"
-                }
-              }
+              "version": "1.1.0"
            },
            "form-data": {
              "version": "0.1.4",
@@ -6539,7 +6540,7 @@
                  }
                },
                "async": {
-                  "version": "0.9.0"
+                  "version": "0.9.2"
                }
              }
            },
@@ -6589,7 +6590,7 @@
          "version": "2.45.1",
          "dependencies": {
            "rimraf": {
-              "version": "2.3.2",
+              "version": "2.3.4",
              "dependencies": {
                "glob": {
                  "version": "4.5.3",
@@ -6606,7 +6607,7 @@
                      "version": "2.0.1"
                    },
                    "minimatch": {
-                      "version": "2.0.4",
+                      "version": "2.0.8",
                      "dependencies": {
                        "brace-expansion": {
                          "version": "1.1.0",
@@ -6622,7 +6623,7 @@
                      }
                    },
                    "once": {
-                      "version": "1.3.1",
+                      "version": "1.3.2",
                      "dependencies": {
                        "wrappy": {
                          "version": "1.0.1"
@@ -6637,7 +6638,7 @@
              "version": "0.0.24"
            },
            "ws": {
-              "version": "0.7.1",
+              "version": "0.7.2",
              "dependencies": {
                "options": {
                  "version": "0.0.6"
@@ -6646,24 +6647,24 @@
                  "version": "1.0.1"
                },
                "bufferutil": {
-                  "version": "1.0.1",
+                  "version": "1.1.0",
                  "dependencies": {
                    "bindings": {
                      "version": "1.2.1"
                    },
                    "nan": {
-                      "version": "1.6.2"
+                      "version": "1.8.4"
                    }
                  }
                },
                "utf-8-validate": {
-                  "version": "1.0.1",
+                  "version": "1.1.0",
                  "dependencies": {
                    "bindings": {
                      "version": "1.2.1"
                    },
                    "nan": {
-                      "version": "1.6.2"
+                      "version": "1.8.4"
                    }
                  }
                }
@@ -6694,13 +6695,16 @@
          "version": "1.1.0"
        },
        "jasminewd2": {
-          "version": "0.0.3"
+          "version": "0.0.5"
        },
        "jasmine": {
-          "version": "2.1.1",
+          "version": "2.3.1",
          "dependencies": {
+            "exit": {
+              "version": "0.1.2"
+            },
            "jasmine-core": {
-              "version": "2.1.3"
+              "version": "2.3.4"
            }
          }
        },
@@ -6717,10 +6721,10 @@
              "version": "0.3.0",
              "dependencies": {
                "lru-cache": {
-                  "version": "2.5.0"
+                  "version": "2.6.4"
                },
                "sigmund": {
-                  "version": "1.0.0"
+                  "version": "1.0.1"
                }
              }
            }
@@ -6733,7 +6737,7 @@
          "version": "0.6.1",
          "dependencies": {
            "wordwrap": {
-              "version": "0.0.2"
+              "version": "0.0.3"
            },
            "minimist": {
              "version": "0.0.10"
@@ -1,6 +1,8 @@
 {
  "name": "angularjs",
-  "branchVersion": "1.3.*",
+  "license": "MIT",
+  "branchVersion": "^1.4.0-beta.0",
+  "branchPattern": "1.4.*",
  "repository": {
    "type": "git",
    "url": "https://github.com/angular/angular.js.git"
@@ -57,7 +59,7 @@
    "marked": "~0.3.0",
    "node-html-encoder": "0.0.2",
    "promises-aplus-tests": "~2.1.0",
-    "protractor": "^2.0.0",
+    "protractor": "^2.1.0",
    "q": "~1.0.0",
    "q-io": "^1.10.9",
    "qq": "^0.3.5",
@@ -17,7 +17,7 @@ ARG_DEFS=(
 )

 function checkVersionNumber() {
-  BRANCH_PATTERN=$(readJsonProp "package.json" "branchVersion")
+  BRANCH_PATTERN=$(readJsonProp "package.json" "branchPattern")
  if [[ $VERSION_NUMBER != $BRANCH_PATTERN ]]; then
    echo "version-number needs to match $BRANCH_PATTERN on this branch"
    usage
@@ -14,21 +14,6 @@ function init {
  TMP_DIR=$(resolveDir ../../tmp)
  BUILD_DIR=$(resolveDir ../../build)
  NEW_VERSION=$(cat $BUILD_DIR/version.txt)
-  REPOS=(
-    angular
-    angular-animate
-    angular-aria
-    angular-cookies
-    angular-i18n
-    angular-loader
-    angular-mocks
-    angular-route
-    angular-resource
-    angular-sanitize
-    angular-scenario
-    angular-touch
-    angular-messages
-  )
 }


@@ -129,4 +114,5 @@ function publish {
  done
 }

+source $(dirname $0)/repos.inc
 source $(dirname $0)/../utils.inc
@@ -0,0 +1,19 @@
+#!/bin/false
+# -*- mode: sh; -*- vim: set filetype=sh:
+
+REPOS=(
+  angular
+  angular-animate
+  angular-aria
+  angular-cookies
+  angular-i18n
+  angular-loader
+  angular-message-format
+  angular-messages
+  angular-mocks
+  angular-resource
+  angular-route
+  angular-sanitize
+  angular-scenario
+  angular-touch
+)
@@ -13,21 +13,6 @@ ARG_DEFS=(

 function init {
  TMP_DIR=$(resolveDir ../../tmp)
-  REPOS=(
-    angular
-    angular-animate
-    angular-aria
-    angular-cookies
-    angular-i18n
-    angular-loader
-    angular-messages
-    angular-mocks
-    angular-route
-    angular-resource
-    angular-sanitize
-    angular-scenario
-    angular-touch
-  )
 }

 function prepare {
@@ -53,4 +38,5 @@ function publish {
  done
 }

+source $(dirname $0)/repos.inc
 source $(dirname $0)/../utils.inc
@@ -23,22 +23,26 @@ function init {
 }

 function prepare {
-  if [[  $IS_SNAPSHOT_BUILD ]]; then
-    # nothing to prepare for snapshot builds as
-    # code.angularjs.org will fetch the current snapshot from
-    # the build server during publish
-    exit 0
-  fi

  echo "-- Cloning code.angularjs.org"
-  git clone git@github.com:angular/code.angularjs.org.git $REPO_DIR
+  git clone git@github.com:angular/code.angularjs.org.git $REPO_DIR --depth=1

-  #
-  # copy the files from the build
-  #
  echo "-- Updating code.angularjs.org"
-  mkdir $REPO_DIR/$NEW_VERSION
-  cp -r $BUILD_DIR/* $REPO_DIR/$NEW_VERSION/
+
+  if [[  $IS_SNAPSHOT_BUILD ]]; then
+    #
+    # update the snapshot folder
+    #
+    rm -rf $REPO_DIR/snapshot
+    mkdir $REPO_DIR/snapshot
+    cp -r $BUILD_DIR/* $REPO_DIR/snapshot/
+  else
+    #
+    # copy the files from the build
+    #
+    mkdir $REPO_DIR/$NEW_VERSION
+    cp -r $BUILD_DIR/* $REPO_DIR/$NEW_VERSION/
+  fi

  #
  # commit
@@ -50,13 +54,6 @@ function prepare {
 }


-function _update_snapshot() {
-  for backend in "$@" ; do
-    echo "-- Updating snapshot version: backend=$backend"
-    curl -G --data-urlencode "ver=$NEW_VERSION" http://$backend:8003/fetchLatestSnapshot.php
-  done
-}
-
 function _update_code() {
  cd $REPO_DIR

@@ -74,12 +71,7 @@ function publish {
  # the currently serving Compute Engine backends.
  # code.angularjs.org is served out of port 8003 on these backends.
  backends=("$(dig backends.angularjs.org +short TXT | python -c 'print raw_input()[1:-1].replace(",", "\n")')")
-
-  if [[  $IS_SNAPSHOT_BUILD ]]; then
-    _update_snapshot ${backends[@]}
-  else
-    _update_code ${backends[@]}
-  fi
+  _update_code ${backends[@]}
 }

 source $(dirname $0)/../utils.inc
@@ -28,14 +28,14 @@
    "manualUppercase": false,
    "isArrayLike": false,
    "forEach": false,
-    "sortedKeys": false,
    "forEachSorted": false,
    "reverseParams": false,
    "nextUid": false,
    "setHashKey": false,
    "extend": false,
-    "int": false,
+    "toInt": false,
    "inherit": false,
+    "merge": false,
    "noop": false,
    "identity": false,
    "valueFn": false,
@@ -55,6 +55,7 @@
    "isBlob": false,
    "isBoolean": false,
    "isPromiseLike": false,
+    "hasCustomToString": false,
    "trim": false,
    "escapeForRegexp": false,
    "isElement": false,
@@ -71,6 +72,8 @@
    "toJsonReplacer": false,
    "toJson": false,
    "fromJson": false,
+    "convertTimezoneToLocal": false,
+    "timezoneToOffset": false,
    "startingTag": false,
    "tryDecodeURIComponent": false,
    "parseKeyValue": false,
@@ -154,6 +157,9 @@
    "urlResolve": false,
    "urlIsSameOrigin": false,

+    /* ng/controller.js */
+    "identifierForController": false,
+
    /* ng/compile.js */
    "directiveNormalize": false,

@@ -22,20 +22,21 @@
  nodeName_: true,
  isArrayLike: true,
  forEach: true,
-  sortedKeys: true,
  forEachSorted: true,
  reverseParams: true,
  nextUid: true,
  setHashKey: true,
  extend: true,
-  int: true,
+  toInt: true,
  inherit: true,
+  merge: true,
  noop: true,
  identity: true,
  valueFn: true,
  isUndefined: true,
  isDefined: true,
  isObject: true,
+  isBlankObject: true,
  isString: true,
  isNumber: true,
  isDate: true,
@@ -59,12 +60,15 @@
  shallowCopy: true,
  equals: true,
  csp: true,
+  jq: true,
  concat: true,
  sliceArgs: true,
  bind: true,
  toJsonReplacer: true,
  toJson: true,
  fromJson: true,
+  convertTimezoneToLocal: true,
+  timezoneToOffset: true,
  startingTag: true,
  tryDecodeURIComponent: true,
  parseKeyValue: true,
@@ -172,6 +176,7 @@ var
    splice            = [].splice,
    push              = [].push,
    toString          = Object.prototype.toString,
+    getPrototypeOf    = Object.getPrototypeOf,
    ngMinErr          = minErr('ng'),

    /** @name angular */
@@ -264,23 +269,32 @@ function forEach(obj, iterator, context) {
      }
    } else if (obj.forEach && obj.forEach !== forEach) {
        obj.forEach(iterator, context, obj);
-    } else {
+    } else if (isBlankObject(obj)) {
+      // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
+      for (key in obj) {
+        iterator.call(context, obj[key], key, obj);
+      }
+    } else if (typeof obj.hasOwnProperty === 'function') {
+      // Slow path for objects inheriting Object.prototype, hasOwnProperty check needed
      for (key in obj) {
        if (obj.hasOwnProperty(key)) {
          iterator.call(context, obj[key], key, obj);
        }
      }
+    } else {
+      // Slow path for objects which do not have a method `hasOwnProperty`
+      for (key in obj) {
+        if (hasOwnProperty.call(obj, key)) {
+          iterator.call(context, obj[key], key, obj);
+        }
+      }
    }
  }
  return obj;
 }

-function sortedKeys(obj) {
-  return Object.keys(obj).sort();
-}
-
 function forEachSorted(obj, iterator, context) {
-  var keys = sortedKeys(obj);
+  var keys = Object.keys(obj).sort();
  for (var i = 0; i < keys.length; i++) {
    iterator.call(context, obj[keys[i]], keys[i]);
  }
@@ -325,6 +339,35 @@ function setHashKey(obj, h) {
  }
 }

+
+function baseExtend(dst, objs, deep) {
+  var h = dst.$$hashKey;
+
+  for (var i = 0, ii = objs.length; i < ii; ++i) {
+    var obj = objs[i];
+    if (!isObject(obj) && !isFunction(obj)) continue;
+    var keys = Object.keys(obj);
+    for (var j = 0, jj = keys.length; j < jj; j++) {
+      var key = keys[j];
+      var src = obj[key];
+
+      if (deep && isObject(src)) {
+        if (isDate(src)) {
+          dst[key] = new Date(src.valueOf());
+        } else {
+          if (!isObject(dst[key])) dst[key] = isArray(src) ? [] : {};
+          baseExtend(dst[key], [src], true);
+        }
+      } else {
+        dst[key] = src;
+      }
+    }
+  }
+
+  setHashKey(dst, h);
+  return dst;
+}
+
 /**
 * @ngdoc function
 * @name angular.extend
@@ -335,31 +378,44 @@ function setHashKey(obj, h) {
 * Extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
 * 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).
+ *
+ * **Note:** Keep in mind that `angular.extend` does not support recursive merge (deep copy). Use
+ * {@link angular.merge} for this.
 *
 * @param {Object} dst Destination object.
 * @param {...Object} src Source object(s).
 * @returns {Object} Reference to `dst`.
 */
 function extend(dst) {
-  var h = dst.$$hashKey;
-
-  for (var i = 1, ii = arguments.length; i < ii; i++) {
-    var obj = arguments[i];
-    if (obj) {
-      var keys = Object.keys(obj);
-      for (var j = 0, jj = keys.length; j < jj; j++) {
-        var key = keys[j];
-        dst[key] = obj[key];
-      }
-    }
-  }
-
-  setHashKey(dst, h);
-  return dst;
+  return baseExtend(dst, slice.call(arguments, 1), false);
 }

-function int(str) {
+
+/**
+* @ngdoc function
+* @name angular.merge
+* @module ng
+* @kind function
+*
+* @description
+* Deeply extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
+* 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.merge({}, object1, object2)`.
+*
+* Unlike {@link angular.extend extend()}, `merge()` recursively descends into object properties of source
+* objects, performing a deep copy.
+*
+* @param {Object} dst Destination object.
+* @param {...Object} src Source object(s).
+* @returns {Object} Reference to `dst`.
+*/
+function merge(dst) {
+  return baseExtend(dst, slice.call(arguments, 1), true);
+}
+
+
+
+function toInt(str) {
  return parseInt(str, 10);
 }

@@ -412,6 +468,11 @@ identity.$inject = [];

 function valueFn(value) {return function() {return value;};}

+function hasCustomToString(obj) {
+  return isFunction(obj.toString) && obj.toString !== Object.prototype.toString;
+}
+
+
 /**
 * @ngdoc function
 * @name angular.isUndefined
@@ -461,6 +522,16 @@ function isObject(value) {
 }


+/**
+ * Determine if a value is an object with a null prototype
+ *
+ * @returns {boolean} True if `value` is an `Object` with a null prototype
+ */
+function isBlankObject(value) {
+  return value !== null && typeof value === 'object' && !getPrototypeOf(value);
+}
+
+
 /**
 * @ngdoc function
 * @name angular.isString
@@ -597,6 +668,12 @@ function isPromiseLike(obj) {
 }


+var TYPED_ARRAY_REGEXP = /^\[object (Uint8(Clamped)?)|(Uint16)|(Uint32)|(Int8)|(Int16)|(Int32)|(Float(32)|(64))Array\]$/;
+function isTypedArray(value) {
+  return TYPED_ARRAY_REGEXP.test(toString.call(value));
+}
+
+
 var trim = function(value) {
  return isString(value) ? value.trim() : value;
 };
@@ -634,8 +711,9 @@ function isElement(node) {
 */
 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;
 }

@@ -650,9 +728,10 @@ function includes(array, obj) {

 function arrayRemove(array, value) {
  var index = array.indexOf(value);
-  if (index >= 0)
+  if (index >= 0) {
    array.splice(index, 1);
-  return value;
+  }
+  return index;
 }

 /**
@@ -718,20 +797,40 @@ function copy(source, destination, stackSource, stackDest) {
    throw ngMinErr('cpws',
      "Can't copy! Making copies of Window or Scope instances is not supported.");
  }
+  if (isTypedArray(destination)) {
+    throw ngMinErr('cpta',
+      "Can't copy! TypedArray destination cannot be mutated.");
+  }

  if (!destination) {
    destination = source;
-    if (source) {
+    if (isObject(source)) {
+      var index;
+      if (stackSource && (index = stackSource.indexOf(source)) !== -1) {
+        return stackDest[index];
+      }
+
+      // TypedArray, Date and RegExp have specific copy functionality and must be
+      // pushed onto the stack before returning.
+      // Array and other objects create the base object and recurse to copy child
+      // objects. The array/object will be pushed onto the stack when recursed.
      if (isArray(source)) {
-        destination = copy(source, [], stackSource, stackDest);
+        return copy(source, [], stackSource, stackDest);
+      } else if (isTypedArray(source)) {
+        destination = new source.constructor(source);
      } else if (isDate(source)) {
        destination = new Date(source.getTime());
      } else if (isRegExp(source)) {
        destination = new RegExp(source.source, source.toString().match(/[^\/]*$/)[0]);
        destination.lastIndex = source.lastIndex;
-      } else if (isObject(source)) {
-        var emptyObject = Object.create(Object.getPrototypeOf(source));
-        destination = copy(source, emptyObject, stackSource, stackDest);
+      } else {
+        var emptyObject = Object.create(getPrototypeOf(source));
+        return copy(source, emptyObject, stackSource, stackDest);
+      }
+
+      if (stackDest) {
+        stackSource.push(source);
+        stackDest.push(destination);
      }
    }
  } else {
@@ -742,23 +841,15 @@ function copy(source, destination, stackSource, stackDest) {
    stackDest = stackDest || [];

    if (isObject(source)) {
-      var index = stackSource.indexOf(source);
-      if (index !== -1) return stackDest[index];
-
      stackSource.push(source);
      stackDest.push(destination);
    }

-    var result;
+    var result, key;
    if (isArray(source)) {
      destination.length = 0;
      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);
-        }
-        destination.push(result);
+        destination.push(copy(source[i], null, stackSource, stackDest));
      }
    } else {
      var h = destination.$$hashKey;
@@ -769,19 +860,28 @@ function copy(source, destination, stackSource, stackDest) {
          delete destination[key];
        });
      }
-      for (var key in source) {
-        if (source.hasOwnProperty(key)) {
-          result = copy(source[key], null, stackSource, stackDest);
-          if (isObject(source[key])) {
-            stackSource.push(source[key]);
-            stackDest.push(result);
+      if (isBlankObject(source)) {
+        // createMap() fast path --- Safe to avoid hasOwnProperty check because prototype chain is empty
+        for (key in source) {
+          destination[key] = copy(source[key], null, stackSource, stackDest);
+        }
+      } else if (source && typeof source.hasOwnProperty === 'function') {
+        // Slow path, which must rely on hasOwnProperty
+        for (key in source) {
+          if (source.hasOwnProperty(key)) {
+            destination[key] = copy(source[key], null, stackSource, stackDest);
+          }
+        }
+      } else {
+        // Slowest path --- hasOwnProperty can't be called as a method
+        for (key in source) {
+          if (hasOwnProperty.call(source, key)) {
+            destination[key] = copy(source[key], null, stackSource, stackDest);
          }
-          destination[key] = result;
        }
      }
      setHashKey(destination,h);
    }
-
  }
  return destination;
 }
@@ -864,14 +964,14 @@ function equals(o1, o2) {
      } else {
        if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
          isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
-        keySet = {};
+        keySet = createMap();
        for (key in o1) {
          if (key.charAt(0) === '$' || isFunction(o1[key])) continue;
          if (!equals(o1[key], o2[key])) return false;
          keySet[key] = true;
        }
        for (key in o2) {
-          if (!keySet.hasOwnProperty(key) &&
+          if (!(key in keySet) &&
              key.charAt(0) !== '$' &&
              o2[key] !== undefined &&
              !isFunction(o2[key])) return false;
@@ -902,7 +1002,58 @@ var csp = function() {
  return (csp.isActive_ = active);
 };

+/**
+ * @ngdoc directive
+ * @module ng
+ * @name ngJq
+ *
+ * @element ANY
+ * @param {string=} ngJq the name of the library available under `window`
+ * to be used for angular.element
+ * @description
+ * Use this directive to force the angular.element library.  This should be
+ * used to force either jqLite by leaving ng-jq blank or setting the name of
+ * the jquery variable under window (eg. jQuery).
+ *
+ * Since angular looks for this directive when it is loaded (doesn't wait for the
+ * DOMContentLoaded event), it must be placed on an element that comes before the script
+ * which loads angular. Also, only the first instance of `ng-jq` will be used and all
+ * others ignored.
+ *
+ * @example
+ * This example shows how to force jqLite using the `ngJq` directive to the `html` tag.
+ ```html
+ <!doctype html>
+ <html ng-app ng-jq>
+ ...
+ ...
+ </html>
+ ```
+ * @example
+ * This example shows how to use a jQuery based library of a different name.
+ * The library name must be available at the top most 'window'.
+ ```html
+ <!doctype html>
+ <html ng-app ng-jq="jQueryLib">
+ ...
+ ...
+ </html>
+ ```
+ */
+var jq = function() {
+  if (isDefined(jq.name_)) return jq.name_;
+  var el;
+  var i, ii = ngAttrPrefixes.length, prefix, name;
+  for (i = 0; i < ii; ++i) {
+    prefix = ngAttrPrefixes[i];
+    if (el = document.querySelector('[' + prefix.replace(':', '\\:') + 'jq]')) {
+      name = el.getAttribute(prefix + 'jq');
+      break;
+    }
+  }

+  return (jq.name_ = name);
+};

 function concat(array1, array2, index) {
  return array1.concat(slice.call(array2, index));
@@ -1013,6 +1164,26 @@ function fromJson(json) {
 }


+function timezoneToOffset(timezone, fallback) {
+  var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
+  return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
+}
+
+
+function addDateMinutes(date, minutes) {
+  date = new Date(date.getTime());
+  date.setMinutes(date.getMinutes() + minutes);
+  return date;
+}
+
+
+function convertTimezoneToLocal(date, timezone, reverse) {
+  reverse = reverse ? -1 : 1;
+  var timezoneOffset = timezoneToOffset(timezone, date.getTimezoneOffset());
+  return addDateMinutes(date, reverse * (timezoneOffset - date.getTimezoneOffset()));
+}
+
+
 /**
 * @returns {string} Returns the string representation of the element.
 */
@@ -1141,10 +1312,9 @@ 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) {
    attr = ngAttrPrefixes[i] + ngAttr;
-    if (isString(attr = element.attr(attr))) {
+    if (isString(attr = element.getAttribute(attr))) {
      return attr;
    }
  }
@@ -1475,7 +1645,12 @@ function bindJQuery() {
  }

  // bind to jQuery if present;
-  jQuery = window.jQuery;
+  var jqName = jq();
+  jQuery = window.jQuery; // use default jQuery.
+  if (isDefined(jqName)) { // `ngJq` present
+    jQuery = jqName === null ? undefined : window[jqName]; // if empty; use jqLite. if not empty, use jQuery specified by `ngJq`.
+  }
+
  // Use jQuery if it exists with proper functionality, otherwise default to us.
  // Angular 1.2+ requires jQuery 1.7+ for on()/off() support.
  // Angular 1.3+ technically requires at least jQuery 2.1+ but it may work with older
@@ -57,6 +57,8 @@

  $AnchorScrollProvider,
  $AnimateProvider,
+  $$CoreAnimateQueueProvider,
+  $$CoreAnimateRunnerProvider,
  $BrowserProvider,
  $CacheFactoryProvider,
  $ControllerProvider,
@@ -65,7 +67,10 @@
  $FilterProvider,
  $InterpolateProvider,
  $IntervalProvider,
+  $$HashMapProvider,
  $HttpProvider,
+  $HttpParamSerializerProvider,
+  $HttpParamSerializerJQLikeProvider,
  $HttpBackendProvider,
  $LocationProvider,
  $LogProvider,
@@ -84,7 +89,8 @@
  $$RAFProvider,
  $$AsyncCallbackProvider,
  $WindowProvider,
-  $$jqLiteProvider
+  $$jqLiteProvider,
+  $$CookieReaderProvider
 */


@@ -116,6 +122,7 @@ function publishExternalAPI(angular) {
    'bootstrap': bootstrap,
    'copy': copy,
    'extend': extend,
+    'merge': merge,
    'equals': equals,
    'element': jqLite,
    'forEach': forEach,
@@ -212,6 +219,8 @@ function publishExternalAPI(angular) {
      $provide.provider({
        $anchorScroll: $AnchorScrollProvider,
        $animate: $AnimateProvider,
+        $$animateQueue: $$CoreAnimateQueueProvider,
+        $$AnimateRunner: $$CoreAnimateRunnerProvider,
        $browser: $BrowserProvider,
        $cacheFactory: $CacheFactoryProvider,
        $controller: $ControllerProvider,
@@ -221,6 +230,8 @@ function publishExternalAPI(angular) {
        $interpolate: $InterpolateProvider,
        $interval: $IntervalProvider,
        $http: $HttpProvider,
+        $httpParamSerializer: $HttpParamSerializerProvider,
+        $httpParamSerializerJQLike: $HttpParamSerializerJQLikeProvider,
        $httpBackend: $HttpBackendProvider,
        $location: $LocationProvider,
        $log: $LogProvider,
@@ -238,7 +249,9 @@ function publishExternalAPI(angular) {
        $window: $WindowProvider,
        $$rAF: $$RAFProvider,
        $$asyncCallback: $$AsyncCallbackProvider,
-        $$jqLite: $$jqLiteProvider
+        $$jqLite: $$jqLiteProvider,
+        $$HashMap: $$HashMapProvider,
+        $$cookieReader: $$CookieReaderProvider
      });
    }
  ]);
@@ -1,6 +1,6 @@
 /**
 * @license AngularJS v"NG_VERSION_FULL"
- * (c) 2010-2014 Google, Inc. http://angularjs.org
+ * (c) 2010-2015 Google, Inc. http://angularjs.org
 * License: MIT
 */
 (function(window, document, undefined) {
@@ -73,3 +73,9 @@ HashMap.prototype = {
    return value;
  }
 };
+
+var $$HashMapProvider = [function() {
+  this.$get = [function() {
+    return HashMap;
+  }];
+}];
@@ -645,7 +645,7 @@ function createInjector(modulesToLoad, strictDi) {
          }));


-  forEach(loadModules(modulesToLoad), function(fn) { instanceInjector.invoke(fn || noop); });
+  forEach(loadModules(modulesToLoad), function(fn) { if (fn) instanceInjector.invoke(fn); });

  return instanceInjector;

@@ -182,6 +182,13 @@ function jqLiteAcceptsData(node) {
  return nodeType === NODE_TYPE_ELEMENT || !nodeType || nodeType === NODE_TYPE_DOCUMENT;
 }

+function jqLiteHasData(node) {
+  for (var key in jqCache[node.ng339]) {
+    return true;
+  }
+  return false;
+}
+
 function jqLiteBuildFragment(html, context) {
  var tmp, tag, wrap,
      fragment = context.createDocumentFragment(),
@@ -556,7 +563,8 @@ function getAliasedAttrName(element, name) {

 forEach({
  data: jqLiteData,
-  removeData: jqLiteRemoveData
+  removeData: jqLiteRemoveData,
+  hasData: jqLiteHasData
 }, function(fn, name) {
  JQLite[name] = fn;
 });
@@ -866,8 +874,9 @@ forEach({
  children: function(element) {
    var children = [];
    forEach(element.childNodes, function(element) {
-      if (element.nodeType === NODE_TYPE_ELEMENT)
+      if (element.nodeType === NODE_TYPE_ELEMENT) {
        children.push(element);
+      }
    });
    return children;
  },
@@ -146,7 +146,7 @@ function setupModuleLoader(window) {
           * @description
           * See {@link auto.$provide#provider $provide.provider()}.
           */
-          provider: invokeLater('$provide', 'provider'),
+          provider: invokeLaterAndSetModuleName('$provide', 'provider'),

          /**
           * @ngdoc method
@@ -157,7 +157,7 @@ function setupModuleLoader(window) {
           * @description
           * See {@link auto.$provide#factory $provide.factory()}.
           */
-          factory: invokeLater('$provide', 'factory'),
+          factory: invokeLaterAndSetModuleName('$provide', 'factory'),

          /**
           * @ngdoc method
@@ -168,7 +168,7 @@ function setupModuleLoader(window) {
           * @description
           * See {@link auto.$provide#service $provide.service()}.
           */
-          service: invokeLater('$provide', 'service'),
+          service: invokeLaterAndSetModuleName('$provide', 'service'),

          /**
           * @ngdoc method
@@ -193,6 +193,18 @@ function setupModuleLoader(window) {
           */
          constant: invokeLater('$provide', 'constant', 'unshift'),

+           /**
+           * @ngdoc method
+           * @name angular.Module#decorator
+           * @module ng
+           * @param {string} The name of the service to decorate.
+           * @param {Function} This function will be invoked when the service needs to be
+           *                                    instantiated and should return the decorated service instance.
+           * @description
+           * See {@link auto.$provide#decorator $provide.decorator()}.
+           */
+          decorator: invokeLaterAndSetModuleName('$provide', 'decorator'),
+
          /**
           * @ngdoc method
           * @name angular.Module#animation
@@ -206,7 +218,7 @@ function setupModuleLoader(window) {
           *
           *
           * Defines an animation hook that can be later used with
-           * {@link ngAnimate.$animate $animate} service and directives that use this service.
+           * {@link $animate $animate} service and directives that use this service.
           *
           * ```js
           * module.animation('.animation-name', function($inject1, $inject2) {
@@ -225,7 +237,7 @@ function setupModuleLoader(window) {
           * See {@link ng.$animateProvider#register $animateProvider.register()} and
           * {@link ngAnimate ngAnimate module} for more information.
           */
-          animation: invokeLater('$animateProvider', 'register'),
+          animation: invokeLaterAndSetModuleName('$animateProvider', 'register'),

          /**
           * @ngdoc method
@@ -243,7 +255,7 @@ function setupModuleLoader(window) {
           * (`myapp_subsection_filterx`).
           * </div>
           */
-          filter: invokeLater('$filterProvider', 'register'),
+          filter: invokeLaterAndSetModuleName('$filterProvider', 'register'),

          /**
           * @ngdoc method
@@ -255,7 +267,7 @@ function setupModuleLoader(window) {
           * @description
           * See {@link ng.$controllerProvider#register $controllerProvider.register()}.
           */
-          controller: invokeLater('$controllerProvider', 'register'),
+          controller: invokeLaterAndSetModuleName('$controllerProvider', 'register'),

          /**
           * @ngdoc method
@@ -268,7 +280,7 @@ function setupModuleLoader(window) {
           * @description
           * See {@link ng.$compileProvider#directive $compileProvider.directive()}.
           */
-          directive: invokeLater('$compileProvider', 'directive'),
+          directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),

          /**
           * @ngdoc method
@@ -318,6 +330,19 @@ function setupModuleLoader(window) {
            return moduleInstance;
          };
        }
+
+        /**
+         * @param {string} provider
+         * @param {string} method
+         * @returns {angular.Module}
+         */
+        function invokeLaterAndSetModuleName(provider, method) {
+          return function(recipeName, factoryFunction) {
+            if (factoryFunction && isFunction(factoryFunction)) factoryFunction.$$moduleName = name;
+            invokeQueue.push([provider, method, arguments]);
+            return moduleInstance;
+          };
+        }
      });
    };
  });
@@ -1,6 +1,6 @@
 /**
 * @license AngularJS v"NG_VERSION_FULL"
- * (c) 2010-2014 Google, Inc. http://angularjs.org
+ * (c) 2010-2015 Google, Inc. http://angularjs.org
 * License: MIT
 */
 'use strict';
@@ -33,28 +33,33 @@
 function minErr(module, ErrorConstructor) {
  ErrorConstructor = ErrorConstructor || Error;
  return function() {
-    var code = arguments[0],
-      prefix = '[' + (module ? module + ':' : '') + code + '] ',
-      template = arguments[1],
-      templateArgs = arguments,
+    var SKIP_INDEXES = 2;

-      message, i;
+    var templateArgs = arguments,
+      code = templateArgs[0],
+      message = '[' + (module ? module + ':' : '') + code + '] ',
+      template = templateArgs[1],
+      paramPrefix, i;

-    message = prefix + template.replace(/\{\d+\}/g, function(match) {
-      var index = +match.slice(1, -1), arg;
+    message += template.replace(/\{\d+\}/g, function(match) {
+      var index = +match.slice(1, -1),
+        shiftedIndex = index + SKIP_INDEXES;

-      if (index + 2 < templateArgs.length) {
-        return toDebugString(templateArgs[index + 2]);
+      if (shiftedIndex < templateArgs.length) {
+        return toDebugString(templateArgs[shiftedIndex]);
      }
+
      return match;
    });

-    message = message + '\nhttp://errors.angularjs.org/"NG_VERSION_FULL"/' +
+    message += '\nhttp://errors.angularjs.org/"NG_VERSION_FULL"/' +
      (module ? module + '/' : '') + code;
-    for (i = 2; i < arguments.length; i++) {
-      message = message + (i == 2 ? '?' : '&') + 'p' + (i - 2) + '=' +
-        encodeURIComponent(toDebugString(arguments[i]));
+
+    for (i = SKIP_INDEXES, paramPrefix = '?'; i < templateArgs.length; i++, paramPrefix = '&') {
+      message += paramPrefix + 'p' + (i - SKIP_INDEXES) + '=' +
+        encodeURIComponent(toDebugString(templateArgs[i]));
    }
+
    return new ErrorConstructor(message);
  };
 }
@@ -1,6 +1,6 @@
 /**
 * @license AngularJS v"NG_VERSION_FULL"
- * (c) 2010-2014 Google, Inc. http://angularjs.org
+ * (c) 2010-2015 Google, Inc. http://angularjs.org
 * License: MIT
 */
 (function(window, angular, undefined) {
@@ -38,9 +38,10 @@ function $AnchorScrollProvider() {
   * @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).
+   * When called, it scrolls to the element related to the specified `hash` or (if omitted) to the
+   * current value of {@link ng.$location#hash $location.hash()}, 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
@@ -49,6 +50,9 @@ function $AnchorScrollProvider() {
   * Additionally, you can use its {@link ng.$anchorScroll#yOffset yOffset} property to specify a
   * vertical scroll-offset (either fixed or dynamic).
   *
+   * @param {string=} hash The hash specifying the element to scroll to. If omitted, the value of
+   *                       {@link ng.$location#hash $location.hash()} will be used.
+   *
   * @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.
@@ -232,8 +236,9 @@ function $AnchorScrollProvider() {
      }
    }

-    function scroll() {
-      var hash = $location.hash(), elm;
+    function scroll(hash) {
+      hash = isString(hash) ? hash : $location.hash();
+      var elm;

      // empty hash, scroll to the top of the page
      if (!hash) scrollTo(null);
@@ -1,6 +1,168 @@
 'use strict';

 var $animateMinErr = minErr('$animate');
+var ELEMENT_NODE = 1;
+var NG_ANIMATE_CLASSNAME = 'ng-animate';
+
+function mergeClasses(a,b) {
+  if (!a && !b) return '';
+  if (!a) return b;
+  if (!b) return a;
+  if (isArray(a)) a = a.join(' ');
+  if (isArray(b)) b = b.join(' ');
+  return a + ' ' + b;
+}
+
+function extractElementNode(element) {
+  for (var i = 0; i < element.length; i++) {
+    var elm = element[i];
+    if (elm.nodeType === ELEMENT_NODE) {
+      return elm;
+    }
+  }
+}
+
+function splitClasses(classes) {
+  if (isString(classes)) {
+    classes = classes.split(' ');
+  }
+
+  // Use createMap() to prevent class assumptions involving property names in
+  // Object.prototype
+  var obj = createMap();
+  forEach(classes, function(klass) {
+    // sometimes the split leaves empty string values
+    // incase extra spaces were applied to the options
+    if (klass.length) {
+      obj[klass] = true;
+    }
+  });
+  return obj;
+}
+
+// if any other type of options value besides an Object value is
+// passed into the $animate.method() animation then this helper code
+// will be run which will ignore it. While this patch is not the
+// greatest solution to this, a lot of existing plugins depend on
+// $animate to either call the callback (< 1.2) or return a promise
+// that can be changed. This helper function ensures that the options
+// are wiped clean incase a callback function is provided.
+function prepareAnimateOptions(options) {
+  return isObject(options)
+      ? options
+      : {};
+}
+
+var $$CoreAnimateRunnerProvider = function() {
+  this.$get = ['$q', '$$rAF', function($q, $$rAF) {
+    function AnimateRunner() {}
+    AnimateRunner.all = noop;
+    AnimateRunner.chain = noop;
+    AnimateRunner.prototype = {
+      end: noop,
+      cancel: noop,
+      resume: noop,
+      pause: noop,
+      complete: noop,
+      then: function(pass, fail) {
+        return $q(function(resolve) {
+          $$rAF(function() {
+            resolve();
+          });
+        }).then(pass, fail);
+      }
+    };
+    return AnimateRunner;
+  }];
+};
+
+// this is prefixed with Core since it conflicts with
+// the animateQueueProvider defined in ngAnimate/animateQueue.js
+var $$CoreAnimateQueueProvider = function() {
+  var postDigestQueue = new HashMap();
+  var postDigestElements = [];
+
+  this.$get = ['$$AnimateRunner', '$rootScope',
+       function($$AnimateRunner,   $rootScope) {
+    return {
+      enabled: noop,
+      on: noop,
+      off: noop,
+      pin: noop,
+
+      push: function(element, event, options, domOperation) {
+        domOperation        && domOperation();
+
+        options = options || {};
+        options.from        && element.css(options.from);
+        options.to          && element.css(options.to);
+
+        if (options.addClass || options.removeClass) {
+          addRemoveClassesPostDigest(element, options.addClass, options.removeClass);
+        }
+
+        return new $$AnimateRunner(); // jshint ignore:line
+      }
+    };
+
+    function addRemoveClassesPostDigest(element, add, remove) {
+      var data = postDigestQueue.get(element);
+      var classVal;
+
+      if (!data) {
+        postDigestQueue.put(element, data = {});
+        postDigestElements.push(element);
+      }
+
+      if (add) {
+        forEach(add.split(' '), function(className) {
+          if (className) {
+            data[className] = true;
+          }
+        });
+      }
+
+      if (remove) {
+        forEach(remove.split(' '), function(className) {
+          if (className) {
+            data[className] = false;
+          }
+        });
+      }
+
+      if (postDigestElements.length > 1) return;
+
+      $rootScope.$$postDigest(function() {
+        forEach(postDigestElements, function(element) {
+          var data = postDigestQueue.get(element);
+          if (data) {
+            var existing = splitClasses(element.attr('class'));
+            var toAdd = '';
+            var toRemove = '';
+            forEach(data, function(status, className) {
+              var hasClass = !!existing[className];
+              if (status !== hasClass) {
+                if (status) {
+                  toAdd += (toAdd.length ? ' ' : '') + className;
+                } else {
+                  toRemove += (toRemove.length ? ' ' : '') + className;
+                }
+              }
+            });
+
+            forEach(element, function(elm) {
+              toAdd    && jqLiteAddClass(elm, toAdd);
+              toRemove && jqLiteRemoveClass(elm, toRemove);
+            });
+            postDigestQueue.remove(element);
+          }
+        });
+
+        postDigestElements.length = 0;
+      });
+    }
+  }];
+};

 /**
 * @ngdoc provider
@@ -8,20 +170,18 @@ var $animateMinErr = minErr('$animate');
 *
 * @description
 * Default implementation of $animate that doesn't perform any animations, instead just
- * synchronously performs DOM
- * updates and calls done() callbacks.
+ * synchronously performs DOM updates and resolves the returned runner promise.
 *
- * In order to enable animations the ngAnimate module has to be loaded.
+ * In order to enable animations the `ngAnimate` module has to be loaded.
 *
- * To see the functional implementation check out src/ngAnimate/animate.js
+ * To see the functional implementation check out `src/ngAnimate/animate.js`.
 */
 var $AnimateProvider = ['$provide', function($provide) {
+  var provider = this;

+  this.$$registeredAnimations = Object.create(null);

-  this.$$selectors = {};
-
-
-  /**
+   /**
   * @ngdoc method
   * @name $animateProvider#register
   *
@@ -30,33 +190,43 @@ var $AnimateProvider = ['$provide', function($provide) {
   * animation object which contains callback functions for each event that is expected to be
   * animated.
   *
-   *   * `eventFn`: `function(Element, doneFunction)` The element to animate, the `doneFunction`
-   *   must be called once the element animation is complete. If a function is returned then the
-   *   animation service will use this function to cancel the animation whenever a cancel event is
-   *   triggered.
+   *   * `eventFn`: `function(element, ... , doneFunction, options)`
+   *   The element to animate, the `doneFunction` and the options fed into the animation. Depending
+   *   on the type of animation additional arguments will be injected into the animation function. The
+   *   list below explains the function signatures for the different animation methods:
   *
+   *   - setClass: function(element, addedClasses, removedClasses, doneFunction, options)
+   *   - addClass: function(element, addedClasses, doneFunction, options)
+   *   - removeClass: function(element, removedClasses, doneFunction, options)
+   *   - enter, leave, move: function(element, doneFunction, options)
+   *   - animate: function(element, fromStyles, toStyles, doneFunction, options)
+   *
+   *   Make sure to trigger the `doneFunction` once the animation is fully complete.
   *
   * ```js
   *   return {
-     *     eventFn : function(element, done) {
-     *       //code to run the animation
-     *       //once complete, then run done()
-     *       return function cancellationFunction() {
-     *         //code to cancel the animation
-     *       }
-     *     }
-     *   }
+   *     //enter, leave, move signature
+   *     eventFn : function(element, done, options) {
+   *       //code to run the animation
+   *       //once complete, then run done()
+   *       return function endFunction(wasCancelled) {
+   *         //code to cancel the animation
+   *       }
+   *     }
+   *   }
   * ```
   *
-   * @param {string} name The name of the animation.
+   * @param {string} name The name of the animation (this is what the class-based CSS value will be compared to).
   * @param {Function} factory The factory function that will be executed to return the animation
   *                           object.
   */
  this.register = function(name, factory) {
+    if (name && name.charAt(0) !== '.') {
+      throw $animateMinErr('notcsel', "Expecting class selector starting with '.' got '{0}'.", name);
+    }
+
    var key = name + '-animation';
-    if (name && name.charAt(0) != '.') throw $animateMinErr('notcsel',
-        "Expecting class selector starting with '.' got '{0}'.", name);
-    this.$$selectors[name.substr(1)] = key;
+    provider.$$registeredAnimations[name.substr(1)] = key;
    $provide.factory(key, factory);
  };

@@ -67,8 +237,8 @@ var $AnimateProvider = ['$provide', function($provide) {
   * @description
   * Sets and/or returns the CSS class regular expression that is checked when performing
   * an animation. Upon bootstrap the classNameFilter value is not set at all and will
-   * therefore enable $animate to attempt to perform an animation on any element.
-   * When setting the classNameFilter value, animations will only be performed on elements
+   * therefore enable $animate to attempt to perform an animation on any element that is triggered.
+   * When setting the `classNameFilter` value, animations will only be performed on elements
   * that successfully match the filter expression. This in turn can boost performance
   * 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
@@ -77,102 +247,167 @@ var $AnimateProvider = ['$provide', function($provide) {
  this.classNameFilter = function(expression) {
    if (arguments.length === 1) {
      this.$$classNameFilter = (expression instanceof RegExp) ? expression : null;
+      if (this.$$classNameFilter) {
+        var reservedRegex = new RegExp("(\\s+|\\/)" + NG_ANIMATE_CLASSNAME + "(\\s+|\\/)");
+        if (reservedRegex.test(this.$$classNameFilter.toString())) {
+          throw $animateMinErr('nongcls','$animateProvider.classNameFilter(regex) prohibits accepting a regex value which matches/contains the "{0}" CSS class.', NG_ANIMATE_CLASSNAME);
+
+        }
+      }
    }
    return this.$$classNameFilter;
  };

-  this.$get = ['$$q', '$$asyncCallback', '$rootScope', function($$q, $$asyncCallback, $rootScope) {
-
-    var currentDefer;
-
-    function runAnimationPostDigest(fn) {
-      var cancelFn, defer = $$q.defer();
-      defer.promise.$$cancelFn = function ngAnimateMaybeCancel() {
-        cancelFn && cancelFn();
-      };
-
-      $rootScope.$$postDigest(function ngAnimatePostDigest() {
-        cancelFn = fn(function ngAnimateNotifyComplete() {
-          defer.resolve();
-        });
-      });
-
-      return defer.promise;
-    }
-
-    function resolveElementClasses(element, classes) {
-      var toAdd = [], toRemove = [];
-
-      var hasClasses = createMap();
-      forEach((element.attr('class') || '').split(/\s+/), function(className) {
-        hasClasses[className] = true;
-      });
-
-      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
-        // element does not currently have the class, the class is scheduled to be added.
-        if (status === false && hasClass) {
-          toRemove.push(className);
-        } else if (status === true && !hasClass) {
-          toAdd.push(className);
+  this.$get = ['$$animateQueue', function($$animateQueue) {
+    function domInsert(element, parentElement, afterElement) {
+      // if for some reason the previous element was removed
+      // from the dom sometime before this code runs then let's
+      // just stick to using the parent element as the anchor
+      if (afterElement) {
+        var afterNode = extractElementNode(afterElement);
+        if (afterNode && !afterNode.parentNode && !afterNode.previousElementSibling) {
+          afterElement = null;
        }
-      });
-
-      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];
-        cache[className] = op;
-      }
-    }
-
-    function asyncPromise() {
-      // only serve one instance of a promise in order to save CPU cycles
-      if (!currentDefer) {
-        currentDefer = $$q.defer();
-        $$asyncCallback(function() {
-          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);
      }
+      afterElement ? afterElement.after(element) : parentElement.prepend(element);
    }

    /**
-     *
     * @ngdoc service
     * @name $animate
-     * @description The $animate service provides rudimentary DOM manipulation functions to
-     * insert, remove and move elements within the DOM, as well as adding and removing classes.
-     * This service is the core service used by the ngAnimate $animator service which provides
-     * high-level animation hooks for CSS and JavaScript.
+     * @description The $animate service exposes a series of DOM utility methods that provide support
+     * for animation hooks. The default behavior is the application of DOM operations, however,
+     * when an animation is detected (and animations are enabled), $animate will do the heavy lifting
+     * to ensure that animation runs with the triggered DOM operation.
     *
-     * $animate is available in the AngularJS core, however, the ngAnimate module must be included
-     * to enable full out animation support. Otherwise, $animate will only perform simple DOM
-     * manipulation operations.
+     * By default $animate doesn't trigger an animations. This is because the `ngAnimate` module isn't
+     * included and only when it is active then the animation hooks that `$animate` triggers will be
+     * functional. Once active then all structural `ng-` directives will trigger animations as they perform
+     * their DOM-related operations (enter, leave and move). Other directives such as `ngClass`,
+     * `ngShow`, `ngHide` and `ngMessages` also provide support for animations.
     *
-     * 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}.
+     * It is recommended that the`$animate` service is always used when executing DOM-related procedures within directives.
+     *
+     * To learn more about enabling animation support, click here to visit the
+     * {@link ngAnimate ngAnimate module page}.
     */
    return {
-      animate: function(element, from, to) {
-        applyStyles(element, { from: from, to: to });
-        return asyncPromise();
+      // we don't call it directly since non-existant arguments may
+      // be interpreted as null within the sub enabled function
+
+      /**
+       *
+       * @ngdoc method
+       * @name $animate#on
+       * @kind function
+       * @description Sets up an event listener to fire whenever the animation event (enter, leave, move, etc...)
+       *    has fired on the given element or among any of its children. Once the listener is fired, the provided callback
+       *    is fired with the following params:
+       *
+       * ```js
+       * $animate.on('enter', container,
+       *    function callback(element, phase) {
+       *      // cool we detected an enter animation within the container
+       *    }
+       * );
+       * ```
+       *
+       * @param {string} event the animation event that will be captured (e.g. enter, leave, move, addClass, removeClass, etc...)
+       * @param {DOMElement} container the container element that will capture each of the animation events that are fired on itself
+       *     as well as among its children
+       * @param {Function} callback the callback function that will be fired when the listener is triggered
+       *
+       * The arguments present in the callback function are:
+       * * `element` - The captured DOM element that the animation was fired on.
+       * * `phase` - The phase of the animation. The two possible phases are **start** (when the animation starts) and **close** (when it ends).
+       */
+      on: $$animateQueue.on,
+
+      /**
+       *
+       * @ngdoc method
+       * @name $animate#off
+       * @kind function
+       * @description Deregisters an event listener based on the event which has been associated with the provided element. This method
+       * can be used in three different ways depending on the arguments:
+       *
+       * ```js
+       * // remove all the animation event listeners listening for `enter`
+       * $animate.off('enter');
+       *
+       * // remove all the animation event listeners listening for `enter` on the given element and its children
+       * $animate.off('enter', container);
+       *
+       * // remove the event listener function provided by `listenerFn` that is set
+       * // to listen for `enter` on the given `element` as well as its children
+       * $animate.off('enter', container, callback);
+       * ```
+       *
+       * @param {string} event the animation event (e.g. enter, leave, move, addClass, removeClass, etc...)
+       * @param {DOMElement=} container the container element the event listener was placed on
+       * @param {Function=} callback the callback function that was registered as the listener
+       */
+      off: $$animateQueue.off,
+
+      /**
+       * @ngdoc method
+       * @name $animate#pin
+       * @kind function
+       * @description Associates the provided element with a host parent element to allow the element to be animated even if it exists
+       *    outside of the DOM structure of the Angular application. By doing so, any animation triggered via `$animate` can be issued on the
+       *    element despite being outside the realm of the application or within another application. Say for example if the application
+       *    was bootstrapped on an element that is somewhere inside of the `<body>` tag, but we wanted to allow for an element to be situated
+       *    as a direct child of `document.body`, then this can be achieved by pinning the element via `$animate.pin(element)`. Keep in mind
+       *    that calling `$animate.pin(element, parentElement)` will not actually insert into the DOM anywhere; it will just create the association.
+       *
+       *    Note that this feature is only active when the `ngAnimate` module is used.
+       *
+       * @param {DOMElement} element the external element that will be pinned
+       * @param {DOMElement} parentElement the host parent element that will be associated with the external element
+       */
+      pin: $$animateQueue.pin,
+
+      /**
+       *
+       * @ngdoc method
+       * @name $animate#enabled
+       * @kind function
+       * @description Used to get and set whether animations are enabled or not on the entire application or on an element and its children. This
+       * function can be called in four ways:
+       *
+       * ```js
+       * // returns true or false
+       * $animate.enabled();
+       *
+       * // changes the enabled state for all animations
+       * $animate.enabled(false);
+       * $animate.enabled(true);
+       *
+       * // returns true or false if animations are enabled for an element
+       * $animate.enabled(element);
+       *
+       * // changes the enabled state for an element and its children
+       * $animate.enabled(element, true);
+       * $animate.enabled(element, false);
+       * ```
+       *
+       * @param {DOMElement=} element the element that will be considered for checking/setting the enabled state
+       * @param {boolean=} enabled whether or not the animations will be enabled for the element
+       *
+       * @return {boolean} whether or not animations are enabled
+       */
+      enabled: $$animateQueue.enabled,
+
+      /**
+       * @ngdoc method
+       * @name $animate#cancel
+       * @kind function
+       * @description Cancels the provided animation.
+       *
+       * @param {Promise} animationPromise The animation promise that is returned when an animation is started.
+       */
+      cancel: function(runner) {
+        runner.end && runner.end();
      },

      /**
@@ -180,39 +415,25 @@ var $AnimateProvider = ['$provide', function($provide) {
       * @ngdoc method
       * @name $animate#enter
       * @kind function
-       * @description Inserts the element into the DOM either after the `after` element or
-       * as the first child within the `parent` element. When the function is called a promise
-       * is returned that will be resolved at a later time.
+       * @description Inserts the element into the DOM either after the `after` element (if provided) or
+       *   as the first child within the `parent` element and then triggers an animation.
+       *   A promise is returned that will be resolved during the next digest once the animation
+       *   has completed.
+       *
       * @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.
+       *   a child (so long as the after element is not present)
+       * @param {DOMElement=} after the sibling element after which the element will be appended
+       * @param {object=} options an optional collection of options/styles that will be applied to the element
+       *
       * @return {Promise} the animation callback promise
       */
      enter: function(element, parent, after, options) {
-        applyStyles(element, options);
-        after ? after.after(element)
-              : parent.prepend(element);
-        return asyncPromise();
-      },
-
-      /**
-       *
-       * @ngdoc method
-       * @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, options) {
-        applyStyles(element, options);
-        element.remove();
-        return asyncPromise();
+        parent = parent && jqLite(parent);
+        after = after && jqLite(after);
+        parent = parent || after.parent();
+        domInsert(element, parent, after);
+        return $$animateQueue.push(element, 'enter', prepareAnimateOptions(options));
      },

      /**
@@ -220,153 +441,150 @@ var $AnimateProvider = ['$provide', function($provide) {
       * @ngdoc method
       * @name $animate#move
       * @kind function
-       * @description Moves the position of the provided element within the DOM to be placed
-       * either after the `after` element or inside of the `parent` element. When the function
-       * is called a promise is returned that will be resolved at a later time.
+       * @description Inserts (moves) the element into its new position in the DOM either after
+       *   the `after` element (if provided) or as the first child within the `parent` element
+       *   and then triggers an animation. A promise is returned that will be resolved
+       *   during the next digest once the animation has completed.
+       *
+       * @param {DOMElement} element the element which will be moved into the new DOM position
+       * @param {DOMElement} parent the parent element which will append the element as
+       *   a child (so long as the after element is not present)
+       * @param {DOMElement=} after the sibling element after which the element will be appended
+       * @param {object=} options an optional collection of options/styles that will be applied to the element
       *
-       * @param {DOMElement} element the element which will be moved around within the
-       *   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, 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, options);
+        parent = parent && jqLite(parent);
+        after = after && jqLite(after);
+        parent = parent || after.parent();
+        domInsert(element, parent, after);
+        return $$animateQueue.push(element, 'move', prepareAnimateOptions(options));
      },

      /**
+       * @ngdoc method
+       * @name $animate#leave
+       * @kind function
+       * @description Triggers an animation and then removes the element from the DOM.
+       * When the function is called a promise is returned that will be resolved during the next
+       * digest once the animation has completed.
       *
+       * @param {DOMElement} element the element which will be removed from the DOM
+       * @param {object=} options an optional collection of options/styles that will be applied to the element
+       *
+       * @return {Promise} the animation callback promise
+       */
+      leave: function(element, options) {
+        return $$animateQueue.push(element, 'leave', prepareAnimateOptions(options), function() {
+          element.remove();
+        });
+      },
+
+      /**
       * @ngdoc method
       * @name $animate#addClass
       * @kind function
-       * @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.
+       *
+       * @description Triggers an addClass animation surrounding the addition of the provided CSS class(es). Upon
+       *   execution, the addClass operation will only be handled after the next digest and it will not trigger an
+       *   animation if element already contains the CSS class or if the class is removed at a later step.
+       *   Note that class-based animations are treated differently compared to structural animations
+       *   (like enter, move and leave) since the CSS classes may be added/removed at different points
+       *   depending if CSS or JavaScript animations are used.
+       *
+       * @param {DOMElement} element the element which the CSS classes will be applied to
+       * @param {string} className the CSS class(es) that will be added (multiple classes are separated via spaces)
+       * @param {object=} options an optional collection of options/styles that will be applied to the element
+       *
       * @return {Promise} the animation callback promise
       */
      addClass: function(element, className, options) {
-        return this.setClass(element, className, [], options);
-      },
-
-      $$addClassImmediately: function(element, className, options) {
-        element = jqLite(element);
-        className = !isString(className)
-                        ? (isArray(className) ? className.join(' ') : '')
-                        : className;
-        forEach(element, function(element) {
-          jqLiteAddClass(element, className);
-        });
-        applyStyles(element, options);
-        return asyncPromise();
+        options = prepareAnimateOptions(options);
+        options.addClass = mergeClasses(options.addclass, className);
+        return $$animateQueue.push(element, 'addClass', options);
      },

      /**
-       *
       * @ngdoc method
       * @name $animate#removeClass
       * @kind function
-       * @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.
+       *
+       * @description Triggers a removeClass animation surrounding the removal of the provided CSS class(es). Upon
+       *   execution, the removeClass operation will only be handled after the next digest and it will not trigger an
+       *   animation if element does not contain the CSS class or if the class is added at a later step.
+       *   Note that class-based animations are treated differently compared to structural animations
+       *   (like enter, move and leave) since the CSS classes may be added/removed at different points
+       *   depending if CSS or JavaScript animations are used.
+       *
+       * @param {DOMElement} element the element which the CSS classes will be applied to
+       * @param {string} className the CSS class(es) that will be removed (multiple classes are separated via spaces)
+       * @param {object=} options an optional collection of options/styles that will be applied to the element
+       *
       * @return {Promise} the animation callback promise
       */
      removeClass: function(element, className, options) {
-        return this.setClass(element, [], className, options);
-      },
-
-      $$removeClassImmediately: function(element, className, options) {
-        element = jqLite(element);
-        className = !isString(className)
-                        ? (isArray(className) ? className.join(' ') : '')
-                        : className;
-        forEach(element, function(element) {
-          jqLiteRemoveClass(element, className);
-        });
-        applyStyles(element, options);
-        return asyncPromise();
+        options = prepareAnimateOptions(options);
+        options.removeClass = mergeClasses(options.removeClass, className);
+        return $$animateQueue.push(element, 'removeClass', options);
      },

      /**
-       *
       * @ngdoc method
       * @name $animate#setClass
       * @kind function
-       * @description Adds and/or removes the given CSS classes to and from the 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 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.
+       *
+       * @description Performs both the addition and removal of a CSS classes on an element and (during the process)
+       *    triggers an animation surrounding the class addition/removal. Much like `$animate.addClass` and
+       *    `$animate.removeClass`, `setClass` will only evaluate the classes being added/removed once a digest has
+       *    passed. Note that class-based animations are treated differently compared to structural animations
+       *    (like enter, move and leave) since the CSS classes may be added/removed at different points
+       *    depending if CSS or JavaScript animations are used.
+       *
+       * @param {DOMElement} element the element which the CSS classes will be applied to
+       * @param {string} add the CSS class(es) that will be added (multiple classes are separated via spaces)
+       * @param {string} remove the CSS class(es) that will be removed (multiple classes are separated via spaces)
+       * @param {object=} options an optional collection of options/styles that will be applied to the element
+       *
       * @return {Promise} the animation callback promise
       */
      setClass: function(element, add, remove, options) {
-        var self = this;
-        var STORAGE_KEY = '$$animateClasses';
-        var createdCache = false;
-        element = jqLite(element);
-
-        var cache = element.data(STORAGE_KEY);
-        if (!cache) {
-          cache = {
-            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(' ');
-        remove = isArray(remove) ? remove : remove.split(' ');
-        cachedClassManipulation(classes, add, true);
-        cachedClassManipulation(classes, remove, false);
-
-        if (createdCache) {
-          cache.promise = runAnimationPostDigest(function(done) {
-            var cache = element.data(STORAGE_KEY);
-            element.removeData(STORAGE_KEY);
-
-            // in the event that the element is removed before postDigest
-            // is run then the cache will be undefined and there will be
-            // no need anymore to add or remove and of the element classes
-            if (cache) {
-              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;
+        options = prepareAnimateOptions(options);
+        options.addClass = mergeClasses(options.addClass, add);
+        options.removeClass = mergeClasses(options.removeClass, remove);
+        return $$animateQueue.push(element, 'setClass', options);
      },

-      $$setClassImmediately: function(element, add, remove, options) {
-        add && this.$$addClassImmediately(element, add);
-        remove && this.$$removeClassImmediately(element, remove);
-        applyStyles(element, options);
-        return asyncPromise();
-      },
+      /**
+       * @ngdoc method
+       * @name $animate#animate
+       * @kind function
+       *
+       * @description Performs an inline animation on the element which applies the provided to and from CSS styles to the element.
+       * If any detected CSS transition, keyframe or JavaScript matches the provided className value then the animation will take
+       * on the provided styles. For example, if a transition animation is set for the given className then the provided from and
+       * to styles will be applied alongside the given transition. If a JavaScript animation is detected then the provided styles
+       * will be given in as function paramters into the `animate` method (or as apart of the `options` parameter).
+       *
+       * @param {DOMElement} element the element which the CSS styles will be applied to
+       * @param {object} from the from (starting) CSS styles that will be applied to the element and across the animation.
+       * @param {object} to the to (destination) CSS styles that will be applied to the element and across the animation.
+       * @param {string=} className an optional CSS class that will be applied to the element for the duration of the animation. If
+       *    this value is left as empty then a CSS class of `ng-inline-animate` will be applied to the element.
+       *    (Note that if no animation is detected then this value will not be appplied to the element.)
+       * @param {object=} options an optional collection of options/styles that will be applied to the element
+       *
+       * @return {Promise} the animation callback promise
+       */
+      animate: function(element, from, to, className, options) {
+        options = prepareAnimateOptions(options);
+        options.from = options.from ? extend(options.from, from) : from;
+        options.to   = options.to   ? extend(options.to, to)     : to;

-      enabled: noop,
-      cancel: noop
+        className = className || 'ng-inline-animate';
+        options.tempClasses = mergeClasses(options.tempClasses, className);
+        return $$animateQueue.push(element, 'animate', options);
+      }
    };
  }];
 }];
@@ -63,7 +63,7 @@ function Browser(window, document, $log, $sniffer) {

  function getHash(url) {
    var index = url.indexOf('#');
-    return index === -1 ? '' : url.substr(index + 1);
+    return index === -1 ? '' : url.substr(index);
  }

  /**
@@ -73,11 +73,6 @@ function Browser(window, document, $log, $sniffer) {
   * @param {function()} callback Function that will be called when no outstanding request
   */
  self.notifyWhenNoOutstandingRequests = function(callback) {
-    // force browser to execute all pollFns - this is needed so that cookies and other pollers fire
-    // at some deterministic time in respect to the test runner's actions. Leaving things up to the
-    // regular poller would result in flaky tests.
-    forEach(pollFns, function(pollFn) { pollFn(); });
-
    if (outstandingRequestCount === 0) {
      callback();
    } else {
@@ -85,44 +80,6 @@ function Browser(window, document, $log, $sniffer) {
    }
  };

-  //////////////////////////////////////////////////////////////
-  // Poll Watcher API
-  //////////////////////////////////////////////////////////////
-  var pollFns = [],
-      pollTimeout;
-
-  /**
-   * @name $browser#addPollFn
-   *
-   * @param {function()} fn Poll function to add
-   *
-   * @description
-   * Adds a function to the list of functions that poller periodically executes,
-   * and starts polling if not started yet.
-   *
-   * @returns {function()} the added function
-   */
-  self.addPollFn = function(fn) {
-    if (isUndefined(pollTimeout)) startPoller(100, setTimeout);
-    pollFns.push(fn);
-    return fn;
-  };
-
-  /**
-   * @param {number} interval How often should browser call poll functions (ms)
-   * @param {function()} setTimeout Reference to a real or fake `setTimeout` function.
-   *
-   * @description
-   * Configures the poller to run in the specified intervals, using the specified
-   * setTimeout fn and kicks it off.
-   */
-  function startPoller(interval, setTimeout) {
-    (function check() {
-      forEach(pollFns, function(pollFn) { pollFn(); });
-      pollTimeout = setTimeout(check, interval);
-    })();
-  }
-
  //////////////////////////////////////////////////////////////
  // URL API
  //////////////////////////////////////////////////////////////
@@ -190,7 +147,7 @@ function Browser(window, document, $log, $sniffer) {
        // Do the assignment again so that those two variables are referentially identical.
        lastHistoryState = cachedState;
      } else {
-        if (!sameBase) {
+        if (!sameBase || reloadLocation) {
          reloadLocation = url;
        }
        if (replace) {
@@ -307,6 +264,16 @@ function Browser(window, document, $log, $sniffer) {
    return callback;
  };

+  /**
+   * @private
+   * Remove popstate and hashchange handler from window.
+   *
+   * NOTE: this api is intended for use only by $rootScope.
+   */
+  self.$$applicationDestroyed = function() {
+    jqLite(window).off('hashchange popstate', cacheStateAndFireUrlChange);
+  };
+
  /**
   * Checks whether the url has changed outside of Angular.
   * Needs to be exported to be able to check for changes that have been done in sync,
@@ -332,89 +299,6 @@ function Browser(window, document, $log, $sniffer) {
    return href ? href.replace(/^(https?\:)?\/\/[^\/]*/, '') : '';
  };

-  //////////////////////////////////////////////////////////////
-  // 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
-   * @param {string=} value Cookie value
-   *
-   * @description
-   * The cookies method provides a 'private' low level access to browser cookies.
-   * It is not meant to be used directly, use the $cookie service instead.
-   *
-   * The return values vary depending on the arguments that the method was called with as follows:
-   *
-   * - cookies() -> hash of all cookies, this is NOT a copy of the internal state, so do not modify
-   *   it
-   * - cookies(name, value) -> set name to value, if value is undefined delete the cookie
-   * - cookies(name) -> the same as (name, undefined) == DELETES (no one calls it right now that
-   *   way)
-   *
-   * @returns {Object} Hash of all cookies (if called without any parameter)
-   */
-  self.cookies = function(name, value) {
-    var cookieLength, cookieArray, cookie, i, index;
-
-    if (name) {
-      if (value === undefined) {
-        rawDocument.cookie = encodeURIComponent(name) + "=;path=" + cookiePath +
-                                ";expires=Thu, 01 Jan 1970 00:00:00 GMT";
-      } else {
-        if (isString(value)) {
-          cookieLength = (rawDocument.cookie = encodeURIComponent(name) + '=' + encodeURIComponent(value) +
-                                ';path=' + cookiePath).length + 1;
-
-          // per http://www.ietf.org/rfc/rfc2109.txt browser must allow at minimum:
-          // - 300 cookies
-          // - 20 cookies per unique domain
-          // - 4096 bytes per cookie
-          if (cookieLength > 4096) {
-            $log.warn("Cookie '" + name +
-              "' possibly not set or overflowed because it was too large (" +
-              cookieLength + " > 4096 bytes)!");
-          }
-        }
-      }
-    } else {
-      if (rawDocument.cookie !== lastCookieString) {
-        lastCookieString = rawDocument.cookie;
-        cookieArray = lastCookieString.split("; ");
-        lastCookies = {};
-
-        for (i = 0; i < cookieArray.length; i++) {
-          cookie = cookieArray[i];
-          index = cookie.indexOf('=');
-          if (index > 0) { //ignore nameless cookies
-            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] = safeDecodeURIComponent(cookie.substring(index + 1));
-            }
-          }
-        }
-      }
-      return lastCookies;
-    }
-  };
-
-
  /**
   * @name $browser#defer
   * @param {function()} fn A function, who's execution should be deferred.
@@ -159,13 +159,13 @@ function $CacheFactoryProvider() {
         * @returns {*} the value stored.
         */
        put: function(key, value) {
+          if (isUndefined(value)) return;
          if (capacity < Number.MAX_VALUE) {
            var lruEntry = lruHash[key] || (lruHash[key] = {key: key});

            refresh(lruEntry);
          }

-          if (isUndefined(value)) return;
          if (!(key in data)) size++;
          data[key] = value;

@@ -237,9 +237,10 @@
 *
 *
 * #### `controllerAs`
- * Controller alias at the directive scope. An alias for the controller so it
- * can be referenced at the directive template. The directive needs to define a scope for this
- * configuration to be used. Useful in the case when directive is used as component.
+ * Identifier name for a reference to the controller in the directive's scope.
+ * This allows the controller to be referenced from the directive template. The directive
+ * needs to define a scope for this configuration to be used. Useful in the case when
+ * directive is used as component.
 *
 *
 * #### `restrict`
@@ -358,7 +359,7 @@
 * `templateUrl` declaration or manual compilation inside the compile function.
 * </div>
 *
- * <div class="alert alert-error">
+ * <div class="alert alert-danger">
 * **Note:** The `transclude` function that is passed to the compile function is deprecated, as it
 *   e.g. does not know about the right outer scope. Please use the transclude function that is passed
 *   to the link function instead.
@@ -398,13 +399,16 @@
 *   * `controller` - the directive's required controller instance(s) - Instances are shared
 *     among all directives, which allows the directives to use the controllers as a communication
 *     channel. The exact value depends on the directive's `require` property:
+ *       * no controller(s) required: the directive's own controller, or `undefined` if it doesn't have one
 *       * `string`: the controller instance
 *       * `array`: array of controller instances
- *       * no controller(s) required: `undefined`
 *
 *     If a required controller cannot be found, and it is optional, the instance is `null`,
 *     otherwise the {@link error:$compile:ctreq Missing Required Controller} error is thrown.
 *
+ *     Note that you can also require the directive's own controller - it will be made available like
+ *     like any other controller.
+ *
 *   * `transcludeFn` - A transclude linking function pre-bound to the correct transclusion scope.
 *     This is the same as the `$transclude`
 *     parameter of directive controllers, see there for details.
@@ -496,7 +500,7 @@
 *
 * <div class="alert alert-info">
 * **Best Practice**: if you intend to add and remove transcluded content manually in your directive
- * (by calling the transclude function to get the DOM and and calling `element.remove()` to remove it),
+ * (by calling the transclude function to get the DOM and calling `element.remove()` to remove it),
 * then you are also responsible for calling `$destroy` on the transclusion scope.
 * </div>
 *
@@ -620,8 +624,8 @@
      }]);
    </script>
    <div ng-controller="GreeterController">
-      <input ng-model="name"> <br>
-      <textarea ng-model="html"></textarea> <br>
+      <input ng-model="name"> <br/>
+      <textarea ng-model="html"></textarea> <br/>
      <div compile="html"></div>
    </div>
   </file>
@@ -643,7 +647,7 @@
 * @param {string|DOMElement} element Element or HTML string to compile into a template function.
 * @param {function(angular.Scope, cloneAttachFn=)} transclude function available to directives - DEPRECATED.
 *
- * <div class="alert alert-error">
+ * <div class="alert alert-danger">
 * **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.
@@ -658,7 +662,7 @@
 *  * `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:
+ *  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.
@@ -731,7 +735,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
  // 'on' and be composed of only English letters.
  var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;

-  function parseIsolateBindings(scope, directiveName) {
+  function parseIsolateBindings(scope, directiveName, isController) {
    var LOCAL_REGEXP = /^\s*([@&]|=(\*?))(\??)\s*(\w*)\s*$/;

    var bindings = {};
@@ -741,9 +745,11 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {

      if (!match) {
        throw $compileMinErr('iscp',
-            "Invalid isolate scope definition for directive '{0}'." +
+            "Invalid {3} for directive '{0}'." +
            " Definition: {... {1}: '{2}' ...}",
-            directiveName, scopeName, definition);
+            directiveName, scopeName, definition,
+            (isController ? "controller bindings definition" :
+            "isolate scope definition"));
      }

      bindings[scopeName] = {
@@ -757,12 +763,53 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
    return bindings;
  }

+  function parseDirectiveBindings(directive, directiveName) {
+    var bindings = {
+      isolateScope: null,
+      bindToController: null
+    };
+    if (isObject(directive.scope)) {
+      if (directive.bindToController === true) {
+        bindings.bindToController = parseIsolateBindings(directive.scope,
+                                                         directiveName, true);
+        bindings.isolateScope = {};
+      } else {
+        bindings.isolateScope = parseIsolateBindings(directive.scope,
+                                                     directiveName, false);
+      }
+    }
+    if (isObject(directive.bindToController)) {
+      bindings.bindToController =
+          parseIsolateBindings(directive.bindToController, directiveName, true);
+    }
+    if (isObject(bindings.bindToController)) {
+      var controller = directive.controller;
+      var controllerAs = directive.controllerAs;
+      if (!controller) {
+        // There is no controller, there may or may not be a controllerAs property
+        throw $compileMinErr('noctrl',
+              "Cannot bind to controller without directive '{0}'s controller.",
+              directiveName);
+      } else if (!identifierForController(controller, controllerAs)) {
+        // There is a controller, but no identifier or controllerAs property
+        throw $compileMinErr('noident',
+              "Cannot bind to controller without identifier for directive '{0}'.",
+              directiveName);
+      }
+    }
+    return bindings;
+  }
+
  function assertValidDirectiveName(name) {
    var letter = name.charAt(0);
    if (!letter || letter !== lowercase(letter)) {
      throw $compileMinErr('baddir', "Directive name '{0}' is invalid. The first character must be a lowercase letter", name);
    }
-    return name;
+    if (name !== name.trim()) {
+      throw $compileMinErr('baddir',
+            "Directive name '{0}' is invalid. The name should not contain leading or trailing whitespaces",
+            name);
+    }
  }

  /**
@@ -803,9 +850,12 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
                directive.name = directive.name || name;
                directive.require = directive.require || (directive.controller && directive.name);
                directive.restrict = directive.restrict || 'EA';
-                if (isObject(directive.scope)) {
-                  directive.$$isolateBindings = parseIsolateBindings(directive.scope, directive.name);
+                var bindings = directive.$$bindings =
+                    parseDirectiveBindings(directive, directive.name);
+                if (isObject(bindings.isolateScope)) {
+                  directive.$$isolateBindings = bindings.isolateScope;
                }
+                directive.$$moduleName = directiveFactory.$$moduleName;
                directives.push(directive);
              } catch (e) {
                $exceptionHandler(e);
@@ -1366,14 +1416,18 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
            if (nodeLinkFn.scope) {
              childScope = scope.$new();
              compile.$$addScopeInfo(jqLite(node), childScope);
+              var destroyBindings = nodeLinkFn.$$destroyBindings;
+              if (destroyBindings) {
+                nodeLinkFn.$$destroyBindings = null;
+                childScope.$on('$destroyed', destroyBindings);
+              }
            } else {
              childScope = scope;
            }

            if (nodeLinkFn.transcludeOnThisElement) {
              childBoundTranscludeFn = createBoundTranscludeFn(
-                  scope, nodeLinkFn.transclude, parentBoundTranscludeFn,
-                  nodeLinkFn.elementTranscludeOnThisElement);
+                  scope, nodeLinkFn.transclude, parentBoundTranscludeFn);

            } else if (!nodeLinkFn.templateOnThisElement && parentBoundTranscludeFn) {
              childBoundTranscludeFn = parentBoundTranscludeFn;
@@ -1385,7 +1439,8 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
              childBoundTranscludeFn = null;
            }

-            nodeLinkFn(childLinkFn, childScope, node, $rootElement, childBoundTranscludeFn);
+            nodeLinkFn(childLinkFn, childScope, node, $rootElement, childBoundTranscludeFn,
+                       nodeLinkFn);

          } else if (childLinkFn) {
            childLinkFn(scope, node.childNodes, undefined, parentBoundTranscludeFn);
@@ -1394,7 +1449,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
      }
    }

-    function createBoundTranscludeFn(scope, transcludeFn, previousBoundTranscludeFn, elementTransclusion) {
+    function createBoundTranscludeFn(scope, transcludeFn, previousBoundTranscludeFn) {

      var boundTranscludeFn = function(transcludedScope, cloneFn, controllers, futureParentElement, containingScope) {

@@ -1493,6 +1548,13 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
          }
          break;
        case NODE_TYPE_TEXT: /* Text Node */
+          if (msie === 11) {
+            // Workaround for #11781
+            while (node.parentNode && node.nextSibling && node.nextSibling.nodeType === NODE_TYPE_TEXT) {
+              node.nodeValue = node.nodeValue + node.nextSibling.nodeValue;
+              node.parentNode.removeChild(node.nextSibling);
+            }
+          }
          addTextInterpolateDirective(directives, node.nodeValue);
          break;
        case NODE_TYPE_COMMENT: /* Comment */
@@ -1592,9 +1654,8 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
      previousCompileContext = previousCompileContext || {};

      var terminalPriority = -Number.MAX_VALUE,
-          newScopeDirective,
+          newScopeDirective = previousCompileContext.newScopeDirective,
          controllerDirectives = previousCompileContext.controllerDirectives,
-          controllers,
          newIsolateScopeDirective = previousCompileContext.newIsolateScopeDirective,
          templateDirective = previousCompileContext.templateDirective,
          nonTlbTranscludeDirective = previousCompileContext.nonTlbTranscludeDirective,
@@ -1652,7 +1713,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {

        if (!directive.templateUrl && directive.controller) {
          directiveValue = directive.controller;
-          controllerDirectives = controllerDirectives || {};
+          controllerDirectives = controllerDirectives || createMap();
          assertNoDuplicate("'" + directiveName + "' controller",
              controllerDirectives[directiveName], directive, $compileNode);
          controllerDirectives[directiveName] = directive;
@@ -1759,6 +1820,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
          nodeLinkFn = compileTemplateUrl(directives.splice(i, directives.length - i), $compileNode,
              templateAttrs, jqCollection, hasTranscludeDirective && childTranscludeFn, preLinkFns, postLinkFns, {
                controllerDirectives: controllerDirectives,
+                newScopeDirective: (newScopeDirective !== directive) && newScopeDirective,
                newIsolateScopeDirective: newIsolateScopeDirective,
                templateDirective: templateDirective,
                nonTlbTranscludeDirective: nonTlbTranscludeDirective
@@ -1786,7 +1848,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {

      nodeLinkFn.scope = newScopeDirective && newScopeDirective.scope === true;
      nodeLinkFn.transcludeOnThisElement = hasTranscludeDirective;
-      nodeLinkFn.elementTranscludeOnThisElement = hasElementTranscludeDirective;
      nodeLinkFn.templateOnThisElement = hasTemplate;
      nodeLinkFn.transclude = childTranscludeFn;

@@ -1820,53 +1881,77 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {


      function getControllers(directiveName, require, $element, elementControllers) {
-        var value, retrievalMethod = 'data', optional = false;
-        var $searchElement = $element;
-        var match;
+        var value;
+
        if (isString(require)) {
-          match = require.match(REQUIRE_PREFIX_REGEXP);
-          require = require.substring(match[0].length);
+          var match = require.match(REQUIRE_PREFIX_REGEXP);
+          var name = require.substring(match[0].length);
+          var inheritType = match[1] || match[3];
+          var optional = match[2] === '?';

-          if (match[3]) {
-            if (match[1]) match[3] = null;
-            else match[1] = match[3];
-          }
-          if (match[1] === '^') {
-            retrievalMethod = 'inheritedData';
-          } else if (match[1] === '^^') {
-            retrievalMethod = 'inheritedData';
-            $searchElement = $element.parent();
-          }
-          if (match[2] === '?') {
-            optional = true;
+          //If only parents then start at the parent element
+          if (inheritType === '^^') {
+            $element = $element.parent();
+          //Otherwise attempt getting the controller from elementControllers in case
+          //the element is transcluded (and has no data) and to avoid .data if possible
+          } else {
+            value = elementControllers && elementControllers[name];
+            value = value && value.instance;
          }

-          value = null;
-
-          if (elementControllers && retrievalMethod === 'data') {
-            if (value = elementControllers[require]) {
-              value = value.instance;
-            }
+          if (!value) {
+            var dataName = '$' + name + 'Controller';
+            value = inheritType ? $element.inheritedData(dataName) : $element.data(dataName);
          }
-          value = value || $searchElement[retrievalMethod]('$' + require + 'Controller');

          if (!value && !optional) {
            throw $compileMinErr('ctreq',
                "Controller '{0}', required by directive '{1}', can't be found!",
-                require, directiveName);
+                name, directiveName);
          }
-          return value || null;
        } else if (isArray(require)) {
          value = [];
-          forEach(require, function(require) {
-            value.push(getControllers(directiveName, require, $element, elementControllers));
-          });
+          for (var i = 0, ii = require.length; i < ii; i++) {
+            value[i] = getControllers(directiveName, require[i], $element, elementControllers);
+          }
        }
-        return value;
+
+        return value || null;
      }

+      function setupControllers($element, attrs, transcludeFn, controllerDirectives, isolateScope, scope) {
+        var elementControllers = createMap();
+        for (var controllerKey in controllerDirectives) {
+          var directive = controllerDirectives[controllerKey];
+          var locals = {
+            $scope: directive === newIsolateScopeDirective || directive.$$isolateScope ? isolateScope : scope,
+            $element: $element,
+            $attrs: attrs,
+            $transclude: transcludeFn
+          };

-      function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn) {
+          var controller = directive.controller;
+          if (controller == '@') {
+            controller = attrs[directive.name];
+          }
+
+          var controllerInstance = $controller(controller, locals, true, directive.controllerAs);
+
+          // For directives with element transclusion the element is a comment,
+          // but jQuery .data doesn't support attaching data to comment nodes as it's hard to
+          // clean up (http://bugs.jquery.com/ticket/8335).
+          // Instead, we save the controllers for the element in a local hash and attach to .data
+          // later, once we have the actual element.
+          elementControllers[directive.name] = controllerInstance;
+          if (!hasElementTranscludeDirective) {
+            $element.data('$' + directive.name + 'Controller', controllerInstance.instance);
+          }
+        }
+        return elementControllers;
+      }
+
+      function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn,
+                          thisLinkFn) {
        var i, ii, linkFn, controller, isolateScope, elementControllers, transcludeFn, $element,
            attrs;

@@ -1890,126 +1975,53 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
        }

        if (controllerDirectives) {
-          // TODO: merge `controllers` and `elementControllers` into single object.
-          controllers = {};
-          elementControllers = {};
-          forEach(controllerDirectives, function(directive) {
-            var locals = {
-              $scope: directive === newIsolateScopeDirective || directive.$$isolateScope ? isolateScope : scope,
-              $element: $element,
-              $attrs: attrs,
-              $transclude: transcludeFn
-            }, controllerInstance;
-
-            controller = directive.controller;
-            if (controller == '@') {
-              controller = attrs[directive.name];
-            }
-
-            controllerInstance = $controller(controller, locals, true, directive.controllerAs);
-
-            // For directives with element transclusion the element is a comment,
-            // but jQuery .data doesn't support attaching data to comment nodes as it's hard to
-            // clean up (http://bugs.jquery.com/ticket/8335).
-            // Instead, we save the controllers for the element in a local hash and attach to .data
-            // later, once we have the actual element.
-            elementControllers[directive.name] = controllerInstance;
-            if (!hasElementTranscludeDirective) {
-              $element.data('$' + directive.name + 'Controller', controllerInstance.instance);
-            }
-
-            controllers[directive.name] = controllerInstance;
-          });
+          elementControllers = setupControllers($element, attrs, transcludeFn, controllerDirectives, isolateScope, scope);
        }

        if (newIsolateScopeDirective) {
+          // Initialize isolate scope bindings for new isolate scope directive.
          compile.$$addScopeInfo($element, isolateScope, true, !(templateDirective && (templateDirective === newIsolateScopeDirective ||
              templateDirective === newIsolateScopeDirective.$$originalDirective)));
          compile.$$addScopeClass($element, true);
-
-          var isolateScopeController = controllers && controllers[newIsolateScopeDirective.name];
-          var isolateBindingContext = isolateScope;
-          if (isolateScopeController && isolateScopeController.identifier &&
-              newIsolateScopeDirective.bindToController === true) {
-            isolateBindingContext = isolateScopeController.instance;
-          }
-
-          forEach(isolateScope.$$isolateBindings = newIsolateScopeDirective.$$isolateBindings, function(definition, scopeName) {
-            var attrName = definition.attrName,
-                optional = definition.optional,
-                mode = definition.mode, // @, =, or &
-                lastValue,
-                parentGet, parentSet, compare;
-
-            switch (mode) {
-
-              case '@':
-                attrs.$observe(attrName, function(value) {
-                  isolateBindingContext[scopeName] = value;
-                });
-                attrs.$$observers[attrName].$$scope = scope;
-                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;
-
-              case '=':
-                if (optional && !attrs[attrName]) {
-                  return;
-                }
-                parentGet = $parse(attrs[attrName]);
-                if (parentGet.literal) {
-                  compare = equals;
-                } else {
-                  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',
-                      "Expression '{0}' used with directive '{1}' is non-assignable!",
-                      attrs[attrName], newIsolateScopeDirective.name);
-                };
-                lastValue = isolateBindingContext[scopeName] = parentGet(scope);
-                var parentValueWatch = function parentValueWatch(parentValue) {
-                  if (!compare(parentValue, isolateBindingContext[scopeName])) {
-                    // we are out of sync and need to copy
-                    if (!compare(parentValue, lastValue)) {
-                      // parent changed and it has precedence
-                      isolateBindingContext[scopeName] = parentValue;
-                    } else {
-                      // if the parent can be assigned then do so
-                      parentSet(scope, parentValue = isolateBindingContext[scopeName]);
-                    }
-                  }
-                  return lastValue = parentValue;
-                };
-                parentValueWatch.$stateful = true;
-                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]);
-                isolateBindingContext[scopeName] = function(locals) {
-                  return parentGet(scope, locals);
-                };
-                break;
-            }
-          });
+          isolateScope.$$isolateBindings =
+              newIsolateScopeDirective.$$isolateBindings;
+          initializeDirectiveBindings(scope, attrs, isolateScope,
+                                      isolateScope.$$isolateBindings,
+                                      newIsolateScopeDirective, isolateScope);
        }
-        if (controllers) {
-          forEach(controllers, function(controller) {
-            controller();
-          });
-          controllers = null;
+        if (elementControllers) {
+          // Initialize bindToController bindings for new/isolate scopes
+          var scopeDirective = newIsolateScopeDirective || newScopeDirective;
+          var bindings;
+          var controllerForBindings;
+          if (scopeDirective && elementControllers[scopeDirective.name]) {
+            bindings = scopeDirective.$$bindings.bindToController;
+            controller = elementControllers[scopeDirective.name];
+
+            if (controller && controller.identifier && bindings) {
+              controllerForBindings = controller;
+              thisLinkFn.$$destroyBindings =
+                  initializeDirectiveBindings(scope, attrs, controller.instance,
+                                              bindings, scopeDirective);
+            }
+          }
+          for (i in elementControllers) {
+            controller = elementControllers[i];
+            var controllerResult = controller();
+
+            if (controllerResult !== controller.instance) {
+              // If the controller constructor has a return value, overwrite the instance
+              // from setupControllers and update the element data
+              controller.instance = controllerResult;
+              $element.data('$' + i + 'Controller', controllerResult);
+              if (controller === controllerForBindings) {
+                // Remove and re-install bindToController bindings
+                thisLinkFn.$$destroyBindings();
+                thisLinkFn.$$destroyBindings =
+                  initializeDirectiveBindings(scope, attrs, controllerResult, bindings, scopeDirective);
+              }
+            }
+          }
        }

        // PRELINKING
@@ -2193,7 +2205,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {

      $compileNode.empty();

-      $templateRequest($sce.getTrustedResourceUrl(templateUrl))
+      $templateRequest(templateUrl)
        .then(function(content) {
          var compileNode, tempTemplateAttrs, $template, childBoundTranscludeFn;

@@ -2267,7 +2279,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
              childBoundTranscludeFn = boundTranscludeFn;
            }
            afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, linkNode, $rootElement,
-              childBoundTranscludeFn);
+              childBoundTranscludeFn, afterTemplateNodeLinkFn);
          }
          linkQueue = null;
        });
@@ -2284,7 +2296,8 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
          if (afterTemplateNodeLinkFn.transcludeOnThisElement) {
            childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude, boundTranscludeFn);
          }
-          afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, node, rootElement, childBoundTranscludeFn);
+          afterTemplateNodeLinkFn(afterTemplateChildLinkFn, scope, node, rootElement, childBoundTranscludeFn,
+                                  afterTemplateNodeLinkFn);
        }
      };
    }
@@ -2300,11 +2313,18 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
      return a.index - b.index;
    }

-
    function assertNoDuplicate(what, previousDirective, directive, element) {
+
+      function wrapModuleNameIfDefined(moduleName) {
+        return moduleName ?
+          (' (module: ' + moduleName + ')') :
+          '';
+      }
+
      if (previousDirective) {
-        throw $compileMinErr('multidir', 'Multiple directives [{0}, {1}] asking for {2} on: {3}',
-            previousDirective.name, directive.name, what, startingTag(element));
+        throw $compileMinErr('multidir', 'Multiple directives [{0}{1}, {2}{3}] asking for {4} on: {5}',
+            previousDirective.name, wrapModuleNameIfDefined(previousDirective.$$moduleName),
+            directive.name, wrapModuleNameIfDefined(directive.$$moduleName), what, startingTag(element));
      }
    }

@@ -2485,26 +2505,28 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
      var fragment = document.createDocumentFragment();
      fragment.appendChild(firstElementToRemove);

-      // Copy over user data (that includes Angular's $scope etc.). Don't copy private
-      // data here because there's no public interface in jQuery to do that and copying over
-      // event listeners (which is the main use of private data) wouldn't work anyway.
-      jqLite(newNode).data(jqLite(firstElementToRemove).data());
+      if (jqLite.hasData(firstElementToRemove)) {
+        // Copy over user data (that includes Angular's $scope etc.). Don't copy private
+        // data here because there's no public interface in jQuery to do that and copying over
+        // event listeners (which is the main use of private data) wouldn't work anyway.
+        jqLite(newNode).data(jqLite(firstElementToRemove).data());

-      // Remove data of the replaced element. We cannot just call .remove()
-      // on the element it since that would deallocate scope that is needed
-      // for the new node. Instead, remove the data "manually".
-      if (!jQuery) {
-        delete jqLite.cache[firstElementToRemove[jqLite.expando]];
-      } else {
-        // jQuery 2.x doesn't expose the data storage. Use jQuery.cleanData to clean up after
-        // the replaced element. The cleanData version monkey-patched by Angular would cause
-        // the scope to be trashed and we do need the very same scope to work with the new
-        // element. However, we cannot just cache the non-patched version and use it here as
-        // that would break if another library patches the method after Angular does (one
-        // example is jQuery UI). Instead, set a flag indicating scope destroying should be
-        // skipped this one time.
-        skipDestroyOnNextJQueryCleanData = true;
-        jQuery.cleanData([firstElementToRemove]);
+        // Remove data of the replaced element. We cannot just call .remove()
+        // on the element it since that would deallocate scope that is needed
+        // for the new node. Instead, remove the data "manually".
+        if (!jQuery) {
+          delete jqLite.cache[firstElementToRemove[jqLite.expando]];
+        } else {
+          // jQuery 2.x doesn't expose the data storage. Use jQuery.cleanData to clean up after
+          // the replaced element. The cleanData version monkey-patched by Angular would cause
+          // the scope to be trashed and we do need the very same scope to work with the new
+          // element. However, we cannot just cache the non-patched version and use it here as
+          // that would break if another library patches the method after Angular does (one
+          // example is jQuery UI). Instead, set a flag indicating scope destroying should be
+          // skipped this one time.
+          skipDestroyOnNextJQueryCleanData = true;
+          jQuery.cleanData([firstElementToRemove]);
+        }
      }

      for (var k = 1, kk = elementsToRemove.length; k < kk; k++) {
@@ -2531,6 +2553,110 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
        $exceptionHandler(e, startingTag($element));
      }
    }
+
+
+    // Set up $watches for isolate scope and controller bindings. This process
+    // only occurs for isolate scopes and new scopes with controllerAs.
+    function initializeDirectiveBindings(scope, attrs, destination, bindings,
+                                         directive, newScope) {
+      var onNewScopeDestroyed;
+      forEach(bindings, function(definition, scopeName) {
+        var attrName = definition.attrName,
+        optional = definition.optional,
+        mode = definition.mode, // @, =, or &
+        lastValue,
+        parentGet, parentSet, compare;
+
+        if (!hasOwnProperty.call(attrs, attrName)) {
+          // In the case of user defined a binding with the same name as a method in Object.prototype but didn't set
+          // the corresponding attribute. We need to make sure subsequent code won't access to the prototype function
+          attrs[attrName] = undefined;
+        }
+
+        switch (mode) {
+
+          case '@':
+            if (!attrs[attrName] && !optional) {
+              destination[scopeName] = undefined;
+            }
+
+            attrs.$observe(attrName, function(value) {
+              destination[scopeName] = value;
+            });
+            attrs.$$observers[attrName].$$scope = scope;
+            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
+              destination[scopeName] = $interpolate(attrs[attrName])(scope);
+            }
+            break;
+
+          case '=':
+            if (optional && !attrs[attrName]) {
+              return;
+            }
+            parentGet = $parse(attrs[attrName]);
+
+            if (parentGet.literal) {
+              compare = equals;
+            } else {
+              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 = destination[scopeName] = parentGet(scope);
+              throw $compileMinErr('nonassign',
+                  "Expression '{0}' used with directive '{1}' is non-assignable!",
+                  attrs[attrName], directive.name);
+            };
+            lastValue = destination[scopeName] = parentGet(scope);
+            var parentValueWatch = function parentValueWatch(parentValue) {
+              if (!compare(parentValue, destination[scopeName])) {
+                // we are out of sync and need to copy
+                if (!compare(parentValue, lastValue)) {
+                  // parent changed and it has precedence
+                  destination[scopeName] = parentValue;
+                } else {
+                  // if the parent can be assigned then do so
+                  parentSet(scope, parentValue = destination[scopeName]);
+                }
+              }
+              return lastValue = parentValue;
+            };
+            parentValueWatch.$stateful = true;
+            var unwatch;
+            if (definition.collection) {
+              unwatch = scope.$watchCollection(attrs[attrName], parentValueWatch);
+            } else {
+              unwatch = scope.$watch($parse(attrs[attrName], parentValueWatch), null, parentGet.literal);
+            }
+            onNewScopeDestroyed = (onNewScopeDestroyed || []);
+            onNewScopeDestroyed.push(unwatch);
+            break;
+
+          case '&':
+            parentGet = $parse(attrs[attrName]);
+
+            // Don't assign noop to destination if expression is not valid
+            if (parentGet === noop && optional) break;
+
+            destination[scopeName] = function(locals) {
+              return parentGet(scope, locals);
+            };
+            break;
+        }
+      });
+      var destroyBindings = onNewScopeDestroyed ? function destroyBindings() {
+        for (var i = 0, ii = onNewScopeDestroyed.length; i < ii; ++i) {
+          onNewScopeDestroyed[i]();
+        }
+      } : noop;
+      if (newScope && destroyBindings !== noop) {
+        newScope.$on('$destroy', destroyBindings);
+        return noop;
+      }
+      return destroyBindings;
+    }
  }];
 }

@@ -2,6 +2,17 @@

 var $controllerMinErr = minErr('$controller');

+
+var CNTRL_REG = /^(\S+)(\s+as\s+(\w+))?$/;
+function identifierForController(controller, ident) {
+  if (ident && isString(ident)) return ident;
+  if (isString(controller)) {
+    var match = CNTRL_REG.exec(controller);
+    if (match) return match[3];
+  }
+}
+
+
 /**
 * @ngdoc provider
 * @name $controllerProvider
@@ -14,9 +25,7 @@ var $controllerMinErr = minErr('$controller');
 */
 function $ControllerProvider() {
  var controllers = {},
-      globals = false,
-      CNTRL_REG = /^(\S+)(\s+as\s+(\w+))?$/;
-
+      globals = false;

  /**
   * @ngdoc method
@@ -124,8 +133,16 @@ function $ControllerProvider() {
          addIdentifier(locals, identifier, instance, constructor || expression.name);
        }

-        return extend(function() {
-          $injector.invoke(expression, instance, locals, constructor);
+        var instantiate;
+        return instantiate = extend(function() {
+          var result = $injector.invoke(expression, instance, locals, constructor);
+          if (result !== instance && (isObject(result) || isFunction(result))) {
+            instance = result;
+            if (identifier) {
+              // If result changed, re-assign controllerAs value to scope.
+              addIdentifier(locals, identifier, instance, constructor || expression.name);
+            }
+          }
          return instance;
        }, {
          instance: instance,
@@ -0,0 +1,56 @@
+'use strict';
+
+/**
+ * @name $$cookieReader
+ * @requires $document
+ *
+ * @description
+ * This is a private service for reading cookies used by $http and ngCookies
+ *
+ * @return {Object} a key/value map of the current cookies
+ */
+function $$CookieReader($document) {
+  var rawDocument = $document[0] || {};
+  var lastCookies = {};
+  var lastCookieString = '';
+
+  function safeDecodeURIComponent(str) {
+    try {
+      return decodeURIComponent(str);
+    } catch (e) {
+      return str;
+    }
+  }
+
+  return function() {
+    var cookieArray, cookie, i, index, name;
+    var currentCookieString = rawDocument.cookie || '';
+
+    if (currentCookieString !== lastCookieString) {
+      lastCookieString = currentCookieString;
+      cookieArray = lastCookieString.split('; ');
+      lastCookies = {};
+
+      for (i = 0; i < cookieArray.length; i++) {
+        cookie = cookieArray[i];
+        index = cookie.indexOf('=');
+        if (index > 0) { //ignore nameless cookies
+          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] = safeDecodeURIComponent(cookie.substring(index + 1));
+          }
+        }
+      }
+    }
+    return lastCookies;
+  };
+}
+
+$$CookieReader.$inject = ['$document'];
+
+function $$CookieReaderProvider() {
+  this.$get = $$CookieReader;
+}
@@ -16,7 +16,7 @@
 var htmlAnchorDirective = valueFn({
  restrict: 'E',
  compile: function(element, attr) {
-    if (!attr.href && !attr.xlinkHref && !attr.name) {
+    if (!attr.href && !attr.xlinkHref) {
      return function(scope, element) {
        // If the linked element is not an anchor tag anymore, do nothing
        if (element[0].nodeName.toLowerCase() !== 'a') return;
@@ -68,7 +68,7 @@
          }, 5000, 'page should navigate to /123');
        });

-        xit('should execute ng-click but not reload when href empty string and name specified', function() {
+        it('should execute ng-click but not reload when href empty string and name specified', function() {
          element(by.id('link-4')).click();
          expect(element(by.model('value')).getAttribute('value')).toEqual('4');
          expect(element(by.id('link-4')).getAttribute('href')).toBe('');
@@ -113,12 +113,12 @@
 *
 * The buggy way to write it:
 * ```html
- * <img src="http://www.gravatar.com/avatar/{{hash}}"/>
+ * <img src="http://www.gravatar.com/avatar/{{hash}}" alt="Description"/>
 * ```
 *
 * The correct way to write it:
 * ```html
- * <img ng-src="http://www.gravatar.com/avatar/{{hash}}"/>
+ * <img ng-src="http://www.gravatar.com/avatar/{{hash}}" alt="Description" />
 * ```
 *
 * @element IMG
@@ -139,12 +139,12 @@
 *
 * The buggy way to write it:
 * ```html
- * <img srcset="http://www.gravatar.com/avatar/{{hash}} 2x"/>
+ * <img srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description"/>
 * ```
 *
 * The correct way to write it:
 * ```html
- * <img ng-srcset="http://www.gravatar.com/avatar/{{hash}} 2x"/>
+ * <img ng-srcset="http://www.gravatar.com/avatar/{{hash}} 2x" alt="Description" />
 * ```
 *
 * @element IMG
@@ -181,7 +181,7 @@
 * @example
    <example>
      <file name="index.html">
-        Click me to toggle: <input type="checkbox" ng-model="checked"><br/>
+        <label>Click me to toggle: <input type="checkbox" ng-model="checked"></label><br/>
        <button ng-model="button" ng-disabled="checked">Button</button>
      </file>
      <file name="protractor.js" type="protractor">
@@ -206,6 +206,13 @@
 * @priority 100
 *
 * @description
+ * Sets the `checked` attribute on the element, if the expression inside `ngChecked` is truthy.
+ *
+ * Note that this directive should not be used together with {@link ngModel `ngModel`},
+ * as this can lead to unexpected behavior.
+ *
+ * ### Why do we need `ngChecked`?
+ *
 * The HTML specification does not require browsers to preserve the values of boolean attributes
 * such as checked. (Their presence means true and their absence means false.)
 * If we put an Angular interpolation expression into such an attribute then the
@@ -216,8 +223,8 @@
 * @example
    <example>
      <file name="index.html">
-        Check me to check both: <input type="checkbox" ng-model="master"><br/>
-        <input id="checkSlave" type="checkbox" ng-checked="master">
+        <label>Check me to check both: <input type="checkbox" ng-model="master"></label><br/>
+        <input id="checkSlave" type="checkbox" ng-checked="master" aria-label="Slave input">
      </file>
      <file name="protractor.js" type="protractor">
        it('should check both checkBoxes', function() {
@@ -230,7 +237,7 @@
 *
 * @element INPUT
 * @param {expression} ngChecked If the {@link guide/expression expression} is truthy,
- *     then special attribute "checked" will be set on the element
+ *     then the `checked` attribute will be set on the element
 */


@@ -251,8 +258,8 @@
 * @example
    <example>
      <file name="index.html">
-        Check me to make text readonly: <input type="checkbox" ng-model="checked"><br/>
-        <input type="text" ng-readonly="checked" value="I'm Angular"/>
+        <label>Check me to make text readonly: <input type="checkbox" ng-model="checked"></label><br/>
+        <input type="text" ng-readonly="checked" value="I'm Angular" aria-label="Readonly field" />
      </file>
      <file name="protractor.js" type="protractor">
        it('should toggle readonly attr', function() {
@@ -287,8 +294,8 @@
 * @example
    <example>
      <file name="index.html">
-        Check me to select: <input type="checkbox" ng-model="selected"><br/>
-        <select>
+        <label>Check me to select: <input type="checkbox" ng-model="selected"></label><br/>
+        <select aria-label="ngSelected demo">
          <option>Hello!</option>
          <option id="greet" ng-selected="selected">Greetings!</option>
        </select>
@@ -324,7 +331,7 @@
 * @example
     <example>
       <file name="index.html">
-         Check me check multiple: <input type="checkbox" ng-model="open"><br/>
+         <label>Check me check multiple: <input type="checkbox" ng-model="open"></label><br/>
         <details id="details" ng-open="open">
            <summary>Show/Hide me</summary>
         </details>
@@ -345,22 +352,34 @@

 var ngAttributeAliasDirectives = {};

-
 // boolean attrs are evaluated
 forEach(BOOLEAN_ATTR, function(propName, attrName) {
  // binding to multiple is not supported
  if (propName == "multiple") return;

+  function defaultLinkFn(scope, element, attr) {
+    scope.$watch(attr[normalized], function ngBooleanAttrWatchAction(value) {
+      attr.$set(attrName, !!value);
+    });
+  }
+
  var normalized = directiveNormalize('ng-' + attrName);
+  var linkFn = defaultLinkFn;
+
+  if (propName === 'checked') {
+    linkFn = function(scope, element, attr) {
+      // ensuring ngChecked doesn't interfere with ngModel when both are set on the same input
+      if (attr.ngModel !== attr[normalized]) {
+        defaultLinkFn(scope, element, attr);
+      }
+    };
+  }
+
  ngAttributeAliasDirectives[normalized] = function() {
    return {
      restrict: 'A',
      priority: 100,
-      link: function(scope, element, attr) {
-        scope.$watch(attr[normalized], function ngBooleanAttrWatchAction(value) {
-          attr.$set(attrName, !!value);
-        });
-      }
+      link: linkFn
    };
  };
 });
@@ -493,18 +493,18 @@ var formDirectiveFactory = function(isNgForm) {
            var parentFormCtrl = controller.$$parentForm;

            if (nameAttr) {
-              setter(scope, null, controller.$name, controller, controller.$name);
+              setter(scope, controller.$name, controller, controller.$name);
              attr.$observe(nameAttr, function(newValue) {
                if (controller.$name === newValue) return;
-                setter(scope, null, controller.$name, undefined, controller.$name);
+                setter(scope, controller.$name, undefined, controller.$name);
                parentFormCtrl.$$renameControl(controller, newValue);
-                setter(scope, null, controller.$name, controller, controller.$name);
+                setter(scope, controller.$name, controller, controller.$name);
              });
            }
            formElement.on('$destroy', function() {
              parentFormCtrl.$removeControl(controller);
              if (nameAttr) {
-                setter(scope, null, attr[nameAttr], undefined, controller.$name);
+                setter(scope, attr[nameAttr], undefined, controller.$name);
              }
              extend(controller, nullFormCtrl); //stop propagating child destruction handlers upwards
            });
@@ -13,7 +13,7 @@
 var ISO_DATE_REGEXP = /\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)/;
 var URL_REGEXP = /^(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?$/;
 var EMAIL_REGEXP = /^[a-z0-9!#$%&'*+\/=?^_`{|}~.-]+@[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/i;
-var NUMBER_REGEXP = /^\s*(\-|\+)?(\d+|(\d*(\.\d*)))\s*$/;
+var NUMBER_REGEXP = /^\s*(\-|\+)?(\d+|(\d*(\.\d*)))([eE][+-]?\d+)?\s*$/;
 var DATE_REGEXP = /^(\d{4})-(\d{2})-(\d{2})$/;
 var DATETIMELOCAL_REGEXP = /^(\d{4})-(\d\d)-(\d\d)T(\d\d):(\d\d)(?::(\d\d)(\.\d{1,3})?)?$/;
 var WEEK_REGEXP = /^(\d{4})-W(\d\d)$/;
@@ -46,9 +46,13 @@ var inputType = {
   *    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$')`.
+   *    If the expression evaluates to a RegExp object, then this is used directly.
+   *    If the expression evaluates to 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$')`.<br />
+   *    **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+   *    start at the index of the last search's match, thus not taking the whole input value into
+   *    account.
   * @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.
@@ -68,13 +72,16 @@ var inputType = {
             }]);
         </script>
         <form name="myForm" ng-controller="ExampleController">
-           Single word: <input type="text" name="input" ng-model="example.text"
-                               ng-pattern="example.word" required ng-trim="false">
-           <span class="error" ng-show="myForm.input.$error.required">
-             Required!</span>
-           <span class="error" ng-show="myForm.input.$error.pattern">
-             Single word only!</span>
-
+           <label>Single word:
+             <input type="text" name="input" ng-model="example.text"
+                    ng-pattern="example.word" required ng-trim="false">
+           </label>
+           <div role="alert">
+             <span class="error" ng-show="myForm.input.$error.required">
+               Required!</span>
+             <span class="error" ng-show="myForm.input.$error.pattern">
+               Single word only!</span>
+           </div>
           <tt>text = {{example.text}}</tt><br/>
           <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
           <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
@@ -153,13 +160,15 @@ var inputType = {
            }]);
       </script>
       <form name="myForm" ng-controller="DateController as dateCtrl">
-          Pick a date in 2013:
+          <label for="exampleInput">Pick a date in 2013:</label>
          <input type="date" id="exampleInput" name="input" ng-model="example.value"
              placeholder="yyyy-MM-dd" min="2013-01-01" max="2013-12-31" required />
-          <span class="error" ng-show="myForm.input.$error.required">
-              Required!</span>
-          <span class="error" ng-show="myForm.input.$error.date">
-              Not a valid date!</span>
+          <div role="alert">
+            <span class="error" ng-show="myForm.input.$error.required">
+                Required!</span>
+            <span class="error" ng-show="myForm.input.$error.date">
+                Not a valid date!</span>
+           </div>
           <tt>value = {{example.value | date: "yyyy-MM-dd"}}</tt><br/>
           <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
           <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
@@ -246,13 +255,15 @@ var inputType = {
          }]);
      </script>
      <form name="myForm" ng-controller="DateController as dateCtrl">
-        Pick a date between in 2013:
+        <label for="exampleInput">Pick a date between in 2013:</label>
        <input type="datetime-local" id="exampleInput" name="input" ng-model="example.value"
            placeholder="yyyy-MM-ddTHH:mm:ss" min="2001-01-01T00:00:00" max="2013-12-31T00:00:00" required />
-        <span class="error" ng-show="myForm.input.$error.required">
-            Required!</span>
-        <span class="error" ng-show="myForm.input.$error.datetimelocal">
-            Not a valid date!</span>
+        <div role="alert">
+          <span class="error" ng-show="myForm.input.$error.required">
+              Required!</span>
+          <span class="error" ng-show="myForm.input.$error.datetimelocal">
+              Not a valid date!</span>
+        </div>
        <tt>value = {{example.value | date: "yyyy-MM-ddTHH:mm:ss"}}</tt><br/>
        <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
        <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
@@ -340,13 +351,15 @@ var inputType = {
        }]);
     </script>
     <form name="myForm" ng-controller="DateController as dateCtrl">
-        Pick a between 8am and 5pm:
+        <label for="exampleInput">Pick a between 8am and 5pm:</label>
        <input type="time" id="exampleInput" name="input" ng-model="example.value"
            placeholder="HH:mm:ss" min="08:00:00" max="17:00:00" required />
-        <span class="error" ng-show="myForm.input.$error.required">
-            Required!</span>
-        <span class="error" ng-show="myForm.input.$error.time">
-            Not a valid date!</span>
+        <div role="alert">
+          <span class="error" ng-show="myForm.input.$error.required">
+              Required!</span>
+          <span class="error" ng-show="myForm.input.$error.time">
+              Not a valid date!</span>
+        </div>
        <tt>value = {{example.value | date: "HH:mm:ss"}}</tt><br/>
        <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
        <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
@@ -433,13 +446,17 @@ var inputType = {
        }]);
      </script>
      <form name="myForm" ng-controller="DateController as dateCtrl">
-        Pick a date between in 2013:
-        <input id="exampleInput" type="week" name="input" ng-model="example.value"
-            placeholder="YYYY-W##" min="2012-W32" max="2013-W52" required />
-        <span class="error" ng-show="myForm.input.$error.required">
-            Required!</span>
-        <span class="error" ng-show="myForm.input.$error.week">
-            Not a valid date!</span>
+        <label>Pick a date between in 2013:
+          <input id="exampleInput" type="week" name="input" ng-model="example.value"
+                 placeholder="YYYY-W##" min="2012-W32"
+                 max="2013-W52" required />
+        </label>
+        <div role="alert">
+          <span class="error" ng-show="myForm.input.$error.required">
+              Required!</span>
+          <span class="error" ng-show="myForm.input.$error.week">
+              Not a valid date!</span>
+        </div>
        <tt>value = {{example.value | date: "yyyy-Www"}}</tt><br/>
        <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
        <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
@@ -526,13 +543,15 @@ var inputType = {
        }]);
     </script>
     <form name="myForm" ng-controller="DateController as dateCtrl">
-       Pick a month in 2013:
+       <label for="exampleInput">Pick a month in 2013:</label>
       <input id="exampleInput" type="month" name="input" ng-model="example.value"
          placeholder="yyyy-MM" min="2013-01" max="2013-12" required />
-       <span class="error" ng-show="myForm.input.$error.required">
-          Required!</span>
-       <span class="error" ng-show="myForm.input.$error.month">
-          Not a valid month!</span>
+       <div role="alert">
+         <span class="error" ng-show="myForm.input.$error.required">
+            Required!</span>
+         <span class="error" ng-show="myForm.input.$error.month">
+            Not a valid month!</span>
+       </div>
       <tt>value = {{example.value | date: "yyyy-MM"}}</tt><br/>
       <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
       <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
@@ -593,6 +612,16 @@ var inputType = {
   * error docs for more information and an example of how to convert your model if necessary.
   * </div>
   *
+   * ## Issues with HTML5 constraint validation
+   *
+   * In browsers that follow the
+   * [HTML5 specification](https://html.spec.whatwg.org/multipage/forms.html#number-state-%28type=number%29),
+   * `input[number]` does not work as expected with {@link ngModelOptions `ngModelOptions.allowInvalid`}.
+   * If a non-number is entered in the input, the browser will report the value as an empty string,
+   * which means the view / model values in `ngModel` and subsequently the scope value
+   * will also be an empty string.
+   *
+   *
   * @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`.
@@ -611,9 +640,13 @@ var inputType = {
   *    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$')`.
+   *    If the expression evaluates to a RegExp object, then this is used directly.
+   *    If the expression evaluates to 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$')`.<br />
+   *    **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+   *    start at the index of the last search's match, thus not taking the whole input value into
+   *    account.
   * @param {string=} ngChange Angular expression to be executed when input changes due to user
   *    interaction with the input element.
   *
@@ -629,12 +662,16 @@ var inputType = {
             }]);
         </script>
         <form name="myForm" ng-controller="ExampleController">
-           Number: <input type="number" name="input" ng-model="example.value"
-                          min="0" max="99" required>
-           <span class="error" ng-show="myForm.input.$error.required">
-             Required!</span>
-           <span class="error" ng-show="myForm.input.$error.number">
-             Not valid number!</span>
+           <label>Number:
+             <input type="number" name="input" ng-model="example.value"
+                    min="0" max="99" required>
+          </label>
+           <div role="alert">
+             <span class="error" ng-show="myForm.input.$error.required">
+               Required!</span>
+             <span class="error" ng-show="myForm.input.$error.number">
+               Not valid number!</span>
+           </div>
           <tt>value = {{example.value}}</tt><br/>
           <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
           <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
@@ -701,9 +738,13 @@ var inputType = {
   *    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$')`.
+   *    If the expression evaluates to a RegExp object, then this is used directly.
+   *    If the expression evaluates to 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$')`.<br />
+   *    **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+   *    start at the index of the last search's match, thus not taking the whole input value into
+   *    account.
   * @param {string=} ngChange Angular expression to be executed when input changes due to user
   *    interaction with the input element.
   *
@@ -719,11 +760,15 @@ var inputType = {
             }]);
         </script>
         <form name="myForm" ng-controller="ExampleController">
-           URL: <input type="url" name="input" ng-model="url.text" required>
-           <span class="error" ng-show="myForm.input.$error.required">
-             Required!</span>
-           <span class="error" ng-show="myForm.input.$error.url">
-             Not valid url!</span>
+           <label>URL:
+             <input type="url" name="input" ng-model="url.text" required>
+           <label>
+           <div role="alert">
+             <span class="error" ng-show="myForm.input.$error.required">
+               Required!</span>
+             <span class="error" ng-show="myForm.input.$error.url">
+               Not valid url!</span>
+           </div>
           <tt>text = {{url.text}}</tt><br/>
           <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
           <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
@@ -792,9 +837,13 @@ var inputType = {
   *    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$')`.
+   *    If the expression evaluates to a RegExp object, then this is used directly.
+   *    If the expression evaluates to 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$')`.<br />
+   *    **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+   *    start at the index of the last search's match, thus not taking the whole input value into
+   *    account.
   * @param {string=} ngChange Angular expression to be executed when input changes due to user
   *    interaction with the input element.
   *
@@ -810,11 +859,15 @@ var inputType = {
             }]);
         </script>
           <form name="myForm" ng-controller="ExampleController">
-             Email: <input type="email" name="input" ng-model="email.text" required>
-             <span class="error" ng-show="myForm.input.$error.required">
-               Required!</span>
-             <span class="error" ng-show="myForm.input.$error.email">
-               Not valid email!</span>
+             <label>Email:
+               <input type="email" name="input" ng-model="email.text" required>
+             </label>
+             <div role="alert">
+               <span class="error" ng-show="myForm.input.$error.required">
+                 Required!</span>
+               <span class="error" ng-show="myForm.input.$error.email">
+                 Not valid email!</span>
+             </div>
             <tt>text = {{email.text}}</tt><br/>
             <tt>myForm.input.$valid = {{myForm.input.$valid}}</tt><br/>
             <tt>myForm.input.$error = {{myForm.input.$error}}</tt><br/>
@@ -860,12 +913,15 @@ var inputType = {
   * HTML radio button.
   *
   * @param {string} ngModel Assignable angular expression to data-bind to.
-   * @param {string} value The value to which the expression should be set when selected.
+   * @param {string} value The value to which the `ngModel` expression should be set when selected.
+   *    Note that `value` only supports `string` values, i.e. the scope model needs to be a string,
+   *    too. Use `ngValue` if you need complex models (`number`, `object`, ...).
   * @param {string=} name Property name of the form under which the control is published.
   * @param {string=} ngChange Angular expression to be executed when input changes due to user
   *    interaction with the input element.
-   * @param {string} ngValue Angular expression which sets the value to which the expression should
-   *    be set when selected.
+   * @param {string} ngValue Angular expression to which `ngModel` will be be set when the radio
+   *    is selected. Should be used instead of the `value` attribute if you need
+   *    a non-string `ngModel` (`boolean`, `array`, ...).
   *
   * @example
      <example name="radio-input-directive" module="radioExample">
@@ -883,9 +939,18 @@ var inputType = {
             }]);
         </script>
         <form name="myForm" ng-controller="ExampleController">
-           <input type="radio" ng-model="color.name" value="red">  Red <br/>
-           <input type="radio" ng-model="color.name" ng-value="specialValue"> Green <br/>
-           <input type="radio" ng-model="color.name" value="blue"> Blue <br/>
+           <label>
+             <input type="radio" ng-model="color.name" value="red">
+             Red
+           </label><br/>
+           <label>
+             <input type="radio" ng-model="color.name" ng-value="specialValue">
+             Green
+           </label><br/>
+           <label>
+             <input type="radio" ng-model="color.name" value="blue">
+             Blue
+           </label><br/>
           <tt>color = {{color.name | json}}</tt><br/>
          </form>
          Note that `ng-value="specialValue"` sets radio item's value to be the value of `$scope.specialValue`.
@@ -933,9 +998,13 @@ var inputType = {
             }]);
         </script>
         <form name="myForm" ng-controller="ExampleController">
-           Value1: <input type="checkbox" ng-model="checkboxModel.value1"> <br/>
-           Value2: <input type="checkbox" ng-model="checkboxModel.value2"
-                          ng-true-value="'YES'" ng-false-value="'NO'"> <br/>
+           <label>Value1:
+             <input type="checkbox" ng-model="checkboxModel.value1">
+           </label><br/>
+           <label>Value2:
+             <input type="checkbox" ng-model="checkboxModel.value2"
+                    ng-true-value="'YES'" ng-false-value="'NO'">
+            </label><br/>
           <tt>value1 = {{checkboxModel.value1}}</tt><br/>
           <tt>value2 = {{checkboxModel.value2}}</tt><br/>
          </form>
@@ -1160,8 +1229,8 @@ function createDateInputType(type, regexp, parseDate, format) {
        // parser/formatter in the processing chain so that the model
        // contains some different data format!
        var parsedDate = parseDate(value, previousDate);
-        if (timezone === 'UTC') {
-          parsedDate.setMinutes(parsedDate.getMinutes() - parsedDate.getTimezoneOffset());
+        if (timezone) {
+          parsedDate = convertTimezoneToLocal(parsedDate, timezone);
        }
        return parsedDate;
      }
@@ -1174,9 +1243,8 @@ function createDateInputType(type, regexp, parseDate, format) {
      }
      if (isValidDate(value)) {
        previousDate = value;
-        if (previousDate && timezone === 'UTC') {
-          var timezoneOffset = 60000 * previousDate.getTimezoneOffset();
-          previousDate = new Date(previousDate.getTime() + timezoneOffset);
+        if (previousDate && timezone) {
+          previousDate = convertTimezoneToLocal(previousDate, timezone, true);
        }
        return $filter('date')(value, format, timezone);
      } else {
@@ -1400,9 +1468,15 @@ function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browser, $filt
 * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
 *    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=} 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 evaluates to 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$')`.<br />
+ *    **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ *    start at the index of the last search's match, thus not taking the whole input value into
+ *    account.
 * @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.
@@ -1433,9 +1507,15 @@ function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browser, $filt
 * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
 *    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=} 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 evaluates to 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$')`.<br />
+ *    **Note:** Avoid using the `g` flag on the RegExp, as it will cause each successive search to
+ *    start at the index of the last search's match, thus not taking the whole input value into
+ *    account.
 * @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.
@@ -1453,26 +1533,36 @@ function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browser, $filt
       </script>
       <div ng-controller="ExampleController">
         <form name="myForm">
-           User name: <input type="text" name="userName" ng-model="user.name" required>
-           <span class="error" ng-show="myForm.userName.$error.required">
-             Required!</span><br>
-           Last name: <input type="text" name="lastName" ng-model="user.last"
-             ng-minlength="3" ng-maxlength="10">
-           <span class="error" ng-show="myForm.lastName.$error.minlength">
-             Too short!</span>
-           <span class="error" ng-show="myForm.lastName.$error.maxlength">
-             Too long!</span><br>
+           <label>
+              User name:
+              <input type="text" name="userName" ng-model="user.name" required>
+           </label>
+           <div role="alert">
+             <span class="error" ng-show="myForm.userName.$error.required">
+              Required!</span>
+           </div>
+           <label>
+              Last name:
+              <input type="text" name="lastName" ng-model="user.last"
+              ng-minlength="3" ng-maxlength="10">
+           </label>
+           <div role="alert">
+             <span class="error" ng-show="myForm.lastName.$error.minlength">
+               Too short!</span>
+             <span class="error" ng-show="myForm.lastName.$error.maxlength">
+               Too long!</span>
+           </div>
         </form>
         <hr>
         <tt>user = {{user}}</tt><br/>
-         <tt>myForm.userName.$valid = {{myForm.userName.$valid}}</tt><br>
-         <tt>myForm.userName.$error = {{myForm.userName.$error}}</tt><br>
-         <tt>myForm.lastName.$valid = {{myForm.lastName.$valid}}</tt><br>
-         <tt>myForm.lastName.$error = {{myForm.lastName.$error}}</tt><br>
-         <tt>myForm.$valid = {{myForm.$valid}}</tt><br>
-         <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br>
-         <tt>myForm.$error.minlength = {{!!myForm.$error.minlength}}</tt><br>
-         <tt>myForm.$error.maxlength = {{!!myForm.$error.maxlength}}</tt><br>
+         <tt>myForm.userName.$valid = {{myForm.userName.$valid}}</tt><br/>
+         <tt>myForm.userName.$error = {{myForm.userName.$error}}</tt><br/>
+         <tt>myForm.lastName.$valid = {{myForm.lastName.$valid}}</tt><br/>
+         <tt>myForm.lastName.$error = {{myForm.lastName.$error}}</tt><br/>
+         <tt>myForm.$valid = {{myForm.$valid}}</tt><br/>
+         <tt>myForm.$error.required = {{!!myForm.$error.required}}</tt><br/>
+         <tt>myForm.$error.minlength = {{!!myForm.$error.minlength}}</tt><br/>
+         <tt>myForm.$error.maxlength = {{!!myForm.$error.maxlength}}</tt><br/>
       </div>
      </file>
      <file name="protractor.js" type="protractor">
@@ -35,7 +35,7 @@
           }]);
       </script>
       <div ng-controller="ExampleController">
-         Enter name: <input type="text" ng-model="name"><br>
+         <label>Enter name: <input type="text" ng-model="name"></label><br>
         Hello <span ng-bind="name"></span>!
       </div>
     </file>
@@ -96,8 +96,8 @@ var ngBindDirective = ['$compile', function($compile) {
           }]);
       </script>
       <div ng-controller="ExampleController">
-        Salutation: <input type="text" ng-model="salutation"><br>
-        Name: <input type="text" ng-model="name"><br>
+        <label>Salutation: <input type="text" ng-model="salutation"></label><br>
+        <label>Name: <input type="text" ng-model="name"></label><br>
        <pre ng-bind-template="{{salutation}} {{name}}!"></pre>
       </div>
     </file>
@@ -39,7 +39,9 @@ function classDirective(name, selector) {
        }

        function digestClassCounts(classes, count) {
-          var classCounts = element.data('$classCounts') || {};
+          // Use createMap() to prevent class assumptions involving property
+          // names in Object.prototype
+          var classCounts = element.data('$classCounts') || createMap();
          var classesToUpdate = [];
          forEach(classes, function(className) {
            if (count > 0 || classCounts[className]) {
@@ -96,12 +98,15 @@ function classDirective(name, selector) {
    }

    function arrayClasses(classVal) {
+      var classes = [];
      if (isArray(classVal)) {
-        return classVal;
+        forEach(classVal, function(v) {
+          classes = classes.concat(arrayClasses(v));
+        });
+        return classes;
      } else if (isString(classVal)) {
        return classVal.split(' ');
      } else if (isObject(classVal)) {
-        var classes = [];
        forEach(classVal, function(v, k) {
          if (v) {
            classes = classes.concat(k.split(' '));
@@ -129,16 +134,18 @@ function classDirective(name, selector) {
 * 1. If the expression evaluates to a string, the string should be one or more space-delimited class
 * names.
 *
- * 2. If the expression evaluates to an array, each element of the array should be a string that is
- * one or more space-delimited class names.
- *
- * 3. If the expression evaluates to an object, then for each key-value pair of the
+ * 2. If the expression evaluates to an object, then for each key-value pair of the
 * object with a truthy value the corresponding key is used as a class name.
 *
+ * 3. If the expression evaluates to an array, each element of the array should either be a string as in
+ * type 1 or an object as in type 2. This means that you can mix strings and objects together in an array
+ * to give you more control over what CSS classes appear. See the code below for an example of this.
+ *
+ *
 * The directive won't add duplicate classes if a particular class was already set.
 *
- * When the expression changes, the previously added classes are removed and only then the
- * new classes are added.
+ * When the expression changes, the previously added classes are removed and only then are the
+ * new classes added.
 *
 * @animations
 * **add** - happens just before the class is applied to the elements
@@ -155,22 +162,39 @@ function classDirective(name, selector) {
 * @example Example that demonstrates basic bindings via ngClass directive.
   <example>
     <file name="index.html">
-       <p ng-class="{strike: deleted, bold: important, red: error}">Map Syntax Example</p>
-       <input type="checkbox" ng-model="deleted"> deleted (apply "strike" class)<br>
-       <input type="checkbox" ng-model="important"> important (apply "bold" class)<br>
-       <input type="checkbox" ng-model="error"> error (apply "red" class)
+       <p ng-class="{strike: deleted, bold: important, 'has-error': error}">Map Syntax Example</p>
+       <label>
+          <input type="checkbox" ng-model="deleted">
+          deleted (apply "strike" class)
+       </label><br>
+       <label>
+          <input type="checkbox" ng-model="important">
+          important (apply "bold" class)
+       </label><br>
+       <label>
+          <input type="checkbox" ng-model="error">
+          error (apply "has-error" class)
+       </label>
       <hr>
       <p ng-class="style">Using String Syntax</p>
-       <input type="text" ng-model="style" placeholder="Type: bold strike red">
+       <input type="text" ng-model="style"
+              placeholder="Type: bold strike red" aria-label="Type: bold strike red">
       <hr>
       <p ng-class="[style1, style2, style3]">Using Array Syntax</p>
-       <input ng-model="style1" placeholder="Type: bold, strike or red"><br>
-       <input ng-model="style2" placeholder="Type: bold, strike or red"><br>
-       <input ng-model="style3" placeholder="Type: bold, strike or red"><br>
+       <input ng-model="style1"
+              placeholder="Type: bold, strike or red" aria-label="Type: bold, strike or red"><br>
+       <input ng-model="style2"
+              placeholder="Type: bold, strike or red" aria-label="Type: bold, strike or red 2"><br>
+       <input ng-model="style3"
+              placeholder="Type: bold, strike or red" aria-label="Type: bold, strike or red 3"><br>
+       <hr>
+       <p ng-class="[style4, {orange: warning}]">Using Array and Map Syntax</p>
+       <input ng-model="style4" placeholder="Type: bold, strike" aria-label="Type: bold, strike"><br>
+       <label><input type="checkbox" ng-model="warning"> warning (apply "orange" class)</label>
     </file>
     <file name="style.css">
       .strike {
-         text-decoration: line-through;
+           text-decoration: line-through;
       }
       .bold {
           font-weight: bold;
@@ -178,6 +202,13 @@ function classDirective(name, selector) {
       .red {
           color: red;
       }
+       .has-error {
+           color: red;
+           background-color: yellow;
+       }
+       .orange {
+           color: orange;
+       }
     </file>
     <file name="protractor.js" type="protractor">
       var ps = element.all(by.css('p'));
@@ -185,13 +216,13 @@ function classDirective(name, selector) {
       it('should let you toggle the class', function() {

         expect(ps.first().getAttribute('class')).not.toMatch(/bold/);
-         expect(ps.first().getAttribute('class')).not.toMatch(/red/);
+         expect(ps.first().getAttribute('class')).not.toMatch(/has-error/);

         element(by.model('important')).click();
         expect(ps.first().getAttribute('class')).toMatch(/bold/);

         element(by.model('error')).click();
-         expect(ps.first().getAttribute('class')).toMatch(/red/);
+         expect(ps.first().getAttribute('class')).toMatch(/has-error/);
       });

       it('should let you toggle string example', function() {
@@ -202,11 +233,18 @@ function classDirective(name, selector) {
       });

       it('array example should have 3 classes', function() {
-         expect(ps.last().getAttribute('class')).toBe('');
+         expect(ps.get(2).getAttribute('class')).toBe('');
         element(by.model('style1')).sendKeys('bold');
         element(by.model('style2')).sendKeys('strike');
         element(by.model('style3')).sendKeys('red');
-         expect(ps.last().getAttribute('class')).toBe('bold strike red');
+         expect(ps.get(2).getAttribute('class')).toBe('bold strike red');
+       });
+
+       it('array with map example should have 2 classes', function() {
+         expect(ps.last().getAttribute('class')).toBe('');
+         element(by.model('style4')).sendKeys('bold');
+         element(by.model('warning')).click();
+         expect(ps.last().getAttribute('class')).toBe('bold orange');
       });
     </file>
   </example>
@@ -256,8 +294,8 @@ function classDirective(name, selector) {
   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 ng.$animate#addClass $animate.addClass} and
-   {@link ng.$animate#removeClass $animate.removeClass}.
+   to view the step by step details of {@link $animate#addClass $animate.addClass} and
+   {@link $animate#removeClass $animate.removeClass}.
 */
 var ngClassDirective = classDirective('', true);

@@ -64,20 +64,20 @@
 * <example name="ngControllerAs" module="controllerAsExample">
 *   <file name="index.html">
 *    <div id="ctrl-as-exmpl" ng-controller="SettingsController1 as settings">
- *      Name: <input type="text" ng-model="settings.name"/>
- *      [ <a href="" ng-click="settings.greet()">greet</a> ]<br/>
+ *      <label>Name: <input type="text" ng-model="settings.name"/></label>
+ *      <button ng-click="settings.greet()">greet</button><br/>
 *      Contact:
 *      <ul>
 *        <li ng-repeat="contact in settings.contacts">
- *          <select ng-model="contact.type">
+ *          <select ng-model="contact.type" aria-label="Contact method" id="select_{{$index}}">
 *             <option>phone</option>
 *             <option>email</option>
 *          </select>
- *          <input type="text" ng-model="contact.value"/>
- *          [ <a href="" ng-click="settings.clearContact(contact)">clear</a>
- *          | <a href="" ng-click="settings.removeContact(contact)">X</a> ]
+ *          <input type="text" ng-model="contact.value" aria-labelledby="select_{{$index}}" />
+ *          <button ng-click="settings.clearContact(contact)">clear</button>
+ *          <button ng-click="settings.removeContact(contact)" aria-label="Remove">X</button>
 *        </li>
- *        <li>[ <a href="" ng-click="settings.addContact()">add</a> ]</li>
+ *        <li><button ng-click="settings.addContact()">add</button></li>
 *     </ul>
 *    </div>
 *   </file>
@@ -127,12 +127,12 @@
 *       expect(secondRepeat.element(by.model('contact.value')).getAttribute('value'))
 *           .toBe('john.smith@example.org');
 *
- *       firstRepeat.element(by.linkText('clear')).click();
+ *       firstRepeat.element(by.buttonText('clear')).click();
 *
 *       expect(firstRepeat.element(by.model('contact.value')).getAttribute('value'))
 *           .toBe('');
 *
- *       container.element(by.linkText('add')).click();
+ *       container.element(by.buttonText('add')).click();
 *
 *       expect(container.element(by.repeater('contact in settings.contacts').row(2))
 *           .element(by.model('contact.value'))
@@ -147,20 +147,20 @@
 * <example name="ngController" module="controllerExample">
 *  <file name="index.html">
 *   <div id="ctrl-exmpl" ng-controller="SettingsController2">
- *     Name: <input type="text" ng-model="name"/>
- *     [ <a href="" ng-click="greet()">greet</a> ]<br/>
+ *     <label>Name: <input type="text" ng-model="name"/></label>
+ *     <button ng-click="greet()">greet</button><br/>
 *     Contact:
 *     <ul>
 *       <li ng-repeat="contact in contacts">
- *         <select ng-model="contact.type">
+ *         <select ng-model="contact.type" id="select_{{$index}}">
 *            <option>phone</option>
 *            <option>email</option>
 *         </select>
- *         <input type="text" ng-model="contact.value"/>
- *         [ <a href="" ng-click="clearContact(contact)">clear</a>
- *         | <a href="" ng-click="removeContact(contact)">X</a> ]
+ *         <input type="text" ng-model="contact.value" aria-labelledby="select_{{$index}}" />
+ *         <button ng-click="clearContact(contact)">clear</button>
+ *         <button ng-click="removeContact(contact)">X</button>
 *       </li>
- *       <li>[ <a href="" ng-click="addContact()">add</a> ]</li>
+ *       <li>[ <button ng-click="addContact()">add</button> ]</li>
 *    </ul>
 *   </div>
 *  </file>
@@ -210,12 +210,12 @@
 *      expect(secondRepeat.element(by.model('contact.value')).getAttribute('value'))
 *          .toBe('john.smith@example.org');
 *
- *      firstRepeat.element(by.linkText('clear')).click();
+ *      firstRepeat.element(by.buttonText('clear')).click();
 *
 *      expect(firstRepeat.element(by.model('contact.value')).getAttribute('value'))
 *          .toBe('');
 *
- *      container.element(by.linkText('add')).click();
+ *      container.element(by.buttonText('add')).click();
 *
 *      expect(container.element(by.repeater('contact in contacts').row(2))
 *          .element(by.model('contact.value'))
@@ -4,6 +4,7 @@
 * @ngdoc directive
 * @name ngIf
 * @restrict A
+ * @multiElement
 *
 * @description
 * The `ngIf` directive removes or recreates a portion of the DOM tree based on an
@@ -46,7 +47,7 @@
 * @example
  <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/>
+      <label>Click me: <input type="checkbox" ng-model="checked" ng-init="checked=true" /></label><br/>
      Show when checked:
      <span ng-if="checked" class="animate-if">
        This is removed when the checkbox is unchecked.
@@ -178,8 +178,8 @@
 * @param {Object} angularEvent Synthetic event object.
 * @param {String} src URL of content to load.
 */
-var ngIncludeDirective = ['$templateRequest', '$anchorScroll', '$animate', '$sce',
-                  function($templateRequest,   $anchorScroll,   $animate,   $sce) {
+var ngIncludeDirective = ['$templateRequest', '$anchorScroll', '$animate',
+                  function($templateRequest,   $anchorScroll,   $animate) {
  return {
    restrict: 'ECA',
    priority: 400,
@@ -215,7 +215,7 @@ var ngIncludeDirective = ['$templateRequest', '$anchorScroll', '$animate', '$sce
          }
        };

-        scope.$watch($sce.parseAsResourceUrl(srcExp), function ngIncludeWatchAction(src) {
+        scope.$watch(srcExp, function ngIncludeWatchAction(src) {
          var afterAnimation = function() {
            if (isDefined(autoScrollExp) && (!autoScrollExp || scope.$eval(autoScrollExp))) {
              $anchorScroll();
--- a/Show More
+++ b/Show More