chore($AnimateRunner): examine the document more carefully

Some internal tests were failing because the `$document[0]` value
was null. This fix ensures that the if statement surrounding that
is more careful.

.travis.yml

@@ -62,7 +62,6 @@ notifications:
   webhooks:
     urls:
       - https://webhooks.gitter.im/e/d2120f3f2bb39a4531b2
-      - http://104.197.9.155:8484/hubot/travis/activity #hubot-server
-    on_success: always  # options: [always|never|change] default: always
+    on_success: change  # options: [always|never|change] default: always
     on_failure: always  # options: [always|never|change] default: always
-    on_start: always    # default: false
+    on_start: false     # default: false

CONTRIBUTING.md

@@ -193,8 +193,6 @@ We have very precise rules over how our git commit messages can be formatted.  T
 readable messages** that are easy to follow when looking through the **project history**.  But also,
 we use the git commit messages to **generate the AngularJS change log**.
 
-The commit message formatting can be added using a typical git workflow or through the use of a CLI wizard ([Commitizen](https://github.com/commitizen/cz-cli)). To use the wizard, run `npm run commit` in your terminal after staging your changes in git.
-
 ### Commit Message Format
 Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special
 format that includes a **type**, a **scope** and a **subject**:

LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2010-2016 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

TRIAGING.md

@@ -20,7 +20,7 @@ The following is done automatically so you don't have to worry about it:
 This process based on the idea of minimizing user pain
 [from this blog post](http://www.lostgarden.com/2008/05/improving-bug-triage-with-user-pain.html).
 
-1. Open the list of [non triaged issues](https://github.com/angular/angular.js/issues?q=is%3Aopen+sort%3Acreated-desc+no%3Amilestone)
+1. Open the list of [non triaged issues](https://github.com/angular/angular.js/issues?direction=desc&milestone=none&page=1&sort=created&state=open)
     * Sort by submit date, with the newest issues first
     * You don't have to do issues in order; feel free to pick and choose issues as you please.
     * You can triage older issues as well

angularFiles.js

@@ -102,7 +102,6 @@ var angularFiles = {
       'src/ngAnimate/animateJsDriver.js',
       'src/ngAnimate/animateQueue.js',
       'src/ngAnimate/animation.js',
-      'src/ngAnimate/ngAnimateSwap.js',
       'src/ngAnimate/module.js'
     ],
     'ngCookies': [

benchmarks/largetable-bp/main.html

@@ -8,20 +8,20 @@
       Large table rendered with AngularJS
       </p>
 
-      <div><label><input type="radio" ng-model="benchmarkType" value="none">none: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="baselineBinding">baseline binding: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="baselineInterpolation">baseline interpolation: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="ngBind">ngBind: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="ngBindOnce">ngBindOnce: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="interpolation">interpolation: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="bindOnceInterpolation">interpolation + bind-once: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="interpolationAttr">attribute interpolation: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="ngBindFn">ngBind + fnInvocation: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="interpolationFn">interpolation + fnInvocation: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="ngBindFilter">ngBind + filter: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="interpolationFilter">interpolation + filter: </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="ngModelConstName">ngModel (const name): </label></div>
-      <div><label><input type="radio" ng-model="benchmarkType" value="ngModelInterpName">ngModel (interp name): </label></div>
+      <div>none: <input type="radio" ng-model="benchmarkType" value="none"></div>
+      <div>baseline binding: <input type="radio" ng-model="benchmarkType" value="baselineBinding"></div>
+      <div>baseline interpolation: <input type="radio" ng-model="benchmarkType" value="baselineInterpolation"></div>
+      <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">

bower.json

@@ -1,6 +1,5 @@
 {
   "name": "AngularJS",
-  "license": "MIT",
   "devDependencies": {
     "jquery": "2.1.1",
     "closure-compiler": "https://dl.google.com/closure-compiler/compiler-20140814.zip",

docs/app/assets/css/docs.css

@@ -315,13 +315,8 @@ iframe.example {
   color:white;
 }
 
-.search-results-group .search-results {
-  padding: 0 5px 0;
-  list-style-type: none;
-}
-
 .search-results-frame > .search-results-group:first-child > .search-results {
-  border-right:1px solid #222;
+  border-right:1px solid #050505;
 }
 
 .search-results-group.col-group-api { width:30%; }
@@ -330,57 +325,10 @@ iframe.example {
 .search-results-group.col-group-misc,
 .search-results-group.col-group-error { width:15%; float: right; }
 
-@supports ((column-count: 2) or (-moz-column-count: 2) or (-ms-column-count: 2) or (-webkit-column-count: 2)) {
-  .search-results-group.col-group-api .search-results {
-    -moz-column-count: 2;
-    -ms-column-count: 2;
-    -webkit-column-count: 2;
-    column-count: 2;
-    /* Prevent bullets in the second column from being hidden in Chrome and IE */
-    -webkit-column-gap: 2em;
-    -ms-column-gap: 2em;
-    column-gap: 2em;
-  }
-}
-
-.search-results-group .search-result {
-  word-wrap: break-word;
-  -webkit-hyphens: auto;
-  -moz-hyphens: auto;
-  -ms-hyphens: auto;
-  hyphens: auto;
-  -ms-column-break-inside: avoid;
-  -webkit-column-break-inside: avoid;
-  -moz-column-break-inside: avoid; /* Unsupported */
-  column-break-inside: avoid;
-  text-indent: -0.65em;  /* Make sure line wrapped words are aligned vertically */
-}
-
-@supports (-moz-column-count: 2) {
-  .search-results-group .search-result {
-    /* Prevents column breaks inside words in FF, but has adverse effects in IE11 and Chrome */
-    overflow: hidden;
-    padding-left: 1em; /* In FF the list item bullet is otherwise  hidden */
-    margin-left: -1em; /* offset the padding left */
-  }
-}
-
-.search-result:before {
-  content: "\002D\00A0"; /* Dash and non-breaking space as List item type */
-  position: relative;
-}
 
 .search-results-group.col-group-api .search-result {
   width:48%;
   display:inline-block;
-  padding-left: 12px;
-}
-
-@supports ((column-count: 2) or (-moz-column-count: 2) or (-ms-column-count: 2) or (-webkit-column-count: 2)) {
-  .search-results-group.col-group-api .search-result {
-    width:auto;
-    display: list-item;
-  }
 }
 
 .search-close {
@@ -740,11 +688,6 @@ ul.events > li {
     padding-bottom:60px;
     text-align:left;
   }
-
-  .search-results-frame > .search-results-group:first-child > .search-results {
-    border-right: none;
-  }
-
   .search-results-group {
     float:none!important;
     display:block!important;
@@ -752,42 +695,14 @@ ul.events > li {
     border:0!important;
     padding:0!important;
   }
-
-  @supports ((column-count: 2) or (-moz-column-count: 2) or (-ms-column-count: 2) or (-webkit-column-count: 2)) {
-    .search-results-group .search-results {
-      -moz-column-count: 2;
-      -ms-column-count: 2;
-      -webkit-column-count: 2;
-      column-count: 2;
-    }
-  }
-
   .search-results-group .search-result {
     display:inline-block!important;
     padding:0 5px;
     width:auto!important;
-    text-indent: initial;
-    margin-left: 0;
   }
-
   .search-results-group .search-result:after {
     content:", ";
   }
-
-  .search-results-group .search-result:before {
-    content: "";
-  }
-
-  @supports ((column-count: 2) or (-moz-column-count: 2) or (-ms-column-count: 2) or (-webkit-column-count: 2)) {
-    .search-results-group .search-result {
-      display: list-item !important;
-    }
-
-    .search-results-group .search-result:after {
-      content: "";
-    }
-  }
-
   #wrapper {
     padding-bottom:0px;
   }

docs/app/assets/js/search-worker.js

@@ -3,7 +3,7 @@
 /* global importScripts, onmessage: true, postMessage, lunr */
 
 // Load up the lunr library
-importScripts('../components/lunr.js-0.5.12/lunr.min.js');
+importScripts('../components/lunr.js-0.4.2/lunr.min.js');
 
 // Create the lunr index - the docs should be an array of object, each object containing
 // the path and search terms for a page

docs/app/src/examples.js

@@ -24,26 +24,7 @@ angular.module('examples', [])
 
 
 .factory('openPlunkr', ['formPostData', '$http', '$q', function(formPostData, $http, $q) {
-
-    var COPYRIGHT = 'Copyright ' + (new Date()).getFullYear() + ' Google Inc. All Rights Reserved.\n'
-     + 'Use of this source code is governed by an MIT-style license that\n'
-     + 'can be found in the LICENSE file at http://angular.io/license';
-    var COPYRIGHT_JS_CSS = '\n\n/*\n' + COPYRIGHT + '\n*/';
-    var COPYRIGHT_HTML = '\n\n<!-- \n' + COPYRIGHT + '\n-->';
-    function getCopyright(filename) {
-      switch (filename.substr(filename.lastIndexOf('.'))) {
-        case '.html':
-          return COPYRIGHT_HTML;
-        case '.js':
-        case '.css':
-          return COPYRIGHT_JS_CSS;
-        case '.md':
-          return COPYRIGHT;
-      }
-      return '';
-    }
-
-    return function(exampleFolder, clickEvent) {
+  return function(exampleFolder, clickEvent) {
 
     var exampleName = 'AngularJS Example';
     var newWindow = clickEvent.ctrlKey || clickEvent.metaKey;
@@ -86,7 +67,7 @@ angular.module('examples', [])
         var postData = {};
 
         angular.forEach(files, function(file) {
-          postData['files[' + file.name + ']'] = file.content + getCopyright(file.name);
+          postData['files[' + file.name + ']'] = file.content;
         });
 
         postData['tags[0]'] = "angularjs";

docs/app/src/search.js

@@ -11,15 +11,7 @@ angular.module('search', [])
     var MIN_SEARCH_LENGTH = 2;
     if(q.length >= MIN_SEARCH_LENGTH) {
       docsSearch(q).then(function(hits) {
-        // Make sure the areas are always in the same order
-        var results = {
-          api: [],
-          guide: [],
-          tutorial: [],
-          error: [],
-          misc: []
-        };
-
+        var results = {};
         angular.forEach(hits, function(hit) {
           var area = hit.area;
 

docs/bower.json

@@ -2,7 +2,7 @@
   "name": "AngularJS-docs-app",
   "dependencies": {
     "jquery": "2.1.1",
-    "lunr.js": "0.5.12",
+    "lunr.js": "0.4.3",
     "open-sans-fontface": "1.0.4",
     "google-code-prettify": "1.0.1",
     "bootstrap": "3.1.1"

docs/config/templates/indexPage.template.html

@@ -147,13 +147,13 @@
         <div class="search-results-container" ng-show="hasResults">
           <div class="container">
             <div class="search-results-frame">
-              <div ng-repeat="(key, value) in results track by key" class="search-results-group" ng-class="colClassName + ' col-group-' + key" ng-show="value.length > 0">
+              <div ng-repeat="(key, value) in results" class="search-results-group" ng-class="colClassName + ' col-group-' + key">
                 <h4 class="search-results-group-heading">{{ key }}</h4>
-                <ul class="search-results">
-                  <!-- Do not insert a line break between li and a. Chrome will insert an actual line-break, which breaks the list item view.
-                  TODO: use a html minifier instead -->
-                  <li ng-repeat="item in value" class="search-result"><a ng-click="hideResults()" ng-href="{{ item.path }}">{{ item.name }}</a></li>
-                </ul>
+                <div class="search-results">
+                  <div ng-repeat="item in value" class="search-result">
+                    - <a ng-click="hideResults()" ng-href="{{ item.path }}">{{ item.name }}</a>
+                  </div>
+                </div>
               </div>
             </div>
             <a href="" ng-click="hideResults()" class="search-close">
@@ -220,7 +220,7 @@
         <p class="pull-right"><a back-to-top>Back to top</a></p>
 
         <p>
-          Super-powered by Google  ©2010-2016
+          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}}" title="Changelog of this version of Angular JS">

docs/content/error/$injector/modulerr.ngdoc

@@ -6,9 +6,6 @@
 This error occurs when a module fails to load due to some exception. The error
 message above should provide additional context.
 
-A common reason why the module fails to load is that you've forgotten to
-include the file with the defined module or that the file couldn't be loaded.
-
 ### Using `ngRoute`
 
 In AngularJS `1.2.0` and later, `ngRoute` has been moved to its own module.
@@ -27,4 +24,4 @@ angular.module('ng').filter('tel', function (){});
 
 Instead create your own module and add it as a dependency to your application's top-level module.
 See [#9692](https://github.com/angular/angular.js/issues/9692) and
-[#7709](https://github.com/angular/angular.js/issues/7709) for more information
+[#7709](https://github.com/angular/angular.js/issues/7709) for more information

docs/content/error/$injector/unpr.ngdoc

@@ -81,6 +81,3 @@ angular.module('myModule', [])
     // a scope object cannot be injected into a service.
   }]);
 ```
-
-If you encounter this error only with minified code, consider using `ngStrictDi` (see
-{@link ng.directive:ngApp ngApp}) to provoke the error with the non-minified source.

docs/content/error/$parse/isecwindow.ngdoc

@@ -14,32 +14,3 @@ perform this check - it's up to the developer to not expose such sensitive and p
 directly on the scope chain.
 
 To resolve this error, avoid Window access.
-
-### Common CoffeeScript Issue
-
-Be aware that if you are using CoffeeScript, it automatically returns the value of the last statement in a
-function. So for instance
-
-```coffeescript
-  scope.foo = ->
-    window.open 'https://example.com'
-```
-
-compiles to something like
-
-```js
-  scope.foo = function() {
-    return window.open('https://example.com');
-  };
-```
-
-You can see that this function will return the result of calling `window.open`, which is a `Window`
-object.
-
-You can avoid this by explicitly returning something else from the function:
-
-```coffeescript
-  scope.foo = ->
-    window.open 'https://example.com'
-    return true;
-```

docs/content/error/$rootScope/inprog.ngdoc

@@ -161,7 +161,7 @@ In this second scenario, we are already inside a `$digest` when the ngFocus dire
 call to `$apply()`, causing this error to be thrown.
 
 It is possible to workaround this problem by moving the call to set the focus outside of the digest,
-by using `$timeout(fn, 0, false)`, where the `false` value tells Angular not to wrap this `fn` in an
+by using `$timeout(fn, 0, false)`, where the `false` value tells Angular not to wrap this `fn` in a
 `$apply` block:
 
 ```
@@ -200,7 +200,7 @@ the top of the call stack.
 Once you have identified this call you work your way up the stack to see what the problem is.
 
 * If the second call was made in your application code then you should look at why this code has been
-called from within an `$apply`/`$digest`.  It may be a simple oversight or maybe it fits with the
+called from within a `$apply`/`$digest`.  It may be a simple oversight or maybe it fits with the
 sync/async scenario described earlier.
 
 * If the second call was made inside an Angular directive then it is likely that it matches the second

docs/content/error/$sanitize/badparse.ngdoc

@@ -0,0 +1,11 @@
+@ngdoc error
+@name $sanitize:badparse
+@fullName Parsing Error while Sanitizing
+@description
+
+This error occurs when the HTML string passed to '$sanitize' can't be parsed by the sanitizer.
+The error contains part of the html string that can't be parsed.
+
+The parser is more strict than a typical browser parser, so it's possible that some obscure input would produce this error despite the string being recognized as valid HTML by a browser.
+
+If a valid html code results in this error, please file a bug.

docs/content/error/$sanitize/noinert.ngdoc

@@ -1,10 +0,0 @@
-@ngdoc error
-@name $sanitize:noinert
-@fullName Can't create an inert html document
-@description
-
-This error occurs when `$sanitize` sanitizer determines that `document.implementation.createHTMLDocument ` api is not supported by the current browser.
-
-This api is necessary for safe parsing of HTML strings into DOM trees and without it the sanitizer can't sanitize the input.
-
-The api is present in all supported browsers including IE 9.0, so the presence of this error usually indicates that Angular's `$sanitize` is being used on an unsupported platform.

docs/content/error/$sanitize/uinput.ngdoc

@@ -1,13 +0,0 @@
-@ngdoc error
-@name $sanitize:uinput
-@fullName Failed to sanitize html because the input is unstable
-@description
-
-This error occurs when `$sanitize` sanitizer tries to check the input for possible mXSS payload and the verification
-errors due to the input mutating indefinitely. This could be a sign that the payload contains code exploiting an mXSS
-vulnerability in the browser.
-
-mXSS attack exploit browser bugs that cause some browsers parse a certain html strings into DOM, which once serialized
-doesn't match the original input. These browser bugs can be exploited by attackers to create payload which looks
-harmless to sanitizers, but due to mutations caused by the browser are turned into dangerous code once processed after
-sanitization.

docs/content/error/linky/notstring.ngdoc

@@ -1,16 +0,0 @@
-@ngdoc error
-@name linky:notstring
-@fullName Not a string
-@description
-
-This error occurs when {@link ngSanitize.linky linky} is used with a non-empty, non-string value:
-```html
-<div ng-bind-html="42 | linky"></div>
-```
-
-`linky` is supposed to be used with string values only, and therefore assumes that several methods
-(such as `.match()`) are available on the passed in value.
-The value can be initialized asynchronously and therefore null or undefined won't throw this error.
-
-If you want to pass non-string values to `linky` (e.g. Objects whose `.toString()` should be
-utilized), you need to manually convert them to strings.

docs/content/error/orderBy/notarray.ngdoc

@@ -1,52 +0,0 @@
-@ngdoc error
-@name orderBy:notarray
-@fullName Value is not array-like
-@description
-
-This error occurs when {@link ng.orderBy orderBy} is not passed an array-like value:
-```html
-<div ng-repeat="(key, value) in myObj | orderBy:someProp">
-  {{ key }} : {{ value }}
-</div>
-```
-
-`orderBy` must be used with an array-like value 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 use `orderBy` to order the properties of an object, you can create your own array based on that object:
-```js
-angular.module('aModule', [])
-  .controller('aController', function($scope) {
-    var myObj = {
-      one: {id: 1, name: 'Some thing'},
-      two: {id: 2, name: 'Another thing'},
-      three: {id: 3, name: 'A third thing'}
-    };
-
-    $scope.arrFromMyObj = Object.keys(myObj).map(function(key) {
-      return myObj[key];
-    });
-  });
-```
-That can be used as:
-```html
-<label>
-  Order by:
-  <select ng-model="orderProp" ng-options="prop for prop in ['id', 'name']"></select>
-</label>
-<div ng-repeat="item in arrFromMyObj | orderBy:orderProp">
-  [{{ item.id }}] {{ item.name }}
-</div>
-```
-
-You could as well convert the object to an array using a filter such as
-[toArrayFilter](https://github.com/petebacondarwin/angular-toArrayFilter):
-```html
-<label>
-  Order by:
-  <select ng-model="orderProp" ng-options="prop for prop in ['id', 'name']"></select>
-</label>
-<div ng-repeat="item in myObj | toArray:false | orderBy:orderProp">
-  [{{ item.id }}] {{ item.name }}
-</div>
-```

docs/content/guide/accessibility.ngdoc

@@ -33,9 +33,6 @@ Currently, ngAria interfaces with the following directives:
 
  * {@link guide/accessibility#ngmodel ngModel}
  * {@link guide/accessibility#ngdisabled ngDisabled}
- * {@link guide/accessibility#ngrequired ngRequired}
- * {@link guide/accessibility#ngvaluechecked ngChecked}
- * {@link guide/accessibility#ngvaluechecked ngValue}
  * {@link guide/accessibility#ngshow ngShow}
  * {@link guide/accessibility#nghide ngHide}
  * {@link guide/accessibility#ngclick ngClick}
@@ -44,7 +41,7 @@ Currently, ngAria interfaces with the following directives:
 
 <h2 id="ngmodel">ngModel</h2>
 
-Much of ngAria's heavy lifting happens in the {@link ng.ngModel ngModel}
+Much 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 role or type of `checkbox`, `radio`, `range` or `textbox`.
 
@@ -137,75 +134,35 @@ attributes (if they have not been explicitly specified by the developer):
 
 ngAria will also add `tabIndex`, ensuring custom elements with these roles will be reachable from
 the keyboard. It is still up to **you** as a developer to **ensure custom controls will be
-accessible**. As a rule, any time you create a widget involving user interaction, be sure to test
+accessible**. As a rule, any time you create a widget involving user interaction, be sure to test 
 it with your keyboard and at least one mobile and desktop screen reader.
 
-<h2 id="ngvaluechecked">ngValue and ngChecked</h2>
-
-To ease the transition between native inputs and custom controls, ngAria now supports
-{@link ng.ngValue ngValue} and {@link ng.ngChecked ngChecked}.
-The original directives were created for native inputs only, so ngAria extends
-support to custom elements by managing `aria-checked` for accessibility.
-
-###Example
-
-```html
-<custom-checkbox ng-checked="val"></custom-checkbox>
-<custom-radio-button ng-value="val"></custom-radio-button>
-```
-
-Becomes:
-
-```html
-<custom-checkbox ng-checked="val" aria-checked="true"></custom-checkbox>
-<custom-radio-button ng-value="val" aria-checked="true"></custom-radio-button>
-```
-
 <h2 id="ngdisabled">ngDisabled</h2>
 
 The `disabled` attribute is only valid for certain elements such as `button`, `input` and
 `textarea`. To properly disable custom element directives such as `<md-checkbox>` or `<taco-tab>`,
-using ngAria with {@link ng.ngDisabled ngDisabled} will also
+using ngAria with [ngDisabled](https://docs.angularjs.org/api/ng/directive/ngDisabled) will also
 add `aria-disabled`. This tells assistive technologies when a non-native input is disabled, helping
 custom controls to be more accessible.
 
 ###Example
 
 ```html
-<md-checkbox ng-disabled="disabled"></md-checkbox>
+<md-checkbox ng-disabled="disabled">
 ```
 
 Becomes:
 
 ```html
-<md-checkbox disabled aria-disabled="true"></md-checkbox>
+<md-checkbox disabled aria-disabled="true">
 ```
 
 >You can check whether a control is legitimately disabled for a screen reader by visiting
 [chrome://accessibility](chrome://accessibility) and inspecting [the accessibility tree](http://www.paciellogroup.com/blog/2015/01/the-browser-accessibility-tree/).
 
-<h2 id="ngrequired">ngRequired</h2>
-
-The boolean `required` attribute is only valid for native form controls such as `input` and
-`textarea`. To properly indicate custom element directives such as `<md-checkbox>` or `<custom-input>`
-as required, using ngAria with {@link ng.ngRequired ngRequired} will also add
-`aria-required`. This tells accessibility APIs when a custom control is required.
-
-###Example
-
-```html
-<md-checkbox ng-required="val"></md-checkbox>
-```
-
-Becomes:
-
-```html
-<md-checkbox ng-required="val" aria-required="true"></md-checkbox>
-```
-
 <h2 id="ngshow">ngShow</h2>
 
->The {@link ng.ngShow ngShow} directive shows or hides the
+>The [ngShow](https://docs.angularjs.org/api/ng/directive/ngShow) directive shows or hides the
 given HTML element based on the expression provided to the `ngShow` attribute. The element is
 shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
 
@@ -242,7 +199,7 @@ Becomes:
 
 <h2 id="nghide">ngHide</h2>
 
->The {@link ng.ngHide ngHide} directive shows or hides the
+>The [ngHide](https://docs.angularjs.org/api/ng/directive/ngHide) directive shows or hides the
 given HTML element based on the expression provided to the `ngHide` attribute. The element is
 shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.
 
@@ -251,7 +208,7 @@ The default CSS for `ngHide`, the inverse method to `ngShow`, makes ngAria redun
 `display: none`. See explanation for {@link guide/accessibility#ngshow ngShow} when overriding the default CSS.
 
 <h2><span id="ngclick">ngClick</span> and <span id="ngdblclick">ngDblclick</span></h2>
-If `ng-click` or `ng-dblclick` is encountered, ngAria will add `tabindex="0"` to any element not in
+If `ng-click` or `ng-dblclick` is encountered, ngAria will add `tabindex="0"` to any element not in 
 a node blacklist:
 
  * Button
@@ -261,14 +218,14 @@ a node blacklist:
  * Select
  * Details/Summary
 
-To fix widespread accessibility problems with `ng-click` on `div` elements, ngAria will
+To fix widespread accessibility problems with `ng-click` on `div` elements, ngAria will 
 dynamically bind a keypress event by default as long as the element isn't in the node blacklist.
-You can turn this functionality on or off with the `bindKeypress` configuration option.
+You can turn this functionality on or off with the `bindKeypress` configuration option. 
 
 ngAria will also add the `button` role to communicate to users of assistive technologies. This can
 be disabled with the `bindRoleForClick` configuration option.
 
-For `ng-dblclick`, you must still manually add `ng-keypress` and a role to non-interactive elements
+For `ng-dblclick`, you must still manually add `ng-keypress` and a role to non-interactive elements 
 such as `div` or `taco-button` to enable keyboard access.
 
 <h3>Example</h3>

docs/content/guide/animations.ngdoc

@@ -274,37 +274,6 @@ myModule.directive('my-directive', ['$animate', function($animate) {
 }]);
 ```
 
-## Preventing flicker before an animation starts
-
-When nesting elements with structural animations such as `ngIf` into elements that have class-based
-animations such as `ngClass`, it sometimes happens that before the actual animation starts, there is a brief flicker or flash of content
-where the animated element is briefly visible.
-
-To prevent this, you can apply styles to the `ng-[event]-prepare` class, which is added as soon as an animation is initialized,
-but removed before the actual animation starts (after waiting for a $digest). This class is only added for *structural*
-animations (`enter`, `move`, and `leave`).
-
-Here's an example where you might see flickering:
-
-```html
-<div ng-class="{red: myProp}">
-  <div ng-class="{blue: myProp}">
-    <div class="message" ng-if="myProp"></div>
-  </div>
-</div>
-```
-
-It is possible that during the `enter` event, the `.message` div will be briefly visible before it starts animating.
-In that case, you can add styles to the CSS that make sure the element stays hidden before the animation starts:
-
-```css
-.message.ng-enter-prepare {
-  opacity: 0;
-}
-
-/* Other animation styles ... */
-```
-
 ## More about animations
 
 For a full breakdown of each method available on `$animate`, see the {@link ng.$animate API documentation}.

docs/content/guide/component.ngdoc

@@ -1,446 +0,0 @@
-@ngdoc overview
-@name Components
-@sortOrder 305
-@description
-
-# Understanding Components
-
-In Angular, a Component is a special kind of {@link guide/directive directive} that uses a simpler
-configuration which is suitable for a component-based application structure.
-
-This makes it easier to write an app in a way that's similar to using Web Components or using Angular
-2's style of application architecture.
-
-Advantages of Components:
-- simpler configuration than plain directives
-- promote sane defaults and best practices
-- optimized for component-based architecture
-- writing component directives will make it easier to upgrade to Angular 2
-
-When not to use Components:
-
-- for directives that rely on DOM manipulation, adding event listeners etc, because the compile
-and link functions are unavailable
-- when you need advanced directive definition options like priority, terminal, multi-element
-- when you want a directive that is triggered by an attribute or CSS class, rather than an element
-
-## Creating and configuring a Component
-
-Components can be registered using the `.component()` method of an Angular module (returned by {@link module `angular.module()`}). The method takes two arguments:
-
-  * The name of the Component (as string).
-  * The Component config object (note that, unlike the `.directive()` method, this method does **not** take a factory function.
-
-<example name="heroComponentSimple" module="heroApp">
-<file name="index.js">
-  angular.module('heroApp', []).controller('mainCtrl', function() {
-    this.hero = {
-      name: 'Spawn'
-    };
-  });
-</file>
-<file name="heroDetail.js">
-
-  function HeroDetailController() {
-
-  }
-
-  angular.module('heroApp').component('heroDetail', {
-    templateUrl: 'heroDetail.html',
-    controller: HeroDetailController,
-    bindings: {
-      hero: '='
-    }
-  });
-</file>
-<file name="index.html">
-  <!-- components match only elements -->
-  <div ng-controller="mainCtrl as ctrl">
-    <b>Hero</b><br>
-    <hero-detail hero="ctrl.hero"></hero-detail>
-  </div>
-</file>
-<file name="heroDetail.html">
-  <span>Name: {{$ctrl.hero.name}}</span>
-</file>
-</example>
-
-It's also possible to add components via {@link $compileProvider#component} in a module's config phase.
-
-### Comparison between Directive definition and Component definition
-
-|                   | Directive            | Component       |
-|-------------------|----------------------|-----------------|
-| bindings          | No                   | Yes (binds to controller)      |
-| bindToController  | Yes (default: false) | No (use bindings instead)       |
-| compile function  | Yes                  | No       |
-| controller        | Yes                  | Yes (default `function() {}`)     |
-| controllerAs      | Yes (default: false) | Yes (default: `$ctrl`)       |
-| link functions    | Yes                  | No       |
-| multiElement      | Yes                  | No       |
-| priority          | Yes                  | No       |
-| require           | Yes                  | Yes      |
-| restrict          | Yes                  | No (restricted to elements only)      |
-| scope             | Yes (default: false) | No (scope is always isolate)      |
-| template          | Yes                  | Yes, injectable      |
-| templateNamespace | Yes                  | No       |
-| templateUrl       | Yes                  | Yes, injectable       |
-| terminal          | Yes                  | No       |
-| transclude        | Yes (default: false) | Yes (default: false)      |
-
-
-## Component-based application architecture
-
-As already mentioned, the component helper makes it easier to structure your application with
-a component-based architecture. But what makes a component beyond the options that
-the component helper has?
-
-- **Components only control their own View and Data:**
-Components should never modify any data or DOM that is out of their own scope. Normally, in Angular
-it is possible to modify data anywhere in the application through scope inheritance and watches. This
-is practical, but can also lead to problems when it is not clear which part of the application is
-responsible for modifying the data. That is why component directives use an isolate scope, so a whole
-class of scope manipulation is not possible.
-
-- **Components have a well-defined public API - Inputs and Outputs:**
-However, scope isolation only goes so far, because Angular uses two-way binding. So if you pass
-an object to a component like this - `bindings: {item: '='}`, and modify one of its properties, the
-change will be reflected in the parent component. For components however, only the component that owns
-the data should modify it, to make it easy to reason about what data is changed, and when. For that reason,
-components should follow a few simple conventions:
-
-  - Inputs are realized with `@` and `=` bindings
-    ```js
-      bindings: {
-        hero: `=`,
-      }
-    ```
-  - Outputs are realized with `&` bindings, which function as callbacks to component events
-    ```js
-      bindings: {
-        onDelete: '&',
-        onUpdate: '&'
-      }
-    ```
-  - Instead of manipulating Input Data, the component calls the correct Output Event with the changed data.
-    For a deletion, that means the component doesn't delete the `hero` itself, but sends it back to
-    the owner component via the correct event.
-    ```html
-        <button ng-click="$ctrl.onDelete({hero: hero})">Delete</button>
-    ```
-  - That way, the parent component can decide what to do with the event (e.g. delete an item or update the properties)
-    ```js
-      ctrl.deleteHero(hero) {
-        $http.delete(...).then(function() {
-          var idx = ctrl.list.indexOf(hero);
-          if (idx >= 0) {
-            ctrl.list.splice(idx, 1);
-          }
-        });
-      }
-    ```
-
-- **An application is a tree of components:**
-Ideally, the whole application should be a tree of components that implement clearly defined inputs
-and outputs, and minimize two-way data binding. That way, it's easier to predict when data changes and what the state
-of a component is.
-
-## Example of a component tree
-
-The following example expands on the simple component example and incorporates the concepts we introduced
-above:
-
-Instead of an ngController, we now have a heroList component that holds the data of
-different heroes, and creates a heroDetail for each of them.
-
-The heroDetail component now contains the following new functionality:
-- a delete button that calls the bound onDelete function of the heroList component
-- an input to change the hero location, in the form of a reusable editableField component. Instead
-of manipulating the hero object itself, it sends the changes upwards to the heroDetail, which sends
-it upwards to the heroList component, which updates it.
-
-<example name="heroComponentTree" module="heroApp">
-<file name="index.js">
-  var mode = angular.module('heroApp', []);
-</file>
-
-<file name="heroList.js">
-  function HeroListController($scope, $element, $attrs) {
-    var ctrl = this;
-
-    // This would be loaded by $http etc.
-    ctrl.list = [
-      {
-        name: 'Superman',
-        location: ''
-      },
-      {
-        name: 'Batman',
-        location: 'Wayne Manor'
-      }
-    ];
-
-    ctrl.updateHero = function(hero, prop, value) {
-      hero[prop] = value;
-    };
-
-    ctrl.deleteHero = function(hero) {
-      var idx = ctrl.list.indexOf(hero);
-      if (idx >= 0) {
-        ctrl.list.splice(idx, 1);
-      }
-    };
-  }
-
-  angular.module('heroApp').component('heroList', {
-    templateUrl: 'heroList.html',
-    controller: HeroListController
-  });
-
-</file>
-
-<file name="heroDetail.js">
-  function HeroDetailController($scope, $element, $attrs) {
-    var ctrl = this;
-
-    ctrl.update = function(prop, value) {
-      ctrl.onUpdate({hero: ctrl.hero, prop: prop, value: value});
-    };
-  }
-
-  angular.module('heroApp').component('heroDetail', {
-    templateUrl: 'heroDetail.html',
-    controller: HeroDetailController,
-    bindings: {
-      hero: '=',
-      onDelete: '&',
-      onUpdate: '&'
-    }
-  });
-</file>
-
-<file name="editableField.js">
-
-  function EditableFieldController($scope, $element, $attrs) {
-    var ctrl = this;
-    this.editMode = false;
-
-    this.handleModeChange = function() {
-      if (ctrl.editMode) {
-        ctrl.onUpdate({value: ctrl.fieldValue});
-        ctrl.fieldValueCopy = ctrl.fieldValue;
-      }
-      ctrl.editMode = !ctrl.editMode;
-    };
-
-    this.reset = function() {
-      ctrl.fieldValue = ctrl.fieldValueCopy;
-    };
-
-    this.$onInit = function() {
-      // Make a copy of the initial value to be able to reset it later
-      this.fieldValueCopy = this.fieldValue;
-
-      // Set a default fieldType
-      if (!this.fieldType) {
-        this.fieldType = 'text';
-      }
-    };
-  }
-
-  angular.module('heroApp').component('editableField', {
-    templateUrl: 'editableField.html',
-    controller: EditableFieldController,
-    bindings: {
-      fieldValue: '@',
-      fieldType: '@',
-      onUpdate: '&'
-    }
-  });
-</file>
-<file name="index.html">
-  <hero-list></hero-list>
-</file>
-<file name="heroList.html">
-  <b>Heroes</b><br>
-  <hero-detail ng-repeat="hero in $ctrl.list" hero="hero" on-delete="$ctrl.deleteHero(hero)" on-update="$ctrl.updateHero(hero, prop, value)"></hero-detail>
-</file>
-<file name="heroDetail.html">
-  <hr>
-  <div>
-    Name: {{$ctrl.hero.name}}<br>
-    Location: <editable-field field-value="{{$ctrl.hero.location}}" field-type="text" on-update="$ctrl.update('location', value)"></editable-field><br>
-    <button ng-click="$ctrl.onDelete({hero: $ctrl.hero})">Delete</button>
-  </div>
-</file>
-<file name="editableField.html">
-  <span ng-switch="$ctrl.editMode">
-    <input ng-switch-when="true" type="text" ng-model="$ctrl.fieldValue">
-    <span ng-switch-default>{{$ctrl.fieldValue}}</span>
-  </span>
-  <button ng-click="$ctrl.handleModeChange()">{{$ctrl.editMode ? 'Save' : 'Edit'}}</button>
-  <button ng-if="$ctrl.editMode" ng-click="$ctrl.reset()">Reset</button>
-</file>
-</example>
-
-## Components as route templates
-Components are also useful as route templates (e.g. when using {@link ngRoute ngRoute}). In a component-based
-application, every view is a component:
-
-```js
-  var myMod = angular.module('myMod', ['ngRoute']);
-  myMod.component('home', {
-    template: '<h1>Home</h1><p>Hello, {{ $ctrl.user.name }} !</p>',
-    controller: function() {
-      this.user = {name: 'world'};
-    }
-  });
-  myMod.config(function($routeProvider) {
-    $routeProvider.when('/', {
-      template: '<home></home>'
-    });
-  });
-```
-<br />
-When using {@link ngRoute.$routeProvider $routeProvider}, you can often avoid some
-boilerplate, by assigning the resolved dependencies directly to the route scope:
-```js
-  var myMod = angular.module('myMod', ['ngRoute']);
-  myMod.component('home', {
-    template: '<h1>Home</h1><p>Hello, {{ $ctrl.user.name }} !</p>',
-    bindings: {user: '='}
-  });
-  myMod.config(function($routeProvider) {
-    $routeProvider.when('/', {
-      template: '<home user="$resolve.user"></home>',
-      resolve: {user: function($http) { return $http.get('...'); }}
-    });
-  });
-```
-
-## Intercomponent Communication
-
-Directives can require the controllers of other directives to enable communication
-between each other. This can be achieved in a component by providing an
-object mapping for the `require` property.  Here is a tab pane example built
-from components:
-
-<example module="docsTabsExample">
-  <file name="script.js">
-angular.module('docsTabsExample', [])
-  .component('myTabs', {
-    transclude: true,
-    controller: function() {
-      var panes = this.panes = [];
-      this.select = function(pane) {
-        angular.forEach(panes, function(pane) {
-          pane.selected = false;
-        });
-        pane.selected = true;
-      };
-      this.addPane = function(pane) {
-        if (panes.length === 0) {
-          this.select(pane);
-        }
-        panes.push(pane);
-      };
-    },
-    templateUrl: 'my-tabs.html'
-  })
-  .component('myPane', {
-    transclude: true,
-    require: {tabsCtrl: '^myTabs'},
-    bindings: {
-      title: '@'
-    },
-    controller: function() {
-      this.$onInit = function() {
-        this.tabsCtrl.addPane(this);
-        console.log(this);
-      };
-    },
-    templateUrl: 'my-pane.html'
-  });
-  </file>
-  <file name="index.html">
-  <my-tabs>
-    <my-pane title="Hello">
-      <h4>Hello</h4>
-      <p>Lorem ipsum dolor sit amet</p>
-    </my-pane>
-    <my-pane title="World">
-      <h4>World</h4>
-      <em>Mauris elementum elementum enim at suscipit.</em>
-      <p><a href ng-click="i = i + 1">counter: {{i || 0}}</a></p>
-    </my-pane>
-  </my-tabs>
-  </file>
-  <file name="my-tabs.html">
-  <div class="tabbable">
-    <ul class="nav nav-tabs">
-      <li ng-repeat="pane in $ctrl.panes" ng-class="{active:pane.selected}">
-        <a href="" ng-click="$ctrl.select(pane)">{{pane.title}}</a>
-      </li>
-    </ul>
-    <div class="tab-content" ng-transclude></div>
-  </div>
-  </file>
-  <file name="my-pane.html">
-    <div class="tab-pane" ng-show="$ctrl.selected" ng-transclude></div>
-  </file>
-</example>
-
-
-# Unit-testing Component Controllers
-
-The easiest way to unit-test a component controller is by using the {@link ngMock.$componentController $componentController}
-that is included in {@link ngMock}. The advantage of this method is that you do not have
-to create any DOM elements. The following example shows how to do this for the `heroDetail` component
-from above.
-
-The examples use the [Jasmine](http://jasmine.github.io/) testing framework.
-
-**Controller Test:**
-```js
-describe('component: heroDetail', function() {
-  var component, scope, hero;
-
-  beforeEach(module('simpleComponent'));
-
-  beforeEach(inject(function($rootScope, $componentController) {
-    scope = $rootScope.$new();
-    hero = {name: 'Wolverine'};
-  }));
-
-  it('should set the default values of the hero', function() {
-    // It's necessary to always pass the scope in the locals, so that the controller instance can be bound to it
-    component = $componentController('heroDetail', {$scope: scope});
-
-    expect(component.hero).toEqual({
-      name: undefined,
-      location: 'unknown'
-    });
-  });
-
-  it('should assign the name bindings to the hero object', function() {
-    // Here we are passing actual bindings to the component
-
-    component = $componentController('heroDetail',
-      {$scope: scope},
-      {hero: hero}
-    );
-    expect(component.hero.name).toBe('Wolverine');
-  });
-
-  it('should call the onDelete binding when a hero is deleted', function() {
-    component = $componentController('heroDetail',
-      {$scope: scope},
-      {hero: hero, onDelete: jasmine.createSpy('deleteSpy')}
-    );
-
-    component.onDelete({hero: component.hero});
-    expect(spy('deleteSpy')).toHaveBeenCalledWith(component.hero);
-  });
-
-});
-```

docs/content/guide/concepts.ngdoc

@@ -334,9 +334,9 @@ The following example shows how this is done with Angular:
         var refresh = function() {
           var url = YAHOO_FINANCE_URL_PATTERN.
                      replace('PAIRS', 'USD' + currencies.join('","USD'));
-          return $http.jsonp(url).then(function(response) {
+          return $http.jsonp(url).success(function(data) {
             var newUsdToForeignRates = {};
-            angular.forEach(response.data.query.results.rate, function(rate) {
+            angular.forEach(data.query.results.rate, function(rate) {
               var currency = rate.id.substring(3,6);
               newUsdToForeignRates[currency] = window.parseFloat(rate.Rate);
             });

docs/content/guide/directive.ngdoc

@@ -99,13 +99,8 @@ For example, the following forms are all equivalent and match the {@link ngBind}
   </file>
   <file name="protractor.js" type="protractor">
     it('should show off bindings', function() {
-      var containerElm = element(by.css('div[ng-controller="Controller"]'));
-      var nameBindings = containerElm.all(by.binding('name'));
-
-      expect(nameBindings.count()).toBe(5);
-      nameBindings.each(function(elem) {
-        expect(elem.getText()).toEqual('Max Karl Ernst Ludwig Planck (April 23, 1858 – October 4, 1947)');
-      });
+      expect(element(by.css('div[ng-controller="Controller"] span[ng-bind]')).getText())
+          .toBe('Max Karl Ernst Ludwig Planck (April 23, 1858 – October 4, 1947)');
     });
   </file>
 </example>
@@ -303,7 +298,6 @@ The `restrict` option is typically set to:
 * `'A'` - only matches attribute name
 * `'E'` - only matches element name
 * `'C'` - only matches class name
-* `'M'` - only matches comment
 
 These restrictions can all be combined as needed:
 
@@ -407,7 +401,7 @@ This is clearly not a great solution.
 
 What we want to be able to do is separate the scope inside a directive from the scope
 outside, and then map the outer scope to a directive's inner scope. We can do this by creating what
-we call an **isolate scope**. To do this, we can use a {@link $compile#-scope- directive's `scope`} option:
+we call an **isolate scope**. To do this, we can use a directive's `scope` option:
 
 <example module="docsIsolateScopeDirective">
   <file name="script.js">
@@ -647,7 +641,6 @@ To do this, we need to use the `transclude` option.
         return {
           restrict: 'E',
           transclude: true,
-          scope: {},
           templateUrl: 'my-dialog.html'
         };
       });
@@ -658,7 +651,8 @@ To do this, we need to use the `transclude` option.
     </div>
   </file>
   <file name="my-dialog.html">
-    <div class="alert" ng-transclude></div>
+    <div class="alert" ng-transclude>
+    </div>
   </file>
 </example>
 
@@ -680,7 +674,7 @@ that redefines `name` as `Jeff`. What do you think the `{{name}}` binding will r
           transclude: true,
           scope: {},
           templateUrl: 'my-dialog.html',
-          link: function (scope) {
+          link: function (scope, element) {
             scope.name = 'Jeff';
           }
         };
@@ -692,7 +686,8 @@ that redefines `name` as `Jeff`. What do you think the `{{name}}` binding will r
     </div>
   </file>
   <file name="my-dialog.html">
-    <div class="alert" ng-transclude></div>
+    <div class="alert" ng-transclude>
+    </div>
   </file>
 </example>
 
@@ -703,7 +698,7 @@ The `transclude` option changes the way scopes are nested. It makes it so that t
 transcluded directive have whatever scope is outside the directive, rather than whatever scope is on
 the inside. In doing so, it gives the contents access to the outside scope.
 
-Note that if the directive did not create its own scope, then `scope` in `scope.name = 'Jeff'` would
+Note that if the directive did not create its own scope, then `scope` in `scope.name = 'Jeff';` would
 reference the outside scope and we would see `Jeff` in the output.
 
 This behavior makes sense for a directive that wraps some content, because otherwise you'd have to
@@ -776,9 +771,9 @@ function.
 
 Often it's desirable to pass data from the isolate scope via an expression to the
 parent scope, this can be done by passing a map of local variable names and values into the expression
-wrapper function. For example, the `hideDialog` function takes a message to display when the dialog
-is hidden. This is specified in the directive by calling `close({message: 'closing for now'})`.
-Then the local variable `message` will be available within the `on-close` expression.
+wrapper fn. For example, the hideDialog function takes a message to display when the dialog is hidden.
+This is specified in the directive by calling `close({message: 'closing for now'})`. Then the local
+variable `message` will be available within the `on-close` expression.
 
 <div class="alert alert-success">
 **Best Practice:** use `&attr` in the `scope` option when you want your directive
@@ -837,7 +832,7 @@ element?
       }]);
   </file>
   <file name="index.html">
-    <span my-draggable>Drag Me</span>
+    <span my-draggable>Drag ME</span>
   </file>
 </example>
 
@@ -882,7 +877,7 @@ to which tab is active.
       })
       .directive('myPane', function() {
         return {
-          require: '^^myTabs',
+          require: '^myTabs',
           restrict: 'E',
           transclude: true,
           scope: {
@@ -898,9 +893,11 @@ to which tab is active.
   <file name="index.html">
     <my-tabs>
       <my-pane title="Hello">
+        <h4>Hello</h4>
         <p>Lorem ipsum dolor sit amet</p>
       </my-pane>
       <my-pane title="World">
+        <h4>World</h4>
         <em>Mauris elementum elementum enim at suscipit.</em>
         <p><a href ng-click="i = i + 1">counter: {{i || 0}}</a></p>
       </my-pane>
@@ -917,25 +914,22 @@ to which tab is active.
     </div>
   </file>
   <file name="my-pane.html">
-    <div class="tab-pane" ng-show="selected">
-      <h4>{{title}}</h4>
-      <div ng-transclude></div>
+    <div class="tab-pane" ng-show="selected" ng-transclude>
     </div>
   </file>
 </example>
 
-The `myPane` directive has a `require` option with value `^^myTabs`. When a directive uses this
-option, `$compile` will throw an error unless the specified controller is found. The `^^` prefix
-means that this directive searches for the controller on its parents. (A `^` prefix would make the
-directive look for the controller on its own element or its parents; without any prefix, the
-directive would look on its own element only.)
+The `myPane` directive has a `require` option with value `^myTabs`. When a directive uses this
+option, `$compile` will throw an error unless the specified controller is found. The `^` prefix
+means that this directive searches for the controller on its parents (without the `^` prefix, the
+directive would look for the controller on just its own element).
 
 So where does this `myTabs` controller come from? Directives can specify controllers using
 the unsurprisingly named `controller` option. As you can see, the `myTabs` directive uses this
 option. Just like `ngController`, this option attaches a controller to the template of the directive.
 
-If it is necessary to reference the controller or any functions bound to the controller from the
-template, you can use the option `controllerAs` to specify the name of the controller as an alias.
+If it is necessary to reference the controller or any functions bound to the controller's scope in
+the template, you can use the option `controllerAs` to specify the name of the controller as an alias.
 The directive needs to define a scope for this configuration to be used. This is particularly useful
 in the case when the directive is used as a component.
 
@@ -950,7 +944,7 @@ The corresponding parameter being sent to the `link` function will also be an ar
 angular.module('docsTabsExample', [])
   .directive('myPane', function() {
     return {
-      require: ['^^myTabs', 'ngModel'],
+      require: ['^myTabs', '^ngModel'],
       restrict: 'E',
       transclude: true,
       scope: {
@@ -986,3 +980,4 @@ available in the {@link guide/compiler compiler guide}.
 
 The {@link ng.$compile `$compile` API} page has a comprehensive list of directive options for
 reference.
+

docs/content/guide/expression.ngdoc

@@ -116,9 +116,6 @@ This restriction is intentional. It prevents accidental access to the global sta
 Instead use services like `$window` and `$location` in functions called from expressions. Such services
 provide mockable access to globals.
 
-It is possible to access the context object using the identifier `this` and the locals object using the
-identifier `$locals`.
-
 <example module="expressionExample">
   <file name="index.html">
     <div class="example2" ng-controller="ExampleController">

docs/content/guide/filter.ngdoc

@@ -32,13 +32,10 @@ E.g. the markup `{{ 1234 | number:2 }}` formats the number 1234 with 2 decimal p
 
 ## Using filters in controllers, services, and directives
 
-You can also use filters in controllers, services, and directives.
-
-<div class="alert alert-info">
-For this, inject a dependency with the name `<filterName>Filter` into your controller/service/directive.
-E.g. a filter called `number` is injected by using the dependency `numberFilter`. The injected argument
-is a function that takes the value to format as first argument, and filter parameters starting with the second argument.
-</div>
+You can also use filters in controllers, services, and directives. For this, inject a dependency
+with the name `<filterName>Filter` to your controller/service/directive. E.g. using the dependency
+`numberFilter` will inject the number filter. The injected argument is a function that takes the
+value to format as first argument and filter parameters starting with the second argument.
 
 The example below uses the filter called {@link ng.filter:filter `filter`}.
 This filter reduces arrays into sub arrays based on
@@ -111,7 +108,6 @@ text upper-case.
       No filter: {{greeting}}<br>
       Reverse: {{greeting|reverse}}<br>
       Reverse + uppercase: {{greeting|reverse:true}}<br>
-      Reverse, filtered in controller: {{filteredGreeting}}<br>
     </div>
   </file>
 
@@ -131,9 +127,8 @@ text upper-case.
           return out;
         };
       })
-      .controller('MyController', ['$scope', 'reverseFilter', function($scope, reverseFilter) {
+      .controller('MyController', ['$scope', function($scope) {
         $scope.greeting = 'hello';
-        $scope.filteredGreeting = reverseFilter($scope.greeting);
       }]);
   </file>
 </example>

docs/content/guide/interpolation.ngdoc

@@ -5,7 +5,7 @@
 
 # Interpolation and data-binding
 
-Interpolation markup with embedded {@link guide/expression expressions} is used by Angular to
+Interpolation markup with embedded @link {guide/expressions expressions} is used by Angular to
 provide data-binding to text nodes and attribute values.
 
 An example of interpolation is shown below:
@@ -43,8 +43,8 @@ interpret the attribute as present, meaning that the button would always be disa
 ```
 
 For this reason, Angular provides special `ng`-prefixed directives for the following boolean attributes:
-{@link ngDisabled `disabled`}, {@link ngRequired `required`}, {@link ngSelected `selected`},
-{@link ngChecked `checked`}, {@link ngReadonly `readOnly`} , and {@link ngOpen `open`}.
+{@link ngDisabled `disabled`}, [@link ngRequired `required`}, [@link ngSelected `selected`},
+{@link ngChecked `checked`}, {@link ngReadonly `readOnly`} , and [@link ngOpen `open`}.
 
 These directives take an expression inside the attribute, and set the corresponding boolean attribute
 to true when the expression evaluates to truthy.

docs/content/guide/migration.ngdoc

@@ -3,225 +3,17 @@
 @sortOrder 550
 @description
 
-# Migrating an App to a newer version
-
 Minor version releases in AngularJS introduce several breaking changes that may require changes to your
 application's source code; for instance from 1.0 to 1.2 and from 1.2 to 1.3.
 
-Although we try to avoid breaking changes, there are some cases where it is unavoidable:
+Although we try to avoid breaking changes, there are some cases where it is unavoidable.
 
 * AngularJS has undergone thorough security reviews to make applications safer by default,
 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.
 
-<hr />
-
-## Contents
-
-<ul class="nav nav-list">
-  <li>{@link guide/migration#migrating-from-1-4-to-1-5 Migrating from 1.4 to 1.5}</li>
-  <li>{@link guide/migration#migrating-from-1-3-to-1-4 Migrating from 1.3 to 1.4}</li>
-  <li>{@link guide/migration#migrating-from-1-2-to-1-3 Migrating from 1.2 to 1.3}</li>
-  <li>{@link guide/migration#migrating-from-1-0-to-1-2 Migrating from 1.0 to 1.2}</li>
-</ul>
-
-
-
-
-
-## Migrating from 1.4 to 1.5
-
-Angular 1.5 takes a big step towards preparing developers for a smoother transition to Angular 2 in
-the future. Architecturing your applications using components, multi-slot transclusion, one-way
-bindings in isolate scopes, using lifecycle hooks in directive controllers and relying on native ES6
-features (such as classes and arrow functions) are now all possible with Angular 1.5.
-
-
-This release includes numerous bug and security fixes, as well as performance improvements to core
-services, directives, filters and helper functions. Existing applications can start enjoying the
-benefits of such changes in `$compile`, `$parse`, `$animate`, `$animateCss`, `$sanitize`, `ngOptions`,
-`currencyFilter`, `numberFilter`, `copy()` (to name but a few) without any change in code.
-
-New features have been added to more than a dozen services, directives and filters across 8 modules.
-Among them, a few stand out:
-
-* `angular.component()`: Introducing "components", a special sort of directive that are easy to
-  configure and promote best practices (plus can bring Angular 1 applications closer to Angular 2's
-  style of architecture).
-* Multi-slot transclusion: Enabling the design of more powerful and complex UI elements with a much
-  simpler configuration and reduced boilerplate.
-* `$onInit` lifecycle hook: Introducing a new lifecycle hook for directive controllers, called after
-  all required controllers have been constructed. This enables access to required controllers from
-  a directive's controller, without having to rely on the linking function.
-* `ngAnimateSwap`: A new directive in `ngAnimate`, making it super easy to create rotating
-  banner-like components.
-* Testing helpers: New helper functions in `ngMock`, simplifying testing for animations, component
-  controllers and routing.
-
-Also, notable is the improved support for ES6 features, such as classes and arrow functions. These
-features are now more reliably detected and correctly handled within the core.
-
-
-All this goodness doesn't come without a price, though. Below is a list of breaking changes (grouped
-by module) that need to be taken into account while migrating from 1.4. Fortunately, the majority of
-them should have a pretty low impact on most applications.
-
-
-### Core
-
-We tried to keep the breaking changes inside the core components to a bare minimum. Still, a few of
-them were unavoidable.
-
-#### Services (`$parse`)
-
-Due to [0ea53503](https://github.com/angular/angular.js/commit/0ea535035a3a1a992948490c3533bffb83235052),
-a new special property, `$locals`, will be available for accessing the locals from an expression.
-This is a breaking change, only if a `$locals` property does already exist (and needs to be
-referenced) either on the `scope` or on the `locals` object. Your expressions should be changed to
-access such existing properties as `this.$locals` and `$locals.$locals` respectively.
-
-
-#### Directives (`ngOptions`)
-
-A fair amount of work has been put into the `ngOptions` directive, fixing bugs and corner-cases and
-neutralizing browser quirks. A couple of breaking changes were made in the process:
-
-Due to [b71d7c3f](https://github.com/angular/angular.js/commit/b71d7c3f3c04e65b02d88b33c22dd90ae3cdfc27),
-falsy values (`''`, `0`, `false` and `null`) are properly recognized as option group identifiers for
-options passed to `ngOptions`. Previously, all of these values were ignored and the option was not
-assigned to any group. `undefined` is still interpreted as "no group".
-If you have options with falsy group indentifiers that should still not be assigned to any group,
-then you must filter the values before passing them to `ngOptions`, converting falsy values to
-`undefined`.
-
-Due to [ded25187](https://github.com/angular/angular.js/commit/ded2518756d4409fdfda0d4af243f2125bea01b5),
-`ngOptions` now explicitly requires `ngModel` on the same element, thus an error will be thrown if
-`ngModel` is not found. Previously, `ngOptions` would silently fail, which could lead to
-hard-to-debug errors.
-This is not expected to have any significant impact on applications, since `ngOptions` didn't work
-without `ngModel` before either. The main difference is that now it will fail with a more
-informative error message.
-
-
-#### Filters (`orderBy`)
-
-Due to [2a85a634](https://github.com/angular/angular.js/commit/2a85a634f86c84f15b411ce009a3515fca7ba580),
-passing a non-array-like value (other than `undefined` or `null`) through the `orderBy` filter will
-throw an error. Previously, the input was returned unchanged, which could lead to hard-to-spot bugs
-and was not consistent with other filters (e.g. `filter`).
-Objects considered array-like include: arrays, array subclasses, strings, NodeLists,
-jqLite/jQuery collections
-
-
-### ngMessages (`ngMessage`)
-
-Due to [4971ef12](https://github.com/angular/angular.js/commit/4971ef12d4c2c268cb8d26f90385dc96eba19db8),
-the `ngMessage` directive is now compiled with a priority of 1, which means directives on the same
-element as `ngMessage` with a priority lower than 1 will be applied when `ngMessage` calls its
-`$transclude` function. Previously, they were applied during the initial compile phase and were
-passed the comment element created by the transclusion of `ngMessage`.
-If you have custom directives that relied on the previous behavior, you need to give them a priority
-of 1 or greater.
-
-
-### ngResource (`$resource`)
-
-The `$resource` service underwent a minor internal refactoring to finally solve a long-standing bug
-preventing requests from being cancelled using promises. Due to the nature of `$resource`'s
-configuration, it was not possible to follow the `$http` convention. A new `$cancelRequest()` method
-was introduced instead.
-
-Due to [98528be3](https://github.com/angular/angular.js/commit/98528be311b48269ba0e15ba4e3e2ad9b89693a9),
-using a promise as `timeout` in `$resource` is no longer supported and will log a warning. This is
-hardly expected to affect the behavior of your application, since a promise as `timeout` didn't work
-before either, but it will now warn you explicitly when trying to pass one.
-If you need to be able to cancel pending requests, you can now use the new `$cancelRequest()` that
-will be available on `$resource` instances.
-
-
-### ngRoute (`ngView`)
-
-Due to [983b0598](https://github.com/angular/angular.js/commit/983b0598121a8c5a3a51a30120e114d7e3085d4d),
-a new property will be available on the scope of the route, allowing easy access to the route's
-resolved values from the view's template. The default name for this property is `$resolve`. This is
-a breaking change, only if a `$resolve` property is already available on the scope, in which case
-the existing property will be hidden or overwritten.
-To fix this, you should choose a custom name for this property, that does not collide with other
-properties on the scope, by specifying the `resolveAs` property on the route.
-
-
-### ngSanitize (`$sanitize`, `linky`)
-
-The HTML sanitizer has been re-implemented using inert documents, increasing security, fixing some
-corner-cases that were difficult to handle and reducing its size by about 20% (in terms of loc). In
-order to make it more secure by default, a couple of breaking changes have been introduced:
-
-Due to [181fc567](https://github.com/angular/angular.js/commit/181fc567d873df065f1e84af7225deb70a8d2eb9),
-SVG support in `$sanitize` is now an opt-in feature (i.e. disabled by default), as it could make
-an application vulnerable to click-hijacking attacks. If your application relies on it, you can
-still turn it on with `$sanitizeProvider.enableSvg(true)`, but you extra precautions need to be
-taken in order to keep your application secure. Read the documentation for more information about
-the dangers and ways to mitigate them.
-
-Due to [7a668cdd](https://github.com/angular/angular.js/commit/7a668cdd7d08a7016883eb3c671cbcd586223ae8),
-the `$sanitize` service will now remove instances of the `<use>` tag from the content passed to it.
-This element is used to import external SVG resources, which is a security risk as the `$sanitize`
-service does not have access to the resource in order to sanitize it.
-
-Similarly, due to [234053fc](https://github.com/angular/angular.js/commit/234053fc9ad90e0d05be7e8359c6af66be94c094),
-the `$sanitize` service will now also remove instances of the `usemap` attribute from any elements
-passed to it. This attribute is used to reference another element by `name` or `id`. Since the
-`name` and `id` attributes are already blacklisted, a sanitized `usemap` attribute could only
-reference unsanitized content, which is a security risk.
-
-Due to [98c2db7f](https://github.com/angular/angular.js/commit/98c2db7f9c2d078a408576e722407d518c7ee10a),
-passing a non-string value (other than `undefined` or `null`) through the `linky` filter will throw
-an error. This is not expected to have any significant impact on applications, since the input was
-always assumed to be of type 'string', so passing non-string values never worked correctly anyway.
-The main difference is that now it will fail faster and with a more informative error message.
-
-
-## ngTouch (`ngClick`)
-
-Due to [0dfc1dfe](https://github.com/angular/angular.js/commit/0dfc1dfebf26af7f951f301c4e3848ac46f05d7f),
-the `ngClick` override directive from the `ngTouch` module is **deprecated and disabled by default**.
-This means that on touch-based devices, users might now experience a 300ms delay before a click
-event is fired.
-
-If you rely on this directive, you can still enable it using
-`$touchProvider.ngClickOverrideEnabled()`:
-
-```js
-angular.module('myApp').config(function($touchProvider) {
-  $touchProvider.ngClickOverrideEnabled(true);
-});
-```
-
-Going forward, we recommend using [FastClick](https://github.com/ftlabs/fastclick) or perhaps one of
-the [Angular 3rd party touch-related modules](http://ngmodules.org/tags/touch) that provide similar
-functionality.
-
-Also note that modern browsers already remove the 300ms delay under some circumstances:
-
-- **Chrome and Firefox for Android** remove the 300ms delay when the well-known
-  `<meta name="viewport" content="width=device-width">` is set.
-- **Internet Explorer** removes the delay, when the `touch-action` css property is set to `none` or
-  `manipulation`.
-- Since **iOS 8, Safari** removes the delay on so-called "slow taps".
-
-For more info on the topic, you can take a look at this
-[article by Telerik](http://developer.telerik.com/featured/300-ms-click-delay-ios-8/).
-
-<div class="alert alert-warning">
-  **Note:** This change does **not** affect the `ngSwipe` directive.
-</div>
-
-
-
-
-
-## Migrating from 1.3 to 1.4
+# 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:
@@ -245,7 +37,7 @@ relatively straightforward otherwise.
 
 
 
-### Animation (`ngAnimate`)
+## 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.
@@ -344,9 +136,9 @@ class based animations (animations triggered via ngClass) in order to ensure tha
 
 
 
-### Forms (`ngMessages`, `ngOptions`, `select`)
+## Forms (`ngMessages`, `ngOptions`, `select`)
 
-#### ngMessages
+### 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
@@ -397,7 +189,7 @@ ctrl.getMessages = function($index) {
 }
 ```
 
-#### ngOptions
+### 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.
@@ -421,7 +213,7 @@ setting the ngOptions attribute expression after the element is compiled, will n
 This worked previously because the ngOptions logic was part of the select directive, while
 it is now implemented in the ngOptions directive itself.
 
-#### select
+### 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`
@@ -452,9 +244,9 @@ ngModelCtrl.$formatters.push(function(value) {
 });
 ```
 
-### Templating (`ngRepeat`, `$compile`)
+## Templating (`ngRepeat`, `$compile`)
 
-#### ngRepeat
+### 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
@@ -473,7 +265,7 @@ https://github.com/petebacondarwin/angular-toArrayFilter
 or some other mechanism, and then sort them manually in the order you need.
 
 
-#### $compile
+### $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
@@ -484,7 +276,7 @@ returning an object from a controller constructor function will now override the
 controllerAs method will no longer get the this reference, but the returned object.
 
 
-### Cookies (`ngCookies`)
+## 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
@@ -523,7 +315,7 @@ delegates calls.
 
 
 
-### Server Requests (`$http`)
+## Server Requests (`$http`)
 
 Due to [5da1256](https://github.com/angular/angular.js/commit/5da1256fc2812d5b28fb0af0de81256054856369),
 `transformRequest` functions can no longer modify request headers.
@@ -556,9 +348,9 @@ $http.get(url, {
 
 
 
-### Filters (`filter`, `limitTo`)
+## Filters (`filter`, `limitTo`)
 
-#### `filter` filter
+### `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.
@@ -566,7 +358,7 @@ 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
+### `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.
@@ -575,9 +367,9 @@ Now, instead of returning empty object/array, it returns unchanged input.
 
 
 
-## Migrating from 1.2 to 1.3
+# Migrating from 1.2 to 1.3
 
-### Controllers
+## Controllers
 
 Due to [3f2232b5](https://github.com/angular/angular.js/commit/3f2232b5a181512fac23775b1df4a6ebda67d018),
 `$controller` will no longer look for controllers on `window`.
@@ -615,7 +407,7 @@ angular.module('myModule').config(['$controllerProvider', function($controllerPr
 }]);
 ```
 
-### Angular Expression Parsing (`$parse` + `$interpolate`)
+## Angular Expression Parsing (`$parse` + `$interpolate`)
 
 - due to [77ada4c8](https://github.com/angular/angular.js/commit/77ada4c82d6b8fc6d977c26f3cdb48c2f5fbe5a5),
 
@@ -673,7 +465,7 @@ expression parser; there are six of them: false, null, undefined, NaN, 0 and "".
 
 
 
-### Miscellaneous Angular helpers
+## Miscellaneous Angular helpers
 
 - **Angular.copy:** due to [b59b04f9](https://github.com/angular/angular.js/commit/b59b04f98a0b59eead53f6a53391ce1bbcbe9b57),
 
@@ -704,14 +496,15 @@ This change also makes our forEach behave more like Array#forEach.
 
 
 - **angular.toJson:** due to [c054288c](https://github.com/angular/angular.js/commit/c054288c9722875e3595e6e6162193e0fb67a251),
-  `toJson()` will no longer strip properties starting with a single `$`. If you relied on
-`toJson()`'s stripping these types of properties before, you will have to do it manually now.
-It will still strip properties starting with `$$` though.
+
+If you expected `toJson` to strip these types of properties before, you will have to
+manually do this yourself now.
 
 
 
 
-### jqLite / JQuery
+
+## jqLite / JQuery
 
 - **jqLite:** due to [a196c8bc](https://github.com/angular/angular.js/commit/a196c8bca82a28c08896d31f1863cf4ecd11401c),
   previously it was possible to set jqLite data on Text/Comment
@@ -727,7 +520,7 @@ jQuery. We don't expect that app code actually depends on this accidental featur
 
 
 
-### Angular HTML Compiler (`$compile`)
+## Angular HTML Compiler (`$compile`)
 
 
 - due to [2ee29c5d](https://github.com/angular/angular.js/commit/2ee29c5da81ffacdc1cabb438f5d125d5e116cb9),
@@ -824,7 +617,7 @@ link: function(scope, element, attr) {
 
 
 
-### Forms, Inputs and ngModel
+## Forms, Inputs and ngModel
 
 - due to [1be9bb9d](https://github.com/angular/angular.js/commit/1be9bb9d3527e0758350c4f7417a4228d8571440),
 
@@ -904,7 +697,7 @@ $scope.resetWithCancel = function (e) {
   See [c90cefe1614](https://github.com/angular/angular.js/commit/c90cefe16142d973a123e945fc9058e8a874c357)
 
 
-### Scopes and Digests (`$scope`)
+## Scopes and Digests (`$scope`)
 
 - due to [8c6a8171](https://github.com/angular/angular.js/commit/8c6a8171f9bdaa5cdabc0cc3f7d3ce10af7b434d),
   Scope#$id is now of type number rather than string. Since the
@@ -924,7 +717,7 @@ anyone.
 
 
 
-### Server Requests (`$http`, `$resource`)
+## Server Requests (`$http`, `$resource`)
 - **$http:** due to [ad4336f9](https://github.com/angular/angular.js/commit/ad4336f9359a073e272930f8f9bcd36587a8648f),
 
 
@@ -991,7 +784,7 @@ More details on the new interceptors API (which has been around as of v1.1.4) ca
 
 
 
-### Modules and Injector (`$inject`)
+## Modules and Injector (`$inject`)
 
 - due to [c0b4e2db](https://github.com/angular/angular.js/commit/c0b4e2db9cbc8bc3164cedc4646145d3ab72536e),
 
@@ -1033,7 +826,7 @@ app. This is no longer possible within a single module.
 
 
 
-### Animation (`ngAnimate`)
+## Animation (`ngAnimate`)
 
 
 - due to [1cb8584e](https://github.com/angular/angular.js/commit/1cb8584e8490ecdb1b410a8846c4478c6c2c0e53),
@@ -1086,7 +879,7 @@ After:
 Please view the documentation for ngAnimate for more info.
 
 
-### Testing
+## Testing
 
 - due to [85880a64](https://github.com/angular/angular.js/commit/85880a64900fa22a61feb926bf52de0965332ca5), some deprecated features of
 Protractor tests no longer work.
@@ -1125,7 +918,7 @@ or simply use:
     var el = element(by.repeater('foo in foos').row(2))
 
 
-### Internet Explorer 8
+## Internet Explorer 8
 
 - due to [eaa1d00b](https://github.com/angular/angular.js/commit/eaa1d00b24008f590b95ad099241b4003688cdda),
   As communicated before, IE8 is no longer supported.
@@ -1135,7 +928,7 @@ or simply use:
 
 
 
-## Migrating from 1.0 to 1.2
+# Migrating from 1.0 to 1.2
 
 
 <div class="alert alert-warning">
@@ -1178,7 +971,7 @@ below should still apply, but you may want to consult the
 </ul>
 
 
-### ngRoute has been moved into its own module
+## ngRoute has been moved into its own module
 
 Just like `ngResource`, `ngRoute` is now its own module.
 
@@ -1209,7 +1002,7 @@ var myApp = angular.module('myApp', ['ngRoute', 'someOtherModule']);
 See [5599b55b](https://github.com/angular/angular.js/commit/5599b55b04788c2e327d7551a4a699d75516dd21).
 
 
-### Templates no longer automatically unwrap promises
+## Templates no longer automatically unwrap promises
 
 `$parse` and templates in general will no longer automatically unwrap promises.
 
@@ -1243,7 +1036,7 @@ See [5dc35b52](https://github.com/angular/angular.js/commit/5dc35b527b3c99f6544b
 [b6a37d11](https://github.com/angular/angular.js/commit/b6a37d112b3e1478f4d14a5f82faabf700443748).
 
 
-### Syntax for named wildcard parameters changed in `$route`
+## Syntax for named wildcard parameters changed in `$route`
 
 To migrate the code, follow the example below. Here, `*highlight` becomes `:highlight*`
 
@@ -1264,7 +1057,7 @@ $routeProvider.when('/Book1/:book/Chapter/:chapter/:highlight*/edit',
 See [04cebcc1](https://github.com/angular/angular.js/commit/04cebcc133c8b433a3ac5f72ed19f3631778142b).
 
 
-### You can only bind one expression to `*[src]`, `*[ng-src]` or `action`
+## You can only bind one expression to `*[src]`, `*[ng-src]` or `action`
 
 With the exception of `<a>` and `<img>` elements, you cannot bind more than one expression to the
 `src` or `action` attribute of elements.
@@ -1339,7 +1132,7 @@ scope.getIframeSrc = function() {
 See [38deedd6](https://github.com/angular/angular.js/commit/38deedd6e3d806eb8262bb43f26d47245f6c2739).
 
 
-### Interpolations inside DOM event handlers are now disallowed
+## Interpolations inside DOM event handlers are now disallowed
 
 DOM event handlers execute arbitrary Javascript code. Using an interpolation for such handlers
 means that the interpolated value is a JS string that is evaluated. Storing or generating such
@@ -1366,7 +1159,7 @@ HTML: <div ng-click="foo()">
 See [39841f2e](https://github.com/angular/angular.js/commit/39841f2ec9b17b3b2920fd1eb548d444251f4f56).
 
 
-### Directives cannot end with -start or -end
+## Directives cannot end with -start or -end
 
 This change was necessary to enable multi-element directives. The best fix is to rename existing
 directives so that they don't end with these suffixes.
@@ -1374,7 +1167,7 @@ directives so that they don't end with these suffixes.
 See [e46100f7](https://github.com/angular/angular.js/commit/e46100f7097d9a8f174bdb9e15d4c6098395c3f2).
 
 
-### In $q, promise.always has been renamed promise.finally
+## In $q, promise.always has been renamed promise.finally
 
 The reason for this change is to align `$q` with the [Q promise
 library](https://github.com/kriskowal/q), despite the fact that this makes it a bit more difficult
@@ -1406,7 +1199,7 @@ $http.get('/foo')['finally'](doSomething);
 See [f078762d](https://github.com/angular/angular.js/commit/f078762d48d0d5d9796dcdf2cb0241198677582c).
 
 
-### ngMobile is now ngTouch
+## ngMobile is now ngTouch
 
 Many touch-enabled devices are not mobile devices, so we decided to rename this module to better
 reflect its concerns.
@@ -1417,7 +1210,7 @@ To migrate, replace all references to `ngMobile` with `ngTouch` and `angular-mob
 See [94ec84e7](https://github.com/angular/angular.js/commit/94ec84e7b9c89358dc00e4039009af9e287bbd05).
 
 
-### resource.$then has been removed
+## resource.$then has been removed
 
 Resource instances do not have a `$then` function anymore. Use the `$promise.then` instead.
 
@@ -1436,7 +1229,7 @@ Resource.query().$promise.then(callback);
 See [05772e15](https://github.com/angular/angular.js/commit/05772e15fbecfdc63d4977e2e8839d8b95d6a92d).
 
 
-### Resource methods return the promise
+## Resource methods return the promise
 
 Methods of a resource instance return the promise rather than the instance itself.
 
@@ -1456,7 +1249,7 @@ resource.chaining = true;
 See [05772e15](https://github.com/angular/angular.js/commit/05772e15fbecfdc63d4977e2e8839d8b95d6a92d).
 
 
-### Resource promises are resolved with the resource instance
+## Resource promises are resolved with the resource instance
 
 On success, the resource promise is resolved with the resource instance rather than HTTP response object.
 
@@ -1487,7 +1280,7 @@ var Resource = $resource('/url', {}, {
 See [05772e15](https://github.com/angular/angular.js/commit/05772e15fbecfdc63d4977e2e8839d8b95d6a92d).
 
 
-### $location.search supports multiple keys
+## $location.search supports multiple keys
 
 {@link ng.$location#search `$location.search`} now supports multiple keys with the
 same value provided that the values are stored in an array.
@@ -1504,7 +1297,7 @@ passing it to `$location`.
 See [80739409](https://github.com/angular/angular.js/commit/807394095b991357225a03d5fed81fea5c9a1abe).
 
 
-### ngBindHtmlUnsafe has been removed and replaced by ngBindHtml
+## ngBindHtmlUnsafe has been removed and replaced by ngBindHtml
 
 `ngBindHtml` provides `ngBindHtmlUnsafe` like
 behavior (evaluate an expression and innerHTML the result into the DOM) when bound to the result
@@ -1520,7 +1313,7 @@ trusted.
 See [dae69473](https://github.com/angular/angular.js/commit/dae694739b9581bea5dbc53522ec00d87b26ae55).
 
 
-### Form names that are expressions are evaluated
+## Form names that are expressions are evaluated
 
 If you have form names that will evaluate as an expression:
 
@@ -1552,7 +1345,7 @@ Supporting the previous behavior offers no benefit.
 See [8ea802a1](https://github.com/angular/angular.js/commit/8ea802a1d23ad8ecacab892a3a451a308d9c39d7).
 
 
-### hasOwnProperty disallowed as an input name
+## hasOwnProperty disallowed as an input name
 
 Inputs with name equal to `hasOwnProperty` are not allowed inside form or ngForm directives.
 
@@ -1563,7 +1356,7 @@ and bad practice. To migrate, change your input name.
 See [7a586e5c](https://github.com/angular/angular.js/commit/7a586e5c19f3d1ecc3fefef084ce992072ee7f60).
 
 
-### Directives: Order of postLink functions reversed
+## Directives: Order of postLink functions reversed
 
 The order of postLink fn is now mirror opposite of the order in which corresponding preLinking and compile functions execute.
 
@@ -1619,7 +1412,7 @@ attribute interpolation directive was adjusted.
 See [31f190d4](https://github.com/angular/angular.js/commit/31f190d4d53921d32253ba80d9ebe57d6c1de82b).
 
 
-### Directive priority
+## Directive priority
 
 the priority of ngRepeat, ngSwitchWhen, ngIf, ngInclude and ngView has changed. This could affect directives that explicitly specify their priority.
 
@@ -1637,7 +1430,7 @@ ngView           | 1000         | 400
 See [b7af76b4](https://github.com/angular/angular.js/commit/b7af76b4c5aa77648cc1bfd49935b48583419023).
 
 
-### ngScenario
+## ngScenario
 
 browserTrigger now uses an eventData object instead of direct parameters for mouse events.
 To migrate, place the `keys`,`x` and `y` parameters inside of an object and place that as the
@@ -1646,7 +1439,7 @@ third parameter for the browserTrigger function.
 See [28f56a38](https://github.com/angular/angular.js/commit/28f56a383e9d1ff378e3568a3039e941c7ffb1d8).
 
 
-### ngInclude and ngView replace its entire element on update
+## ngInclude and ngView replace its entire element on update
 
 Previously `ngInclude` and `ngView` only updated its element's content. Now these directives will
 recreate the element every time a new content is included.
@@ -1658,7 +1451,7 @@ See [7d69d52a](https://github.com/angular/angular.js/commit/7d69d52acff8578e0f7d
 [aa2133ad](https://github.com/angular/angular.js/commit/aa2133ad818d2e5c27cbd3933061797096356c8a).
 
 
-### URLs are now sanitized against a whitelist
+## URLs are now sanitized against a whitelist
 
 A whitelist configured via `$compileProvider` can be used to configure what URLs are considered safe.
 By default all common protocol prefixes are whitelisted including `data:` URIs with mime types `image/*`.
@@ -1668,7 +1461,7 @@ See [1adf29af](https://github.com/angular/angular.js/commit/1adf29af13890d612868
 [3e39ac7e](https://github.com/angular/angular.js/commit/3e39ac7e1b10d4812a44dad2f959a93361cd823b).
 
 
-### Isolate scope only exposed to directives with `scope` property
+## Isolate scope only exposed to directives with `scope` property
 
 If you declare a scope option on a directive, that directive will have an
 [isolate scope](https://github.com/angular/angular.js/wiki/Understanding-Scopes). In Angular 1.0, if a
@@ -1741,7 +1534,7 @@ See [909cabd3](https://github.com/angular/angular.js/commit/909cabd36d779598763c
 [#2500](https://github.com/angular/angular.js/issues/2500).
 
 
-### Change to interpolation priority
+## Change to interpolation priority
 
 Previously, the interpolation priority was `-100` in 1.2.0-rc.2, and `100` before 1.2.0-rc.2.
 Before this change the binding was setup in the post-linking phase.
@@ -1754,7 +1547,7 @@ See [79223eae](https://github.com/angular/angular.js/commit/79223eae502283889334
 [#4528](https://github.com/angular/angular.js/issues/4528), and
 [#4649](https://github.com/angular/angular.js/issues/4649)
 
-### Underscore-prefixed/suffixed properties are non-bindable
+## Underscore-prefixed/suffixed properties are non-bindable
 
 <div class="alert alert-info">
 <p>**Reverted**: This breaking change has been reverted in 1.2.1, and so can be ignored if you're using **version 1.2.1 or higher**</p>
@@ -1793,7 +1586,7 @@ are actually needed by the expressions.
 See [3d6a89e8](https://github.com/angular/angular.js/commit/3d6a89e8888b14ae5cb5640464e12b7811853c7e).
 
 
-### You cannot bind to select[multiple]
+## You cannot bind to select[multiple]
 
 Switching between `select[single]` and `select[multiple]` has always been odd due to browser quirks.
 This feature never worked with two-way data-binding so it's not expected that anyone is using it.
@@ -1803,7 +1596,7 @@ If you are interested in properly adding this feature, please submit a pull requ
 See [d87fa004](https://github.com/angular/angular.js/commit/d87fa0042375b025b98c40bff05e5f42c00af114).
 
 
-### Uncommon region-specific local files were removed from i18n
+## Uncommon region-specific local files were removed from i18n
 
 AngularJS uses the Google Closure library's locale files. The following locales were removed from
 Closure, so Angular is not able to continue to support them:
@@ -1819,7 +1612,7 @@ load and use your copy of the locale file provided that you maintain it yourself
 
 See [6382e21f](https://github.com/angular/angular.js/commit/6382e21fb28541a2484ac1a241d41cf9fbbe9d2c).
 
-### Services can now return functions
+## Services can now return functions
 
 Previously, the service constructor only returned objects regardless of whether a function was returned.
 

docs/content/guide/module.ngdoc

@@ -75,8 +75,9 @@ that you break your application to multiple modules like this:
   * And an application level module which depends on the above modules and contains any
     initialization code.
 
-You can find a community  
-[style guide](https://github.com/johnpapa/angular-styleguide) to help yourself when application grows.
+We've also
+[written a document](http://angularjs.blogspot.com/2014/02/an-angularjs-style-guide-and-best.html)
+on how we organize large apps at Google.
 
 The above is a suggestion. Tailor it to your needs.
 

docs/content/guide/unit-testing.ngdoc

@@ -6,7 +6,7 @@
 JavaScript is a dynamically typed language which comes with great power of expression, but it also
 comes with almost no help from the compiler. For this reason we feel very strongly that any code
 written in JavaScript needs to come with a strong set of tests. We have built many features into
-Angular which make testing your Angular applications easy. With Angular, there is no excuse for not testing.
+Angular which makes testing your Angular applications easy. So there is no excuse for not testing.
 
 ## Separation of Concerns
 
@@ -20,13 +20,13 @@ related pieces such as the DOM elements, or making any XHR calls to fetch the da
 
 While this may seem obvious it can be very difficult to call an individual function on a
 typical project. The reason is that the developers often mix concerns resulting in a
-piece of code which does everything. It makes an XHR request, it sorts the response data, and then it
+piece of code which does everything. It makes an XHR request, it sorts the response data and then it
 manipulates the DOM.
 
-With Angular, we try to make it easy for you to do the right thing. For your XHR requests, we
-provide dependency injection, so your requests can be simulated. For the DOM, we abstract it, so you can
-test your model without having to manipulate the DOM directly. Your tests can then
-assert that the data has been sorted without having to create or look at the state of the DOM or to
+With Angular we try to make it easy for you to do the right thing, and so we
+provide dependency injection for your XHR requests, which can be mocked, and we provide abstractions which
+allow you to test your model without having to resort to manipulating the DOM. The test can then
+assert that the data has been sorted without having to create or look at the state of the DOM or
 wait for any XHR requests to return data. The individual sort function can be tested in isolation.
 
 ## With great power comes great responsibility

docs/content/misc/downloading.ngdoc

@@ -46,7 +46,7 @@ Download the version you want and have fun.
 Each directory under <http://code.angularjs.org/> includes the following set of files:
 
 * __`angular.js`__ — This file is non-obfuscated, non-minified, and human-readable by
-opening it in any editor or browser. In order to get better error messages during development, you
+opening it it any editor or browser. In order to get better error messages during development, you
 should always use this non-minified angular script.
 
 * __`angular.min.js`__ — This is a minified and obfuscated version of

docs/content/tutorial/index.ngdoc

@@ -246,15 +246,6 @@ npm run update-webdriver
 
 *(You should only need to do this once.)*
 
-You will need to have Java present on your dev machine to allow the Selenium standalone to be started.
-Check if you already have java installed by opening a terminal/command line window and typing
-'''
-java -version
-'''
-If java is already installed and exists in the PATH then you will be shown the version installed,
-if, however you receive a message that "java is not recognized as an internal command or external
-command" you will need to install [java].
-
 Since Protractor works by interacting with a running application, we need to start our web server:
 
 ```
@@ -289,4 +280,3 @@ Now that you have set up your local machine, let's get started with the tutorial
 [bower]: http://bower.io/
 [http-server]: https://github.com/nodeapps/http-server
 [karma]: https://github.com/karma-runner/karma
-[java]: https://www.java.com/en/download/help/download_options.xml

docs/content/tutorial/step_06.ngdoc

@@ -43,7 +43,7 @@ __`app/index.html`:__
 ...
         <ul class="phones">
           <li ng-repeat="phone in phones | filter:query | orderBy:orderProp" class="thumbnail">
-            <a href="#/phones/{{phone.id}}" class="thumb"><img ng-src="{{phone.imageUrl}}" alt="{{phone.name}}"></a>
+            <a href="#/phones/{{phone.id}}" class="thumb"><img ng-src="{{phone.imageUrl}}"></a>
             <a href="#/phones/{{phone.id}}">{{phone.name}}</a>
             <p>{{phone.snippet}}</p>
           </li>

docs/content/tutorial/step_07.ngdoc

@@ -53,18 +53,6 @@ preconfigured npm to run bower install for us:
 npm install
 ```
 
-<div class="alert alert-warning">
-  **Warning:** If a new version of Angular has been released since you last ran `npm install`, then you may have a
-  problem with the `bower install` due to a conflict between the versions of angular.js that need to
-  be installed.  If you get this then simply delete your `app/bower_components` folder before running
-  `npm install`.
-</div>
-
-<div class="alert alert-info">
-  **Note:** If you have bower installed globally then you can run `bower install` but for this project we have
-  preconfigured `npm install` to run bower for us.
-</div>
-
 
 ## Multiple Views, Routing and Layout Template
 

docs/content/tutorial/step_12.ngdoc

@@ -239,7 +239,7 @@ The name of the starting class is the name of the event that is fired (like `ent
 The active class name is the same as the starting class's but with an `-active` suffix.
 This two-class CSS naming convention allows the developer to craft an animation, beginning to end.
 
-In our example above, elements are expanded from a height of **0** to **120 pixels** when they're added to the
+In our example above, elements are expanded from a height of **0** to **120 pixels** when they're added to the 
 list and are collapsed back down to **0 pixels** before being removed from the list.
 There's also a nice fade-in and fade-out effect that occurs at the same time. All of this is handled
 by the CSS transition declarations at the top of the example code above.
@@ -357,10 +357,10 @@ For more on CSS animations, see the
 ## Animating `ngClass` with JavaScript
 
 Let's add another animation to our application. Switching to our `phone-detail.html` page,
-we see that we have a nice thumbnail swapper. By hovering over the thumbnails listed on the page,
+we see that we have a nice thumbnail swapper. By clicking on the thumbnails listed on the page,
 the profile phone image changes. But how can we change this around to add animations?
 
-Let's think about it first. Basically, when you hover over a thumbnail image, you're changing the
+Let's think about it first. Basically, when you click on a thumbnail image, you're changing the
 state of the profile image to reflect the newly selected thumbnail image.
 The best way to specify state changes within HTML is to use classes.
 Much like before, how we used a CSS class to specify an animation, this time the animation will
@@ -369,7 +369,7 @@ occur whenever the CSS class itself changes.
 Whenever a new phone thumbnail is selected, the state changes and the `.active` CSS class is added
 to the matching profile image and the animation plays.
 
-Let's get started and tweak our HTML code on the `phone-detail.html` page first. Notice that we
+Let's get started and tweak our HTML code on the `phone-detail.html` page first. Notice that we 
 have changed the way we display our large image:
 
 __`app/partials/phone-detail.html`.__

i18n/closure/numberSymbolsExt.js

@@ -20,7 +20,7 @@
  * using the --for_closure flag.
  * File generated from CLDR ver. 27.0.1
  *
- * This file covers those locales that are not covered in
+ * This file coveres those locales that are not covered in
  * "numberformatsymbols.js".
  *
  * Before checkin, this file could have been manually edited. This is

i18n/generate.sh

@@ -5,7 +5,7 @@ set -e
 BASE_DIR=`dirname $0`
 cd $BASE_DIR
 
-npm run test-i18n
+./run-tests.sh
 
 node src/closureSlurper.js
 

i18n/run-tests.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+set -e
+PARENT_DIR="$(dirname "$0")"
+
+../node_modules/.bin/jasmine-node "$PARENT_DIR"/spec/

i18n/spec/closureI18nExtractorSpec.js

@@ -4,7 +4,6 @@ findLocaleId = closureI18nExtractor.findLocaleId;
 extractNumberSymbols = closureI18nExtractor.extractNumberSymbols;
 extractCurrencySymbols = closureI18nExtractor.extractCurrencySymbols;
 extractDateTimeSymbols = closureI18nExtractor.extractDateTimeSymbols;
-outputLocale = closureI18nExtractor.outputLocale;
 
 
 function newTestLocaleInfo() {
@@ -73,7 +72,7 @@ describe("findLocaleId", function() {
   it("should throw an error otherwise", function() {
     expect(function() {
       findLocaleId("str", "otherwise")
-    }).toThrowError("unknown type in findLocaleId: otherwise");
+    }).toThrow("unknown type in findLocaleId: otherwise");
   });
 });
 
@@ -132,10 +131,7 @@ describe("extractCurrencySymbols", function() {
     ].join('\n');
 
     var localeInfo = {};
-    var currencySymbols = extractCurrencySymbols(CONTENT);
-    expect(currencySymbols.GBP).toEqual([2, '£', 'GB£']);
-    expect(currencySymbols.AOA).toEqual([2, 'Kz', 'Kz']);
-    expect(currencySymbols).toEqual({
+    expect(extractCurrencySymbols(CONTENT)).toEqual({
       'GBP':[2, '£', 'GB£'],
       'AOA':[2, 'Kz', 'Kz']
     });
@@ -146,71 +142,71 @@ describe("extractCurrencySymbols", function() {
 describe("extractDateTimeSymbols", function() {
   it("should extract date time data", function() {
     var CONTENT = [
-      "goog.i18n.DateTimeSymbols_fr_CA = {",
-      "  ERAS: ['av. J.-C.', 'ap. J.-C.'],",
-      "  ERANAMES: ['avant Jésus-Christ', 'après Jésus-Christ'],",
-      "  NARROWMONTHS: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],",
-      "  STANDALONENARROWMONTHS: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O',",
-      "      'N', 'D'],",
-      "  MONTHS: ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet',",
-      "      'août', 'septembre', 'octobre', 'novembre', 'décembre'],",
-      "  STANDALONEMONTHS: ['janvier', 'février', 'mars', 'avril', 'mai', 'juin',",
-      "      'juillet', 'août', 'septembre', 'octobre', 'novembre', 'décembre'],",
-      "  SHORTMONTHS: ['janv.', 'févr.', 'mars', 'avr.', 'mai', 'juin', 'juil.',",
-      "      'août', 'sept.', 'oct.', 'nov.', 'déc.'],",
-      "  STANDALONESHORTMONTHS: ['janv.', 'févr.', 'mars', 'avr.', 'mai', 'juin',",
-      "      'juil.', 'août', 'sept.', 'oct.', 'nov.', 'déc.'],",
-      "  WEEKDAYS: ['dimanche', 'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi',",
-      "      'samedi'],",
-      "  STANDALONEWEEKDAYS: ['dimanche', 'lundi', 'mardi', 'mercredi', 'jeudi',",
-      "      'vendredi', 'samedi'],",
-      "  SHORTWEEKDAYS: ['dim.', 'lun.', 'mar.', 'mer.', 'jeu.', 'ven.', 'sam.'],",
-      "  STANDALONESHORTWEEKDAYS: ['dim.', 'lun.', 'mar.', 'mer.', 'jeu.', 'ven.',",
-      "      'sam.'],",
-      "  NARROWWEEKDAYS: ['D', 'L', 'M', 'M', 'J', 'V', 'S'],",
-      "  STANDALONENARROWWEEKDAYS: ['D', 'L', 'M', 'M', 'J', 'V', 'S'],",
-      "  SHORTQUARTERS: ['T1', 'T2', 'T3', 'T4'],",
-      "  QUARTERS: ['1er trimestre', '2e trimestre', '3e trimestre', '4e trimestre'],",
-      "  AMPMS: ['AM', 'PM'],",
-      "  DATEFORMATS: ['EEEE d MMMM y', 'd MMMM y', 'yyyy-MM-dd', 'yy-MM-dd'],",
-      "  TIMEFORMATS: ['HH \\'h\\' mm \\'min\\' ss \\'s\\' zzzz', 'HH:mm:ss z',",
-      "      'HH:mm:ss', 'HH:mm'],",
-      "  FIRSTDAYOFWEEK: 6,",
-      "  WEEKENDRANGE: [5, 6],",
-      "  FIRSTWEEKCUTOFFDAY: 2",
-      "};"
+"goog.i18n.DateTimeSymbols_fr_CA = {",
+"  ERAS: ['av. J.-C.', 'ap. J.-C.'],",
+"  ERANAMES: ['avant Jésus-Christ', 'après Jésus-Christ'],",
+"  NARROWMONTHS: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],",
+"  STANDALONENARROWMONTHS: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O',",
+"      'N', 'D'],",
+"  MONTHS: ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet',",
+"      'août', 'septembre', 'octobre', 'novembre', 'décembre'],",
+"  STANDALONEMONTHS: ['janvier', 'février', 'mars', 'avril', 'mai', 'juin',",
+"      'juillet', 'août', 'septembre', 'octobre', 'novembre', 'décembre'],",
+"  SHORTMONTHS: ['janv.', 'févr.', 'mars', 'avr.', 'mai', 'juin', 'juil.',",
+"      'août', 'sept.', 'oct.', 'nov.', 'déc.'],",
+"  STANDALONESHORTMONTHS: ['janv.', 'févr.', 'mars', 'avr.', 'mai', 'juin',",
+"      'juil.', 'août', 'sept.', 'oct.', 'nov.', 'déc.'],",
+"  WEEKDAYS: ['dimanche', 'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi',",
+"      'samedi'],",
+"  STANDALONEWEEKDAYS: ['dimanche', 'lundi', 'mardi', 'mercredi', 'jeudi',",
+"      'vendredi', 'samedi'],",
+"  SHORTWEEKDAYS: ['dim.', 'lun.', 'mar.', 'mer.', 'jeu.', 'ven.', 'sam.'],",
+"  STANDALONESHORTWEEKDAYS: ['dim.', 'lun.', 'mar.', 'mer.', 'jeu.', 'ven.',",
+"      'sam.'],",
+"  NARROWWEEKDAYS: ['D', 'L', 'M', 'M', 'J', 'V', 'S'],",
+"  STANDALONENARROWWEEKDAYS: ['D', 'L', 'M', 'M', 'J', 'V', 'S'],",
+"  SHORTQUARTERS: ['T1', 'T2', 'T3', 'T4'],",
+"  QUARTERS: ['1er trimestre', '2e trimestre', '3e trimestre', '4e trimestre'],",
+"  AMPMS: ['AM', 'PM'],",
+"  DATEFORMATS: ['EEEE d MMMM y', 'd MMMM y', 'yyyy-MM-dd', 'yy-MM-dd'],",
+"  TIMEFORMATS: ['HH \\'h\\' mm \\'min\\' ss \\'s\\' zzzz', 'HH:mm:ss z',",
+"      'HH:mm:ss', 'HH:mm'],",
+"  FIRSTDAYOFWEEK: 6,",
+"  WEEKENDRANGE: [5, 6],",
+"  FIRSTWEEKCUTOFFDAY: 2",
+"};"
     ].join('\n');
-    var localeInfo = {};
-    var expectedLocaleInfo = {
-        fr_CA: {
-            DATETIME_FORMATS: {
-                MONTH: ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet', 'août', 'septembre',
-                    'octobre', 'novembre', 'décembre'],
-                STANDALONEMONTH: ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet',
-                    'août', 'septembre', 'octobre', 'novembre', 'décembre'],
-                SHORTMONTH: ['janv.', 'févr.', 'mars', 'avr.', 'mai', 'juin', 'juil.', 'août', 'sept.', 'oct.',
-                    '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'],
-                medium: 'yyyy-MM-dd HH:mm:ss',
-                short: 'yy-MM-dd HH:mm',
-                fullDate: 'EEEE d MMMM y',
-                longDate: 'd MMMM y',
-                mediumDate: 'yyyy-MM-dd',
-                shortDate: 'yy-MM-dd',
-                mediumTime: 'HH:mm:ss',
-                shortTime: 'HH:mm'
+      var localeInfo = {};
+      var expectedLocaleInfo = {
+          fr_CA: {
+              DATETIME_FORMATS: {
+                  MONTH: ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet', 'août', 'septembre',
+                      'octobre', 'novembre', 'décembre'],
+                  STANDALONEMONTH: ['janvier', 'février', 'mars', 'avril', 'mai', 'juin', 'juillet',
+                      'août', 'septembre', 'octobre', 'novembre', 'décembre'],
+                  SHORTMONTH: ['janv.', 'févr.', 'mars', 'avr.', 'mai', 'juin', 'juil.', 'août', 'sept.', 'oct.',
+                      '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'],
+                  medium: 'yyyy-MM-dd HH:mm:ss',
+                  short: 'yy-MM-dd HH:mm',
+                  fullDate: 'EEEE d MMMM y',
+                  longDate: 'd MMMM y',
+                  mediumDate: 'yyyy-MM-dd',
+                  shortDate: 'yy-MM-dd',
+                  mediumTime: 'HH:mm:ss',
+                  shortTime: 'HH:mm'
+              }
             }
-          }
-        };
-    extractDateTimeSymbols(CONTENT, localeInfo);
-    expect(localeInfo).toEqual(expectedLocaleInfo);
-  });
+          };
+      extractDateTimeSymbols(CONTENT, localeInfo);
+      expect(localeInfo).toEqual(expectedLocaleInfo);
+      })
 });
 
 describe("pluralExtractor", function() {
@@ -276,10 +272,3 @@ describe("serializeContent", function() {
   });
 });
 
-describe("outputLocale", function() {
-  it("should render the correct locale ids", function() {
-    var output = outputLocale(newTestLocaleInfo(), 'fr_CA');
-    expect(output).toContain('"id": "fr-ca"');
-    expect(output).toContain('"localeID": "fr_CA"');
-  });
-});

i18n/src/closureI18nExtractor.js

@@ -50,10 +50,10 @@ function extractNumberSymbols(content, localeInfo, currencySymbols) {
 function extractCurrencySymbols(content) {
   //eval script in the current context so that we get access to all the symbols
   eval(content.toString());
-  // var currencySymbols = goog.i18n.currency.CurrencyInfo;
-  // currencySymbols.__proto__ = goog.i18n.currency.CurrencyInfoTier2;
+  var currencySymbols = goog.i18n.currency.CurrencyInfo;
+  currencySymbols.__proto__ = goog.i18n.currency.CurrencyInfoTier2;
 
-  return Object.assign({}, goog.i18n.currency.CurrencyInfoTier2, goog.i18n.currency.CurrencyInfo);
+  return currencySymbols;
 }
 
 function extractDateTimeSymbols(content, localeInfo) {
@@ -79,7 +79,7 @@ function pluralExtractor(content, localeInfo) {
     goog.LOCALE = localeIds[i].match(/[^_]+/)[0];
     try {
       eval(contentText);
-    } catch (e) {
+    } catch(e) {
       console.log("Error in eval(contentText): " + e.stack);
     }
     if (!goog.i18n.pluralRules.select) {
@@ -133,7 +133,7 @@ function canonicalizeForJsonStringify(unused_key, object) {
 
 function serializeContent(localeObj) {
   return JSON.stringify(localeObj, canonicalizeForJsonStringify, '  ')
-    .replace(new RegExp('[\\u007f-\\uffff]', 'g'), function(c) { return '\\u' + ('0000' + c.charCodeAt(0).toString(16)).slice(-4); })
+    .replace(new RegExp('[\\u007f-\\uffff]', 'g'), function(c) { return '\\u'+('0000'+c.charCodeAt(0).toString(16)).slice(-4); })
     .replace(/"@@|@@"/g, '');
 }
 
@@ -161,7 +161,6 @@ function outputLocale(localeInfo, localeID) {
   if (!localeObj.DATETIME_FORMATS) {
     localeObj.DATETIME_FORMATS = fallBackObj.DATETIME_FORMATS;
   }
-  localeObj.localeID = localeID;
   localeObj.id = correctedLocaleId(localeID);
 
   var getDecimals = [
@@ -202,11 +201,10 @@ function outputLocale(localeInfo, localeID) {
     DATETIME_FORMATS: localeObj.DATETIME_FORMATS,
     NUMBER_FORMATS: localeObj.NUMBER_FORMATS,
     pluralCat: localeObj.pluralCat,
-    id: localeObj.id,
-    localeID: localeID
+    id: localeObj.id
   };
 
-  var content = serializeContent(localeObj);
+  var content = serializeContent(localeInfo[localeID]);
   if (content.indexOf('getVF(') < 0) {
     getVF = '';
   }

i18n/src/parser.js

@@ -11,7 +11,7 @@ var PATTERN_SEP = ';',
     DIGIT       = '#';
 
 /**
- * main function for parser
+ * main funciton for parser
  * @param str {string} pattern to be parsed (e.g. #,##0.###).
  */
 function parsePattern(pattern) {

images/docs/guide/concepts.graffle/data.plist

@@ -2142,7 +2142,7 @@ queue}</string>
 \pard\tx560\tx1120\tx1680\tx2240\tx2800\tx3360\tx3920\tx4480\tx5040\tx5600\tx6160\tx6720\pardirnatural\qr
 
 \f0\fs22 \cf2 $scope\
-name='World'}</string>
+name='Wold'}</string>
 						<key>VerticalPad</key>
 						<integer>0</integer>
 					</dict>

karma-shared.conf.js

@@ -37,7 +37,7 @@ module.exports = function(config, specificOptions) {
       'SL_Chrome': {
         base: 'SauceLabs',
         browserName: 'chrome',
-        version: '45'
+        version: '43'
       },
       'SL_Firefox': {
         base: 'SauceLabs',

lib/htmlparser/htmlparser.js

@@ -0,0 +1,309 @@
+/*
+ * HTML Parser By John Resig (ejohn.org)
+ * Original code by Erik Arvidsson, Mozilla Public License
+ * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
+ *
+ * // Use like so:
+ * htmlParser(htmlString, {
+ *     start: function(tag, attrs, unary) {},
+ *     end: function(tag) {},
+ *     chars: function(text) {},
+ *     comment: function(text) {}
+ * });
+ *
+ * // or to get an XML string:
+ * HTMLtoXML(htmlString);
+ *
+ * // or to get an XML DOM Document
+ * HTMLtoDOM(htmlString);
+ *
+ * // or to inject into an existing document/DOM node
+ * HTMLtoDOM(htmlString, document);
+ * HTMLtoDOM(htmlString, document.body);
+ *
+ */
+
+(function(){
+
+  // Regular Expressions for parsing tags and attributes
+  var startTag = /^<(\w+)((?:\s+\w+(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,
+    endTag = /^<\/(\w+)[^>]*>/,
+    attr = /(\w+)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g;
+
+  // Empty Elements - HTML 4.01
+  var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,isindex,link,meta,param,embed");
+
+  // Block Elements - HTML 4.01
+  var block = makeMap("address,applet,blockquote,button,center,dd,del,dir,div,dl,dt,fieldset,form,frameset,hr,iframe,ins,isindex,li,map,menu,noframes,noscript,object,ol,p,pre,script,table,tbody,td,tfoot,th,thead,tr,ul");
+
+  // Inline Elements - HTML 4.01
+  var inline = makeMap("a,abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var");
+
+  // Elements that you can, intentionally, leave open
+  // (and which close themselves)
+  var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr");
+
+  // Attributes that have their values filled in disabled="disabled"
+  var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected");
+
+  // Special Elements (can contain anything)
+  var special = makeMap("script,style");
+
+  var htmlParser = this.htmlParser = function( html, handler ) {
+    var index, chars, match, stack = [], last = html;
+    stack.last = function(){
+      return this[ this.length - 1 ];
+    };
+
+    while ( html ) {
+      chars = true;
+
+      // Make sure we're not in a script or style element
+      if ( !stack.last() || !special[ stack.last() ] ) {
+
+        // Comment
+        if ( html.indexOf("<!--") == 0 ) {
+          index = html.indexOf("-->");
+
+          if ( index >= 0 ) {
+            if ( handler.comment )
+              handler.comment( html.substring( 4, index ) );
+            html = html.substring( index + 3 );
+            chars = false;
+          }
+
+        // end tag
+        } else if ( html.indexOf("</") == 0 ) {
+          match = html.match( endTag );
+
+          if ( match ) {
+            html = html.substring( match[0].length );
+            match[0].replace( endTag, parseEndTag );
+            chars = false;
+          }
+
+        // start tag
+        } else if ( html.indexOf("<") == 0 ) {
+          match = html.match( startTag );
+
+          if ( match ) {
+            html = html.substring( match[0].length );
+            match[0].replace( startTag, parseStartTag );
+            chars = false;
+          }
+        }
+
+        if ( chars ) {
+          index = html.indexOf("<");
+
+          var text = index < 0 ? html : html.substring( 0, index );
+          html = index < 0 ? "" : html.substring( index );
+
+          if ( handler.chars )
+            handler.chars( text );
+        }
+
+      } else {
+        html = html.replace(new RegExp("(.*)<\/" + stack.last() + "[^>]*>"), function(all, text){
+          text = text.replace(/<!--(.*?)-->/g, "$1")
+            .replace(/<!\[CDATA\[(.*?)]]>/g, "$1");
+
+          if ( handler.chars )
+            handler.chars( text );
+
+          return "";
+        });
+
+        parseEndTag( "", stack.last() );
+      }
+
+      if ( html == last )
+        throw "Parse Error: " + html;
+      last = html;
+    }
+
+    // Clean up any remaining tags
+    parseEndTag();
+
+    function parseStartTag( tag, tagName, rest, unary ) {
+      if ( block[ tagName ] ) {
+        while ( stack.last() && inline[ stack.last() ] ) {
+          parseEndTag( "", stack.last() );
+        }
+      }
+
+      if ( closeSelf[ tagName ] && stack.last() == tagName ) {
+        parseEndTag( "", tagName );
+      }
+
+      unary = empty[ tagName ] || !!unary;
+
+      if ( !unary )
+        stack.push( tagName );
+
+      if ( handler.start ) {
+        var attrs = [];
+
+        rest.replace(attr, function(match, name) {
+          var value = arguments[2] ? arguments[2] :
+            arguments[3] ? arguments[3] :
+            arguments[4] ? arguments[4] :
+            fillAttrs[name] ? name : "";
+
+          attrs.push({
+            name: name,
+            value: value,
+            escaped: value.replace(/(^|[^\\])"/g, '$1\\\"') //"
+          });
+        });
+
+        if ( handler.start )
+          handler.start( tagName, attrs, unary );
+      }
+    }
+
+    function parseEndTag( tag, tagName ) {
+      // If no tag name is provided, clean shop
+      if ( !tagName )
+        var pos = 0;
+
+      // Find the closest opened tag of the same type
+      else
+        for ( var pos = stack.length - 1; pos >= 0; pos-- )
+          if ( stack[ pos ] == tagName )
+            break;
+
+      if ( pos >= 0 ) {
+        // Close all the open elements, up the stack
+        for ( var i = stack.length - 1; i >= pos; i-- )
+          if ( handler.end )
+            handler.end( stack[ i ] );
+
+        // Remove the open elements from the stack
+        stack.length = pos;
+      }
+    }
+  };
+
+  this.HTMLtoXML = function( html ) {
+    var results = "";
+
+    htmlParser(html, {
+      start: function( tag, attrs, unary ) {
+        results += "<" + tag;
+
+        for ( var i = 0; i < attrs.length; i++ )
+          results += " " + attrs[i].name + '="' + attrs[i].escaped + '"';
+
+        results += (unary ? "/" : "") + ">";
+      },
+      end: function( tag ) {
+        results += "</" + tag + ">";
+      },
+      chars: function( text ) {
+        results += text;
+      },
+      comment: function( text ) {
+        results += "<!--" + text + "-->";
+      }
+    });
+
+    return results;
+  };
+
+  this.HTMLtoDOM = function( html, doc ) {
+    // There can be only one of these elements
+    var one = makeMap("html,head,body,title");
+
+    // Enforce a structure for the document
+    var structure = {
+      link: "head",
+      base: "head"
+    };
+
+    if ( !doc ) {
+      if ( typeof DOMDocument != "undefined" )
+        doc = new DOMDocument();
+      else if ( typeof document != "undefined" && document.implementation && document.implementation.createDocument )
+        doc = document.implementation.createDocument("", "", null);
+      else if ( typeof ActiveX != "undefined" )
+        doc = new ActiveXObject("Msxml.DOMDocument");
+
+    } else
+      doc = doc.ownerDocument ||
+        doc.getOwnerDocument && doc.getOwnerDocument() ||
+        doc;
+
+    var elems = [],
+      documentElement = doc.documentElement ||
+        doc.getDocumentElement && doc.getDocumentElement();
+
+    // If we're dealing with an empty document then we
+    // need to pre-populate it with the HTML document structure
+    if ( !documentElement && doc.createElement ) (function(){
+      var html = doc.createElement("html");
+      var head = doc.createElement("head");
+      head.appendChild( doc.createElement("title") );
+      html.appendChild( head );
+      html.appendChild( doc.createElement("body") );
+      doc.appendChild( html );
+    })();
+
+    // Find all the unique elements
+    if ( doc.getElementsByTagName )
+      for ( var i in one )
+        one[ i ] = doc.getElementsByTagName( i )[0];
+
+    // If we're working with a document, inject contents into
+    // the body element
+    var curParentNode = one.body;
+
+    htmlParser( html, {
+      start: function( tagName, attrs, unary ) {
+        // If it's a pre-built element, then we can ignore
+        // its construction
+        if ( one[ tagName ] ) {
+          curParentNode = one[ tagName ];
+          return;
+        }
+
+        var elem = doc.createElement( tagName );
+
+        for ( var attr in attrs )
+          elem.setAttribute( attrs[ attr ].name, attrs[ attr ].value );
+
+        if ( structure[ tagName ] && typeof one[ structure[ tagName ] ] != "boolean" )
+          one[ structure[ tagName ] ].appendChild( elem );
+
+        else if ( curParentNode && curParentNode.appendChild )
+          curParentNode.appendChild( elem );
+
+        if ( !unary ) {
+          elems.push( elem );
+          curParentNode = elem;
+        }
+      },
+      end: function( tag ) {
+        elems.length -= 1;
+
+        // Init the new parentNode
+        curParentNode = elems[ elems.length - 1 ];
+      },
+      chars: function( text ) {
+        curParentNode.appendChild( doc.createTextNode( text ) );
+      },
+      comment: function( text ) {
+        // create comment node
+      }
+    });
+
+    return doc;
+  };
+
+  function makeMap(str){
+    var obj = {}, items = str.split(",");
+    for ( var i = 0; i < items.length; i++ )
+      obj[ items[i] ] = true;
+    return obj;
+  }
+})();

lib/saucelabs/start_tunnel.sh

@@ -11,7 +11,8 @@ set -e
 # Curl and run this script as part of your .travis.yml before_script section:
 # before_script:
 #   - curl https://gist.github.com/santiycr/5139565/raw/sauce_connect_setup.sh | bash
-CONNECT_URL="https://saucelabs.com/downloads/sc-4.3.13-linux.tar.gz"
+
+CONNECT_URL="https://saucelabs.com/downloads/sc-4.3.7-linux.tar.gz"
 CONNECT_DIR="/tmp/sauce-connect-$RANDOM"
 CONNECT_DOWNLOAD="sc-4.3.7-linux.tar.gz"
 

lib/versions/version-info.js

@@ -178,7 +178,7 @@ var getSnapshotVersion = function() {
     // last release was a non beta release. Increment the patch level to
     // indicate the next release that we will be doing.
     // E.g. last release was 1.3.0, then the snapshot will be
-    // 1.3.1-build.1, which is lesser than 1.3.1 according to the semver!
+    // 1.3.1-build.1, which is lesser than 1.3.1 accorind the semver!
 
     // If the last release was a beta release we don't update the
     // beta number by purpose, as otherwise the semver comparison

package.json

@@ -1,23 +1,22 @@
 {
   "name": "angularjs",
   "license": "MIT",
-  "branchVersion": "^1.5.0-beta.2",
-  "branchPattern": "1.5.*",
-  "distTag": "beta",
+  "branchVersion": "^1.4.0-beta.0",
+  "branchPattern": "1.4.*",
+  "distTag": "latest",
   "repository": {
     "type": "git",
     "url": "https://github.com/angular/angular.js.git"
   },
   "engines": {
-    "node": "<5",
+    "node": "~0.10",
     "npm": "~2.5"
   },
   "engineStrict": true,
   "scripts": {
     "preinstall": "node scripts/npm/check-node-modules.js --purge",
     "postinstall": "node scripts/npm/copy-npm-shrinkwrap.js",
-    "commit": "git-cz",
-    "test-i18n": "jasmine-node i18n/spec"
+    "commit": "git-cz"
   },
   "devDependencies": {
     "angular-benchpress": "0.x.x",
@@ -27,7 +26,7 @@
     "canonical-path": "0.0.2",
     "cheerio": "^0.17.0",
     "commitizen": "^2.3.0",
-    "cz-conventional-changelog": "1.1.4",
+    "cz-conventional-changelog": "^1.1.4",
     "dgeni": "^0.4.0",
     "dgeni-packages": "^0.11.0",
     "event-stream": "~3.1.0",
@@ -41,7 +40,7 @@
     "grunt-contrib-jshint": "~0.10.0",
     "grunt-ddescribe-iit": "~0.0.1",
     "grunt-jasmine-node": "git://github.com/vojtajina/grunt-jasmine-node.git#fix-grunt-exit-code",
-    "grunt-jscs": "^2.1.0",
+    "grunt-jscs": "~1.2.0",
     "grunt-merge-conflict": "~0.0.1",
     "grunt-shell": "~1.1.1",
     "gulp": "~3.8.0",
@@ -52,7 +51,7 @@
     "gulp-sourcemaps": "^1.2.2",
     "gulp-uglify": "^1.0.1",
     "gulp-util": "^3.0.1",
-    "jasmine-node": "^2.0.0",
+    "jasmine-node": "~1.14.5",
     "jasmine-reporters": "~1.0.1",
     "jshint-stylish": "~1.0.0",
     "karma": "^0.13.19",

src/.jshintrc

@@ -94,6 +94,8 @@
     "VALIDITY_STATE_PROPERTY": false,
     "reloadWithDebugInfo": false,
 
+    "skipDestroyOnNextJQueryCleanData": true,
+
     "NODE_TYPE_ELEMENT": false,
     "NODE_TYPE_ATTRIBUTE": false,
     "NODE_TYPE_TEXT": false,
@@ -138,7 +140,6 @@
     "jqLiteInheritedData": false,
     "jqLiteBuildFragment": false,
     "jqLiteParseHTML": false,
-    "jqLiteWrapNode": false,
     "getBooleanAttrName": false,
     "getAliasedAttrName": false,
     "createEventHandler": false,

src/Angular.js

@@ -119,9 +119,29 @@ var REGEX_STRING_REGEXP = /^\/(.+)\/([a-z]*)$/;
 // This is used so that it's possible for internal tests to create mock ValidityStates.
 var VALIDITY_STATE_PROPERTY = 'validity';
 
+/**
+ * @ngdoc function
+ * @name angular.lowercase
+ * @module ng
+ * @kind function
+ *
+ * @description Converts the specified string to lowercase.
+ * @param {string} string String to be converted to lowercase.
+ * @returns {string} Lowercased string.
+ */
+var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 
-var lowercase = function(string) {return isString(string) ? string.toLowerCase() : string;};
+/**
+ * @ngdoc function
+ * @name angular.uppercase
+ * @module ng
+ * @kind function
+ *
+ * @description Converts the specified string to uppercase.
+ * @param {string} string String to be converted to uppercase.
+ * @returns {string} Uppercased string.
+ */
 var uppercase = function(string) {return isString(string) ? string.toUpperCase() : string;};
 
 
@@ -141,7 +161,7 @@ var manualUppercase = function(s) {
 
 // String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish
 // locale, for this reason we need to detect this case and redefine lowercase/uppercase methods
-// with correct but slower alternatives. See https://github.com/angular/angular.js/issues/11387
+// with correct but slower alternatives.
 if ('i' !== 'I'.toLowerCase()) {
   lowercase = manualLowercase;
   uppercase = manualUppercase;
@@ -184,7 +204,7 @@ function isArrayLike(obj) {
 
   // arrays, strings and jQuery/jqLite objects are array like
   // * jqLite is either the jQuery or jqLite constructor function
-  // * we have to check the existence of jqLite first as this method is called
+  // * we have to check the existance of jqLite first as this method is called
   //   via the forEach method when constructing the jqLite object in the first place
   if (isArray(obj) || isString(obj) || (jqLite && obj instanceof jqLite)) return true;
 
@@ -293,7 +313,7 @@ function forEachSorted(obj, iterator, context) {
  * @returns {function(*, string)}
  */
 function reverseParams(iteratorFn) {
-  return function(value, key) {iteratorFn(key, value);};
+  return function(value, key) { iteratorFn(key, value); };
 }
 
 /**
@@ -664,10 +684,6 @@ function isTypedArray(value) {
   return value && isNumber(value.length) && TYPED_ARRAY_REGEXP.test(toString.call(value));
 }
 
-function isArrayBuffer(obj) {
-  return toString.call(obj) === '[object ArrayBuffer]';
-}
-
 
 var trim = function(value) {
   return isString(value) ? value.trim() : value;
@@ -705,7 +721,7 @@ function isElement(node) {
  * @returns {object} in the form of {key1:true, key2:true, ...}
  */
 function makeMap(str) {
-  var obj = {}, items = str.split(','), i;
+  var obj = {}, items = str.split(","), i;
   for (i = 0; i < items.length; i++) {
     obj[items[i]] = true;
   }
@@ -792,7 +808,7 @@ function copy(source, destination) {
   var stackDest = [];
 
   if (destination) {
-    if (isTypedArray(destination) || isArrayBuffer(destination)) {
+    if (isTypedArray(destination)) {
       throw ngMinErr('cpta', "Can't copy! TypedArray destination cannot be mutated.");
     }
     if (source === destination) {
@@ -866,10 +882,22 @@ function copy(source, destination) {
     }
 
     var needsRecurse = false;
-    var destination = copyType(source);
+    var destination;
 
-    if (destination === undefined) {
-      destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
+    if (isArray(source)) {
+      destination = [];
+      needsRecurse = true;
+    } 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 (isFunction(source.cloneNode)) {
+        destination = source.cloneNode(true);
+    } else {
+      destination = Object.create(getPrototypeOf(source));
       needsRecurse = true;
     }
 
@@ -880,45 +908,6 @@ function copy(source, destination) {
       ? copyRecurse(source, destination)
       : destination;
   }
-
-  function copyType(source) {
-    switch (toString.call(source)) {
-      case '[object Int8Array]':
-      case '[object Int16Array]':
-      case '[object Int32Array]':
-      case '[object Float32Array]':
-      case '[object Float64Array]':
-      case '[object Uint8Array]':
-      case '[object Uint8ClampedArray]':
-      case '[object Uint16Array]':
-      case '[object Uint32Array]':
-        return new source.constructor(copyElement(source.buffer));
-
-      case '[object ArrayBuffer]':
-        //Support: IE10
-        if (!source.slice) {
-          var copied = new ArrayBuffer(source.byteLength);
-          new Uint8Array(copied).set(new Uint8Array(source));
-          return copied;
-        }
-        return source.slice(0);
-
-      case '[object Boolean]':
-      case '[object Number]':
-      case '[object String]':
-      case '[object Date]':
-        return new source.constructor(source.valueOf());
-
-      case '[object RegExp]':
-        var re = new RegExp(source.source, source.toString().match(/[^\/]*$/)[0]);
-        re.lastIndex = source.lastIndex;
-        return re;
-    }
-
-    if (isFunction(source.cloneNode)) {
-      return source.cloneNode(true);
-    }
-  }
 }
 
 /**
@@ -981,37 +970,38 @@ function equals(o1, o2) {
   if (o1 === null || o2 === null) return false;
   if (o1 !== o1 && o2 !== o2) return true; // NaN === NaN
   var t1 = typeof o1, t2 = typeof o2, length, key, keySet;
-  if (t1 == t2 && t1 == 'object') {
-    if (isArray(o1)) {
-      if (!isArray(o2)) return false;
-      if ((length = o1.length) == o2.length) {
-        for (key = 0; key < length; key++) {
+  if (t1 == t2) {
+    if (t1 == 'object') {
+      if (isArray(o1)) {
+        if (!isArray(o2)) return false;
+        if ((length = o1.length) == o2.length) {
+          for (key = 0; key < length; key++) {
+            if (!equals(o1[key], o2[key])) return false;
+          }
+          return true;
+        }
+      } else if (isDate(o1)) {
+        if (!isDate(o2)) return false;
+        return equals(o1.getTime(), o2.getTime());
+      } else if (isRegExp(o1)) {
+        return isRegExp(o2) ? o1.toString() == o2.toString() : false;
+      } else {
+        if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
+          isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
+        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 (!(key in keySet) &&
+              key.charAt(0) !== '$' &&
+              isDefined(o2[key]) &&
+              !isFunction(o2[key])) return false;
         }
         return true;
       }
-    } else if (isDate(o1)) {
-      if (!isDate(o2)) return false;
-      return equals(o1.getTime(), o2.getTime());
-    } else if (isRegExp(o1)) {
-      if (!isRegExp(o2)) return false;
-      return o1.toString() == o2.toString();
-    } else {
-      if (isScope(o1) || isScope(o2) || isWindow(o1) || isWindow(o2) ||
-        isArray(o2) || isDate(o2) || isRegExp(o2)) return false;
-      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 (!(key in keySet) &&
-            key.charAt(0) !== '$' &&
-            isDefined(o2[key]) &&
-            !isFunction(o2[key])) return false;
-      }
-      return true;
     }
   }
   return false;
@@ -1188,7 +1178,7 @@ function toJsonReplacer(key, value) {
  * @returns {string|undefined} JSON-ified string representing `obj`.
  */
 function toJson(obj, pretty) {
-  if (isUndefined(obj)) return undefined;
+  if (typeof obj === 'undefined') return undefined;
   if (!isNumber(pretty)) {
     pretty = pretty ? 2 : null;
   }
@@ -1215,10 +1205,7 @@ function fromJson(json) {
 }
 
 
-var ALL_COLONS = /:/g;
 function timezoneToOffset(timezone, fallback) {
-  // IE/Edge do not "understand" colon (`:`) in timezone
-  timezone = timezone.replace(ALL_COLONS, '');
   var requestedTimezoneOffset = Date.parse('Jan 01, 1970 00:00:00 ' + timezone) / 60000;
   return isNaN(requestedTimezoneOffset) ? fallback : requestedTimezoneOffset;
 }
@@ -1233,9 +1220,8 @@ function addDateMinutes(date, minutes) {
 
 function convertTimezoneToLocal(date, timezone, reverse) {
   reverse = reverse ? -1 : 1;
-  var dateTimezoneOffset = date.getTimezoneOffset();
-  var timezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
-  return addDateMinutes(date, reverse * (timezoneOffset - dateTimezoneOffset));
+  var timezoneOffset = timezoneToOffset(timezone, date.getTimezoneOffset());
+  return addDateMinutes(date, reverse * (timezoneOffset - date.getTimezoneOffset()));
 }
 
 
@@ -1254,7 +1240,7 @@ function startingTag(element) {
     return element[0].nodeType === NODE_TYPE_TEXT ? lowercase(elemHtml) :
         elemHtml.
           match(/^(<[^>]+>)/)[1].
-          replace(/^<([\w\-]+)/, function(match, nodeName) {return '<' + lowercase(nodeName);});
+          replace(/^<([\w\-]+)/, function(match, nodeName) { return '<' + lowercase(nodeName); });
   } catch (e) {
     return lowercase(elemHtml);
   }
@@ -1697,6 +1683,7 @@ function snake_case(name, separator) {
 }
 
 var bindJQueryFired = false;
+var skipDestroyOnNextJQueryCleanData;
 function bindJQuery() {
   var originalCleanData;
 
@@ -1730,11 +1717,15 @@ function bindJQuery() {
     originalCleanData = jQuery.cleanData;
     jQuery.cleanData = function(elems) {
       var events;
-      for (var i = 0, elem; (elem = elems[i]) != null; i++) {
-        events = jQuery._data(elem, "events");
-        if (events && events.$destroy) {
-          jQuery(elem).triggerHandler('$destroy');
+      if (!skipDestroyOnNextJQueryCleanData) {
+        for (var i = 0, elem; (elem = elems[i]) != null; i++) {
+          events = jQuery._data(elem, "events");
+          if (events && events.$destroy) {
+            jQuery(elem).triggerHandler('$destroy');
+          }
         }
+      } else {
+        skipDestroyOnNextJQueryCleanData = false;
       }
       originalCleanData(elems);
     };

src/AngularPublic.js

@@ -63,7 +63,6 @@
   $BrowserProvider,
   $CacheFactoryProvider,
   $ControllerProvider,
-  $DateProvider,
   $DocumentProvider,
   $ExceptionHandlerProvider,
   $FilterProvider,

src/angular.prefix

@@ -1,6 +1,6 @@
 /**
  * @license AngularJS v"NG_VERSION_FULL"
- * (c) 2010-2016 Google, Inc. http://angularjs.org
+ * (c) 2010-2015 Google, Inc. http://angularjs.org
  * License: MIT
  */
 (function(window, document, undefined) {

src/auto/injector.js

@@ -62,23 +62,17 @@
  * Implicit module which gets automatically added to each {@link auto.$injector $injector}.
  */
 
-var ARROW_ARG = /^([^\(]+?)=>/;
 var FN_ARGS = /^[^\(]*\(\s*([^\)]*)\)/m;
 var FN_ARG_SPLIT = /,/;
 var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
 var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
 var $injectorMinErr = minErr('$injector');
 
-function extractArgs(fn) {
-  var fnText = fn.toString().replace(STRIP_COMMENTS, ''),
-      args = fnText.match(ARROW_ARG) || fnText.match(FN_ARGS);
-  return args;
-}
-
 function anonFn(fn) {
   // For anonymous functions, showing at the very least the function signature can help in
   // debugging.
-  var args = extractArgs(fn);
+  var fnText = fn.toString().replace(STRIP_COMMENTS, ''),
+      args = fnText.match(FN_ARGS);
   if (args) {
     return 'function(' + (args[1] || '').replace(/[\s\r\n]+/, ' ') + ')';
   }
@@ -87,6 +81,7 @@ function anonFn(fn) {
 
 function annotate(fn, strictDi, name) {
   var $inject,
+      fnText,
       argDecl,
       last;
 
@@ -101,7 +96,8 @@ function annotate(fn, strictDi, name) {
           throw $injectorMinErr('strictdi',
             '{0} is not using explicit annotation and cannot be invoked in strict mode', name);
         }
-        argDecl = extractArgs(fn);
+        fnText = fn.toString().replace(STRIP_COMMENTS, '');
+        argDecl = fnText.match(FN_ARGS);
         forEach(argDecl[1].split(FN_ARG_SPLIT), function(arg) {
           arg.replace(FN_ARG, function(all, underscore, name) {
             $inject.push(name);
@@ -491,20 +487,8 @@ function annotate(fn, strictDi, name) {
  *
  * Register a **service constructor**, which will be invoked with `new` to create the service
  * instance.
- * This is short for registering a service where its provider's `$get` property is a factory
- * function that returns an instance instantiated by the injector from the service constructor
- * function.
- *
- * Internally it looks a bit like this:
- *
- * ```
- * {
- *   $get: function() {
- *     return $injector.instantiate(constructor);
- *   }
- * }
- * ```
- *
+ * This is short for registering a service where its provider's `$get` property is the service
+ * constructor function that will be used to instantiate the service instance.
  *
  * You should use {@link auto.$provide#service $provide.service(class)} if you define your service
  * as a type/class.
@@ -654,19 +638,14 @@ function createInjector(modulesToLoad, strictDi) {
             throw $injectorMinErr('unpr', "Unknown provider: {0}", path.join(' <- '));
           })),
       instanceCache = {},
-      protoInstanceInjector =
+      instanceInjector = (instanceCache.$injector =
           createInternalInjector(instanceCache, function(serviceName, caller) {
             var provider = providerInjector.get(serviceName + providerSuffix, caller);
-            return instanceInjector.invoke(
-                provider.$get, provider, undefined, serviceName);
-          }),
-      instanceInjector = protoInstanceInjector;
+            return instanceInjector.invoke(provider.$get, provider, undefined, serviceName);
+          }));
 
-  providerCache['$injector' + providerSuffix] = { $get: valueFn(protoInstanceInjector) };
-  var runBlocks = loadModules(modulesToLoad);
-  instanceInjector = protoInstanceInjector.get('$injector');
-  instanceInjector.strictDi = strictDi;
-  forEach(runBlocks, function(fn) { if (fn) instanceInjector.invoke(fn); });
+
+  forEach(loadModules(modulesToLoad), function(fn) { if (fn) instanceInjector.invoke(fn); });
 
   return instanceInjector;
 
@@ -816,66 +795,47 @@ function createInjector(modulesToLoad, strictDi) {
       }
     }
 
-
-    function injectionArgs(fn, locals, serviceName) {
-      var args = [],
-          $inject = createInjector.$$annotate(fn, strictDi, serviceName);
-
-      for (var i = 0, length = $inject.length; i < length; i++) {
-        var key = $inject[i];
-        if (typeof key !== 'string') {
-          throw $injectorMinErr('itkn',
-                  'Incorrect injection token! Expected service name as string, got {0}', key);
-        }
-        args.push(locals && locals.hasOwnProperty(key) ? locals[key] :
-                                                         getService(key, serviceName));
-      }
-      return args;
-    }
-
-    function isClass(func) {
-      // IE 9-11 do not support classes and IE9 leaks with the code below.
-      if (msie <= 11) {
-        return false;
-      }
-      // Workaround for MS Edge.
-      // Check https://connect.microsoft.com/IE/Feedback/Details/2211653
-      return typeof func === 'function'
-        && /^(?:class\s|constructor\()/.test(Function.prototype.toString.call(func));
-    }
-
     function invoke(fn, self, locals, serviceName) {
       if (typeof locals === 'string') {
         serviceName = locals;
         locals = null;
       }
 
-      var args = injectionArgs(fn, locals, serviceName);
+      var args = [],
+          $inject = createInjector.$$annotate(fn, strictDi, serviceName),
+          length, i,
+          key;
+
+      for (i = 0, length = $inject.length; i < length; i++) {
+        key = $inject[i];
+        if (typeof key !== 'string') {
+          throw $injectorMinErr('itkn',
+                  'Incorrect injection token! Expected service name as string, got {0}', key);
+        }
+        args.push(
+          locals && locals.hasOwnProperty(key)
+          ? locals[key]
+          : getService(key, serviceName)
+        );
+      }
       if (isArray(fn)) {
-        fn = fn[fn.length - 1];
+        fn = fn[length];
       }
 
-      if (!isClass(fn)) {
-        // http://jsperf.com/angularjs-invoke-apply-vs-switch
-        // #5388
-        return fn.apply(self, args);
-      } else {
-        args.unshift(null);
-        return new (Function.prototype.bind.apply(fn, args))();
-      }
+      // http://jsperf.com/angularjs-invoke-apply-vs-switch
+      // #5388
+      return fn.apply(self, args);
     }
 
-
     function instantiate(Type, locals, serviceName) {
       // Check if Type is annotated and use just the given function at n-1 as parameter
       // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
-      var ctor = (isArray(Type) ? Type[Type.length - 1] : Type);
-      var args = injectionArgs(Type, locals, serviceName);
-      // Empty object at position 0 is ignored for invocation with `new`, but required.
-      args.unshift(null);
-      return new (Function.prototype.bind.apply(ctor, args))();
-    }
+      // Object creation: http://jsperf.com/create-constructor/2
+      var instance = Object.create((isArray(Type) ? Type[Type.length - 1] : Type).prototype || null);
+      var returnedValue = invoke(Type, instance, locals, serviceName);
 
+      return isObject(returnedValue) || isFunction(returnedValue) ? returnedValue : instance;
+    }
 
     return {
       invoke: invoke,

src/jqLite.js

@@ -196,12 +196,6 @@ function jqLiteHasData(node) {
   return false;
 }
 
-function jqLiteCleanData(nodes) {
-  for (var i = 0, ii = nodes.length; i < ii; i++) {
-    jqLiteRemoveData(nodes[i]);
-  }
-}
-
 function jqLiteBuildFragment(html, context) {
   var tmp, tag, wrap,
       fragment = context.createDocumentFragment(),
@@ -254,16 +248,6 @@ function jqLiteParseHTML(html, context) {
   return [];
 }
 
-function jqLiteWrapNode(node, wrapper) {
-  var parent = node.parentNode;
-
-  if (parent) {
-    parent.replaceChild(wrapper, node);
-  }
-
-  wrapper.appendChild(node);
-}
-
 
 // IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
 var jqLiteContains = Node.prototype.contains || function(arg) {
@@ -514,7 +498,7 @@ function jqLiteRemove(element, keepData) {
 function jqLiteDocumentLoaded(action, win) {
   win = win || window;
   if (win.document.readyState === 'complete') {
-    // Force the action to be run async for consistent behavior
+    // Force the action to be run async for consistent behaviour
     // from the action's point of view
     // i.e. it will definitely not be in a $apply
     win.setTimeout(action);
@@ -600,8 +584,7 @@ function getAliasedAttrName(name) {
 forEach({
   data: jqLiteData,
   removeData: jqLiteRemoveData,
-  hasData: jqLiteHasData,
-  cleanData: jqLiteCleanData
+  hasData: jqLiteHasData
 }, function(fn, name) {
   JQLite[name] = fn;
 });
@@ -956,7 +939,12 @@ forEach({
   },
 
   wrap: function(element, wrapNode) {
-    jqLiteWrapNode(element, jqLite(wrapNode).eq(0).clone()[0]);
+    wrapNode = jqLite(wrapNode).eq(0).clone()[0];
+    var parent = element.parentNode;
+    if (parent) {
+      parent.replaceChild(wrapNode, element);
+    }
+    wrapNode.appendChild(element);
   },
 
   remove: jqLiteRemove,

src/loader.js

@@ -282,19 +282,6 @@ function setupModuleLoader(window) {
            */
           directive: invokeLaterAndSetModuleName('$compileProvider', 'directive'),
 
-          /**
-           * @ngdoc method
-           * @name angular.Module#component
-           * @module ng
-           * @param {string} name Name of the component in camel-case (i.e. myComp which will match as my-comp)
-           * @param {Object} options Component definition object (a simplified
-           *    {@link ng.$compile#directive-definition-object directive definition object})
-           *
-           * @description
-           * See {@link ng.$compileProvider#component $compileProvider.component()}.
-           */
-          component: invokeLaterAndSetModuleName('$compileProvider', 'component'),
-
           /**
            * @ngdoc method
            * @name angular.Module#config

src/loader.prefix

@@ -1,8 +1,8 @@
 /**
  * @license AngularJS v"NG_VERSION_FULL"
- * (c) 2010-2016 Google, Inc. http://angularjs.org
+ * (c) 2010-2015 Google, Inc. http://angularjs.org
  * License: MIT
  */
 'use strict';
 (function() {
-    function isFunction(value) {return typeof value === 'function';};
+    function isFunction(value) {return typeof value === 'function';};

src/module.prefix

@@ -1,6 +1,6 @@
 /**
  * @license AngularJS v"NG_VERSION_FULL"
- * (c) 2010-2016 Google, Inc. http://angularjs.org
+ * (c) 2010-2015 Google, Inc. http://angularjs.org
  * License: MIT
  */
 (function(window, angular, undefined) {

src/ng/animate.js

@@ -329,8 +329,8 @@ var $AnimateProvider = ['$provide', function($provide) {
        * // 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 `callback` that is set
-       * // to listen for `enter` on the given `container` as well as its children
+       * // 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);
        * ```
        *
@@ -553,7 +553,7 @@ var $AnimateProvider = ['$provide', function($provide) {
        *
        * @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 classNamem, then the provided `from` and
+       * 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 the CSS style provided in `from` does not have a corresponding
        * style in `to`, the style in `from` is applied immediately, and no animation is run.
        * If a JavaScript animation is detected then the provided styles will be given in as function parameters into the `animate`
@@ -575,7 +575,7 @@ var $AnimateProvider = ['$provide', function($provide) {
        * @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 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

src/ng/animateCss.js

@@ -36,7 +36,7 @@ var $CoreAnimateCssProvider = function() {
         options.from = null;
       }
 
-      /* jshint newcap: false */
+      /* jshint newcap: false*/
       var closed, runner = new $$AnimateRunner();
       return {
         start: run,

src/ng/compile.js

@@ -128,7 +128,7 @@
  * When this property is set to true, the HTML compiler will collect DOM nodes between
  * nodes with the attributes `directive-name-start` and `directive-name-end`, and group them
  * together as the directive elements. It is recommended that this feature be used on directives
- * which are not strictly behavioral (such as {@link ngClick}), and which
+ * which are not strictly behavioural (such as {@link ngClick}), and which
  * do not manipulate or replace child nodes (such as {@link ngInclude}).
  *
  * #### `priority`
@@ -166,62 +166,35 @@
  * is bound to the parent scope, via matching attributes on the directive's element:
  *
  * * `@` or `@attr` - bind a local scope property to the value of DOM attribute. The result is
- *   always a string since DOM attributes are strings. If no `attr` name is specified then the
- *   attribute name is assumed to be the same as the local name. Given `<my-component
- *   my-attr="hello {{name}}">` and the isolate scope definition `scope: { localName:'@myAttr' }`,
- *   the directive's scope property `localName` will reflect the interpolated value of `hello
- *   {{name}}`. As the `name` attribute changes so will the `localName` property on the directive's
- *   scope. The `name` is read from the parent scope (not the directive's scope).
+ *   always a string since DOM attributes are strings. If no `attr` name is specified  then the
+ *   attribute name is assumed to be the same as the local name.
+ *   Given `<widget my-attr="hello {{name}}">` and widget definition
+ *   of `scope: { localName:'@myAttr' }`, then widget scope property `localName` will reflect
+ *   the interpolated value of `hello {{name}}`. As the `name` attribute changes so will the
+ *   `localName` property on the widget scope. The `name` is read from the parent scope (not
+ *   component scope).
  *
- * * `=` or `=attr` - set up a bidirectional binding between a local scope property and an expression
- *   passed via the attribute `attr`. The expression is evaluated in the context of the parent scope.
- *   If no `attr` name is specified then the attribute name is assumed to be the same as the local
- *   name. Given `<my-component my-attr="parentModel">` and the isolate scope definition `scope: {
- *   localModel: '=myAttr' }`, the property `localModel` on the directive's scope will reflect the
- *   value of `parentModel` on the parent scope. Changes to `parentModel` will be reflected in
- *   `localModel` and vice versa. Optional attributes should be marked as such with a question mark:
- *   `=?` or `=?attr`. If the binding expression is non-assignable, or if the attribute isn't
- *   optional and doesn't exist, an exception ({@link error/$compile/nonassign `$compile:nonassign`})
- *   will be thrown upon discovering changes to the local value, since it will be impossible to sync
- *   them back to the parent scope. By default, the {@link ng.$rootScope.Scope#$watch `$watch`}
- *   method is used for tracking changes, and the equality check is based on object identity.
- *   However, if an object literal or an array literal is passed as the binding expression, the
- *   equality check is done by value (using the {@link angular.equals} function). It's also possible
- *   to watch the evaluated value shallowly with {@link ng.$rootScope.Scope#$watchCollection
- *   `$watchCollection`}: use `=*` or `=*attr` (`=*?` or `=*?attr` if the attribute is optional).
- *
-  * * `<` or `<attr` - set up a one-way (one-directional) binding between a local scope property and an
- *   expression passed via the attribute `attr`. The expression is evaluated in the context of the
- *   parent scope. If no `attr` name is specified then the attribute name is assumed to be the same as the
- *   local name. You can also make the binding optional by adding `?`: `<?` or `<?attr`.
- *
- *   For example, given `<my-component my-attr="parentModel">` and directive definition of
- *   `scope: { localModel:'<myAttr' }`, then the isolated scope property `localModel` will reflect the
+ * * `=` or `=attr` - set up bi-directional binding between a local scope property and the
+ *   parent scope property of name defined via the value of the `attr` attribute. If no `attr`
+ *   name is specified then the attribute name is assumed to be the same as the local name.
+ *   Given `<widget my-attr="parentModel">` and widget definition of
+ *   `scope: { localModel:'=myAttr' }`, then widget scope property `localModel` will reflect the
  *   value of `parentModel` on the parent scope. Any changes to `parentModel` will be reflected
- *   in `localModel`, but changes in `localModel` will not reflect in `parentModel`. There are however
- *   two caveats:
- *     1. one-way binding does not copy the value from the parent to the isolate scope, it simply
- *     sets the same value. That means if your bound value is an object, changes to its properties
- *     in the isolated scope will be reflected in the parent scope (because both reference the same object).
- *     2. one-way binding watches changes to the **identity** of the parent value. That means the
- *     {@link ng.$rootScope.Scope#$watch `$watch`} on the parent value only fires if the reference
- *     to the value has changed. In most cases, this should not be of concern, but can be important
- *     to know if you one-way bind to an object, and then replace that object in the isolated scope.
- *     If you now change a property of the object in your parent scope, the change will not be
- *     propagated to the isolated scope, because the identity of the object on the parent scope
- *     has not changed. Instead you must assign a new object.
+ *   in `localModel` and any changes in `localModel` will reflect in `parentModel`. If the parent
+ *   scope property doesn't exist, it will throw a NON_ASSIGNABLE_MODEL_EXPRESSION exception. You
+ *   can avoid this behavior using `=?` or `=?attr` in order to flag the property as optional. If
+ *   you want to shallow watch for changes (i.e. $watchCollection instead of $watch) you can use
+ *   `=*` or `=*attr` (`=*?` or `=*?attr` if the property is optional).
  *
- *   One-way binding is useful if you do not plan to propagate changes to your isolated scope bindings
- *   back to the parent. However, it does not make this completely impossible.
- *
- * * `&` or `&attr` - provides a way to execute an expression in the context of the parent scope. If
- *   no `attr` name is specified then the attribute name is assumed to be the same as the local name.
- *   Given `<my-component my-attr="count = count + value">` and the isolate scope definition `scope: {
- *   localFn:'&myAttr' }`, the isolate scope property `localFn` will point to a function wrapper for
- *   the `count = count + value` expression. Often it's desirable to pass data from the isolated scope
- *   via an expression to the parent scope. This can be done by passing a map of local variable names
- *   and values into the expression wrapper fn. For example, if the expression is `increment(amount)`
- *   then we can specify the amount value by calling the `localFn` as `localFn({amount: 22})`.
+ * * `&` or `&attr` - provides a way to execute an expression in the context of the parent scope.
+ *   If no `attr` name is specified then the attribute name is assumed to be the same as the
+ *   local name. Given `<widget my-attr="count = count + value">` and widget definition of
+ *   `scope: { localFn:'&myAttr' }`, then isolate scope property `localFn` will point to
+ *   a function wrapper for the `count = count + value` expression. Often it's desirable to
+ *   pass data from the isolated scope via an expression to the parent scope, this can be
+ *   done by passing a map of local variable names and values into the expression wrapper fn.
+ *   For example, if the expression is `increment(amount)` then we can specify the amount value
+ *   by calling the `localFn` as `localFn({amount: 22})`.
  *
  * In general it's possible to apply more than one directive to one element, but there might be limitations
  * depending on the type of scope required by the directives. The following points will help explain these limitations.
@@ -245,18 +218,8 @@
  * definition: `controller: 'myCtrl as myAlias'`.
  *
  * When an isolate scope is used for a directive (see above), `bindToController: true` will
- * allow a component to have its properties bound to the controller, rather than to scope.
- *
- * After the controller is instantiated, the initial values of the isolate scope bindings will be bound to the controller
- * properties. You can access these bindings once they have been initialized by providing a controller method called
- * `$onInit`, which is called after all the controllers on an element have been constructed and had their bindings
- * initialized.
- *
- * <div class="alert alert-warning">
- * **Deprecation warning:** although bindings for non-ES6 class controllers are currently
- * bound to `this` before the controller constructor is called, this use is now deprecated. Please place initialization
- * code that relies upon bindings inside a `$onInit` method on the controller, instead.
- * </div>
+ * allow a component to have its properties bound to the controller, rather than to scope. When the controller
+ * is instantiated, the initial values of the isolate scope bindings are already available.
  *
  * It is also possible to set `bindToController` to an object hash with the same format as the `scope` property.
  * This will set up the scope bindings to the controller directly. Note that `scope` can still be used
@@ -276,10 +239,10 @@
  * * `$element` - Current element
  * * `$attrs` - Current attributes object for the element
  * * `$transclude` - A transclude linking function pre-bound to the correct transclusion scope:
- *   `function([scope], cloneLinkingFn, futureParentElement, slotName)`:
- *    * `scope`: (optional) override the scope.
- *    * `cloneLinkingFn`: (optional) argument to create clones of the original transcluded content.
- *    * `futureParentElement` (optional):
+ *   `function([scope], cloneLinkingFn, futureParentElement)`.
+ *    * `scope`: optional argument to override the scope.
+ *    * `cloneLinkingFn`: optional argument to create clones of the original transcluded content.
+ *    * `futureParentElement`:
  *        * defines the parent to which the `cloneLinkingFn` will add the cloned elements.
  *        * default: `$element.parent()` resp. `$element` for `transclude:'element'` resp. `transclude:true`.
  *        * only needed for transcludes that are allowed to contain non html elements (e.g. SVG elements)
@@ -287,34 +250,14 @@
  *          as those elements need to created and cloned in a special way when they are defined outside their
  *          usual containers (e.g. like `<svg>`).
  *        * See also the `directive.templateNamespace` property.
- *    * `slotName`: (optional) the name of the slot to transclude. If falsy (e.g. `null`, `undefined` or `''`)
- *      then the default translusion is provided.
- *    The `$transclude` function also has a method on it, `$transclude.isSlotFilled(slotName)`, which returns
- *    `true` if the specified slot contains content (i.e. one or more DOM nodes).
  *
- * The controller can provide the following methods that act as life-cycle hooks:
- * * `$onInit` - Called on each controller after all the controllers on an element have been constructed and
- *   had their bindings initialized (and before the pre &amp; post linking functions for the directives on
- *   this element). This is a good place to put initialization code for your controller.
  *
  * #### `require`
  * Require another directive and inject its controller as the fourth argument to the linking function. The
- * `require` property can be a string, an array or an object:
- * * a **string** containing the name of the directive to pass to the linking function
- * * an **array** containing the names of directives to pass to the linking function. The argument passed to the
- * linking function will be an array of controllers in the same order as the names in the `require` property
- * * an **object** whose property values are the names of the directives to pass to the linking function. The argument
- * passed to the linking function will also be an object with matching keys, whose values will hold the corresponding
- * controllers.
- *
- * If the `require` property is an object and `bindToController` is truthy, then the required controllers are
- * bound to the controller using the keys of the `require` property. This binding occurs after all the controllers
- * have been constructed but before `$onInit` is called.
- * See the {@link $compileProvider#component} helper for an example of how this can be used.
- *
- * If no such required directive(s) can be found, or if the directive does not have a controller, then an error is
- * raised (unless no link function is specified and the required controllers are not being bound to the directive
- * controller, in which case error checking is skipped). The name can be prefixed with:
+ * `require` takes a string name (or array of strings) of the directive(s) to pass in. If an array is used, the
+ * injected argument will be an array in corresponding order. If no such directive can be
+ * found, or if the directive does not have a controller, then an error is raised (unless no link function
+ * is specified, in which case error checking is skipped). The name can be prefixed with:
  *
  * * (no prefix) - Locate the required controller on the current element. Throw an error if not found.
  * * `?` - Attempt to locate the required controller or pass `null` to the `link` fn if not found.
@@ -407,6 +350,14 @@
  * The contents are compiled and provided to the directive as a **transclusion function**. See the
  * {@link $compile#transclusion Transclusion} section below.
  *
+ * There are two kinds of transclusion depending upon whether you want to transclude just the contents of the
+ * directive's element or the entire element:
+ *
+ * * `true` - transclude the content (i.e. the child nodes) of the directive's element.
+ * * `'element'` - transclude the whole of the directive's element including any directives on this
+ *   element that defined at a lower priority than this directive. When used, the `template`
+ *   property is ignored.
+ *
  *
  * #### `compile`
  *
@@ -434,7 +385,7 @@
 
  * <div class="alert alert-warning">
  * **Note:** The compile function cannot handle directives that recursively use themselves in their
- * own templates or compile functions. Compiling these directives results in an infinite loop and
+ * own templates or compile functions. Compiling these directives results in an infinite loop and a
  * stack overflow errors.
  *
  * This can be avoided by manually using $compile in the postLink function to imperatively compile
@@ -536,34 +487,6 @@
  * Testing Transclusion Directives}.
  * </div>
  *
- * There are three kinds of transclusion depending upon whether you want to transclude just the contents of the
- * directive's element, the entire element or multiple parts of the element contents:
- *
- * * `true` - transclude the content (i.e. the child nodes) of the directive's element.
- * * `'element'` - transclude the whole of the directive's element including any directives on this
- *   element that defined at a lower priority than this directive. When used, the `template`
- *   property is ignored.
- * * **`{...}` (an object hash):** - map elements of the content onto transclusion "slots" in the template.
- *
- * **Mult-slot transclusion** is declared by providing an object for the `transclude` property.
- *
- * This object is a map where the keys are the name of the slot to fill and the value is an element selector
- * used to match the HTML to the slot. The element selector should be in normalized form (e.g. `myElement`)
- * and will match the standard element variants (e.g. `my-element`, `my:element`, `data-my-element`, etc).
- *
- * For further information check out the guide on {@link guide/directive#matching-directives Matching Directives}
- *
- * If the element selector is prefixed with a `?` then that slot is optional.
- *
- * For example, the transclude object `{ slotA: '?myCustomElement' }` maps `<my-custom-element>` elements to
- * the `slotA` slot, which can be accessed via the `$transclude` function or via the {@link ngTransclude} directive.
- *
- * Slots that are not marked as optional (`?`) will trigger a compile time error if there are no matching elements
- * in the transclude content. If you wish to know if an optional slot was filled with content, then you can call
- * `$transclude.isSlotFilled(slotName)` on the transclude function passed to the directive's link function and
- * injectable into the directive's controller.
- *
- *
  * #### Transclusion Functions
  *
  * When a directive requests transclusion, the compiler extracts its contents and provides a **transclusion
@@ -584,7 +507,7 @@
  * content and the `scope` is the newly created transclusion scope, to which the clone is bound.
  *
  * <div class="alert alert-info">
- * **Best Practice**: Always provide a `cloneFn` (clone attach function) when you call a transclude function
+ * **Best Practice**: Always provide a `cloneFn` (clone attach function) when you call a translude function
  * since you then get a fresh clone of the original DOM and also have access to the new transclusion scope.
  * </div>
  *
@@ -616,7 +539,7 @@
  * </div>
  *
  * The built-in DOM manipulation directives, such as {@link ngIf}, {@link ngSwitch} and {@link ngRepeat}
- * automatically destroy their transcluded clones as necessary so you do not need to worry about this if
+ * automatically destroy their transluded clones as necessary so you do not need to worry about this if
  * you are simply using {@link ngTransclude} to inject the transclusion into your directive.
  *
  *
@@ -661,9 +584,10 @@
  * The {@link ng.$compile.directive.Attributes Attributes} object - passed as a parameter in the
  * `link()` or `compile()` functions. It has a variety of uses.
  *
- * * *Accessing normalized attribute names:* Directives like 'ngBind' can be expressed in many ways:
- *   'ng:bind', `data-ng-bind`, or 'x-ng-bind'. The attributes object allows for normalized access
- *   to the attributes.
+ * accessing *Normalized attribute names:*
+ * Directives like 'ngBind' can be expressed in many ways: 'ng:bind', `data-ng-bind`, or 'x-ng-bind'.
+ * the attributes object allows for normalized access to
+ *   the attributes.
  *
  * * *Directive inter-communication:* All directives share the same instance of the attributes
  *   object which allows the directives to use the attributes object as inter directive
@@ -853,7 +777,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
   var EVENT_HANDLER_ATTR_REGEXP = /^(on[a-z]+|formaction)$/;
 
   function parseIsolateBindings(scope, directiveName, isController) {
-    var LOCAL_REGEXP = /^\s*([@&<]|=(\*?))(\??)\s*(\w*)\s*$/;
+    var LOCAL_REGEXP = /^\s*([@&]|=(\*?))(\??)\s*(\w*)\s*$/;
 
     var bindings = {};
 
@@ -940,8 +864,8 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
    * @param {string|Object} name Name of the directive in camel-case (i.e. <code>ngBind</code> which
    *    will match as <code>ng-bind</code>), or an object map of directives where the keys are the
    *    names and the values are the factories.
-   * @param {Function|Array} directiveFactory An injectable directive factory function. See the
-   *    {@link guide/directive directive guide} and the {@link $compile compile API} for more info.
+   * @param {Function|Array} directiveFactory An injectable directive factory function. See
+   *    {@link guide/directive} for more info.
    * @returns {ng.$compileProvider} Self for chaining.
    */
    this.directive = function registerDirective(name, directiveFactory) {
@@ -988,128 +912,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
     return this;
   };
 
-  /**
-   * @ngdoc method
-   * @name $compileProvider#component
-   * @module ng
-   * @param {string} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`)
-   * @param {Object} options Component definition object (a simplified
-   *    {@link ng.$compile#directive-definition-object directive definition object}),
-   *    with the following properties (all optional):
-   *
-   *    - `controller` – `{(string|function()=}` – controller constructor function that should be
-   *      associated with newly created scope or the name of a {@link ng.$compile#-controller-
-   *      registered controller} if passed as a string. An empty `noop` function by default.
-   *    - `controllerAs` – `{string=}` – identifier name for to reference the controller in the component's scope.
-   *      If present, the controller will be published to scope under the `controllerAs` name.
-   *      If not present, this will default to be `$ctrl`.
-   *    - `template` – `{string=|function()=}` – html template as a string or a function that
-   *      returns an html template as a string which should be used as the contents of this component.
-   *      Empty string by default.
-   *
-   *      If `template` is a function, then it is {@link auto.$injector#invoke injected} with
-   *      the following locals:
-   *
-   *      - `$element` - Current element
-   *      - `$attrs` - Current attributes object for the element
-   *
-   *    - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html
-   *      template that should be used  as the contents of this component.
-   *
-   *      If `templateUrl` is a function, then it is {@link auto.$injector#invoke injected} with
-   *      the following locals:
-   *
-   *      - `$element` - Current element
-   *      - `$attrs` - Current attributes object for the element
-   *
-   *    - `bindings` – `{object=}` – defines bindings between DOM attributes and component properties.
-   *      Component properties are always bound to the component controller and not to the scope.
-   *      See {@link ng.$compile#-bindtocontroller- `bindToController`}.
-   *    - `transclude` – `{boolean=}` – whether {@link $compile#transclusion content transclusion} is enabled.
-   *      Disabled by default.
-   *    - `$...` – `{function()=}` – additional annotations to provide to the directive factory function.
-   *
-   * @returns {ng.$compileProvider} the compile provider itself, for chaining of function calls.
-   * @description
-   * Register a **component definition** with the compiler. This is a shorthand for registering a special
-   * type of directive, which represents a self-contained UI component in your application. Such components
-   * are always isolated (i.e. `scope: {}`) and are always restricted to elements (i.e. `restrict: 'E'`).
-   *
-   * Component definitions are very simple and do not require as much configuration as defining general
-   * directives. Component definitions usually consist only of a template and a controller backing it.
-   *
-   * In order to make the definition easier, components enforce best practices like use of `controllerAs`,
-   * `bindToController`. They always have **isolate scope** and are restricted to elements.
-   *
-   * Here are a few examples of how you would usually define components:
-   *
-   * ```js
-   *   var myMod = angular.module(...);
-   *   myMod.component('myComp', {
-   *     template: '<div>My name is {{$ctrl.name}}</div>',
-   *     controller: function() {
-   *       this.name = 'shahar';
-   *     }
-   *   });
-   *
-   *   myMod.component('myComp', {
-   *     template: '<div>My name is {{$ctrl.name}}</div>',
-   *     bindings: {name: '@'}
-   *   });
-   *
-   *   myMod.component('myComp', {
-   *     templateUrl: 'views/my-comp.html',
-   *     controller: 'MyCtrl as ctrl',
-   *     bindings: {name: '@'}
-   *   });
-   *
-   * ```
-   * For more examples, and an in-depth guide, see the {@link guide/component component guide}.
-   *
-   * <br />
-   * See also {@link ng.$compileProvider#directive $compileProvider.directive()}.
-   */
-  this.component = function registerComponent(name, options) {
-    var controller = options.controller || function() {};
-
-    function factory($injector) {
-      function makeInjectable(fn) {
-        if (isFunction(fn) || isArray(fn)) {
-          return function(tElement, tAttrs) {
-            return $injector.invoke(fn, this, {$element: tElement, $attrs: tAttrs});
-          };
-        } else {
-          return fn;
-        }
-      }
-
-      var template = (!options.template && !options.templateUrl ? '' : options.template);
-      return {
-        controller: controller,
-        controllerAs: identifierForController(options.controller) || options.controllerAs || '$ctrl',
-        template: makeInjectable(template),
-        templateUrl: makeInjectable(options.templateUrl),
-        transclude: options.transclude,
-        scope: {},
-        bindToController: options.bindings || {},
-        restrict: 'E',
-        require: options.require
-      };
-    }
-
-    // Copy any annotation properties (starting with $) over to the factory function
-    // These could be used by libraries such as the new component router
-    forEach(options, function(val, key) {
-      if (key.charAt(0) === '$') {
-        factory[key] = val;
-      }
-    });
-
-    factory.$inject = ['$injector'];
-
-    return this.directive(name, factory);
-  };
-
 
   /**
    * @ngdoc method
@@ -1207,8 +1009,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
     function($injector,   $interpolate,   $exceptionHandler,   $templateRequest,   $parse,
              $controller,   $rootScope,   $sce,   $animate,   $$sanitizeUri) {
 
-    var SIMPLE_ATTR_NAME = /^\w/;
-    var specialAttrHolder = document.createElement('div');
     var Attributes = function(element, attributesToCopy) {
       if (attributesToCopy) {
         var keys = Object.keys(attributesToCopy);
@@ -1344,7 +1144,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
 
         nodeName = nodeName_(this.$$element);
 
-        if ((nodeName === 'a' && (key === 'href' || key === 'xlinkHref')) ||
+        if ((nodeName === 'a' && key === 'href') ||
             (nodeName === 'img' && key === 'src')) {
           // sanitize a[href] and img[src] values
           this[key] = value = $$sanitizeUri(value, key === 'src');
@@ -1388,11 +1188,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
           if (value === null || isUndefined(value)) {
             this.$$element.removeAttr(attrName);
           } else {
-            if (SIMPLE_ATTR_NAME.test(attrName)) {
-              this.$$element.attr(attrName, value);
-            } else {
-              setSpecialAttr(this.$$element[0], attrName, value);
-            }
+            this.$$element.attr(attrName, value);
           }
         }
 
@@ -1446,18 +1242,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
       }
     };
 
-    function setSpecialAttr(element, attrName, value) {
-      // Attributes names that do not start with letters (such as `(click)`) cannot be set using `setAttribute`
-      // so we have to jump through some hoops to get such an attribute
-      // https://github.com/angular/angular.js/pull/13318
-      specialAttrHolder.innerHTML = "<span " + attrName + ">";
-      var attributes = specialAttrHolder.firstChild.attributes;
-      var attribute = attributes[0];
-      // We have to remove the attribute from its container element before we can add it to the destination element
-      attributes.removeNamedItem(attribute.name);
-      attribute.value = value;
-      element.attributes.setNamedItem(attribute);
-    }
 
     function safeAddClass($element, className) {
       try {
@@ -1471,7 +1255,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
 
     var startSymbol = $interpolate.startSymbol(),
         endSymbol = $interpolate.endSymbol(),
-        denormalizeTemplate = (startSymbol == '{{' && endSymbol  == '}}')
+        denormalizeTemplate = (startSymbol == '{{' || endSymbol  == '}}')
             ? identity
             : function denormalizeTemplate(template) {
               return template.replace(/\{\{/g, startSymbol).replace(/}}/g, endSymbol);
@@ -1515,19 +1299,13 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
         // modify it.
         $compileNodes = jqLite($compileNodes);
       }
-
-      var NOT_EMPTY = /\S+/;
-
       // We can not compile top level text elements since text nodes can be merged and we will
       // not be able to attach scope data to them, so we will wrap them in <span>
-      for (var i = 0, len = $compileNodes.length; i < len; i++) {
-        var domNode = $compileNodes[i];
-
-        if (domNode.nodeType === NODE_TYPE_TEXT && domNode.nodeValue.match(NOT_EMPTY) /* non-empty */) {
-          jqLiteWrapNode(domNode, $compileNodes[i] = document.createElement('span'));
+      forEach($compileNodes, function(node, index) {
+        if (node.nodeType == NODE_TYPE_TEXT && node.nodeValue.match(/\S+/) /* non-empty */ ) {
+          $compileNodes[index] = jqLite(node).wrap('<span></span>').parent()[0];
         }
-      }
-
+      });
       var compositeLinkFn =
               compileNodes($compileNodes, transcludeFn, $compileNodes,
                            maxPriority, ignoreDirective, previousCompileContext);
@@ -1598,7 +1376,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
       if (!node) {
         return 'html';
       } else {
-        return nodeName_(node) !== 'foreignobject' && toString.call(node).match(/SVG/) ? 'svg' : 'html';
+        return nodeName_(node) !== 'foreignobject' && node.toString().match(/SVG/) ? 'svg' : 'html';
       }
     }
 
@@ -1732,17 +1510,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
         });
       };
 
-      // We need  to attach the transclusion slots onto the `boundTranscludeFn`
-      // so that they are available inside the `controllersBoundTransclude` function
-      var boundSlots = boundTranscludeFn.$$slots = createMap();
-      for (var slotName in transcludeFn.$$slots) {
-        if (transcludeFn.$$slots[slotName]) {
-          boundSlots[slotName] = createBoundTranscludeFn(scope, transcludeFn.$$slots[slotName], previousBoundTranscludeFn);
-        } else {
-          boundSlots[slotName] = null;
-        }
-      }
-
       return boundTranscludeFn;
     }
 
@@ -1901,37 +1668,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
       };
     }
 
-    /**
-     * A function generator that is used to support both eager and lazy compilation
-     * linking function.
-     * @param eager
-     * @param $compileNodes
-     * @param transcludeFn
-     * @param maxPriority
-     * @param ignoreDirective
-     * @param previousCompileContext
-     * @returns {Function}
-     */
-    function compilationGenerator(eager, $compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext) {
-        if (eager) {
-            return compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext);
-        }
-
-        var compiled;
-
-        return function() {
-            if (!compiled) {
-                compiled = compile($compileNodes, transcludeFn, maxPriority, ignoreDirective, previousCompileContext);
-
-                // Null out all of these references in order to make them eligible for garbage collection
-                // since this is a potentially long lived closure
-                $compileNodes = transcludeFn = previousCompileContext = null;
-            }
-
-            return compiled.apply(this, arguments);
-        };
-    }
-
     /**
      * Once the directives have been collected, their compile functions are executed. This method
      * is responsible for inlining directive templates as well as terminating the application
@@ -1976,8 +1712,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
           replaceDirective = originalReplaceDirective,
           childTranscludeFn = transcludeFn,
           linkFn,
-          didScanForMultipleTransclusion = false,
-          mightHaveMultipleTransclusionError = false,
           directiveValue;
 
       // executes all directives on the current element
@@ -2020,27 +1754,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
 
         directiveName = directive.name;
 
-        // If we encounter a condition that can result in transclusion on the directive,
-        // then scan ahead in the remaining directives for others that may cause a multiple
-        // transclusion error to be thrown during the compilation process.  If a matching directive
-        // is found, then we know that when we encounter a transcluded directive, we need to eagerly
-        // compile the `transclude` function rather than doing it lazily in order to throw
-        // exceptions at the correct time
-        if (!didScanForMultipleTransclusion && ((directive.replace && (directive.templateUrl || directive.template))
-            || (directive.transclude && !directive.$$tlb))) {
-                var candidateDirective;
-
-                for (var scanningIndex = i + 1; candidateDirective = directives[scanningIndex++];) {
-                    if ((candidateDirective.transclude && !candidateDirective.$$tlb)
-                        || (candidateDirective.replace && (candidateDirective.templateUrl || candidateDirective.template))) {
-                        mightHaveMultipleTransclusionError = true;
-                        break;
-                    }
-                }
-
-                didScanForMultipleTransclusion = true;
-        }
-
         if (!directive.templateUrl && directive.controller) {
           directiveValue = directive.controller;
           controllerDirectives = controllerDirectives || createMap();
@@ -2070,7 +1783,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
             compileNode = $compileNode[0];
             replaceWith(jqCollection, sliceArgs($template), compileNode);
 
-            childTranscludeFn = compilationGenerator(mightHaveMultipleTransclusionError, $template, transcludeFn, terminalPriority,
+            childTranscludeFn = compile($template, transcludeFn, terminalPriority,
                                         replaceDirective && replaceDirective.name, {
                                           // Don't pass in:
                                           // - controllerDirectives - otherwise we'll create duplicates controllers
@@ -2082,69 +1795,10 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
                                           nonTlbTranscludeDirective: nonTlbTranscludeDirective
                                         });
           } else {
-
-            var slots = createMap();
-
             $template = jqLite(jqLiteClone(compileNode)).contents();
-
-            if (isObject(directiveValue)) {
-
-              // We have transclusion slots,
-              // collect them up, compile them and store their transclusion functions
-              $template = [];
-
-              var slotMap = createMap();
-              var filledSlots = createMap();
-
-              // Parse the element selectors
-              forEach(directiveValue, function(elementSelector, slotName) {
-                // If an element selector starts with a ? then it is optional
-                var optional = (elementSelector.charAt(0) === '?');
-                elementSelector = optional ? elementSelector.substring(1) : elementSelector;
-
-                slotMap[elementSelector] = slotName;
-
-                // We explicitly assign `null` since this implies that a slot was defined but not filled.
-                // Later when calling boundTransclusion functions with a slot name we only error if the
-                // slot is `undefined`
-                slots[slotName] = null;
-
-                // filledSlots contains `true` for all slots that are either optional or have been
-                // filled. This is used to check that we have not missed any required slots
-                filledSlots[slotName] = optional;
-              });
-
-              // Add the matching elements into their slot
-              forEach($compileNode.contents(), function(node) {
-                var slotName = slotMap[directiveNormalize(nodeName_(node))];
-                if (slotName) {
-                  filledSlots[slotName] = true;
-                  slots[slotName] = slots[slotName] || [];
-                  slots[slotName].push(node);
-                } else {
-                  $template.push(node);
-                }
-              });
-
-              // Check for required slots that were not filled
-              forEach(filledSlots, function(filled, slotName) {
-                if (!filled) {
-                  throw $compileMinErr('reqslot', 'Required transclusion slot `{0}` was not filled.', slotName);
-                }
-              });
-
-              for (var slotName in slots) {
-                if (slots[slotName]) {
-                  // Only define a transclusion function if the slot was filled
-                  slots[slotName] = compilationGenerator(mightHaveMultipleTransclusionError, slots[slotName], transcludeFn);
-                }
-              }
-            }
-
             $compileNode.empty(); // clear contents
-            childTranscludeFn = compilationGenerator(mightHaveMultipleTransclusionError, $template, transcludeFn, undefined,
+            childTranscludeFn = compile($template, transcludeFn, undefined,
                 undefined, { needsNewScope: directive.$$isolateScope || directive.$$newScope});
-            childTranscludeFn.$$slots = slots;
           }
         }
 
@@ -2307,11 +1961,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
           for (var i = 0, ii = require.length; i < ii; i++) {
             value[i] = getControllers(directiveName, require[i], $element, elementControllers);
           }
-        } else if (isObject(require)) {
-          value = {};
-          forEach(require, function(controller, property) {
-            value[property] = getControllers(directiveName, controller, $element, elementControllers);
-          });
         }
 
         return value || null;
@@ -2349,7 +1998,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
       }
 
       function nodeLinkFn(childLinkFn, scope, linkNode, $rootElement, boundTranscludeFn) {
-        var i, ii, linkFn, isolateScope, controllerScope, elementControllers, transcludeFn, $element,
+        var linkFn, isolateScope, controllerScope, elementControllers, transcludeFn, $element,
             attrs, removeScopeBindingWatches, removeControllerBindingWatches;
 
         if (compileNode === linkNode) {
@@ -2372,10 +2021,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
           // is later passed as `parentBoundTranscludeFn` to `publicLinkFn`
           transcludeFn = controllersBoundTransclude;
           transcludeFn.$$boundTransclude = boundTranscludeFn;
-          // expose the slots on the `$transclude` function
-          transcludeFn.isSlotFilled = function(slotName) {
-            return !!boundTranscludeFn.$$slots[slotName];
-          };
         }
 
         if (controllerDirectives) {
@@ -2420,21 +2065,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
           }
         }
 
-        // Bind the required controllers to the controller, if `require` is an object and `bindToController` is truthy
-        forEach(controllerDirectives, function(controllerDirective, name) {
-          var require = controllerDirective.require;
-          if (controllerDirective.bindToController && !isArray(require) && isObject(require)) {
-            extend(elementControllers[name].instance, getControllers(name, require, $element, elementControllers));
-          }
-        });
-
-        // Trigger the `$onInit` method on all controllers that have one
-        forEach(elementControllers, function(controller) {
-          if (isFunction(controller.instance.$onInit)) {
-            controller.instance.$onInit();
-          }
-        });
-
         // PRELINKING
         for (i = 0, ii = preLinkFns.length; i < ii; i++) {
           linkFn = preLinkFns[i];
@@ -2470,11 +2100,11 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
 
         // This is the function that is injected as `$transclude`.
         // Note: all arguments are optional!
-        function controllersBoundTransclude(scope, cloneAttachFn, futureParentElement, slotName) {
+        function controllersBoundTransclude(scope, cloneAttachFn, futureParentElement) {
           var transcludeControllers;
+
           // No scope passed in:
           if (!isScope(scope)) {
-            slotName = futureParentElement;
             futureParentElement = cloneAttachFn;
             cloneAttachFn = scope;
             scope = undefined;
@@ -2486,23 +2116,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
           if (!futureParentElement) {
             futureParentElement = hasElementTranscludeDirective ? $element.parent() : $element;
           }
-          if (slotName) {
-            // slotTranscludeFn can be one of three things:
-            //  * a transclude function - a filled slot
-            //  * `null` - an optional slot that was not filled
-            //  * `undefined` - a slot that was not declared (i.e. invalid)
-            var slotTranscludeFn = boundTranscludeFn.$$slots[slotName];
-            if (slotTranscludeFn) {
-              return slotTranscludeFn(scope, cloneAttachFn, transcludeControllers, futureParentElement, scopeToChild);
-            } else if (isUndefined(slotTranscludeFn)) {
-              throw $compileMinErr('noslot',
-               'No parent directive that requires a transclusion with slot name "{0}". ' +
-               'Element: {1}',
-               slotName, startingTag($element));
-            }
-          } else {
-            return boundTranscludeFn(scope, cloneAttachFn, transcludeControllers, futureParentElement, scopeToChild);
-          }
+          return boundTranscludeFn(scope, cloneAttachFn, transcludeControllers, futureParentElement, scopeToChild);
         }
       }
     }
@@ -2934,14 +2548,9 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
         parent.replaceChild(newNode, firstElementToRemove);
       }
 
-      // Append all the `elementsToRemove` to a fragment. This will...
-      // - remove them from the DOM
-      // - allow them to still be traversed with .nextSibling
-      // - allow a single fragment.qSA to fetch all elements being removed
+      // TODO(perf): what's this document fragment for? is it needed? can we at least reuse it?
       var fragment = document.createDocumentFragment();
-      for (i = 0; i < removeCount; i++) {
-        fragment.appendChild(elementsToRemove[i]);
-      }
+      fragment.appendChild(firstElementToRemove);
 
       if (jqLite.hasData(firstElementToRemove)) {
         // Copy over user data (that includes Angular's $scope etc.). Don't copy private
@@ -2949,18 +2558,31 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
         // event listeners (which is the main use of private data) wouldn't work anyway.
         jqLite.data(newNode, jqLite.data(firstElementToRemove));
 
-        // Remove $destroy event listeners from `firstElementToRemove`
-        jqLite(firstElementToRemove).off('$destroy');
+        // 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]);
+        }
       }
 
-      // Cleanup any data/listeners on the elements and children.
-      // This includes invoking the $destroy event on any elements with listeners.
-      jqLite.cleanData(fragment.querySelectorAll('*'));
-
-      // Update the jqLite collection to only contain the `newNode`
-      for (i = 1; i < removeCount; i++) {
-        delete elementsToRemove[i];
+      for (var k = 1, kk = elementsToRemove.length; k < kk; k++) {
+        var element = elementsToRemove[k];
+        jqLite(element).remove(); // must do this way to clean up expando
+        fragment.appendChild(element);
+        delete elementsToRemove[k];
       }
+
       elementsToRemove[0] = newNode;
       elementsToRemove.length = 1;
     }
@@ -2989,7 +2611,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
         optional = definition.optional,
         mode = definition.mode, // @, =, or &
         lastValue,
-        parentGet, parentSet, compare, removeWatch;
+        parentGet, parentSet, compare;
 
         switch (mode) {
 
@@ -3003,15 +2625,10 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
               }
             });
             attrs.$$observers[attrName].$$scope = scope;
-            lastValue = attrs[attrName];
-            if (isString(lastValue)) {
+            if (isString(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(lastValue)(scope);
-            } else if (isBoolean(lastValue)) {
-              // If the attributes is one of the BOOLEAN_ATTR then Angular will have converted
-              // the value to boolean rather than a string, so we special case this situation
-              destination[scopeName] = lastValue;
+              destination[scopeName] = $interpolate(attrs[attrName])(scope);
             }
             break;
 
@@ -3032,8 +2649,8 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
               // reset the change, or we will throw this exception on every $digest
               lastValue = destination[scopeName] = parentGet(scope);
               throw $compileMinErr('nonassign',
-                  "Expression '{0}' in attribute '{1}' used with directive '{2}' is non-assignable!",
-                  attrs[attrName], attrName, directive.name);
+                  "Expression '{0}' used with directive '{1}' is non-assignable!",
+                  attrs[attrName], directive.name);
             };
             lastValue = destination[scopeName] = parentGet(scope);
             var parentValueWatch = function parentValueWatch(parentValue) {
@@ -3050,6 +2667,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
               return lastValue = parentValue;
             };
             parentValueWatch.$stateful = true;
+            var removeWatch;
             if (definition.collection) {
               removeWatch = scope.$watchCollection(attrs[attrName], parentValueWatch);
             } else {
@@ -3058,24 +2676,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
             removeWatchCollection.push(removeWatch);
             break;
 
-          case '<':
-            if (!hasOwnProperty.call(attrs, attrName)) {
-              if (optional) break;
-              attrs[attrName] = void 0;
-            }
-            if (optional && !attrs[attrName]) break;
-
-            parentGet = $parse(attrs[attrName]);
-
-            destination[scopeName] = parentGet(scope);
-
-            removeWatch = scope.$watch(parentGet, function parentValueWatchAction(newParentValue) {
-              destination[scopeName] = newParentValue;
-            }, parentGet.literal);
-
-            removeWatchCollection.push(removeWatch);
-            break;
-
           case '&':
             // Don't assign Object.prototype method to scope
             parentGet = attrs.hasOwnProperty(attrName) ? $parse(attrs[attrName]) : noop;

src/ng/directive/form.js

@@ -127,7 +127,7 @@ function FormController(element, attrs, $scope, $animate, $interpolate) {
    *
    * However, if the method is used programmatically, for example by adding dynamically created controls,
    * or controls that have been previously removed without destroying their corresponding DOM element,
-   * it's the developers responsibility to make sure the current state propagates to the parent form.
+   * it's the developers responsiblity to make sure the current state propagates to the parent form.
    *
    * For example, if an input control is added that is already `$dirty` and has `$error` properties,
    * calling `$setDirty()` and `$validate()` afterwards will propagate the state to the parent form.

src/ng/directive/input.js

@@ -56,8 +56,8 @@ var inputType = {
    * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
    *    that contains the regular expression body that will be converted to a regular expression
    *    as in the ngPattern directive.
-   * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
-   *    does not match a RegExp found by evaluating the Angular expression given in the attribute value.
+   * @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
@@ -344,7 +344,7 @@ var inputType = {
    *
    * @description
    * Input with time validation and transformation. In browsers that do not yet support
-   * the HTML5 time input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
+   * the HTML5 date input, a text element will be used. In that case, the text must be entered in a valid ISO-8601
    * local time format (HH:mm:ss), for example: `14:57:00`. Model must be a Date object. This binding will always output a
    * Date object to the model of January 1, 1970, or local date `new Date(1970, 0, 1, HH, mm, ss)`.
    *
@@ -691,8 +691,8 @@ var inputType = {
    * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
    *    that contains the regular expression body that will be converted to a regular expression
    *    as in the ngPattern directive.
-   * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
-   *    does not match a RegExp found by evaluating the Angular expression given in the attribute value.
+   * @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
@@ -789,8 +789,8 @@ var inputType = {
    * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
    *    that contains the regular expression body that will be converted to a regular expression
    *    as in the ngPattern directive.
-   * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
-   *    does not match a RegExp found by evaluating the Angular expression given in the attribute value.
+   * @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
@@ -888,8 +888,8 @@ var inputType = {
    * @param {string=} pattern Similar to `ngPattern` except that the attribute value is the actual string
    *    that contains the regular expression body that will be converted to a regular expression
    *    as in the ngPattern directive.
-   * @param {string=} ngPattern Sets `pattern` validation error key if the ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
-   *    does not match a RegExp found by evaluating the Angular expression given in the attribute value.
+   * @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
@@ -1349,7 +1349,11 @@ function badInputChecker(scope, element, attr, ctrl) {
   if (nativeValidation) {
     ctrl.$parsers.push(function(value) {
       var validity = element.prop(VALIDITY_STATE_PROPERTY) || {};
-      return validity.badInput || validity.typeMismatch ? undefined : value;
+      // Detect bug in FF35 for input[email] (https://bugzilla.mozilla.org/show_bug.cgi?id=1064430):
+      // - also sets validity.badInput (should only be validity.typeMismatch).
+      // - see http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#e-mail-state-(type=email)
+      // - can ignore this case as we can still read out the erroneous email...
+      return validity.badInput && !validity.typeMismatch ? undefined : value;
     });
   }
 }
@@ -1521,8 +1525,8 @@ 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 ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
- *    does not match a RegExp found by evaluating the Angular expression given in the attribute value.
+ * @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
@@ -1560,8 +1564,8 @@ 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 ngModel {@link ngModel.NgModelController#$viewValue $viewValue}
- *    value does not match a RegExp found by evaluating the Angular expression given in the attribute value.
+ * @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

src/ng/directive/ngCsp.js

@@ -47,7 +47,7 @@
  *
  * * no-inline-style: this stops Angular from injecting CSS styles into the DOM
  *
- * * no-unsafe-eval: this stops Angular from optimizing $parse with unsafe eval of strings
+ * * no-unsafe-eval: this stops Angular from optimising $parse with unsafe eval of strings
  *
  * You can use these values in the following combinations:
  *
@@ -64,7 +64,7 @@
  * inline styles. E.g. `<body ng-csp="no-unsafe-eval">`.
  *
  * * Specifying only `no-inline-style` tells Angular that we must not inject styles, but that we can
- * run eval - no automatic check for unsafe eval will occur. E.g. `<body ng-csp="no-inline-style">`
+ * run eval - no automcatic check for unsafe eval will occur. E.g. `<body ng-csp="no-inline-style">`
  *
  * * Specifying both `no-unsafe-eval` and `no-inline-style` tells Angular that we must not inject
  * styles nor use eval, which is the same as an empty: ng-csp.

src/ng/directive/ngInclude.js

@@ -285,7 +285,7 @@ var ngIncludeFillContentDirective = ['$compile',
       priority: -400,
       require: 'ngInclude',
       link: function(scope, $element, $attr, ctrl) {
-        if (toString.call($element[0]).match(/SVG/)) {
+        if (/SVG/.test($element[0].toString())) {
           // WebKit: https://bugs.webkit.org/show_bug.cgi?id=135698 --- SVG elements do not
           // support innerHTML, so detect this here and try to generate the contents
           // specially.

src/ng/directive/ngModel.js

@@ -14,9 +14,7 @@ var VALID_CLASS = 'ng-valid',
     DIRTY_CLASS = 'ng-dirty',
     UNTOUCHED_CLASS = 'ng-untouched',
     TOUCHED_CLASS = 'ng-touched',
-    PENDING_CLASS = 'ng-pending',
-    EMPTY_CLASS = 'ng-empty',
-    NOT_EMPTY_CLASS = 'ng-not-empty';
+    PENDING_CLASS = 'ng-pending';
 
 var ngModelMinErr = minErr('ngModel');
 
@@ -320,17 +318,6 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
     return isUndefined(value) || value === '' || value === null || value !== value;
   };
 
-  this.$$updateEmptyClasses = function(value) {
-    if (ctrl.$isEmpty(value)) {
-      $animate.removeClass($element, NOT_EMPTY_CLASS);
-      $animate.addClass($element, EMPTY_CLASS);
-    } else {
-      $animate.removeClass($element, EMPTY_CLASS);
-      $animate.addClass($element, NOT_EMPTY_CLASS);
-    }
-  };
-
-
   var currentValidationRunId = 0;
 
   /**
@@ -694,7 +681,6 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
     if (ctrl.$$lastCommittedViewValue === viewValue && (viewValue !== '' || !ctrl.$$hasNativeValidators)) {
       return;
     }
-    ctrl.$$updateEmptyClasses(viewValue);
     ctrl.$$lastCommittedViewValue = viewValue;
 
     // change to dirty
@@ -793,7 +779,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
    * However, custom controls might also pass objects to this method. In this case, we should make
    * a copy of the object before passing it to `$setViewValue`. This is because `ngModel` does not
    * perform a deep watch of objects, it only looks for a change of identity. If you only change
-   * the property of the object then ngModel will not realize that the object has changed and
+   * the property of the object then ngModel will not realise that the object has changed and
    * will not invoke the `$parsers` and `$validators` pipelines. For this reason, you should
    * not change properties of the copy once it has been passed to `$setViewValue`.
    * Otherwise you may cause the model value on the scope to change incorrectly.
@@ -877,7 +863,6 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
         viewValue = formatters[idx](viewValue);
       }
       if (ctrl.$viewValue !== viewValue) {
-        ctrl.$$updateEmptyClasses(viewValue);
         ctrl.$viewValue = ctrl.$$lastCommittedViewValue = viewValue;
         ctrl.$render();
 
@@ -908,8 +893,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
  *   require.
  * - Providing validation behavior (i.e. required, number, email, url).
  * - Keeping the state of the control (valid/invalid, dirty/pristine, touched/untouched, validation errors).
- * - Setting related css classes on the element (`ng-valid`, `ng-invalid`, `ng-dirty`, `ng-pristine`, `ng-touched`,
- *   `ng-untouched`, `ng-empty`, `ng-not-empty`) including animations.
+ * - Setting related css classes on the element (`ng-valid`, `ng-invalid`, `ng-dirty`, `ng-pristine`, `ng-touched`, `ng-untouched`) including animations.
  * - Registering the control with its parent {@link ng.directive:form form}.
  *
  * Note: `ngModel` will try to bind to the property given by evaluating the expression on the
@@ -937,22 +921,6 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
  *  - {@link ng.directive:select select}
  *  - {@link ng.directive:textarea textarea}
  *
- * # Complex Models (objects or collections)
- *
- * By default, `ngModel` watches the model by reference, not value. This is important to know when
- * binding inputs to models that are objects (e.g. `Date`) or collections (e.g. arrays). If only properties of the
- * object or collection change, `ngModel` will not be notified and so the input will not be  re-rendered.
- *
- * The model must be assigned an entirely new object or collection before a re-rendering will occur.
- *
- * Some directives have options that will cause them to use a custom `$watchCollection` on the model expression
- * - for example, `ngOptions` will do so when a `track by` clause is included in the comprehension expression or
- * if the select is given the `multiple` attribute.
- *
- * The `$watchCollection()` method only does a shallow comparison, meaning that changing properties deeper than the
- * first level of the object (or only changing the properties of an item in the collection if it's an array) will still
- * not trigger a re-rendering of the model.
- *
  * # CSS classes
  * The following CSS classes are added and removed on the associated input/select/textarea element
  * depending on the validity of the model.
@@ -966,16 +934,13 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
  *  - `ng-touched`: the control has been blurred
  *  - `ng-untouched`: the control hasn't been blurred
  *  - `ng-pending`: any `$asyncValidators` are unfulfilled
- *  - `ng-empty`: the view does not contain a value or the value is deemed "empty", as defined
- *     by the {@link ngModel.NgModelController#$isEmpty} method
- *  - `ng-not-empty`: the view contains a non-empty value
  *
  * Keep in mind that ngAnimate can detect each of these classes when added and removed.
  *
  * ## Animation Hooks
  *
  * Animations within models are triggered when any of the associated CSS classes are added and removed
- * on the input element which is attached to the model. These classes include: `.ng-pristine`, `.ng-dirty`,
+ * on the input element which is attached to the model. These classes are: `.ng-pristine`, `.ng-dirty`,
  * `.ng-invalid` and `.ng-valid` as well as any other validations that are performed on the model itself.
  * The animations that are triggered within ngModel are similar to how they work in ngClass and
  * animations can be hooked into using CSS transitions, keyframes as well as JS animations.

src/ng/directive/ngOptions.js

@@ -409,10 +409,14 @@ var ngOptionsDirective = ['$compile', '$parse', function($compile, $parse) {
   var optionTemplate = document.createElement('option'),
       optGroupTemplate = document.createElement('optgroup');
 
+
     function ngOptionsPostLink(scope, selectElement, attr, ctrls) {
 
-      var selectCtrl = ctrls[0];
+      // if ngModel is not defined, we don't need to do anything
       var ngModelCtrl = ctrls[1];
+      if (!ngModelCtrl) return;
+
+      var selectCtrl = ctrls[0];
       var multiple = attr.multiple;
 
       // The emptyOption allows the application developer to provide their own custom "empty"
@@ -672,7 +676,7 @@ var ngOptionsDirective = ['$compile', '$parse', function($compile, $parse) {
           var groupElement;
           var optionElement;
 
-          if (isDefined(option.group)) {
+          if (option.group) {
 
             // This option is to live in a group
             // See if we have already created this group
@@ -746,7 +750,7 @@ var ngOptionsDirective = ['$compile', '$parse', function($compile, $parse) {
   return {
     restrict: 'A',
     terminal: true,
-    require: ['select', 'ngModel'],
+    require: ['select', '?ngModel'],
     link: {
       pre: function ngOptionsPreLink(scope, selectElement, attr, ctrls) {
         // Deactivate the SelectController.register method to prevent

src/ng/directive/ngPluralize.js

@@ -215,7 +215,7 @@ var ngPluralizeDirective = ['$locale', '$interpolate', '$log', function($locale,
         }
 
         // If both `count` and `lastCount` are NaN, we don't need to re-register a watch.
-        // In JS `NaN !== NaN`, so we have to explicitly check.
+        // In JS `NaN !== NaN`, so we have to exlicitly check.
         if ((count !== lastCount) && !(countIsNaN && isNumber(lastCount) && isNaN(lastCount))) {
           watchRemover();
           var whenExpFn = whensExpFns[count];

src/ng/directive/ngRepeat.js

@@ -93,7 +93,7 @@
  * by the identifier instead of the whole object. Should you reload your data later, `ngRepeat`
  * will not have to rebuild the DOM elements for items it has already rendered, even if the
  * JavaScript objects in the collection have been substituted for new ones. For large collections,
- * this significantly improves rendering performance. If you don't have a unique identifier,
+ * this signifincantly improves rendering performance. If you don't have a unique identifier,
  * `track by $index` can also provide a performance boost.
  * </div>
  * ```html
@@ -170,8 +170,6 @@
  *
  * **.move** - when an adjacent item is filtered out causing a reorder or when the item contents are reordered
  *
- * See the example below for defining CSS animations with ngRepeat.
- *
  * @element ANY
  * @scope
  * @priority 1000
@@ -224,11 +222,22 @@
  *     For example: `item in items | filter : x | orderBy : order | limitTo : limit as results` .
  *
  * @example
- * This example uses `ngRepeat` to display a list of people. A filter is used to restrict the displayed
- * results by name. New (entering) and removed (leaving) items are animated.
-  <example module="ngRepeat" name="ngRepeat" deps="angular-animate.js" animations="true">
+ * This example initializes the scope to a list of names and
+ * then uses `ngRepeat` to display every person:
+  <example module="ngAnimate" deps="angular-animate.js" animations="true">
     <file name="index.html">
-      <div ng-controller="repeatController">
+      <div ng-init="friends = [
+        {name:'John', age:25, gender:'boy'},
+        {name:'Jessie', age:30, gender:'girl'},
+        {name:'Johanna', age:28, gender:'girl'},
+        {name:'Joy', age:15, gender:'girl'},
+        {name:'Mary', age:28, gender:'girl'},
+        {name:'Peter', age:95, gender:'boy'},
+        {name:'Sebastian', age:50, gender:'boy'},
+        {name:'Erika', age:27, gender:'girl'},
+        {name:'Patrick', age:40, gender:'boy'},
+        {name:'Samantha', age:60, gender:'girl'}
+      ]">
         I have {{friends.length}} friends. They are:
         <input type="search" ng-model="q" placeholder="filter friends..." aria-label="filter friends" />
         <ul class="example-animate-container">
@@ -241,22 +250,6 @@
         </ul>
       </div>
     </file>
-    <file name="script.js">
-      angular.module('ngRepeat', ['ngAnimate']).controller('repeatController', function($scope) {
-        $scope.friends = [
-          {name:'John', age:25, gender:'boy'},
-          {name:'Jessie', age:30, gender:'girl'},
-          {name:'Johanna', age:28, gender:'girl'},
-          {name:'Joy', age:15, gender:'girl'},
-          {name:'Mary', age:28, gender:'girl'},
-          {name:'Peter', age:95, gender:'boy'},
-          {name:'Sebastian', age:50, gender:'boy'},
-          {name:'Erika', age:27, gender:'girl'},
-          {name:'Patrick', age:40, gender:'boy'},
-          {name:'Samantha', age:60, gender:'girl'}
-        ];
-      });
-    </file>
     <file name="animations.css">
       .example-animate-container {
         background:white;
@@ -267,7 +260,7 @@
       }
 
       .animate-repeat {
-        line-height:30px;
+        line-height:40px;
         list-style:none;
         box-sizing:border-box;
       }
@@ -289,7 +282,7 @@
       .animate-repeat.ng-move.ng-move-active,
       .animate-repeat.ng-enter.ng-enter-active {
         opacity:1;
-        max-height:30px;
+        max-height:40px;
       }
     </file>
     <file name="protractor.js" type="protractor">

src/ng/directive/ngTransclude.js

@@ -8,186 +8,66 @@
  * @description
  * Directive that marks the insertion point for the transcluded DOM of the nearest parent directive that uses transclusion.
  *
- * You can specify that you want to insert a named transclusion slot, instead of the default slot, by providing the slot name
- * as the value of the `ng-transclude` or `ng-transclude-slot` attribute.
- *
- * If the transcluded content is not empty (i.e. contains one or more DOM nodes, including whitespace text nodes), any existing
- * content of this element will be removed before the transcluded content is inserted.
- * If the transcluded content is empty, the existing content is left intact. This lets you provide fallback content in the case
- * that no transcluded content is provided.
+ * Any existing content of the element that this directive is placed on will be removed before the transcluded content is inserted.
  *
  * @element ANY
  *
- * @param {string} ngTransclude|ngTranscludeSlot the name of the slot to insert at this point. If this is not provided, is empty
- *                                               or its value is the same as the name of the attribute then the default slot is used.
- *
  * @example
- * ### Basic transclusion
- * This example demonstrates basic transclusion of content into a component directive.
- * <example name="simpleTranscludeExample" module="transcludeExample">
- *   <file name="index.html">
- *     <script>
- *       angular.module('transcludeExample', [])
- *        .directive('pane', function(){
- *           return {
- *             restrict: 'E',
- *             transclude: true,
- *             scope: { title:'@' },
- *             template: '<div style="border: 1px solid black;">' +
- *                         '<div style="background-color: gray">{{title}}</div>' +
- *                         '<ng-transclude></ng-transclude>' +
- *                       '</div>'
- *           };
- *       })
- *       .controller('ExampleController', ['$scope', function($scope) {
- *         $scope.title = 'Lorem Ipsum';
- *         $scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...';
- *       }]);
- *     </script>
- *     <div ng-controller="ExampleController">
- *       <input ng-model="title" aria-label="title"> <br/>
- *       <textarea ng-model="text" aria-label="text"></textarea> <br/>
- *       <pane title="{{title}}">{{text}}</pane>
- *     </div>
- *   </file>
- *   <file name="protractor.js" type="protractor">
- *      it('should have transcluded', function() {
- *        var titleElement = element(by.model('title'));
- *        titleElement.clear();
- *        titleElement.sendKeys('TITLE');
- *        var textElement = element(by.model('text'));
- *        textElement.clear();
- *        textElement.sendKeys('TEXT');
- *        expect(element(by.binding('title')).getText()).toEqual('TITLE');
- *        expect(element(by.binding('text')).getText()).toEqual('TEXT');
- *      });
- *   </file>
- * </example>
+   <example module="transcludeExample">
+     <file name="index.html">
+       <script>
+         angular.module('transcludeExample', [])
+          .directive('pane', function(){
+             return {
+               restrict: 'E',
+               transclude: true,
+               scope: { title:'@' },
+               template: '<div style="border: 1px solid black;">' +
+                           '<div style="background-color: gray">{{title}}</div>' +
+                           '<ng-transclude></ng-transclude>' +
+                         '</div>'
+             };
+         })
+         .controller('ExampleController', ['$scope', function($scope) {
+           $scope.title = 'Lorem Ipsum';
+           $scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...';
+         }]);
+       </script>
+       <div ng-controller="ExampleController">
+         <input ng-model="title" aria-label="title"> <br/>
+         <textarea ng-model="text" aria-label="text"></textarea> <br/>
+         <pane title="{{title}}">{{text}}</pane>
+       </div>
+     </file>
+     <file name="protractor.js" type="protractor">
+        it('should have transcluded', function() {
+          var titleElement = element(by.model('title'));
+          titleElement.clear();
+          titleElement.sendKeys('TITLE');
+          var textElement = element(by.model('text'));
+          textElement.clear();
+          textElement.sendKeys('TEXT');
+          expect(element(by.binding('title')).getText()).toEqual('TITLE');
+          expect(element(by.binding('text')).getText()).toEqual('TEXT');
+        });
+     </file>
+   </example>
  *
- * @example
- * ### Transclude fallback content
- * This example shows how to use `NgTransclude` with fallback content, that
- * is displayed if no transcluded content is provided.
- *
- * <example module="transcludeFallbackContentExample">
- * <file name="index.html">
- * <script>
- * angular.module('transcludeFallbackContentExample', [])
- * .directive('myButton', function(){
- *             return {
- *               restrict: 'E',
- *               transclude: true,
- *               scope: true,
- *               template: '<button style="cursor: pointer;">' +
- *                           '<ng-transclude>' +
- *                             '<b style="color: red;">Button1</b>' +
- *                           '</ng-transclude>' +
- *                         '</button>'
- *             };
- *         });
- * </script>
- * <!-- fallback button content -->
- * <my-button id="fallback"></my-button>
- * <!-- modified button content -->
- * <my-button id="modified">
- *   <i style="color: green;">Button2</i>
- * </my-button>
- * </file>
- * <file name="protractor.js" type="protractor">
- * it('should have different transclude element content', function() {
- *          expect(element(by.id('fallback')).getText()).toBe('Button1');
- *          expect(element(by.id('modified')).getText()).toBe('Button2');
- *        });
- * </file>
- * </example>
- *
- * @example
- * ### Multi-slot transclusion
- * This example demonstrates using multi-slot transclusion in a component directive.
- * <example name="multiSlotTranscludeExample" module="multiSlotTranscludeExample">
- *   <file name="index.html">
- *    <style>
- *      .title, .footer {
- *        background-color: gray
- *      }
- *    </style>
- *    <div ng-controller="ExampleController">
- *      <input ng-model="title" aria-label="title"> <br/>
- *      <textarea ng-model="text" aria-label="text"></textarea> <br/>
- *      <pane>
- *        <pane-title><a ng-href="{{link}}">{{title}}</a></pane-title>
- *        <pane-body><p>{{text}}</p></pane-body>
- *      </pane>
- *    </div>
- *   </file>
- *   <file name="app.js">
- *    angular.module('multiSlotTranscludeExample', [])
- *     .directive('pane', function(){
- *        return {
- *          restrict: 'E',
- *          transclude: {
- *            'title': '?paneTitle',
- *            'body': 'paneBody',
- *            'footer': '?paneFooter'
- *          },
- *          template: '<div style="border: 1px solid black;">' +
- *                      '<div class="title" ng-transclude="title">Fallback Title</div>' +
- *                      '<div ng-transclude="body"></div>' +
- *                      '<div class="footer" ng-transclude="footer">Fallback Footer</div>' +
- *                    '</div>'
- *        };
- *    })
- *    .controller('ExampleController', ['$scope', function($scope) {
- *      $scope.title = 'Lorem Ipsum';
- *      $scope.link = "https://google.com";
- *      $scope.text = 'Neque porro quisquam est qui dolorem ipsum quia dolor...';
- *    }]);
- *   </file>
- *   <file name="protractor.js" type="protractor">
- *      it('should have transcluded the title and the body', function() {
- *        var titleElement = element(by.model('title'));
- *        titleElement.clear();
- *        titleElement.sendKeys('TITLE');
- *        var textElement = element(by.model('text'));
- *        textElement.clear();
- *        textElement.sendKeys('TEXT');
- *        expect(element(by.css('.title')).getText()).toEqual('TITLE');
- *        expect(element(by.binding('text')).getText()).toEqual('TEXT');
- *        expect(element(by.css('.footer')).getText()).toEqual('Fallback Footer');
- *      });
- *   </file>
- * </example>
  */
-var ngTranscludeMinErr = minErr('ngTransclude');
 var ngTranscludeDirective = ngDirective({
   restrict: 'EAC',
   link: function($scope, $element, $attrs, controller, $transclude) {
-
-    if ($attrs.ngTransclude === $attrs.$attr.ngTransclude) {
-      // If the attribute is of the form: `ng-transclude="ng-transclude"`
-      // then treat it like the default
-      $attrs.ngTransclude = '';
-    }
-
-    function ngTranscludeCloneAttachFn(clone) {
-      if (clone.length) {
-        $element.empty();
-        $element.append(clone);
-      }
-    }
-
     if (!$transclude) {
-      throw ngTranscludeMinErr('orphan',
+      throw minErr('ngTransclude')('orphan',
        'Illegal use of ngTransclude directive in the template! ' +
        'No parent directive that requires a transclusion found. ' +
        'Element: {0}',
        startingTag($element));
     }
 
-    // If there is no slot name defined or the slot name is not optional
-    // then transclude the slot
-    var slotName = $attrs.ngTransclude || $attrs.ngTranscludeSlot;
-    $transclude(ngTranscludeCloneAttachFn, null, slotName);
+    $transclude(function(clone) {
+      $element.empty();
+      $element.append(clone);
+    });
   }
 });
-

src/ng/directive/select.js

@@ -80,9 +80,6 @@ var SelectController =
 
   // Tell the select control that an option, with the given value, has been added
   self.addOption = function(value, element) {
-    // Skip comment nodes, as they only pollute the `optionsMap`
-    if (element[0].nodeType === NODE_TYPE_COMMENT) return;
-
     assertNotHasOwnProperty(value, '"option value"');
     if (value === '') {
       self.emptyOption = element;
@@ -167,7 +164,7 @@ var SelectController =
  *
  * <div class="alert alert-warning">
  * Note that the value of a `select` directive used without `ngOptions` is always a string.
- * When the model needs to be bound to a non-string value, you must either explicitly convert it
+ * When the model needs to be bound to a non-string value, you must either explictly convert it
  * using a directive (see example below) or use `ngOptions` to specify the set of options.
  * This is because an option element can only be bound to string values at present.
  * </div>
@@ -455,6 +452,7 @@ var optionDirective = ['$interpolate', function($interpolate) {
     restrict: 'E',
     priority: 100,
     compile: function(element, attr) {
+
       if (isDefined(attr.value)) {
         // If the value attribute is defined, check if it contains an interpolation
         var interpolateValueFn = $interpolate(attr.value, true);
@@ -468,6 +466,7 @@ var optionDirective = ['$interpolate', function($interpolate) {
       }
 
       return function(scope, element, attr) {
+
         // This is an optimization over using ^^ since we don't want to have to search
         // all the way to the root of the DOM for every single option element
         var selectCtrlName = '$selectController',

src/ng/directive/validators.js

@@ -15,7 +15,7 @@
  * for more info.
  *
  * The validator will set the `required` error key to true if the `required` attribute is set and
- * calling {@link ngModel.NgModelController#$isEmpty `NgModelController.$isEmpty`} with the
+ * calling {@link ngModel.NgModelController#$isEmpty `NgModelController.$isEmpty` with the
  * {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`} returns `true`. For example, the
  * `$isEmpty()` implementation for `input[text]` checks the length of the `$viewValue`. When developing
  * custom controls, `$isEmpty()` can be overwritten to account for a $viewValue that is not string-based.

src/ng/filter/filters.js

@@ -607,13 +607,13 @@ function dateFilter($locale) {
 
     var dateTimezoneOffset = date.getTimezoneOffset();
     if (timezone) {
-      dateTimezoneOffset = timezoneToOffset(timezone, dateTimezoneOffset);
+      dateTimezoneOffset = timezoneToOffset(timezone, date.getTimezoneOffset());
       date = convertTimezoneToLocal(date, timezone, true);
     }
     forEach(parts, function(value) {
       fn = DATE_FORMATS[value];
       text += fn ? fn(date, $locale.DATETIME_FORMATS, dateTimezoneOffset)
-                 : value === "''" ? "'" : value.replace(/(^'|'$)/g, '').replace(/''/g, "'");
+                 : value.replace(/(^'|'$)/g, '').replace(/''/g, "'");
     });
 
     return text;

src/ng/filter/orderBy.js

@@ -9,9 +9,8 @@
  * Orders a specified `array` by the `expression` predicate. It is ordered alphabetically
  * for strings and numerically for numbers. Note: if you notice numbers are not being sorted
  * as expected, make sure they are actually being saved as numbers and not strings.
- * Array-like values (e.g. NodeLists, jQuery objects, TypedArrays, Strings, etc) are also supported.
  *
- * @param {Array} array The array (or array-like object) to sort.
+ * @param {Array} array The array to sort.
  * @param {function(*)|string|Array.<(function(*)|string)>=} expression A predicate to be
  *    used by the comparator to determine the order of elements.
  *
@@ -198,10 +197,7 @@ orderByFilter.$inject = ['$parse'];
 function orderByFilter($parse) {
   return function(array, sortPredicate, reverseOrder) {
 
-    if (array == null) return array;
-    if (!isArrayLike(array)) {
-      throw minErr('orderBy')('notarray', 'Expected array but received: {0}', array);
-    }
+    if (!(isArrayLike(array))) return array;
 
     if (!isArray(sortPredicate)) { sortPredicate = [sortPredicate]; }
     if (sortPredicate.length === 0) { sortPredicate = ['+']; }

src/ng/http.js

@@ -521,7 +521,7 @@ function $HttpProvider() {
      *
      * ```
      * module.run(function($http) {
-     *   $http.defaults.headers.common.Authorization = 'Basic YmVlcDpib29w';
+     *   $http.defaults.headers.common.Authorization = 'Basic YmVlcDpib29w'
      * });
      * ```
      *
@@ -749,13 +749,13 @@ function $HttpProvider() {
      *
      * ### Cross Site Request Forgery (XSRF) Protection
      *
-     * [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery) is an attack technique by
-     * which the attacker can trick an authenticated user into unknowingly executing actions on your
-     * website. Angular provides a mechanism to counter XSRF. When performing XHR requests, the
-     * $http service reads a token from a cookie (by default, `XSRF-TOKEN`) and sets it as an HTTP
-     * header (`X-XSRF-TOKEN`). Since only JavaScript that runs on your domain could read the
-     * cookie, your server can be assured that the XHR came from JavaScript running on your domain.
-     * The header will not be set for cross-domain requests.
+     * [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery) is a technique by which
+     * an unauthorized site can gain your user's private data. Angular provides a mechanism
+     * to counter XSRF. When performing XHR requests, the $http service reads a token from a cookie
+     * (by default, `XSRF-TOKEN`) and sets it as an HTTP header (`X-XSRF-TOKEN`). Since only
+     * JavaScript that runs on your domain could read the cookie, your server can be assured that
+     * the XHR came from JavaScript running on your domain. The header will not be set for
+     * cross-domain requests.
      *
      * To take advantage of this, your server needs to set a token in a JavaScript readable session
      * cookie called `XSRF-TOKEN` on the first HTTP GET request. On subsequent XHR requests the
@@ -914,7 +914,7 @@ function $HttpProvider() {
      */
     function $http(requestConfig) {
 
-      if (!isObject(requestConfig)) {
+      if (!angular.isObject(requestConfig)) {
         throw minErr('$http')('badreq', 'Http request configuration must be an object.  Received: {0}', requestConfig);
       }
 
@@ -1034,7 +1034,7 @@ function $HttpProvider() {
 
         defHeaders = extend({}, defHeaders.common, defHeaders[lowercase(config.method)]);
 
-        // using for-in instead of forEach to avoid unnecessary iteration after header has been found
+        // using for-in instead of forEach to avoid unecessary iteration after header has been found
         defaultHeadersIteration:
         for (defHeaderName in defHeaders) {
           lowercaseDefHeaderName = lowercase(defHeaderName);

src/ng/interpolate.js

@@ -20,14 +20,6 @@ $interpolateMinErr.interr = function(text, err) {
  *
  * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
  *
- * <div class="alert alert-danger">
- * This feature is sometimes used to mix different markup languages, e.g. to wrap an Angular
- * template within a Python Jinja template (or any other template language). Mixing templating
- * languages is **very dangerous**. The embedding template language will not safely escape Angular
- * expressions, so any user-controlled values in the template will cause Cross Site Scripting (XSS)
- * security bugs!
- * </div>
- *
  * @example
 <example name="custom-interpolation-markup" module="customInterpolationApp">
 <file name="index.html">
@@ -128,15 +120,6 @@ function $InterpolateProvider() {
       return value;
     }
 
-    //TODO: this is the same as the constantWatchDelegate in parse.js
-    function constantWatchDelegate(scope, listener, objectEquality, constantInterp) {
-      var unwatch;
-      return unwatch = scope.$watch(function constantInterpolateWatch(scope) {
-        unwatch();
-        return constantInterp(scope);
-      }, listener, objectEquality);
-    }
-
     /**
      * @ngdoc service
      * @name $interpolate
@@ -232,19 +215,6 @@ function $InterpolateProvider() {
      * - `context`: evaluation context for all expressions embedded in the interpolated text
      */
     function $interpolate(text, mustHaveExpression, trustedContext, allOrNothing) {
-      // Provide a quick exit and simplified result function for text with no interpolation
-      if (!text.length || text.indexOf(startSymbol) === -1) {
-        var constantInterp;
-        if (!mustHaveExpression) {
-          var unescapedText = unescapeText(text);
-          constantInterp = valueFn(unescapedText);
-          constantInterp.exp = text;
-          constantInterp.expressions = [];
-          constantInterp.$$watchDelegate = constantWatchDelegate;
-        }
-        return constantInterp;
-      }
-
       allOrNothing = !!allOrNothing;
       var startIndex,
           endIndex,

src/ng/interval.js

@@ -2,8 +2,8 @@
 
 
 function $IntervalProvider() {
-  this.$get = ['$rootScope', '$window', '$q', '$$q', '$browser',
-       function($rootScope,   $window,   $q,   $$q,   $browser) {
+  this.$get = ['$rootScope', '$window', '$q', '$$q',
+       function($rootScope,   $window,   $q,   $$q) {
     var intervals = {};
 
 
@@ -144,12 +144,11 @@ function $IntervalProvider() {
 
       count = isDefined(count) ? count : 0;
 
+      promise.then(null, null, (!hasParams) ? fn : function() {
+        fn.apply(null, args);
+      });
+
       promise.$$intervalId = setInterval(function tick() {
-        if (skipApply) {
-          $browser.defer(callback);
-        } else {
-          $rootScope.$evalAsync(callback);
-        }
         deferred.notify(iteration++);
 
         if (count > 0 && iteration >= count) {
@@ -165,14 +164,6 @@ function $IntervalProvider() {
       intervals[promise.$$intervalId] = deferred;
 
       return promise;
-
-      function callback() {
-        if (!hasParams) {
-          fn(iteration);
-        } else {
-          fn.apply(null, args);
-        }
-      }
     }
 
 

src/ng/parse.js

@@ -48,22 +48,23 @@ function ensureSafeMemberName(name, fullExpression) {
   return name;
 }
 
-function getStringValue(name) {
+function getStringValue(name, fullExpression) {
+  // From the JavaScript docs:
   // Property names must be strings. This means that non-string objects cannot be used
   // as keys in an object. Any non-string object, including a number, is typecasted
   // into a string via the toString method.
-  // -- MDN, https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Property_accessors#Property_names
   //
-  // So, to ensure that we are checking the same `name` that JavaScript would use, we cast it
-  // to a string. It's not always possible. If `name` is an object and its `toString` method is
-  // 'broken' (doesn't return a string, isn't a function, etc.), an error will be thrown:
-  //
-  // TypeError: Cannot convert object to primitive value
-  //
-  // For performance reasons, we don't catch this error here and allow it to propagate up the call
-  // stack. Note that you'll get the same error in JavaScript if you try to access a property using
-  // such a 'broken' object as a key.
-  return name + '';
+  // So, to ensure that we are checking the same `name` that JavaScript would use,
+  // we cast it to a string, if possible.
+  // Doing `name + ''` can cause a repl error if the result to `toString` is not a string,
+  // this is, this will handle objects that misbehave.
+  name = name + '';
+  if (!isString(name)) {
+    throw $parseMinErr('iseccst',
+        'Cannot convert object to primitive value! '
+        + 'Expression: {0}', fullExpression);
+  }
+  return name;
 }
 
 function ensureSafeObject(obj, fullExpression) {
@@ -324,7 +325,6 @@ AST.ArrayExpression = 'ArrayExpression';
 AST.Property = 'Property';
 AST.ObjectExpression = 'ObjectExpression';
 AST.ThisExpression = 'ThisExpression';
-AST.LocalsExpression = 'LocalsExpression';
 
 // Internal use only
 AST.NGValueParameter = 'NGValueParameter';
@@ -625,8 +625,7 @@ AST.prototype = {
     'false': { type: AST.Literal, value: false },
     'null': { type: AST.Literal, value: null },
     'undefined': {type: AST.Literal, value: undefined },
-    'this': {type: AST.ThisExpression },
-    '$locals': {type: AST.LocalsExpression }
+    'this': {type: AST.ThisExpression }
   }
 };
 
@@ -746,10 +745,6 @@ function findConstantAndWatchExpressions(ast, $filter) {
     ast.constant = false;
     ast.toWatch = [];
     break;
-  case AST.LocalsExpression:
-    ast.constant = false;
-    ast.toWatch = [];
-    break;
   }
 }
 
@@ -993,9 +988,6 @@ ASTCompiler.prototype = {
       intoId = intoId || this.nextId();
       self.recurse(ast.object, left, undefined, function() {
         self.if_(self.notNull(left), function() {
-          if (create && create !== 1) {
-            self.addEnsureSafeAssignContext(left);
-          }
           if (ast.computed) {
             right = self.nextId();
             self.recurse(ast.property, right);
@@ -1119,10 +1111,6 @@ ASTCompiler.prototype = {
       this.assign(intoId, 's');
       recursionFn('s');
       break;
-    case AST.LocalsExpression:
-      this.assign(intoId, 'l');
-      recursionFn('l');
-      break;
     case AST.NGValueParameter:
       this.assign(intoId, 'v');
       recursionFn('v');
@@ -1230,7 +1218,7 @@ ASTCompiler.prototype = {
   },
 
   getStringValue: function(item) {
-    this.assign(item, 'getStringValue(' + item + ')');
+    this.assign(item, 'getStringValue(' + item + ',text)');
   },
 
   ensureSafeAssignContext: function(item) {
@@ -1450,10 +1438,6 @@ ASTInterpreter.prototype = {
       return function(scope) {
         return context ? {value: scope} : scope;
       };
-    case AST.LocalsExpression:
-      return function(scope, locals) {
-        return context ? {value: locals} : locals;
-      };
     case AST.NGValueParameter:
       return function(scope, locals, assign, inputs) {
         return context ? {value: assign} : assign;
@@ -1618,11 +1602,8 @@ ASTInterpreter.prototype = {
         rhs = right(scope, locals, assign, inputs);
         rhs = getStringValue(rhs);
         ensureSafeMemberName(rhs, expression);
-        if (create && create !== 1) {
-          ensureSafeAssignContext(lhs);
-          if (lhs && !(lhs[rhs])) {
-            lhs[rhs] = {};
-          }
+        if (create && create !== 1 && lhs && !(lhs[rhs])) {
+          lhs[rhs] = {};
         }
         value = lhs[rhs];
         ensureSafeObject(value, expression);
@@ -1637,11 +1618,8 @@ ASTInterpreter.prototype = {
   nonComputedMember: function(left, right, expensiveChecks, context, create, expression) {
     return function(scope, locals, assign, inputs) {
       var lhs = left(scope, locals, assign, inputs);
-      if (create && create !== 1) {
-        ensureSafeAssignContext(lhs);
-        if (lhs && !(lhs[right])) {
-          lhs[right] = {};
-        }
+      if (create && create !== 1 && lhs && !(lhs[right])) {
+        lhs[right] = {};
       }
       var value = lhs != null ? lhs[right] : undefined;
       if (expensiveChecks || isPossiblyDangerousMemberName(right)) {
@@ -1757,19 +1735,10 @@ function $ParseProvider() {
           csp: noUnsafeEval,
           expensiveChecks: true
         };
-    var runningChecksEnabled = false;
 
-    $parse.$$runningExpensiveChecks = function() {
-      return runningChecksEnabled;
-    };
-
-    return $parse;
-
-    function $parse(exp, interceptorFn, expensiveChecks) {
+    return function $parse(exp, interceptorFn, expensiveChecks) {
       var parsedExpression, oneTime, cacheKey;
 
-      expensiveChecks = expensiveChecks || runningChecksEnabled;
-
       switch (typeof exp) {
         case 'string':
           exp = exp.trim();
@@ -1795,9 +1764,6 @@ function $ParseProvider() {
             } else if (parsedExpression.inputs) {
               parsedExpression.$$watchDelegate = inputsWatchDelegate;
             }
-            if (expensiveChecks) {
-              parsedExpression = expensiveChecksInterceptor(parsedExpression);
-            }
             cache[cacheKey] = parsedExpression;
           }
           return addInterceptor(parsedExpression, interceptorFn);
@@ -1808,31 +1774,7 @@ function $ParseProvider() {
         default:
           return addInterceptor(noop, interceptorFn);
       }
-    }
-
-    function expensiveChecksInterceptor(fn) {
-      if (!fn) return fn;
-      expensiveCheckFn.$$watchDelegate = fn.$$watchDelegate;
-      expensiveCheckFn.assign = expensiveChecksInterceptor(fn.assign);
-      expensiveCheckFn.constant = fn.constant;
-      expensiveCheckFn.literal = fn.literal;
-      for (var i = 0; fn.inputs && i < fn.inputs.length; ++i) {
-        fn.inputs[i] = expensiveChecksInterceptor(fn.inputs[i]);
-      }
-      expensiveCheckFn.inputs = fn.inputs;
-
-      return expensiveCheckFn;
-
-      function expensiveCheckFn(scope, locals, assign, inputs) {
-        var expensiveCheckOldValue = runningChecksEnabled;
-        runningChecksEnabled = true;
-        try {
-          return fn(scope, locals, assign, inputs);
-        } finally {
-          runningChecksEnabled = expensiveCheckOldValue;
-        }
-      }
-    }
+    };
 
     function expressionInputDirtyCheck(newValue, oldValueOfValue) {
 
@@ -1949,9 +1891,13 @@ function $ParseProvider() {
     function constantWatchDelegate(scope, listener, objectEquality, parsedExpression) {
       var unwatch;
       return unwatch = scope.$watch(function constantWatch(scope) {
-        unwatch();
         return parsedExpression(scope);
-      }, listener, objectEquality);
+      }, function constantListener(value, old, scope) {
+        if (isFunction(listener)) {
+          listener.apply(this, arguments);
+        }
+        unwatch();
+      }, objectEquality);
     }
 
     function addInterceptor(parsedExpression, interceptorFn) {

src/ng/q.js

@@ -53,7 +53,7 @@
  *
  * Note: progress/notify callbacks are not currently supported via the ES6-style interface.
  *
- * Note: unlike ES6 behavior, an exception thrown in the constructor function will NOT implicitly reject the promise.
+ * Note: unlike ES6 behaviour, an exception thrown in the constructor function will NOT implicitly reject the promise.
  *
  * However, the more traditional CommonJS-style usage is still available, and documented below.
  *
@@ -243,6 +243,18 @@ function $$QProvider() {
  */
 function qFactory(nextTick, exceptionHandler) {
   var $qMinErr = minErr('$q', TypeError);
+  function callOnce(self, resolveFn, rejectFn) {
+    var called = false;
+    function wrap(fn) {
+      return function(value) {
+        if (called) return;
+        called = true;
+        fn.call(self, value);
+      };
+    }
+
+    return [wrap(resolveFn), wrap(rejectFn)];
+  }
 
   /**
    * @ngdoc method
@@ -255,12 +267,7 @@ function qFactory(nextTick, exceptionHandler) {
    * @returns {Deferred} Returns a new instance of deferred.
    */
   var defer = function() {
-    var d = new Deferred();
-    //Necessary to support unbound execution :/
-    d.resolve = simpleBind(d, d.resolve);
-    d.reject = simpleBind(d, d.reject);
-    d.notify = simpleBind(d, d.notify);
-    return d;
+    return new Deferred();
   };
 
   function Promise() {
@@ -333,6 +340,10 @@ function qFactory(nextTick, exceptionHandler) {
 
   function Deferred() {
     this.promise = new Promise();
+    //Necessary to support unbound execution :/
+    this.resolve = simpleBind(this, this.resolve);
+    this.reject = simpleBind(this, this.reject);
+    this.notify = simpleBind(this, this.notify);
   }
 
   extend(Deferred.prototype, {
@@ -350,34 +361,23 @@ function qFactory(nextTick, exceptionHandler) {
     },
 
     $$resolve: function(val) {
-      var then;
-      var that = this;
-      var done = false;
+      var then, fns;
+
+      fns = callOnce(this, this.$$resolve, this.$$reject);
       try {
         if ((isObject(val) || isFunction(val))) then = val && val.then;
         if (isFunction(then)) {
           this.promise.$$state.status = -1;
-          then.call(val, resolvePromise, rejectPromise, simpleBind(this, this.notify));
+          then.call(val, fns[0], fns[1], this.notify);
         } else {
           this.promise.$$state.value = val;
           this.promise.$$state.status = 1;
           scheduleProcessQueue(this.promise.$$state);
         }
       } catch (e) {
-        rejectPromise(e);
+        fns[1](e);
         exceptionHandler(e);
       }
-
-      function resolvePromise(val) {
-        if (done) return;
-        done = true;
-        that.$$resolve(val);
-      }
-      function rejectPromise(val) {
-        if (done) return;
-        done = true;
-        that.$$reject(val);
-      }
     },
 
     reject: function(reason) {
@@ -566,6 +566,11 @@ function qFactory(nextTick, exceptionHandler) {
       throw $qMinErr('norslvr', "Expected resolverFn, got '{0}'", resolver);
     }
 
+    if (!(this instanceof Q)) {
+      // More useful when $Q is the Promise itself.
+      return new Q(resolver);
+    }
+
     var deferred = new Deferred();
 
     function resolveFn(value) {
@@ -581,10 +586,6 @@ function qFactory(nextTick, exceptionHandler) {
     return deferred.promise;
   };
 
-  // Let's make the instanceof operator work for promises, so that
-  // `new $q(fn) instanceof $q` would evaluate to true.
-  $Q.prototype = Promise.prototype;
-
   $Q.defer = defer;
   $Q.reject = reject;
   $Q.when = when;

src/ng/rootScope.js

@@ -94,8 +94,8 @@ function $RootScopeProvider() {
     return ChildScope;
   }
 
-  this.$get = ['$exceptionHandler', '$parse', '$browser',
-      function($exceptionHandler, $parse, $browser) {
+  this.$get = ['$injector', '$exceptionHandler', '$parse', '$browser',
+      function($injector, $exceptionHandler, $parse, $browser) {
 
     function destroyChildScope($event) {
         $event.currentScope.$$destroyed = true;
@@ -379,7 +379,7 @@ function $RootScopeProvider() {
        *    - `newVal` contains the current value of the `watchExpression`
        *    - `oldVal` contains the previous value of the `watchExpression`
        *    - `scope` refers to the current scope
-       * @param {boolean=} [objectEquality=false] Compare for object equality using {@link angular.equals} instead of
+       * @param {boolean=} objectEquality Compare for object equality using {@link angular.equals} instead of
        *     comparing for reference equality.
        * @returns {function()} Returns a deregistration function for this listener.
        */
@@ -744,7 +744,7 @@ function $RootScopeProvider() {
        *
        */
       $digest: function() {
-        var watch, value, last, fn, get,
+        var watch, value, last,
             watchers,
             length,
             dirty, ttl = TTL,
@@ -790,8 +790,7 @@ function $RootScopeProvider() {
                   // Most common watches are on primitives, in which case we can short
                   // circuit it with === operator, only when === fails do we use .equals
                   if (watch) {
-                    get = watch.get;
-                    if ((value = get(current)) !== (last = watch.last) &&
+                    if ((value = watch.get(current)) !== (last = watch.last) &&
                         !(watch.eq
                             ? equals(value, last)
                             : (typeof value === 'number' && typeof last === 'number'
@@ -799,8 +798,7 @@ function $RootScopeProvider() {
                       dirty = true;
                       lastDirtyWatch = watch;
                       watch.last = watch.eq ? copy(value, null) : value;
-                      fn = watch.fn;
-                      fn(value, ((last === initWatchVal) ? value : last), current);
+                      watch.fn(value, ((last === initWatchVal) ? value : last), current);
                       if (ttl < 5) {
                         logIdx = 4 - ttl;
                         if (!watchLog[logIdx]) watchLog[logIdx] = [];
@@ -1000,7 +998,7 @@ function $RootScopeProvider() {
           });
         }
 
-        asyncQueue.push({scope: this, expression: $parse(expr), locals: locals});
+        asyncQueue.push({scope: this, expression: expr, locals: locals});
       },
 
       $$postDigest: function(fn) {
@@ -1092,7 +1090,6 @@ function $RootScopeProvider() {
       $applyAsync: function(expr) {
         var scope = this;
         expr && applyAsyncQueue.push($applyAsyncExpression);
-        expr = $parse(expr);
         scheduleApplyAsync();
 
         function $applyAsyncExpression() {

src/ng/sce.js

@@ -144,15 +144,13 @@ function $SceDelegateProvider() {
    * @kind function
    *
    * @param {Array=} whitelist When provided, replaces the resourceUrlWhitelist with the value
-   *    provided.  This must be an array or null.  A snapshot of this array is used so further
-   *    changes to the array are ignored.
+   *     provided.  This must be an array or null.  A snapshot of this array is used so further
+   *     changes to the array are ignored.
    *
-   *    Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
-   *    allowed in this array.
+   *     Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
+   *     allowed in this array.
    *
-   *    <div class="alert alert-warning">
-   *    **Note:** an empty whitelist array will block all URLs!
-   *    </div>
+   *     Note: **an empty whitelist array will block all URLs**!
    *
    * @return {Array} the currently set whitelist array.
    *
@@ -175,17 +173,17 @@ function $SceDelegateProvider() {
    * @kind function
    *
    * @param {Array=} blacklist When provided, replaces the resourceUrlBlacklist with the value
-   *    provided.  This must be an array or null.  A snapshot of this array is used so further
-   *    changes to the array are ignored.
+   *     provided.  This must be an array or null.  A snapshot of this array is used so further
+   *     changes to the array are ignored.
    *
-   *    Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
-   *    allowed in this array.
+   *     Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
+   *     allowed in this array.
    *
-   *    The typical usage for the blacklist is to **block
-   *    [open redirects](http://cwe.mitre.org/data/definitions/601.html)** served by your domain as
-   *    these would otherwise be trusted but actually return content from the redirected domain.
+   *     The typical usage for the blacklist is to **block
+   *     [open redirects](http://cwe.mitre.org/data/definitions/601.html)** served by your domain as
+   *     these would otherwise be trusted but actually return content from the redirected domain.
    *
-   *    Finally, **the blacklist overrides the whitelist** and has the final say.
+   *     Finally, **the blacklist overrides the whitelist** and has the final say.
    *
    * @return {Array} the currently set blacklist array.
    *
@@ -344,11 +342,6 @@ function $SceDelegateProvider() {
      * returns the originally supplied value if the queried context type is a supertype of the
      * created type.  If this condition isn't satisfied, throws an exception.
      *
-     * <div class="alert alert-danger">
-     * Disabling auto-escaping is extremely dangerous, it usually creates a Cross Site Scripting
-     * (XSS) vulnerability in your application.
-     * </div>
-     *
      * @param {string} type The kind of context in which this value is to be used.
      * @param {*} maybeTrusted The result of a prior {@link ng.$sceDelegate#trustAs
      *     `$sceDelegate.trustAs`} call.

src/ng/templateRequest.js

@@ -3,63 +3,26 @@
 var $compileMinErr = minErr('$compile');
 
 /**
- * @ngdoc provider
- * @name $templateRequestProvider
- * @description
- * Used to configure the options passed to the {@link $http} service when making a template request.
+ * @ngdoc service
+ * @name $templateRequest
  *
- * For example, it can be used for specifying the "Accept" header that is sent to the server, when
- * requesting a template.
+ * @description
+ * The `$templateRequest` service runs security checks then downloads the provided template using
+ * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request
+ * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the
+ * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
+ * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
+ * when `tpl` is of type string and `$templateCache` has the matching entry.
+ *
+ * @param {string|TrustedResourceUrl} tpl The HTTP request template URL
+ * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
+ *
+ * @return {Promise} a promise for the HTTP response data of the given URL.
+ *
+ * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
  */
 function $TemplateRequestProvider() {
-
-  var httpOptions;
-
-  /**
-   * @ngdoc method
-   * @name $templateRequestProvider#httpOptions
-   * @description
-   * The options to be passed to the {@link $http} service when making the request.
-   * You can use this to override options such as the "Accept" header for template requests.
-   *
-   * The {@link $templateRequest} will set the `cache` and the `transformResponse` properties of the
-   * options if not overridden here.
-   *
-   * @param {string=} value new value for the {@link $http} options.
-   * @returns {string|self} Returns the {@link $http} options when used as getter and self if used as setter.
-   */
-  this.httpOptions = function(val) {
-    if (val) {
-      httpOptions = val;
-      return this;
-    }
-    return httpOptions;
-  };
-
-  /**
-   * @ngdoc service
-   * @name $templateRequest
-   *
-   * @description
-   * The `$templateRequest` service runs security checks then downloads the provided template using
-   * `$http` and, upon success, stores the contents inside of `$templateCache`. If the HTTP request
-   * fails or the response data of the HTTP request is empty, a `$compile` error will be thrown (the
-   * exception can be thwarted by setting the 2nd parameter of the function to true). Note that the
-   * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
-   * when `tpl` is of type string and `$templateCache` has the matching entry.
-   *
-   * If you want to pass custom options to the `$http` service, such as setting the Accept header you
-   * can configure this via {@link $templateRequestProvider#httpOptions}.
-   *
-   * @param {string|TrustedResourceUrl} tpl The HTTP request template URL
-   * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
-   *
-   * @return {Promise} a promise for the HTTP response data of the given URL.
-   *
-   * @property {number} totalPendingRequests total amount of pending template requests being downloaded.
-   */
   this.$get = ['$templateCache', '$http', '$q', '$sce', function($templateCache, $http, $q, $sce) {
-
     function handleRequestFn(tpl, ignoreRequestError) {
       handleRequestFn.totalPendingRequests++;
 
@@ -82,10 +45,12 @@ function $TemplateRequestProvider() {
         transformResponse = null;
       }
 
-      return $http.get(tpl, extend({
-          cache: $templateCache,
-          transformResponse: transformResponse
-        }, httpOptions))
+      var httpOptions = {
+        cache: $templateCache,
+        transformResponse: transformResponse
+      };
+
+      return $http.get(tpl, httpOptions)
         ['finally'](function() {
           handleRequestFn.totalPendingRequests--;
         })

src/ngAnimate/.jshintrc

@@ -29,7 +29,6 @@
     "REMOVE_CLASS_SUFFIX": false,
     "EVENT_CLASS_PREFIX": false,
     "ACTIVE_CLASS_SUFFIX": false,
-    "PREPARE_CLASS_SUFFIX": false,
 
     "TRANSITION_DURATION_PROP": false,
     "TRANSITION_DELAY_PROP": false,
@@ -49,7 +48,7 @@
     "assertArg": false,
     "isPromiseLike": false,
     "mergeClasses": false,
-    "mergeAnimationDetails": false,
+    "mergeAnimationOptions": false,
     "prepareAnimationOptions": false,
     "applyAnimationStyles": false,
     "applyAnimationFromStyles": false,

src/ngAnimate/animateChildrenDirective.js

@@ -1,100 +1,15 @@
 'use strict';
 
-/**
- * @ngdoc directive
- * @name ngAnimateChildren
- * @restrict AE
- * @element ANY
- *
- * @description
- *
- * ngAnimateChildren allows you to specify that children of this element should animate even if any
- * of the children's parents are currently animating. By default, when an element has an active `enter`, `leave`, or `move`
- * (structural) animation, child elements that also have an active structural animation are not animated.
- *
- * Note that even if `ngAnimteChildren` is set, no child animations will run when the parent element is removed from the DOM (`leave` animation).
- *
- *
- * @param {string} ngAnimateChildren If the value is empty, `true` or `on`,
- *     then child animations are allowed. If the value is `false`, child animations are not allowed.
- *
- * @example
- * <example module="ngAnimateChildren" name="ngAnimateChildren" deps="angular-animate.js" animations="true">
-     <file name="index.html">
-       <div ng-controller="mainController as main">
-         <label>Show container? <input type="checkbox" ng-model="main.enterElement" /></label>
-         <label>Animate children? <input type="checkbox" ng-model="main.animateChildren" /></label>
-         <hr>
-         <div ng-animate-children="{{main.animateChildren}}">
-           <div ng-if="main.enterElement" class="container">
-             List of items:
-             <div ng-repeat="item in [0, 1, 2, 3]" class="item">Item {{item}}</div>
-           </div>
-         </div>
-       </div>
-     </file>
-     <file name="animations.css">
-
-      .container.ng-enter,
-      .container.ng-leave {
-        transition: all ease 1.5s;
-      }
-
-      .container.ng-enter,
-      .container.ng-leave-active {
-        opacity: 0;
-      }
-
-      .container.ng-leave,
-      .container.ng-enter-active {
-        opacity: 1;
-      }
-
-      .item {
-        background: firebrick;
-        color: #FFF;
-        margin-bottom: 10px;
-      }
-
-      .item.ng-enter,
-      .item.ng-leave {
-        transition: transform 1.5s ease;
-      }
-
-      .item.ng-enter {
-        transform: translateX(50px);
-      }
-
-      .item.ng-enter-active {
-        transform: translateX(0);
-      }
-    </file>
-    <file name="script.js">
-      angular.module('ngAnimateChildren', ['ngAnimate'])
-        .controller('mainController', function() {
-          this.animateChildren = false;
-          this.enterElement = false;
-        });
-    </file>
-  </example>
- */
-var $$AnimateChildrenDirective = ['$interpolate', function($interpolate) {
-  return {
-    link: function(scope, element, attrs) {
-      var val = attrs.ngAnimateChildren;
-      if (angular.isString(val) && val.length === 0) { //empty attribute
-        element.data(NG_ANIMATE_CHILDREN_DATA, true);
-      } else {
-        // Interpolate and set the value, so that it is available to
-        // animations that run right after compilation
-        setData($interpolate(val)(scope));
-        attrs.$observe('ngAnimateChildren', setData);
-      }
-
-      function setData(value) {
+var $$AnimateChildrenDirective = [function() {
+  return function(scope, element, attrs) {
+    var val = attrs.ngAnimateChildren;
+    if (angular.isString(val) && val.length === 0) { //empty attribute
+      element.data(NG_ANIMATE_CHILDREN_DATA, true);
+    } else {
+      attrs.$observe('ngAnimateChildren', function(value) {
         value = value === 'on' || value === 'true';
         element.data(NG_ANIMATE_CHILDREN_DATA, value);
-      }
+      });
     }
   };
 }];

src/ngAnimate/animateCss.js

@@ -167,7 +167,7 @@ var ANIMATE_TIMER_KEY = '$$animateCss';
  * ```
  *
  * To actually start the animation we need to run `animation.start()` which will then return a promise that we can hook into to detect when the animation ends.
- * If we choose not to run the animation then we MUST run `animation.end()` to perform a cleanup on the element (since some CSS classes and styles may have been
+ * If we choose not to run the animation then we MUST run `animation.end()` to perform a cleanup on the element (since some CSS classes and stlyes may have been
  * applied to the element during the preparation phase). Note that all other properties such as duration, delay, transitions and keyframes are just properties
  * and that changing them will not reconfigure the parameters of the animation.
  *
@@ -204,11 +204,11 @@ var ANIMATE_TIMER_KEY = '$$animateCss';
  * * `stagger` - A numeric time value representing the delay between successively animated elements
  * ({@link ngAnimate#css-staggering-animations Click here to learn how CSS-based staggering works in ngAnimate.})
  * * `staggerIndex` - The numeric index representing the stagger item (e.g. a value of 5 is equal to the sixth item in the stagger; therefore when a
- *   `stagger` option value of `0.1` is used then there will be a stagger delay of `600ms`)
- * * `applyClassesEarly` - Whether or not the classes being added or removed will be used when detecting the animation. This is set by `$animate` when enter/leave/move animations are fired to ensure that the CSS classes are resolved in time. (Note that this will prevent any transitions from occurring on the classes being added and removed.)
+ * * `stagger` option value of `0.1` is used then there will be a stagger delay of `600ms`)
+ * * `applyClassesEarly` - Whether or not the classes being added or removed will be used when detecting the animation. This is set by `$animate` when enter/leave/move animations are fired to ensure that the CSS classes are resolved in time. (Note that this will prevent any transitions from occuring on the classes being added and removed.)
  * * `cleanupStyles` - Whether or not the provided `from` and `to` styles will be removed once
  *    the animation is closed. This is useful for when the styles are used purely for the sake of
- *    the animation and do not have a lasting visual effect on the element (e.g. a collapse and open animation).
+ *    the animation and do not have a lasting visual effect on the element (e.g. a colapse and open animation).
  *    By default this value is set to `false`.
  *
  * @return {object} an object with start and end methods and details about the animation.
@@ -261,7 +261,7 @@ function computeCssStyles($window, element, properties) {
       }
 
       // by setting this to null in the event that the delay is not set or is set directly as 0
-      // then we can still allow for negative values to be used later on and not mistake this
+      // then we can still allow for zegative values to be used later on and not mistake this
       // value for being greater than any other negative value.
       if (val === 0) {
         val = null;
@@ -377,7 +377,7 @@ var $AnimateCssProvider = ['$animateProvider', function($animateProvider) {
       }
 
       // we keep putting this in multiple times even though the value and the cacheKey are the same
-      // because we're keeping an internal tally of how many duplicate animations are detected.
+      // because we're keeping an interal tally of how many duplicate animations are detected.
       gcsLookup.put(cacheKey, timings);
       return timings;
     }
@@ -756,13 +756,6 @@ var $AnimateCssProvider = ['$animateProvider', function($animateProvider) {
           element.off(events.join(' '), onAnimationProgress);
         }
 
-        //Cancel the fallback closing timeout and remove the timer data
-        var animationTimerData = element.data(ANIMATE_TIMER_KEY);
-        if (animationTimerData) {
-          $timeout.cancel(animationTimerData[0].timer);
-          element.removeData(ANIMATE_TIMER_KEY);
-        }
-
         // if the preparation function fails then the promise is not setup
         if (runner) {
           runner.complete(!rejected);
@@ -851,9 +844,9 @@ var $AnimateCssProvider = ['$animateProvider', function($animateProvider) {
           }
         };
 
-        // checking the stagger duration prevents an accidentally cascade of the CSS delay style
+        // checking the stagger duration prevents an accidently cascade of the CSS delay style
         // being inherited from the parent. If the transition duration is zero then we can safely
-        // rely that the delay value is an intentional stagger delay style.
+        // rely that the delay value is an intential stagger delay style.
         var maxStagger = itemIndex > 0
                          && ((timings.transitionDuration && stagger.transitionDuration === 0) ||
                             (timings.animationDuration && stagger.animationDuration === 0))

src/ngAnimate/animateCssDriver.js

@@ -24,7 +24,7 @@ var $$AnimateCssDriverProvider = ['$$animationProvider', function($$animationPro
 
     var rootBodyElement = jqLite(
       // this is to avoid using something that exists outside of the body
-      // we also special case the doc fragment case because our unit test code
+      // we also special case the doc fragement case because our unit test code
       // appends the $rootElement to the body after the app has been bootstrapped
       isDocumentFragment(rootNode) || bodyNode.contains(rootNode) ? rootNode : bodyNode
     );
@@ -124,7 +124,7 @@ var $$AnimateCssDriverProvider = ['$$animationProvider', function($$animationPro
         var coords = getDomNode(anchor).getBoundingClientRect();
 
         // we iterate directly since safari messes up and doesn't return
-        // all the keys for the coords object when iterated
+        // all the keys for the coods object when iterated
         forEach(['width','height','top','left'], function(key) {
           var value = coords[key];
           switch (key) {

src/ngAnimate/animateQueue.js

@@ -42,21 +42,22 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
     });
   }
 
-  function hasAnimationClasses(animation, and) {
-    var a = (animation.addClass || '').length > 0;
-    var b = (animation.removeClass || '').length > 0;
+  function hasAnimationClasses(options, and) {
+    options = options || {};
+    var a = (options.addClass || '').length > 0;
+    var b = (options.removeClass || '').length > 0;
     return and ? a && b : a || b;
   }
 
   rules.join.push(function(element, newAnimation, currentAnimation) {
     // if the new animation is class-based then we can just tack that on
-    return !newAnimation.structural && hasAnimationClasses(newAnimation);
+    return !newAnimation.structural && hasAnimationClasses(newAnimation.options);
   });
 
   rules.skip.push(function(element, newAnimation, currentAnimation) {
     // there is no need to animate anything if no classes are being added and
     // there is no structural animation that will be triggered
-    return !newAnimation.structural && !hasAnimationClasses(newAnimation);
+    return !newAnimation.structural && !hasAnimationClasses(newAnimation.options);
   });
 
   rules.skip.push(function(element, newAnimation, currentAnimation) {
@@ -82,17 +83,19 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
   });
 
   rules.cancel.push(function(element, newAnimation, currentAnimation) {
-    var nA = newAnimation.addClass;
-    var nR = newAnimation.removeClass;
-    var cA = currentAnimation.addClass;
-    var cR = currentAnimation.removeClass;
+
+
+    var nA = newAnimation.options.addClass;
+    var nR = newAnimation.options.removeClass;
+    var cA = currentAnimation.options.addClass;
+    var cR = currentAnimation.options.removeClass;
 
     // early detection to save the global CPU shortage :)
     if ((isUndefined(nA) && isUndefined(nR)) || (isUndefined(cA) && isUndefined(cR))) {
       return false;
     }
 
-    return hasMatchingClasses(nA, cR) || hasMatchingClasses(nR, cA);
+    return (hasMatchingClasses(nA, cR)) || (hasMatchingClasses(nR, cA));
   });
 
   this.$get = ['$$rAF', '$rootScope', '$rootElement', '$document', '$$HashMap',
@@ -164,8 +167,8 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
 
     var applyAnimationClasses = applyAnimationClassesFactory($$jqLite);
 
-    function normalizeAnimationDetails(element, animation) {
-      return mergeAnimationDetails(element, animation, {});
+    function normalizeAnimationOptions(element, options) {
+      return mergeAnimationOptions(element, options, {});
     }
 
     // IE9-11 has no method "contains" in SVG element and in Node.prototype. Bug #10259.
@@ -359,8 +362,6 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
         structural: isStructural,
         element: element,
         event: event,
-        addClass: options.addClass,
-        removeClass: options.removeClass,
         close: close,
         options: options,
         runner: runner
@@ -373,10 +374,11 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
             close();
             return runner;
           } else {
-            mergeAnimationDetails(element, existingAnimation, newAnimation);
+            mergeAnimationOptions(element, existingAnimation.options, options);
             return existingAnimation.runner;
           }
         }
+
         var cancelAnimationFlag = isAllowed('cancel', element, newAnimation, existingAnimation);
         if (cancelAnimationFlag) {
           if (existingAnimation.state === RUNNING_STATE) {
@@ -391,8 +393,7 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
             existingAnimation.close();
           } else {
             // this will merge the new animation options into existing animation options
-            mergeAnimationDetails(element, existingAnimation, newAnimation);
-
+            mergeAnimationOptions(element, existingAnimation.options, newAnimation.options);
             return existingAnimation.runner;
           }
         } else {
@@ -402,12 +403,12 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
           var joinAnimationFlag = isAllowed('join', element, newAnimation, existingAnimation);
           if (joinAnimationFlag) {
             if (existingAnimation.state === RUNNING_STATE) {
-              normalizeAnimationDetails(element, newAnimation);
+              normalizeAnimationOptions(element, options);
             } else {
               applyGeneratedPreparationClasses(element, isStructural ? event : null, options);
 
               event = newAnimation.event = existingAnimation.event;
-              options = mergeAnimationDetails(element, existingAnimation, newAnimation);
+              options = mergeAnimationOptions(element, existingAnimation.options, newAnimation.options);
 
               //we return the same runner since only the option values of this animation will
               //be fed into the `existingAnimation`.
@@ -418,7 +419,7 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
       } else {
         // normalization in this case means that it removes redundant CSS classes that
         // already exist (addClass) or do not exist (removeClass) on the element
-        normalizeAnimationDetails(element, newAnimation);
+        normalizeAnimationOptions(element, options);
       }
 
       // when the options are merged and cleaned up we may end up not having to do
@@ -428,7 +429,7 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
       if (!isValidAnimation) {
         // animate (from/to) can be quickly checked first, otherwise we check if any classes are present
         isValidAnimation = (newAnimation.event === 'animate' && Object.keys(newAnimation.options.to || {}).length > 0)
-                            || hasAnimationClasses(newAnimation);
+                            || hasAnimationClasses(newAnimation.options);
       }
 
       if (!isValidAnimation) {
@@ -458,7 +459,7 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
         var isValidAnimation = parentElement.length > 0
                                 && (animationDetails.event === 'animate'
                                     || animationDetails.structural
-                                    || hasAnimationClasses(animationDetails));
+                                    || hasAnimationClasses(animationDetails.options));
 
         // this means that the previous animation was cancelled
         // even if the follow-up animation is the same event
@@ -490,7 +491,7 @@ var $$AnimateQueueProvider = ['$animateProvider', function($animateProvider) {
 
         // this combined multiple class to addClass / removeClass into a setClass event
         // so long as a structural event did not take over the animation
-        event = !animationDetails.structural && hasAnimationClasses(animationDetails, true)
+        event = !animationDetails.structural && hasAnimationClasses(animationDetails.options, true)
             ? 'setClass'
             : animationDetails.event;
 

src/ngAnimate/animation.js

@@ -135,12 +135,6 @@ var $$AnimationProvider = ['$animateProvider', function($animateProvider) {
         options.tempClasses = null;
       }
 
-      var prepareClassName;
-      if (isStructural) {
-        prepareClassName = 'ng-' + event + PREPARE_CLASS_SUFFIX;
-        $$jqLite.addClass(element, prepareClassName);
-      }
-
       animationQueue.push({
         // this data is used by the postDigest code and passed into
         // the driver step function
@@ -305,7 +299,7 @@ var $$AnimationProvider = ['$animateProvider', function($animateProvider) {
             };
 
             // the anchor animations require that the from and to elements both have at least
-            // one shared CSS class which effectively marries the two elements together to use
+            // one shared CSS class which effictively marries the two elements together to use
             // the same animation driver and to properly sequence the anchor animation.
             if (group.classes.length) {
               preparedAnimations.push(group);
@@ -363,10 +357,6 @@ var $$AnimationProvider = ['$animateProvider', function($animateProvider) {
         if (tempClasses) {
           $$jqLite.addClass(element, tempClasses);
         }
-        if (prepareClassName) {
-          $$jqLite.removeClass(element, prepareClassName);
-          prepareClassName = null;
-        }
       }
 
       function updateAnimationRunners(animation, newRunner) {

src/ngAnimate/module.js

@@ -2,7 +2,6 @@
 
 /* global angularAnimateModule: true,
 
-   ngAnimateSwapDirective,
    $$AnimateAsyncRunFactory,
    $$rAFSchedulerFactory,
    $$AnimateChildrenDirective,
@@ -254,39 +253,11 @@
  * the CSS class once an animation has completed.)
  *
  *
- * ### The `ng-[event]-prepare` class
- *
- * This is a special class that can be used to prevent unwanted flickering / flash of content before
- * the actual animation starts. The class is added as soon as an animation is initialized, but removed
- * before the actual animation starts (after waiting for a $digest).
- * It is also only added for *structural* animations (`enter`, `move`, and `leave`).
- *
- * In practice, flickering can appear when nesting elements with structural animations such as `ngIf`
- * into elements that have class-based animations such as `ngClass`.
- *
- * ```html
- * <div ng-class="{red: myProp}">
- *   <div ng-class="{blue: myProp}">
- *     <div class="message" ng-if="myProp"></div>
- *   </div>
- * </div>
- * ```
- *
- * It is possible that during the `enter` animation, the `.message` div will be briefly visible before it starts animating.
- * In that case, you can add styles to the CSS that make sure the element stays hidden before the animation starts:
- *
- * ```css
- * .message.ng-enter-prepare {
- *   opacity: 0;
- * }
- *
- * ```
- *
  * ## JavaScript-based Animations
  *
  * ngAnimate also allows for animations to be consumed by JavaScript code. The approach is similar to CSS-based animations (where there is a shared
  * CSS class that is referenced in our HTML code) but in addition we need to register the JavaScript animation on the module. By making use of the
- * `module.animation()` module function we can register the animation.
+ * `module.animation()` module function we can register the ainmation.
  *
  * Let's see an example of a enter/leave animation using `ngRepeat`:
  *
@@ -766,8 +737,6 @@
  * Click here {@link ng.$animate to learn more about animations with `$animate`}.
  */
 angular.module('ngAnimate', [])
-  .directive('ngAnimateSwap', ngAnimateSwapDirective)
-
   .directive('ngAnimateChildren', $$AnimateChildrenDirective)
   .factory('$$rAFScheduler', $$rAFSchedulerFactory)
 

src/ngAnimate/ngAnimateSwap.js

@@ -1,110 +0,0 @@
-'use strict';
-
-/**
- * @ngdoc directive
- * @name ngAnimateSwap
- * @restrict A
- * @scope
- *
- * @description
- *
- * ngAnimateSwap is a animation-oriented directive that allows for the container to
- * be removed and entered in whenever the associated expression changes. A
- * common usecase for this directive is a rotating banner component which
- * contains one image being present at a time. When the active image changes
- * then the old image will perform a `leave` animation and the new element
- * will be inserted via an `enter` animation.
- *
- * @example
- * <example name="ngAnimateSwap-directive" module="ngAnimateSwapExample"
- *          deps="angular-animate.js"
- *          animations="true" fixBase="true">
- *   <file name="index.html">
- *     <div class="container" ng-controller="AppCtrl">
- *       <div ng-animate-swap="number" class="cell swap-animation" ng-class="colorClass(number)">
- *         {{ number }}
- *       </div>
- *     </div>
- *   </file>
- *   <file name="script.js">
- *     angular.module('ngAnimateSwapExample', ['ngAnimate'])
- *       .controller('AppCtrl', ['$scope', '$interval', function($scope, $interval) {
- *         $scope.number = 0;
- *         $interval(function() {
- *           $scope.number++;
- *         }, 1000);
- *
- *         var colors = ['red','blue','green','yellow','orange'];
- *         $scope.colorClass = function(number) {
- *           return colors[number % colors.length];
- *         };
- *       }]);
- *   </file>
- *  <file name="animations.css">
- *  .container {
- *    height:250px;
- *    width:250px;
- *    position:relative;
- *    overflow:hidden;
- *    border:2px solid black;
- *  }
- *  .container .cell {
- *    font-size:150px;
- *    text-align:center;
- *    line-height:250px;
- *    position:absolute;
- *    top:0;
- *    left:0;
- *    right:0;
- *    border-bottom:2px solid black;
- *  }
- *  .swap-animation.ng-enter, .swap-animation.ng-leave {
- *    transition:0.5s linear all;
- *  }
- *  .swap-animation.ng-enter {
- *    top:-250px;
- *  }
- *  .swap-animation.ng-enter-active {
- *    top:0px;
- *  }
- *  .swap-animation.ng-leave {
- *    top:0px;
- *  }
- *  .swap-animation.ng-leave-active {
- *    top:250px;
- *  }
- *  .red { background:red; }
- *  .green { background:green; }
- *  .blue { background:blue; }
- *  .yellow { background:yellow; }
- *  .orange { background:orange; }
- *  </file>
- * </example>
- */
-var ngAnimateSwapDirective = ['$animate', '$rootScope', function($animate, $rootScope) {
-  return {
-    restrict: 'A',
-    transclude: 'element',
-    terminal: true,
-    priority: 600, // we use 600 here to ensure that the directive is caught before others
-    link: function(scope, $element, attrs, ctrl, $transclude) {
-      var previousElement, previousScope;
-      scope.$watchCollection(attrs.ngAnimateSwap || attrs['for'], function(value) {
-        if (previousElement) {
-          $animate.leave(previousElement);
-        }
-        if (previousScope) {
-          previousScope.$destroy();
-          previousScope = null;
-        }
-        if (value || value === 0) {
-          previousScope = scope.$new();
-          $transclude(previousScope, function(element) {
-            previousElement = element;
-            $animate.enter(element, null, $element);
-          });
-        }
-      });
-    }
-  };
-}];

src/ngAnimate/rafScheduler.js

@@ -14,7 +14,7 @@ var $$rAFSchedulerFactory = ['$$rAF', function($$rAF) {
   queue = scheduler.queue = [];
 
   /* waitUntilQuiet does two things:
-   * 1. It will run the FINAL `fn` value only when an uncanceled RAF has passed through
+   * 1. It will run the FINAL `fn` value only when an uncancelled RAF has passed through
    * 2. It will delay the next wave of tasks from running until the quiet `fn` has run.
    *
    * The motivation here is that animation code can request more time from the scheduler

src/ngAnimate/shared.js

@@ -21,7 +21,6 @@ var ADD_CLASS_SUFFIX = '-add';
 var REMOVE_CLASS_SUFFIX = '-remove';
 var EVENT_CLASS_PREFIX = 'ng-';
 var ACTIVE_CLASS_SUFFIX = '-active';
-var PREPARE_CLASS_SUFFIX = '-prepare';
 
 var NG_ANIMATE_CLASSNAME = 'ng-animate';
 var NG_ANIMATE_CHILDREN_DATA = '$$ngAnimateChildren';
@@ -218,10 +217,7 @@ function applyAnimationToStyles(element, options) {
   }
 }
 
-function mergeAnimationDetails(element, oldAnimation, newAnimation) {
-  var target = oldAnimation.options || {};
-  var newOptions = newAnimation.options || {};
-
+function mergeAnimationOptions(element, target, newOptions) {
   var toAdd = (target.addClass || '') + ' ' + (newOptions.addClass || '');
   var toRemove = (target.removeClass || '') + ' ' + (newOptions.removeClass || '');
   var classes = resolveElementClasses(element.attr('class'), toAdd, toRemove);
@@ -253,9 +249,6 @@ function mergeAnimationDetails(element, oldAnimation, newAnimation) {
     target.removeClass = null;
   }
 
-  oldAnimation.addClass = target.addClass;
-  oldAnimation.removeClass = target.removeClass;
-
   return target;
 }
 

src/ngAria/aria.js

@@ -16,23 +16,19 @@
  *
  * For ngAria to do its magic, simply include the module `ngAria` as a dependency. The following
  * directives are supported:
- * `ngModel`, `ngChecked`, `ngRequired`, `ngValue`, `ngDisabled`, `ngShow`, `ngHide`, `ngClick`,
- * `ngDblClick`, and `ngMessages`.
+ * `ngModel`, `ngDisabled`, `ngShow`, `ngHide`, `ngClick`, `ngDblClick`, and `ngMessages`.
  *
  * Below is a more detailed breakdown of the attributes handled by ngAria:
  *
  * | Directive                                   | Supported Attributes                                                                   |
  * |---------------------------------------------|----------------------------------------------------------------------------------------|
- * | {@link ng.directive:ngModel ngModel}        | aria-checked, aria-valuemin, aria-valuemax, aria-valuenow, aria-invalid, aria-required, input roles |
  * | {@link ng.directive:ngDisabled ngDisabled}  | aria-disabled                                                                          |
- * | {@link ng.directive:ngRequired ngRequired}  | aria-required                                                                          |
- * | {@link ng.directive:ngChecked ngChecked}    | aria-checked                                                                           |
- * | {@link ng.directive:ngValue ngValue}        | aria-checked                                                                           |
  * | {@link ng.directive:ngShow ngShow}          | aria-hidden                                                                            |
  * | {@link ng.directive:ngHide ngHide}          | aria-hidden                                                                            |
  * | {@link ng.directive:ngDblclick ngDblclick}  | tabindex                                                                               |
  * | {@link module:ngMessages ngMessages}        | aria-live                                                                              |
- * | {@link ng.directive:ngClick ngClick}        | tabindex, keypress event, button role                                                  |
+ * | {@link ng.directive:ngModel ngModel}        | aria-checked, aria-valuemin, aria-valuemax, aria-valuenow, aria-invalid, aria-required, input roles |
+ * | {@link ng.directive:ngClick ngClick}        | tabindex, keypress event, button role                                                               |
  *
  * Find out more information about each directive by reading the
  * {@link guide/accessibility ngAria Developer Guide}.
@@ -94,6 +90,7 @@ function $AriaProvider() {
     ariaDisabled: true,
     ariaRequired: true,
     ariaInvalid: true,
+    ariaMultiline: true,
     ariaValue: true,
     tabindex: true,
     bindKeypress: true,
@@ -111,10 +108,11 @@ function $AriaProvider() {
    *  - **ariaDisabled** – `{boolean}` – Enables/disables aria-disabled tags
    *  - **ariaRequired** – `{boolean}` – Enables/disables aria-required tags
    *  - **ariaInvalid** – `{boolean}` – Enables/disables aria-invalid tags
+   *  - **ariaMultiline** – `{boolean}` – Enables/disables aria-multiline tags
    *  - **ariaValue** – `{boolean}` – Enables/disables aria-valuemin, aria-valuemax and aria-valuenow tags
    *  - **tabindex** – `{boolean}` – Enables/disables tabindex tags
-   *  - **bindKeypress** – `{boolean}` – Enables/disables keypress event binding on `div` and
-   *    `li` elements with ng-click
+   *  - **bindKeypress** – `{boolean}` – Enables/disables keypress event binding on `<div>` and
+   *    `<li>` elements with ng-click
    *  - **bindRoleForClick** – `{boolean}` – Adds role=button to non-interactive elements like `div`
    *    using ng-click, making them more accessible to users of assistive technologies
    *
@@ -153,15 +151,15 @@ function $AriaProvider() {
    *
    *```js
    * ngAriaModule.directive('ngDisabled', ['$aria', function($aria) {
-   *   return $aria.$$watchExpr('ngDisabled', 'aria-disabled', nodeBlackList, false);
+   *   return $aria.$$watchExpr('ngDisabled', 'aria-disabled');
    * }])
    *```
    * Shown above, the ngAria module creates a directive with the same signature as the
    * traditional `ng-disabled` directive. But this ngAria version is dedicated to
-   * solely managing accessibility attributes on custom elements. The internal `$aria` service is
-   * used to watch the boolean attribute `ngDisabled`. If it has not been explicitly set by the
-   * developer, `aria-disabled` is injected as an attribute with its value synchronized to the
-   * value in `ngDisabled`.
+   * solely managing accessibility attributes. The internal `$aria` service is used to watch the
+   * boolean attribute `ngDisabled`. If it has not been explicitly set by the developer,
+   * `aria-disabled` is injected as an attribute with its value synchronized to the value in
+   * `ngDisabled`.
    *
    * Because ngAria hooks into the `ng-disabled` directive, developers do not have to do
    * anything to enable this feature. The `aria-disabled` attribute is automatically managed
@@ -169,15 +167,12 @@ function $AriaProvider() {
    *
    * The full list of directives that interface with ngAria:
    * * **ngModel**
-   * * **ngChecked**
-   * * **ngRequired**
-   * * **ngDisabled**
-   * * **ngValue**
    * * **ngShow**
    * * **ngHide**
    * * **ngClick**
    * * **ngDblclick**
    * * **ngMessages**
+   * * **ngDisabled**
    *
    * Read the {@link guide/accessibility ngAria Developer Guide} for a thorough explanation of each
    * directive.
@@ -203,25 +198,13 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
 .directive('ngHide', ['$aria', function($aria) {
   return $aria.$$watchExpr('ngHide', 'aria-hidden', [], false);
 }])
-.directive('ngValue', ['$aria', function($aria) {
-  return $aria.$$watchExpr('ngValue', 'aria-checked', nodeBlackList, false);
-}])
-.directive('ngChecked', ['$aria', function($aria) {
-  return $aria.$$watchExpr('ngChecked', 'aria-checked', nodeBlackList, false);
-}])
-.directive('ngRequired', ['$aria', function($aria) {
-  return $aria.$$watchExpr('ngRequired', 'aria-required', nodeBlackList, false);
-}])
 .directive('ngModel', ['$aria', function($aria) {
 
-  function shouldAttachAttr(attr, normalizedAttr, elem, allowBlacklistEls) {
-    return $aria.config(normalizedAttr) && !elem.attr(attr) && (allowBlacklistEls || !isNodeOneOf(elem, nodeBlackList));
+  function shouldAttachAttr(attr, normalizedAttr, elem) {
+    return $aria.config(normalizedAttr) && !elem.attr(attr);
   }
 
   function shouldAttachRole(role, elem) {
-    // if element does not have role attribute
-    // AND element type is equal to role (if custom element has a type equaling shape) <-- remove?
-    // AND element is not INPUT
     return !elem.attr('role') && (elem.attr('type') === role) && (elem[0].nodeName !== 'INPUT');
   }
 
@@ -231,19 +214,20 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
 
     return ((type || role) === 'checkbox' || role === 'menuitemcheckbox') ? 'checkbox' :
            ((type || role) === 'radio'    || role === 'menuitemradio') ? 'radio' :
-           (type === 'range'              || role === 'progressbar' || role === 'slider') ? 'range' : '';
+           (type === 'range'              || role === 'progressbar' || role === 'slider') ? 'range' :
+           (type || role) === 'textbox'   || elem[0].nodeName === 'TEXTAREA' ? 'multiline' : '';
   }
 
   return {
     restrict: 'A',
-    require: 'ngModel',
+    require: '?ngModel',
     priority: 200, //Make sure watches are fired after any other directives that affect the ngModel value
     compile: function(elem, attr) {
       var shape = getShape(attr, elem);
 
       return {
         pre: function(scope, elem, attr, ngModel) {
-          if (shape === 'checkbox') {
+          if (shape === 'checkbox' && attr.type !== 'checkbox') {
             //Use the input[checkbox] $isEmpty implementation for elements with checkbox roles
             ngModel.$isEmpty = function(value) {
               return value === false;
@@ -251,18 +235,29 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
           }
         },
         post: function(scope, elem, attr, ngModel) {
-          var needsTabIndex = shouldAttachAttr('tabindex', 'tabindex', elem, false);
+          var needsTabIndex = shouldAttachAttr('tabindex', 'tabindex', elem)
+                                && !isNodeOneOf(elem, nodeBlackList);
 
           function ngAriaWatchModelValue() {
             return ngModel.$modelValue;
           }
 
-          function getRadioReaction(newVal) {
-            var boolVal = (attr.value == ngModel.$viewValue);
-            elem.attr('aria-checked', boolVal);
+          function getRadioReaction() {
+            if (needsTabIndex) {
+              needsTabIndex = false;
+              return function ngAriaRadioReaction(newVal) {
+                var boolVal = (attr.value == ngModel.$viewValue);
+                elem.attr('aria-checked', boolVal);
+                elem.attr('tabindex', 0 - !boolVal);
+              };
+            } else {
+              return function ngAriaRadioReaction(newVal) {
+                elem.attr('aria-checked', (attr.value == ngModel.$viewValue));
+              };
+            }
           }
 
-          function getCheckboxReaction() {
+          function ngAriaCheckboxReaction() {
             elem.attr('aria-checked', !ngModel.$isEmpty(ngModel.$viewValue));
           }
 
@@ -272,9 +267,9 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
               if (shouldAttachRole(shape, elem)) {
                 elem.attr('role', shape);
               }
-              if (shouldAttachAttr('aria-checked', 'ariaChecked', elem, false)) {
+              if (shouldAttachAttr('aria-checked', 'ariaChecked', elem)) {
                 scope.$watch(ngAriaWatchModelValue, shape === 'radio' ?
-                    getRadioReaction : getCheckboxReaction);
+                    getRadioReaction() : ngAriaCheckboxReaction);
               }
               if (needsTabIndex) {
                 elem.attr('tabindex', 0);
@@ -311,17 +306,22 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
                 elem.attr('tabindex', 0);
               }
               break;
+            case 'multiline':
+              if (shouldAttachAttr('aria-multiline', 'ariaMultiline', elem)) {
+                elem.attr('aria-multiline', true);
+              }
+              break;
           }
 
-          if (!attr.hasOwnProperty('ngRequired') && ngModel.$validators.required
-            && shouldAttachAttr('aria-required', 'ariaRequired', elem, false)) {
-            // ngModel.$error.required is undefined on custom controls
-            attr.$observe('required', function() {
-              elem.attr('aria-required', !!attr['required']);
+          if (ngModel.$validators.required && shouldAttachAttr('aria-required', 'ariaRequired', elem)) {
+            scope.$watch(function ngAriaRequiredWatch() {
+              return ngModel.$error.required;
+            }, function ngAriaRequiredReaction(newVal) {
+              elem.attr('aria-required', !!newVal);
             });
           }
 
-          if (shouldAttachAttr('aria-invalid', 'ariaInvalid', elem, true)) {
+          if (shouldAttachAttr('aria-invalid', 'ariaInvalid', elem)) {
             scope.$watch(function ngAriaInvalidWatch() {
               return ngModel.$invalid;
             }, function ngAriaInvalidReaction(newVal) {
@@ -334,7 +334,7 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
   };
 }])
 .directive('ngDisabled', ['$aria', function($aria) {
-  return $aria.$$watchExpr('ngDisabled', 'aria-disabled', nodeBlackList, false);
+  return $aria.$$watchExpr('ngDisabled', 'aria-disabled', []);
 }])
 .directive('ngMessages', function() {
   return {

src/ngCookies/cookies.js

@@ -34,17 +34,16 @@ angular.module('ngCookies', ['ng']).
      * The object may have following properties:
      *
      * - **path** - `{string}` - The cookie will be available only for this path and its
-     *   sub-paths. By default, this is the URL that appears in your `<base>` tag.
+     *   sub-paths. By default, this would be the URL that appears in your base tag.
      * - **domain** - `{string}` - The cookie will be available only for this domain and
-     *   its sub-domains. For security reasons the user agent will not accept the cookie
-     *   if the current domain is not a sub-domain of this domain or equal to it.
+     *   its sub-domains. For obvious security reasons the user agent will not accept the
+     *   cookie if the current domain is not a sub domain or equals to the requested domain.
      * - **expires** - `{string|Date}` - String of the form "Wdy, DD Mon YYYY HH:MM:SS GMT"
      *   or a Date object indicating the exact date/time this cookie will expire.
-     * - **secure** - `{boolean}` - If `true`, then the cookie will only be available through a
-     *   secured connection.
+     * - **secure** - `{boolean}` - The cookie will be available only in secured connection.
      *
-     * Note: By default, the address that appears in your `<base>` tag will be used as the path.
-     * This is important so that cookies will be visible for all routes when html5mode is enabled.
+     * Note: by default the address that appears in your `<base>` tag will be used as path.
+     * This is important so that cookies will be visible for all routes in case html5mode is enabled
      *
      **/
     var defaults = this.defaults = {};

src/ngLocale/angular-locale_af-na.js

@@ -119,7 +119,6 @@ $provide.value("$locale", {
     ]
   },
   "id": "af-na",
-  "localeID": "af_NA",
   "pluralCat": function(n, opt_precision) {  if (n == 1) {    return PLURAL_CATEGORY.ONE;  }  return PLURAL_CATEGORY.OTHER;}
 });
 }]);

src/ngLocale/angular-locale_af-za.js

@@ -119,7 +119,6 @@ $provide.value("$locale", {
     ]
   },
   "id": "af-za",
-  "localeID": "af_ZA",
   "pluralCat": function(n, opt_precision) {  if (n == 1) {    return PLURAL_CATEGORY.ONE;  }  return PLURAL_CATEGORY.OTHER;}
 });
 }]);