docs($interval): correcting example code indentation

Bueno! Closes #10372
chore(changelog): add test for addition of trailing newline
2014-12-08 16:29:39 -05:00 · 2014-12-08 13:04:15 -05:00 · 2014-12-08 11:05:49 -05:00 · 2014-12-08 10:50:03 -05:00 · 2014-12-08 09:04:13 +01:00 · 2014-12-06 10:16:28 +01:00
350 changed files with 9652 additions and 5592 deletions
@@ -8,14 +8,16 @@ branches:

 env:
  matrix:
-    - JOB=unit
-    - JOB=e2e TEST_TARGET=jqlite
-    - JOB=e2e TEST_TARGET=jquery
+    - JOB=unit BROWSER_PROVIDER=saucelabs
+    - JOB=e2e TEST_TARGET=jqlite BROWSER_PROVIDER=saucelabs
+    - JOB=e2e TEST_TARGET=jquery BROWSER_PROVIDER=saucelabs
  global:
    - SAUCE_USERNAME=angular-ci
    - SAUCE_ACCESS_KEY=9b988f434ff8-fbca-8aa4-4ae3-35442987
+    - BROWSER_STACK_USERNAME=VojtaJina
+    - BROWSER_STACK_ACCESS_KEY=QCQJ1ZpWXpBkSwEdD8ev
    - LOGS_DIR=/tmp/angular-build/logs
-    - BROWSER_PROVIDER_READY_FILE=/tmp/sauce-connect-ready
+    - BROWSER_PROVIDER_READY_FILE=/tmp/browsersprovider-tunnel-ready

 install:
  # - npm config set registry http://23.251.144.68
@@ -28,7 +30,7 @@ install:

 before_script:
  - mkdir -p $LOGS_DIR
-  - ./lib/sauce/sauce_connect_setup.sh
+  - ./scripts/travis/start_browser_provider.sh
  - npm install -g grunt-cli
  - grunt package
  - ./scripts/travis/wait_for_browser_provider.sh
@@ -1,3 +1,223 @@
+<a name="1.3.5"></a>
+# 1.3.5 cybernetic-mercantilism (2014-12-01)
+
+
+## Bug Fixes
+
+- **$templateRequest:** propagate rejection reason when ignoreRequestError flag is set
+  ([f6458826](https://github.com/angular/angular.js/commit/f6458826ac974914597a10b0ffdeee3c5d2c62ef),
+   [#10266](https://github.com/angular/angular.js/issues/10266))
+- **$httpBackend:** allow canceling request with falsy timeoutId
+  ([719d5c5f](https://github.com/angular/angular.js/commit/719d5c5fa59ae1617691a0dca02da861fcf5f933),
+   [#10177](https://github.com/angular/angular.js/issues/10177))
+- **linky:** encode all double quotes when serializing email addresses
+  ([2ec8d1ff](https://github.com/angular/angular.js/commit/2ec8d1ffc04e06a39cb1b74a8d675da38e0a1c6b),
+   [#10090](https://github.com/angular/angular.js/issues/10090))
+- **ngMock:**
+  - annotate $RootScopeDecorator
+  ([9a83f9d2](https://github.com/angular/angular.js/commit/9a83f9d2fabe0a259c283b7f7cd935e4b36e2b5d),
+   [#10273](https://github.com/angular/angular.js/issues/10273), [#10275](https://github.com/angular/angular.js/issues/10275), [#10277](https://github.com/angular/angular.js/issues/10277))
+  - respond did not always take a statusText argument
+  ([08cd5c19](https://github.com/angular/angular.js/commit/08cd5c19c7a5116e7e74691391fc5e28bfae4521),
+   [#8270](https://github.com/angular/angular.js/issues/8270))
+- **select:**
+  - use strict compare when removing option from ctrl
+  ([9fa73cb4](https://github.com/angular/angular.js/commit/9fa73cb4e7190b4d00b65f2f8f9f7d37607308ba),
+   [#9714](https://github.com/angular/angular.js/issues/9714), [#10115](https://github.com/angular/angular.js/issues/10115), [#10203](https://github.com/angular/angular.js/issues/10203))
+  - fix several issues when moving options between groups
+  ([30694c80](https://github.com/angular/angular.js/commit/30694c802763d46d6787f7298f47dfef53ed4229),
+   [#10166](https://github.com/angular/angular.js/issues/10166))
+
+
+<a name="1.3.4"></a>
+# 1.3.4 highfalutin-petroglyph (2014-11-24)
+
+## Bug Fixes
+
+- **$browser:** allow chaining url() calls in setter mode
+  ([764fa869](https://github.com/angular/angular.js/commit/764fa869dd8809d494924c23f30ddaa4cac84249),
+   [#10157](https://github.com/angular/angular.js/issues/10157))
+- **$http:** return empty headers, ignore properties in Object prototype
+  ([637c020f](https://github.com/angular/angular.js/commit/637c020f828a7ceeaacf83bb1a54ed3092e6c273),
+   [#7779](https://github.com/angular/angular.js/issues/7779), [#10113](https://github.com/angular/angular.js/issues/10113), [#10091](https://github.com/angular/angular.js/issues/10091))
+- **$locale:** Allow currency filter to fall back to maxFrac from locale
+  ([6dbd606a](https://github.com/angular/angular.js/commit/6dbd606ad7b708d5886c0e7ffee20ae8f8719711),
+   [#10179](https://github.com/angular/angular.js/issues/10179))
+- **$location:** allow empty string URLs to reset path, search, and hash
+  ([7812dfce](https://github.com/angular/angular.js/commit/7812dfcee8ab98cbf38261f9948d9541656bf554),
+   [#10063](https://github.com/angular/angular.js/issues/10063), [#10064](https://github.com/angular/angular.js/issues/10064))
+- **$route:** fix redirection with optional/eager params
+  ([891acf4c](https://github.com/angular/angular.js/commit/891acf4c201823fd2c925ee321c70d06737d5944),
+   [#9819](https://github.com/angular/angular.js/issues/9819), [#9827](https://github.com/angular/angular.js/issues/9827))
+- **Angular:** properly get node name for svg element wrapper
+  ([09a98323](https://github.com/angular/angular.js/commit/09a9832358960c98392c9df1a9fd9592f59bc844),
+   [#10078](https://github.com/angular/angular.js/issues/10078), [#10172](https://github.com/angular/angular.js/issues/10172))
+- **NgModelController:** typo $rawModelValue -> $$rawModelValue
+  ([4f4ff5f3](https://github.com/angular/angular.js/commit/4f4ff5f31b82c6f7be409ea4edbad4c2913ac1f1))
+- **input:**
+  - set ngTrueValue on required checkbox
+  ([8692f87a](https://github.com/angular/angular.js/commit/8692f87a4689fa0dd3640f4dcab5c6b6f960489b),
+   [#5164](https://github.com/angular/angular.js/issues/5164))
+  - call $setTouched in blur asynchronously if necessary
+  ([eab27187](https://github.com/angular/angular.js/commit/eab271876cb87c1f5f6c6f29e814fb8fecad87ff),
+   [#8762](https://github.com/angular/angular.js/issues/8762), [#9808](https://github.com/angular/angular.js/issues/9808), [#10014](https://github.com/angular/angular.js/issues/10014))
+- **input[date]:** do not use `$isEmpty` to check the model validity
+  ([40406e2f](https://github.com/angular/angular.js/commit/40406e2f22713efbd37ef3eff408339727cb62d9))
+- **linky:** encode double quotes when serializing email addresses
+  ([8ee8ffeb](https://github.com/angular/angular.js/commit/8ee8ffeba0a5a133fa792745c1019d294ecfcef3),
+   [#8945](https://github.com/angular/angular.js/issues/8945), [#8964](https://github.com/angular/angular.js/issues/8964), [#5946](https://github.com/angular/angular.js/issues/5946), [#10090](https://github.com/angular/angular.js/issues/10090), [#9256](https://github.com/angular/angular.js/issues/9256))
+- **ngMaxlength:** ignore maxlength when not set to a non-negative integer
+  ([92f87b11](https://github.com/angular/angular.js/commit/92f87b114242b01876e1dc5c6fddd061352ecb2c),
+   [#9874](https://github.com/angular/angular.js/issues/9874))
+- **ngModel:** don't run parsers when executing $validate
+  ([e3764e30](https://github.com/angular/angular.js/commit/e3764e30a301ec6136c8e6b5493d39feb3cd1ecc))
+- **ngModelOptions:** preserve context of getter/setters
+  ([bb4d3b73](https://github.com/angular/angular.js/commit/bb4d3b73a1ccf3dee55b0c25baf031bae5cbb676),
+   [#9394](https://github.com/angular/angular.js/issues/9394), [#9865](https://github.com/angular/angular.js/issues/9865))
+
+
+## Features
+
+- **ngMaxlength:** add support for disabling max length limit
+  ([5c1fdff6](https://github.com/angular/angular.js/commit/5c1fdff691b9367d73f72f6a0298cb6a6e259f35),
+   [#9995](https://github.com/angular/angular.js/issues/9995))
+- **ngModelController:** add $setDirty method
+  ([e8941c0f](https://github.com/angular/angular.js/commit/e8941c0fe5217d2e705bad8253dc0162aff4c709),
+   [#10038](https://github.com/angular/angular.js/issues/10038), [#10049](https://github.com/angular/angular.js/issues/10049))
+- **ngPluralize:** add support for `count` to be a one-time expression
+  ([2b41a586](https://github.com/angular/angular.js/commit/2b41a5868aee79e3872ad92db66e30959207d98e),
+   [#10004](https://github.com/angular/angular.js/issues/10004))
+
+
+## Performance Improvements
+
+- use Object.create instead of creating temporary constructors
+  ([bf6a79c3](https://github.com/angular/angular.js/commit/bf6a79c3484f474c300b5442ae73483030ef5782),
+   [#10058](https://github.com/angular/angular.js/issues/10058))
+
+
+## Breaking Changes
+
+- **ngModelOptions:** due to [bb4d3b73](https://github.com/angular/angular.js/commit/bb4d3b73a1ccf3dee55b0c25baf031bae5cbb676),
+  previously, ngModel invoked getter/setters in the global context.
+
+For example:
+
+```js
+<input ng-model="model.value" ng-model-options="{ getterSetter: true }">
+```
+
+would previously invoke `model.value()` in the global context.
+
+Now, ngModel invokes `value` with `model` as the context.
+
+It's unlikely that real apps relied on this behavior. If they did they can use `.bind` to explicilty
+bind a getter/getter to the global context, or just reference globals normally without `this`.
+
+
+<a name="1.2.27"></a>
+# 1.2.27 prime-factorization (2014-11-20)
+
+
+## Bug Fixes
+
+- **$animate:** clear the GCS cache even when no animation is detected
+  ([f619d032](https://github.com/angular/angular.js/commit/f619d032c932752313c646b5295bad8a68ef3871),
+   [#8813](https://github.com/angular/angular.js/issues/8813))
+- **$browser:**
+  - Cache `location.href` only during page reload phase
+  ([434d7a09](https://github.com/angular/angular.js/commit/434d7a09039151c1e627ac156213905d06b7df10),
+   [#9235](https://github.com/angular/angular.js/issues/9235), [#9470](https://github.com/angular/angular.js/issues/9470))
+  - don’t use history api when only the hash changes
+  ([a6e6438d](https://github.com/angular/angular.js/commit/a6e6438dae1ed92b29608d0b8830b0a7fbb624ef),
+   [#9423](https://github.com/angular/angular.js/issues/9423), [#9424](https://github.com/angular/angular.js/issues/9424))
+  - handle async href on url change in <=IE9
+  ([fe7d9ded](https://github.com/angular/angular.js/commit/fe7d9dedaa5ec3b3f56d9eb9c513cf99e40121ce),
+   [#9235](https://github.com/angular/angular.js/issues/9235))
+- **$http:** add missing shortcut methods and missing docs
+  ([ec4fe1bc](https://github.com/angular/angular.js/commit/ec4fe1bcab6f981103a10f860a3a00122aa78607),
+   [#9180](https://github.com/angular/angular.js/issues/9180), [#9321](https://github.com/angular/angular.js/issues/9321))
+- **$location:**
+  - revert erroneous logic and backport refactorings from master
+  ([1ee9b4ef](https://github.com/angular/angular.js/commit/1ee9b4ef5e4a795061d3aa19adefdeb7e0209eeb),
+   [#8492](https://github.com/angular/angular.js/issues/8492))
+  - allow 0 in path() and hash()
+  ([f807d7ab](https://github.com/angular/angular.js/commit/f807d7ab4ebd18899154528ea9ed50d5bc25c57a))
+- **$parse:** add quick check for Function constructor in fast path
+  ([756640f5](https://github.com/angular/angular.js/commit/756640f5aa8f3fd0084bff50534e23976a6fff00))
+- **$parse, events:** prevent accidental misuse of properties on $event
+  ([4d0614fd](https://github.com/angular/angular.js/commit/4d0614fd0da12c5783dfb4956c330edac87e62fe),
+   [#9969](https://github.com/angular/angular.js/issues/9969))
+- **ngMock:** $httpBackend should match data containing Date objects correctly
+  ([1426b029](https://github.com/angular/angular.js/commit/1426b02980badfd322eb960d71bfb1a14d657847),
+   [#5127](https://github.com/angular/angular.js/issues/5127))
+- **orderBy:** sort by identity if no predicate is given
+  ([45b896a1](https://github.com/angular/angular.js/commit/45b896a16abbcbfcdfb9a95c2d10c76a805b57cc),
+   [#5847](https://github.com/angular/angular.js/issues/5847), [#4579](https://github.com/angular/angular.js/issues/4579), [#9403](https://github.com/angular/angular.js/issues/9403))
+- **select:** ensure the label attribute is updated in Internet Explorer
+  ([16833d0f](https://github.com/angular/angular.js/commit/16833d0fb6585117e9978d1accc3ade83e22e797),
+   [#9621](https://github.com/angular/angular.js/issues/9621), [#10042](https://github.com/angular/angular.js/issues/10042))
+
+
+## Performance Improvements
+
+- **orderBy:** copy array with slice instead of for loop
+  ([409bcb38](https://github.com/angular/angular.js/commit/409bcb3810a1622178268f7ff7f4130887a1a3dc),
+   [#9942](https://github.com/angular/angular.js/issues/9942))
+
+
+<a name="1.3.3"></a>
+# 1.3.3 undersea-arithmetic (2014-11-17)
+
+
+## Bug Fixes
+
+- **$http:** don't parse single space responses as JSON
+  ([6f19a6fd](https://github.com/angular/angular.js/commit/6f19a6fd33ab72d3908e3418fba47ee8e1598fa6),
+   [#9907](https://github.com/angular/angular.js/issues/9907))
+- **minErr:** stringify non-JSON compatible objects in error messages
+  ([cf43ccdf](https://github.com/angular/angular.js/commit/cf43ccdf9b8665a2fd5d6aa52f80cb2d7c9bb7e2),
+   [#10085](https://github.com/angular/angular.js/issues/10085))
+- **$rootScope:** handle cyclic references in scopes when creating error messages
+  ([e80053d9](https://github.com/angular/angular.js/commit/e80053d91fd7c722e092a23d326384de2e552eb6),
+   [#10085](https://github.com/angular/angular.js/issues/10085))
+- **ngRepeat:** support cyclic object references in error messages
+  ([fa12c3c8](https://github.com/angular/angular.js/commit/fa12c3c86af7965d1b9d9a5dd3434755e9e04635),
+   [#9838](https://github.com/angular/angular.js/issues/9838), [#10065](https://github.com/angular/angular.js/issues/10065), [#10085](https://github.com/angular/angular.js/issues/10085))
+- **ngMock:** call $interval callbacks even when invokeApply is false
+  ([d81ff888](https://github.com/angular/angular.js/commit/d81ff8885b77f70c6417d7be3124d86d07447375),
+   [#10032](https://github.com/angular/angular.js/issues/10032))
+- **ngPattern:** match behaviour of native HTML pattern attribute
+  ([85eb9660](https://github.com/angular/angular.js/commit/85eb9660ef67c24d5104a6a1921bedad0bd1b57e),
+   [#9881](https://github.com/angular/angular.js/issues/9881), [#9888](https://github.com/angular/angular.js/issues/9888))
+- **select:** ensure the label attribute is updated in Internet Explorer
+  ([6604c236](https://github.com/angular/angular.js/commit/6604c2361427fba8c43a39dc2e92197390dfbdbe),
+   [#9621](https://github.com/angular/angular.js/issues/9621), [#10042](https://github.com/angular/angular.js/issues/10042))
+
+
+## Features
+
+- **$location:** allow to location to be changed during $locationChangeStart
+  ([a9352c19](https://github.com/angular/angular.js/commit/a9352c19ce33f0393d6581547c7ea8dfc2a8b78f),
+   [#9607](https://github.com/angular/angular.js/issues/9607), [#9678](https://github.com/angular/angular.js/issues/9678))
+- **$routeProvider:** allow setting caseInsensitiveMatch on the provider
+  ([0db573b7](https://github.com/angular/angular.js/commit/0db573b7493f76abd94ff65ce660017d617e865b),
+   [#6477](https://github.com/angular/angular.js/issues/6477), [#9873](https://github.com/angular/angular.js/issues/9873))
+
+
+## Performance Improvements
+
+- **orderBy:** copy array with slice instead of for loop
+  ([8eabc546](https://github.com/angular/angular.js/commit/8eabc5463c795d87f37e5a9eacbbb14435024061),
+   [#9942](https://github.com/angular/angular.js/issues/9942))
+
+## Breaking Changes
+
+- **$parse:** due to [fbad2805](https://github.com/angular/angular.js/commit/fbad2805703569058a4a860747b0e2d8aee36bdf),
+    you can't use characters that have special meaning in AngularJS expressions (ex.: `.` or `-`)
+    as part of filter's name. Before this commit custom filters could contain special characters
+    (like a dot) in their name but this wasn't intentional.
+
 <a name="1.3.2"></a>
 # 1.3.2 cardiovasculatory-magnification (2014-11-07)

@@ -2578,6 +2798,16 @@ jQuery. We don't expect that app code actually depends on this accidental featur

 ## Breaking Changes

+- **$compile:** due to [2ee29c5d](https://github.com/angular/angular.js/commit/2ee29c5da81ffacdc1cabb438f5d125d5e116cb9),
+
+The isolated scope of a component directive no longer leaks into the template
+that contains the instance of the directive.  This means that you can no longer
+access the isolated scope from attributes on the element where the isolated
+directive is defined.
+
+See https://github.com/angular/angular.js/issues/10236 for an example.
+
+
 - **$resource:** due to [d3c50c84](https://github.com/angular/angular.js/commit/d3c50c845671f0f8bcc3f7842df9e2fb1d1b1c40),

  If you expected `$resource` to strip these types of properties before,
@@ -127,7 +127,7 @@ Before you submit your pull request consider the following guidelines:

    ```shell
    git rebase master -i
-    git push -f
+    git push origin my-fix-branch -f
    ```

 That's it! Thank you for your contribution!
@@ -30,14 +30,6 @@ module.exports = function(grunt) {
        benchmarksPath: 'benchmarks'
      }
    },
-    parallel: {
-      travis: {
-        tasks: [
-          util.parallelTask(['test:unit', 'test:promises-aplus', 'tests:docs'], {stream: true}),
-          util.parallelTask(['test:e2e'])
-        ]
-      }
-    },

    connect: {
      devserver: {
@@ -202,6 +202,7 @@ var generate = function(version, file) {

 // publish for testing
 exports.parseRawCommit = parseRawCommit;
+exports.printSection = printSection;

 // hacky start if not run by jasmine :-D
 if (process.argv.join('').indexOf('jasmine-node') === -1) {
@@ -1,4 +1,4 @@
-/* global describe: false, it: false, expect: false */
+/* global describe: false, beforeEach: false, afterEach: false, it: false, expect: false */

 'use strict';

@@ -44,4 +44,65 @@ describe('changelog.js', function() {
      expect(msg.breaking).toEqual(' first breaking change\nsomething else\nanother line with more info\n');
    });
  });
+
+  describe('printSection', function() {
+    var output;
+    var streamMock = {
+      write: function(str) {
+        output += str;
+      }
+    };
+
+    beforeEach(function() {
+      output = '';
+    });
+
+    it('should add a new line at the end of each breaking change list item ' +
+       'when there is 1 item per component', function() {
+      var title = 'test';
+      var printCommitLinks = false;
+
+      var section = {
+        module1: [{subject: 'breaking change 1'}],
+        module2: [{subject: 'breaking change 2'}]
+      };
+      var expectedOutput =
+          '\n' + '## test\n\n' +
+          '- **module1:** breaking change 1\n' +
+          '- **module2:** breaking change 2\n' +
+          '\n';
+
+      ch.printSection(streamMock, title, section, printCommitLinks);
+      expect(output).toBe(expectedOutput);
+    });
+
+    it('should add a new line at the end of each breaking change list item ' +
+       'when there are multiple items per component', function() {
+      var title = 'test';
+      var printCommitLinks = false;
+
+      var section = {
+        module1: [
+          {subject: 'breaking change 1.1'},
+          {subject: 'breaking change 1.2'}
+        ],
+        module2: [
+          {subject: 'breaking change 2.1'},
+          {subject: 'breaking change 2.2'}
+        ]
+      };
+      var expectedOutput =
+          '\n' + '## test\n\n' +
+          '- **module1:**\n' +
+          '  - breaking change 1.1\n' +
+          '  - breaking change 1.2\n' +
+          '- **module2:**\n' +
+          '  - breaking change 2.1\n' +
+          '  - breaking change 2.2\n' +
+          '\n';
+
+      ch.printSection(streamMock, title, section, printCommitLinks);
+      expect(output).toBe(expectedOutput);
+    });
+  });
 });
@@ -1,7 +1,10 @@
+"use strict";
+
 angular.module('versions', [])

 .controller('DocsVersionsCtrl', ['$scope', '$location', '$window', 'NG_VERSIONS', function($scope, $location, $window, NG_VERSIONS) {
  $scope.docs_version  = NG_VERSIONS[0];
+  $scope.docs_versions = NG_VERSIONS;

  for(var i=0, minor = NaN; i < NG_VERSIONS.length; i++) {
    var version = NG_VERSIONS[i];
@@ -13,9 +16,8 @@ angular.module('versions', [])
    minor = version.minor;
  }

-  $scope.docs_versions = NG_VERSIONS;
  $scope.getGroupName = function(v) {
-    return v.isLatest ? 'Latest' : (v.isStable ? 'Stable' : 'Unstable');
+    return v.isLatest ? 'Latest' : ('v' + v.major + '.' + v.minor + '.x');
  };

  $scope.jumpToDocsVersion = function(version) {
@@ -0,0 +1,10 @@
+@ngdoc error
+@name $http:badreq
+@fullName Bad Request Configuration
+@description
+
+This error occurs when the request configuration parameter passed to the {@link ng.$http `$http`} service is not an object.  `$http` expects a single parameter, the request configuration object, but received a parameter that was not an object.  The error message should provide additional context such as the actual value of the parameter that was received.  If you passed a string parameter, perhaps you meant to call one of the shorthand methods on `$http` such as `$http.get(…)`, etc.
+
+To resolve this error, make sure you pass a valid request configuration object to `$http`.
+
+For more information, see the {@link ng.$http `$http`} service API documentation.
@@ -1,17 +0,0 @@
-@ngdoc error
-@name $location:ihshprfx
-@fullName Missing Hash Prefix
-@description
-
-This error occurs when {@link ng.$location $location} service is configured to use a hash prefix but this prefix was not present in a url that the `$location` service was asked to parse.
-
-For example if you configure `$location` service with prefix `'!'`:
-```
-myApp.config(function($locationProvider) {
-  $locationProvider.prefix('!');
-});
-```
-
-If you enter the app at url `http:/myapp.com/#/myView` this error will be throw.
-
-The correct url for this configuration is `http:/myapp.com/#!/myView` (note the `'!'` after `'#'` symbol).
@@ -344,7 +344,7 @@ to anchors on the same page without needing to know on which page the user curre
 Using this mode requires URL rewriting on server side, basically you have to rewrite all your links
 to entry point of your application (e.g. index.html). Requiring a `<base>` tag is also important for
 this case, as it allows Angular to differentiate between the part of the url that is the application
-base and the path that should be handeled by the application.
+base and the path that should be handled by the application.

 ### Sending links among different browsers

@@ -31,12 +31,12 @@ added it as a dependency, you can test a few things:
 ##Supported directives
 Currently, ngAria interfaces with the following directives:

- * <a href="#ngmodel">ngModel</a>
- * <a href="#ngdisabled">ngDisabled</a>
- * <a href="#ngshow">ngShow</a>
- * <a href="#nghide">ngHide</a>
- * <a href="#ngclick-and-ngdblclick">ngClick</a>
- * <a href="#ngclick-and-ngdblclick">ngDblClick</a>
+ * {@link guide/accessibility#ngmodel ngModel}
+ * {@link guide/accessibility#ngdisabled ngDisabled}
+ * {@link guide/accessibility#ngshow ngShow}
+ * {@link guide/accessibility#nghide ngHide}
+ * {@link guide/accessibility#ngclick ngClick}
+ * {@link guide/accessibility#ngdblclick ngDblClick}

 <h2 id="ngmodel">ngModel</h2>

@@ -206,9 +206,9 @@ shown or hidden by removing or adding the `.ng-hide` CSS class onto the element.

 The default CSS for `ngHide`, the inverse method to `ngShow`, makes ngAria redundant. It toggles
 `aria-hidden` on the directive when it is hidden or shown, but the content is already hidden with
-`display: none`. See explanation for <a href="#ngshow">ngShow</a> when overriding the default CSS.
+`display: none`. See explanation for {@link guide/accessibility#ngshow ngShow} when overriding the default CSS.

-<h2 id="ngclick-and-ngdblclick">ngClick and ngDblclick</h2>
+<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` if it isn't there already.
 Even with this, you must currently still add `ng-keypress` to non-interactive elements such as `div`
 or `taco-button` to enable keyboard access. Conversation is currently ongoing about whether ngAria
@@ -326,7 +326,7 @@ describe('state', function() {
        expect(childScope.timeOfDay).toBe('morning');
        expect(childScope.name).toBe('Mattie');
        expect(grandChildScope.timeOfDay).toBe('evening');
-        expect(grandChildScope.name).toBe('Gingerbreak Baby');
+        expect(grandChildScope.name).toBe('Gingerbread Baby');
    });
 });
 ```
@@ -13,21 +13,26 @@ Angular sets these CSS classes. It is up to your application to provide useful s
    is defined. (see {@link guide/scope scope} guide for more information about scopes)

 * `ng-isolate-scope`
-  - **Usage:** angular applies this class to any element for which a new 
-    {@link guide/directive#isolating-the-scope-of-a-directive isolate scope} is defined. 
+  - **Usage:** angular applies this class to any element for which a new
+    {@link guide/directive#isolating-the-scope-of-a-directive isolate scope} is defined.

 * `ng-binding`
  - **Usage:** angular applies this class to any element that is attached to a data binding, via `ng-bind` or
    `{{}}` curly braces, for example. (see {@link guide/databinding databinding} guide)

 * `ng-invalid`, `ng-valid`
-  - **Usage:** angular applies this class to an input widget element if that element's input does
+  - **Usage:** angular applies this class to a form control widget element if that element's input does
    not pass validation. (see {@link ng.directive:input input} directive)

 * `ng-pristine`, `ng-dirty`
-  - **Usage:** angular {@link ng.directive:input input} directive applies `ng-pristine` class
-    to a new input widget element which did not have user interaction. Once the user interacts with
-    the input widget the class is changed to `ng-dirty`.
+  - **Usage:** angular {@link ng.directive:ngModel ngModel} directive applies `ng-pristine` class
+    to a new form control widget which did not have user interaction. Once the user interacts with
+    the form control, the class is changed to `ng-dirty`.
+
+* `ng-touched`, `ng-untouched`
+  - **Usage:** angular {@link ng.directive:ngModel ngModel} directive applies `ng-untouched` class
+    to a new form control widget which has not been blurred. Once the user blurs the form control,
+    the class is changed to `ng-touched`.


 ## Related Topics
@@ -91,6 +91,11 @@ The filter function should be a [pure function](http://en.wikipedia.org/wiki/Pur
 means that it should be stateless and idempotent. Angular relies on these properties and executes
 the filter only when the inputs to the function change.

+<div class="alert alert-warning">
+**Note:** filter names must be valid angular expression identifiers, such as `uppercase` or `orderBy`.
+Names with special characters, such as hyphens and dots, are not allowed.
+</div>
+
 The following sample filter reverses a text string. In addition, it conditionally makes the
 text upper-case.

@@ -27,8 +27,8 @@ for other directives to augment its behavior.
        E-mail: <input type="email" ng-model="user.email" /><br />
        Gender: <input type="radio" ng-model="user.gender" value="male" />male
        <input type="radio" ng-model="user.gender" value="female" />female<br />
-        <button ng-click="reset()">RESET</button>
-        <button ng-click="update(user)">SAVE</button>
+        <input type="button" ng-click="reset()" value="Reset" />
+        <input type="submit" ng-click="update(user)" value="Save" />
      </form>
      <pre>form = {{user | json}}</pre>
      <pre>master = {{master | json}}</pre>
@@ -77,29 +77,29 @@ To allow styling of form as well as controls, `ngModel`  adds these CSS classes:

 The following example uses the CSS to display validity of each form control.
 In the example both `user.name` and `user.email` are required, but are rendered
-with red background only when they are dirty. This ensures that the user is not distracted
-with an error until after interacting with the control, and failing to satisfy its validity.
+with red background only after the input is blurred (loses focus).
+This ensures that the user is not distracted with an error until after interacting with the control,
+and failing to satisfy its validity.

 <example module="formExample">
  <file name="index.html">
    <div ng-controller="ExampleController">
      <form novalidate class="css-form">
-        Name:
-          <input type="text" ng-model="user.name" required /><br />
+        Name: <input type="text" ng-model="user.name" required /><br />
        E-mail: <input type="email" ng-model="user.email" required /><br />
        Gender: <input type="radio" ng-model="user.gender" value="male" />male
        <input type="radio" ng-model="user.gender" value="female" />female<br />
-        <button ng-click="reset()">RESET</button>
-        <button ng-click="update(user)">SAVE</button>
+        <input type="button" ng-click="reset()" value="Reset" />
+        <input type="submit" ng-click="update(user)" value="Save" />
      </form>
    </div>

    <style type="text/css">
-      .css-form input.ng-invalid.ng-dirty {
+      .css-form input.ng-invalid.ng-touched {
        background-color: #FA787E;
      }

-      .css-form input.ng-valid.ng-dirty {
+      .css-form input.ng-valid.ng-touched {
        background-color: #78FA89;
      }
    </style>
@@ -140,34 +140,45 @@ the view using the standard binding primitives.

 This allows us to extend the above example with these features:

- RESET button is enabled only if form has some changes
- SAVE button is enabled only if form has some changes and is valid
- custom error messages for `user.email` and `user.agree`
+- Custom error message displayed after the user interacted with a control (i.e. when `$touched` is set)
+- Custom error message displayed upon submitting the form (`$submitted` is set), even if the user
+didn't interact with a control
+

 <example module="formExample">
  <file name="index.html">
    <div ng-controller="ExampleController">
      <form name="form" class="css-form" novalidate>
        Name:
-          <input type="text" ng-model="user.name" name="uName" required /><br />
+        <input type="text" ng-model="user.name" name="uName" required="" />
+        <br />
+        <div ng-show="form.$submitted || form.uName.$touched">
+          <div ng-show="form.uName.$error.required">Tell us your name.</div>
+        </div>
+
        E-mail:
-          <input type="email" ng-model="user.email" name="uEmail" required/><br />
-        <div ng-show="form.uEmail.$dirty && form.uEmail.$invalid">Invalid:
+        <input type="email" ng-model="user.email" name="uEmail" required="" />
+        <br />
+        <div ng-show="form.$submitted || form.uEmail.$touched">
          <span ng-show="form.uEmail.$error.required">Tell us your email.</span>
          <span ng-show="form.uEmail.$error.email">This is not a valid email.</span>
        </div>

-        Gender: <input type="radio" ng-model="user.gender" value="male" />male
-        <input type="radio" ng-model="user.gender" value="female" />female<br />
+        Gender:
+        <input type="radio" ng-model="user.gender" value="male" />male
+        <input type="radio" ng-model="user.gender" value="female" />female
+        <br />
+        <input type="checkbox" ng-model="user.agree" name="userAgree" required="" />

-        <input type="checkbox" ng-model="user.agree" name="userAgree" required />
-        I agree: <input ng-show="user.agree" type="text" ng-model="user.agreeSign"
-                  required /><br />
-        <div ng-show="!user.agree || !user.agreeSign">Please agree and sign.</div>
+        I agree:
+        <input ng-show="user.agree" type="text" ng-model="user.agreeSign" required="" />
+        <br />
+        <div ng-show="form.$submitted || form.userAgree.$touched">
+          <div ng-show="!user.agree || !user.agreeSign">Please agree and sign.</div>
+        </div>

-        <button ng-click="reset()" ng-disabled="isUnchanged(user)">RESET</button>
-        <button ng-click="update(user)"
-                ng-disabled="form.$invalid || isUnchanged(user)">SAVE</button>
+        <input type="button" ng-click="reset(form)" value="Reset" />
+        <input type="submit" ng-click="update(user)" value="Save" />
      </form>
    </div>
  </file>
@@ -181,14 +192,14 @@ This allows us to extend the above example with these features:
          $scope.master = angular.copy(user);
        };

-        $scope.reset = function() {
+        $scope.reset = function(form) {
+          if (form) {
+            form.$setPristine();
+            form.$setUntouched();
+          }
          $scope.user = angular.copy($scope.master);
        };

-        $scope.isUnchanged = function(user) {
-          return angular.equals(user, $scope.master);
-        };
-
        $scope.reset();
      }]);
  </file>
@@ -6,7 +6,7 @@
 # Internet Explorer Compatibility

 <div class="alert alert-warning">
-**Note:** AngularJS 1.3 is dropping support for IE8. Read more about it on
+**Note:** AngularJS 1.3 has dropped support for IE8. Read more about it on
 [our blog](http://blog.angularjs.org/2013/12/angularjs-13-new-release-approaches.html).
 AngularJS 1.2 will continue to support IE8, but the core team does not plan to spend time
 addressing issues specific to IE8 or earlier.
@@ -14,7 +14,7 @@ addressing issues specific to IE8 or earlier.

 This document describes the Internet Explorer (IE) idiosyncrasies when dealing with custom HTML
 attributes and tags. Read this document if you are planning on deploying your Angular application
-on IE8 or earlier.
+on IE.

 The project currently supports and will attempt to fix bugs for IE9 and above. The continuous
 integration server runs all the tests against IE9, IE10, and IE11. See
@@ -25,186 +25,7 @@ We do not run tests on IE8 and below. A subset of the AngularJS functionality ma
 browsers, but it is up to you to test and decide whether it works for your particular app.


-## Short Version
-
-To make your Angular application work on IE please make sure that:
-
-  1. You polyfill JSON.stringify for IE7 and below. You can use
-     [JSON2](https://github.com/douglascrockford/JSON-js) or
-     [JSON3](http://bestiejs.github.com/json3/) polyfills for this.
-
-     ```html
-       <!doctype html>
-       <html xmlns:ng="http://angularjs.org">
-         <head>
-           <!--[if lte IE 7]>
-             <script src="/path/to/json2.js"></script>
-           <![endif]-->
-         </head>
-         <body>
-           ...
-         </body>
-       </html>
-     ```
-
-  2. add `id="ng-app"` to the root element in conjunction with `ng-app` attribute
-
-     ```html
-       <!doctype html>
-       <html xmlns:ng="http://angularjs.org" id="ng-app" ng-app="optionalModuleName">
-         ...
-       </html>
-     ```
-
-  3. you **do not** use custom element tags such as `<ng:view>` (use the attribute version
-     `<div ng-view>` instead), or
-
-  4. if you **do use** custom element tags, then you must take these steps to make IE 8 and below happy:
-
-     ```html
-       <!doctype html>
-       <html xmlns:ng="http://angularjs.org" id="ng-app" ng-app="optionalModuleName">
-         <head>
-           <!--[if lte IE 8]>
-             <script>
-               document.createElement('ng-include');
-               document.createElement('ng-pluralize');
-               document.createElement('ng-view');
-
-               // Optionally these for CSS
-               document.createElement('ng:include');
-               document.createElement('ng:pluralize');
-               document.createElement('ng:view');
-             </script>
-           <![endif]-->
-         </head>
-         <body>
-           ...
-         </body>
-       </html>
-     ```
-  5. Use `ng-style` tags instead of `style="{{ someCss }}"`. The later works in Chrome and Firefox
-     but does not work in Internet Explorer <= 11 (the most recent version at time of writing).
-
-
-The **important** parts are:
-
-  * `xmlns:ng` - *namespace* - you need one namespace for each custom tag you are planning on
-    using.
-
-  * `document.createElement(yourTagName)` - *creation of custom tag names* - Since this is an
-    issue only for older version of IE you need to load it conditionally. For each tag which does
-    not have namespace and which is not defined in HTML you need to pre-declare it to make IE
-    happy.
-
-
-## Long Version
-
-IE has issues with element tag names which are not standard HTML tag names. These fall into two
-categories, and each category has its own fix.
-
-  * If the tag name starts with `my:` prefix then it is considered an XML namespace and must
-    have corresponding namespace declaration on `<html xmlns:my="ignored">`
-
-  * If the tag has no `:` but it is not a standard HTML tag, then it must be pre-created using
-    `document.createElement('my-tag')`
-
-  * If you are planning on styling the custom tag with CSS selectors, then it must be
-    pre-created using `document.createElement('my-tag')` regardless of XML namespace.
-
-
-## The Good News
-
-The good news is that these restrictions only apply to element tag names, and not to element
-attribute names. So this requires no special handling in IE: `<div my-tag your:tag></div>`.
-
-
-## What happens if I fail to do this?
-
-Suppose you have HTML with unknown tag `mytag` (this could also be `my:tag` or `my-tag` with same
-result):
-
-```html
-  <html>
-    <body>
-      <mytag>some text</mytag>
-    </body>
-  </html>
-```
-
-It should parse into the following DOM:
-
-```
-#document
-  +- HTML
-     +- BODY
-        +- mytag
-           +- #text: some text
-```
-
-The expected behavior is that the `BODY` element has a child element `mytag`, which in turn has
-the text `some text`.
-
-But this is not what IE does (if the above fixes are not included):
-
-```
-#document
-  +- HTML
-     +- BODY
-        +- mytag
-        +- #text: some text
-        +- /mytag
-```
-
-In IE, the behavior is that the `BODY` element has three children:
-
-  1. A self closing `mytag`. Example of self closing tag is `<br/>`. The trailing `/` is optional,
-  but the `<br>` tag is not allowed to have any children, and browsers consider `<br>some
-  text</br>` as three siblings not a `<br>` with `some text` as child.
-
-  2. A text node with `some text`. This should have been a child of `mytag` above, not a sibling.
-
-  3. A corrupt self closing `/mytag`. This is corrupt since element names are not allowed to have
-  the `/` character. Furthermore this closing element should not be part of the DOM since it is
-  only used to delineate the structure of the DOM.
-
-
-## CSS Styling of Custom Tag Names
-
-To make CSS selectors work with custom elements, the custom element name must be pre-created with
-`document.createElement('my-tag')` regardless of XML namespace.
-
-```html
-  <html xmlns:ng="needed for ng: namespace">
-    <head>
-      <!--[if lte IE 8]>
-        <script>
-          // needed to make ng-include parse properly
-          document.createElement('ng-include');
-
-          // needed to enable CSS reference
-          document.createElement('ng:view');
-        </script>
-      <![endif]-->
-      <style>
-        ng\:view {
-          display: block;
-          border: 1px solid red;
-        }
-
-        ng-include {
-          display: block;
-          border: 1px solid blue;
-        }
-      </style>
-    </head>
-    <body>
-      <ng:view></ng:view>
-      <ng-include></ng-include>
-      ...
-    </body>
-  </html>
-```
-
-
+To ensure your Angular application works on IE please consider:

+1. Use `ng-style` tags instead of `style="{{ someCss }}"`. The latter works in Chrome and Firefox
+   but does not work in Internet Explorer <= 11 (the most recent version at time of writing).
@@ -15,28 +15,68 @@ which drives many of these changes.

 # Migrating from 1.2 to 1.3

- **$parse:**
-  - due to [77ada4c8](https://github.com/angular/angular.js/commit/77ada4c82d6b8fc6d977c26f3cdb48c2f5fbe5a5),
+## Angular Expression Parsing (`$parse` + `$interpolate`)
+
+- due to [77ada4c8](https://github.com/angular/angular.js/commit/77ada4c82d6b8fc6d977c26f3cdb48c2f5fbe5a5),

 You can no longer invoke .bind, .call or .apply on a function in angular expressions.
 This is to disallow changing the behaviour of existing functions
 in an unforseen fashion.
+
  - due to [6081f207](https://github.com/angular/angular.js/commit/6081f20769e64a800ee8075c168412b21f026d99),

 The (deprecated) __proto__ property does not work inside angular expressions
 anymore.
-  - due to [48fa3aad](https://github.com/angular/angular.js/commit/48fa3aadd546036c7e69f71046f659ab1de244c6),
+
+
+- due to [48fa3aad](https://github.com/angular/angular.js/commit/48fa3aadd546036c7e69f71046f659ab1de244c6),

 This prevents the use of __{define,lookup}{Getter,Setter}__ inside angular
 expressions. If you really need them for some reason, please wrap/bind them to make them
 less dangerous, then make them available through the scope object.
-  - due to [528be29d](https://github.com/angular/angular.js/commit/528be29d1662122a34e204dd607e1c0bd9c16bbc),
+
+
+- due to [528be29d](https://github.com/angular/angular.js/commit/528be29d1662122a34e204dd607e1c0bd9c16bbc),

 This prevents the use of `Object` inside angular expressions.
 If you need Object.keys, make it accessible in the scope.
- **Angular.copy:** due to [b59b04f9](https://github.com/angular/angular.js/commit/b59b04f98a0b59eead53f6a53391ce1bbcbe9b57),


+- due to [bdfc9c02](https://github.com/angular/angular.js/commit/bdfc9c02d021e08babfbc966a007c71b4946d69d),
+  values 'f', '0', 'false', 'no', 'n', '[]' are no longer
+treated as falsy. Only JavaScript falsy values are now treated as falsy by the
+expression parser; there are six of them: false, null, undefined, NaN, 0 and "".
+
+
+- due to [fa6e411d](https://github.com/angular/angular.js/commit/fa6e411da26824a5bae55f37ce7dbb859653276d),
+  promise unwrapping has been removed. It has been deprecated since 1.2.0-rc.3.
+  It can no longer be turned on.
+  Two methods have been removed:
+  * `$parseProvider.unwrapPromises`
+  * `$parseProvider.logPromiseWarnings`
+
+
+- **$interpolate:** due to [88c2193c](https://github.com/angular/angular.js/commit/88c2193c71954b9e7e7e4bdf636a2b168d36300d),
+  the function returned by `$interpolate`
+  no longer has a `.parts` array set on it.
+
+  Instead it has two arrays:
+  * `.expressions`, an array of the expressions in the
+    interpolated text. The expressions are parsed with
+    `$parse`, with an extra layer converting them to strings
+    when computed
+  * `.separators`, an array of strings representing the
+    separations between interpolations in the text.
+    This array is **always** 1 item longer than the
+    `.expressions` array for easy merging with it
+
+
+
+
+## Miscellaneous Angular helpers
+
+- **Angular.copy:** due to [b59b04f9](https://github.com/angular/angular.js/commit/b59b04f98a0b59eead53f6a53391ce1bbcbe9b57),
+
 This changes `angular.copy` so that it applies the prototype of the original
 object to the copied object.  Previously, `angular.copy` would copy properties
 of the original object's prototype chain directly onto the copied object.
@@ -53,17 +93,54 @@ not filter them with `hasOwnProperty`.
 **Be aware that this change also uses a feature that is not compatible with
 IE8.**  If you need this to work on IE8 then you would need to provide a polyfill
 for `Object.create` and `Object.getPrototypeOf`.
- **core:** due to [bdfc9c02](https://github.com/angular/angular.js/commit/bdfc9c02d021e08babfbc966a007c71b4946d69d),
-  values 'f', '0', 'false', 'no', 'n', '[]' are no longer
-treated as falsy. Only JavaScript falsy values are now treated as falsy by the
-expression parser; there are six of them: false, null, undefined, NaN, 0 and "".
-
-Closes #3969
-Closes #4277
-Closes #7960


- **$compile:** due to [2cde927e](https://github.com/angular/angular.js/commit/2cde927e58c8d1588569d94a797e43cdfbcedaf9),
+- **forEach:** due to [55991e33](https://github.com/angular/angular.js/commit/55991e33af6fece07ea347a059da061b76fc95f5),
+  forEach will iterate only over the initial number of items in
+the array. So if items are added to the array during the iteration, these won't
+be iterated over during the initial forEach call.
+
+This change also makes our forEach behave more like Array#forEach.
+
+
+- **angular.toJson:** due to [c054288c](https://github.com/angular/angular.js/commit/c054288c9722875e3595e6e6162193e0fb67a251),
+
+If you expected `toJson` to strip these types of properties before, you will have to
+manually do this yourself now.
+
+
+
+
+
+## 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
+nodes, but now that is allowed only on Element and Document nodes just like in
+jQuery. We don't expect that app code actually depends on this accidental feature.
+
+
+- **jqLite:** due to [d71dbb1a](https://github.com/angular/angular.js/commit/d71dbb1ae50f174680533492ce4c7db3ff74df00),
+  the jQuery `detach()` method does not trigger the `$destroy` event.
+  If you want to destroy Angular data attached to the element, use `remove()`.
+
+
+
+
+
+## Angular HTML Compiler (`$compile`)
+
+
+- due to [2ee29c5d](https://github.com/angular/angular.js/commit/2ee29c5da81ffacdc1cabb438f5d125d5e116cb9),
+
+The isolated scope of a component directive no longer leaks into the template
+that contains the instance of the directive.  This means that you can no longer
+access the isolated scope from attributes on the element where the isolated
+directive is defined.
+
+See https://github.com/angular/angular.js/issues/10236 for an example.
+
+- due to [2cde927e](https://github.com/angular/angular.js/commit/2cde927e58c8d1588569d94a797e43cdfbcedaf9),


 Requesting isolate scope and any other scope on a single element is an error.
@@ -77,9 +154,50 @@ If you find that your code is now throwing a `$compile:multidir` error,
 check that you do not have directives on the same element that are trying
 to request both an isolate and a non-isolate scope and fix your code.

-Closes #4402
-Closes #4421
- **NgModel:** due to [1be9bb9d](https://github.com/angular/angular.js/commit/1be9bb9d3527e0758350c4f7417a4228d8571440),
+
+- due to [eec6394a](https://github.com/angular/angular.js/commit/eec6394a342fb92fba5270eee11c83f1d895e9fb), The `replace` flag for defining directives that
+  replace the element that they are on will be removed in the next major angular version.
+  This feature has difficult semantics (e.g. how attributes are merged) and leads to more
+  problems compared to what it solves. Also, with Web Components it is normal to have
+  custom elements in the DOM.
+
+
+- due to [299b220f](https://github.com/angular/angular.js/commit/299b220f5e05e1d4e26bfd58d0b2fd7329ca76b1),
+  calling `attr.$observe` no longer returns the observer function, but a
+    deregistration function instead. To migrate the code follow the example below:
+
+Before:
+
+    directive('directiveName', function() {
+      return {
+        link: function(scope, elm, attr) {
+          var observer = attr.$observe('someAttr', function(value) {
+            console.log(value);
+          });
+        }
+      };
+    });
+
+After:
+
+    directive('directiveName', function() {
+      return {
+        link: function(scope, elm, attr) {
+          var observer = function(value) {
+            console.log(value);
+          };
+
+          attr.$observe('someAttr', observer);
+        }
+      };
+    });
+
+
+
+
+## Forms, Inputs and ngModel
+
+- due to [1be9bb9d](https://github.com/angular/angular.js/commit/1be9bb9d3527e0758350c4f7417a4228d8571440),


 If an expression is used on ng-pattern (such as `ng-pattern="exp"`) or on the
@@ -95,45 +213,70 @@ this limitation, use a regular expression object as the value for the expression

    //after
    $scope.exp = /abc/i;
- **Scope:** due to [8c6a8171](https://github.com/angular/angular.js/commit/8c6a8171f9bdaa5cdabc0cc3f7d3ce10af7b434d),
+
+
+- **ngModelOptions:** due to [adfc322b](https://github.com/angular/angular.js/commit/adfc322b04a58158fb9697e5b99aab9ca63c80bb),
+
+
+This commit changes the API on `NgModelController`, both semantically and
+in terms of adding and renaming methods.
+
+* `$setViewValue(value)` -
+This method still changes the `$viewValue` but does not immediately commit this
+change through to the `$modelValue` as it did previously.
+Now the value is committed only when a trigger specified in an associated
+`ngModelOptions` directive occurs. If `ngModelOptions` also has a `debounce` delay
+specified for the trigger then the change will also be debounced before being
+committed.
+In most cases this should not have a significant impact on how `NgModelController`
+is used: If `updateOn` includes `default` then `$setViewValue` will trigger
+a (potentially debounced) commit immediately.
+* `$cancelUpdate()` - is renamed to `$rollbackViewValue()` and has the same meaning,
+which is to revert the current `$viewValue` back to the `$lastCommittedViewValue`,
+to cancel any pending debounced updates and to re-render the input.
+
+To migrate code that used `$cancelUpdate()` follow the example below:
+
+Before:
+
+```js
+$scope.resetWithCancel = function (e) {
+  if (e.keyCode == 27) {
+    $scope.myForm.myInput1.$cancelUpdate();
+    $scope.myValue = '';
+  }
+};
+```
+
+After:
+
+```js
+$scope.resetWithCancel = function (e) {
+  if (e.keyCode == 27) {
+    $scope.myForm.myInput1.$rollbackViewValue();
+    $scope.myValue = '';
+  }
+}
+```
+
+- types date, time, datetime-local, month, week now always
+  require a `Date` object as model ([46bd6dc8](https://github.com/angular/angular.js/commit/46bd6dc88de252886d75426efc2ce8107a5134e9),
+   [#5864](https://github.com/angular/angular.js/issues/5864))
+
+
+
+
+
+
+## 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
 id is primarily being used for debugging purposes this change should not affect
 anyone.
- **forEach:** due to [55991e33](https://github.com/angular/angular.js/commit/55991e33af6fece07ea347a059da061b76fc95f5),
-  forEach will iterate only over the initial number of items in
-the array. So if items are added to the array during the iteration, these won't
-be iterated over during the initial forEach call.

-This change also makes our forEach behave more like Array#forEach.
- **jqLite:** due to [a196c8bc](https://github.com/angular/angular.js/commit/a196c8bca82a28c08896d31f1863cf4ecd11401c),
-  previously it was possible to set jqLite data on Text/Comment
-nodes, but now that is allowed only on Element and Document nodes just like in
-jQuery. We don't expect that app code actually depends on this accidental feature.

- **$resource:** due to [d3c50c84](https://github.com/angular/angular.js/commit/d3c50c845671f0f8bcc3f7842df9e2fb1d1b1c40),
-
-  If you expected `$resource` to strip these types of properties before,
-  you will have to manually do this yourself now.
-
- **angular.toJson:** due to [c054288c](https://github.com/angular/angular.js/commit/c054288c9722875e3595e6e6162193e0fb67a251),
-
-  If you expected `toJson` to strip these types of properties before,
-  you will have to manually do this yourself now.
-
- **$compile:** due to [eec6394a](https://github.com/angular/angular.js/commit/eec6394a342fb92fba5270eee11c83f1d895e9fb), The `replace` flag for defining directives that
-  replace the element that they are on will be removed in the next major angular version.
-  This feature has difficult semantics (e.g. how attributes are merged) and leads to more
-  problems compared to what it solves. Also, with Web Components it is normal to have
-  custom elements in the DOM.
-
- **$parse:** due to [fa6e411d](https://github.com/angular/angular.js/commit/fa6e411da26824a5bae55f37ce7dbb859653276d),
-  promise unwrapping has been removed. It has been deprecated since 1.2.0-rc.3.
-  It can no longer be turned on.
-  Two methods have been removed:
-  * `$parseProvider.unwrapPromises`
-  * `$parseProvider.logPromiseWarnings`
-
- **Scope:** due to [82f45aee](https://github.com/angular/angular.js/commit/82f45aee5bd84d1cc53fb2e8f645d2263cdaacbc),
+- due to [82f45aee](https://github.com/angular/angular.js/commit/82f45aee5bd84d1cc53fb2e8f645d2263cdaacbc),
  [#7445](https://github.com/angular/angular.js/issues/7445),
  [#7523](https://github.com/angular/angular.js/issues/7523)
  `$broadcast` and `$emit` will now reset the `currentScope` property of the event to
@@ -141,11 +284,11 @@ jQuery. We don't expect that app code actually depends on this accidental featur
  `currentScope` property, it should be migrated to use `targetScope` instead. All of these cases
  should be considered programming bugs.

- **jqLite:** due to [d71dbb1a](https://github.com/angular/angular.js/commit/d71dbb1ae50f174680533492ce4c7db3ff74df00),
-  the jQuery `detach()` method does not trigger the `$destroy` event.
-  If you want to destroy Angular data attached to the element, use `remove()`.


+
+
+## Server Requests (`$http`, `$resource`)
 - **$http:** due to [ad4336f9](https://github.com/angular/angular.js/commit/ad4336f9359a073e272930f8f9bcd36587a8648f),


@@ -197,7 +340,24 @@ More details on the new interceptors API (which has been around as of v1.1.4) ca
 {@link $http#interceptors interceptors}


- **injector:** due to [c0b4e2db](https://github.com/angular/angular.js/commit/c0b4e2db9cbc8bc3164cedc4646145d3ab72536e),
+
+- **$httpBackend:** due to [6680b7b9](https://github.com/angular/angular.js/commit/6680b7b97c0326a80bdccaf0a35031e4af641e0e), the JSONP behavior for erroneous and empty responses changed:
+    Previously, a JSONP response was regarded as erroneous if it was empty. Now Angular is listening to the
+    correct events to detect errors, i.e. even empty responses can be successful.
+
+
+- **$resource:** due to [d3c50c84](https://github.com/angular/angular.js/commit/d3c50c845671f0f8bcc3f7842df9e2fb1d1b1c40),
+
+  If you expected `$resource` to strip these types of properties before,
+  you will have to manually do this yourself now.
+
+
+
+
+
+## Modules and Injector (`$inject`)
+
+- due to [c0b4e2db](https://github.com/angular/angular.js/commit/c0b4e2db9cbc8bc3164cedc4646145d3ab72536e),

 Previously, config blocks would be able to control behaviour of provider registration, due to being
 invoked prior to provider registration. Now, provider registration always occurs prior to configuration
@@ -234,66 +394,13 @@ and "$dependentProvider" would have actually accomplished something and changed
 app. This is no longer possible within a single module.


- **ngModelOptions:** due to [adfc322b](https://github.com/angular/angular.js/commit/adfc322b04a58158fb9697e5b99aab9ca63c80bb),


-This commit changes the API on `NgModelController`, both semantically and
-in terms of adding and renaming methods.

-* `$setViewValue(value)` -
-This method still changes the `$viewValue` but does not immediately commit this
-change through to the `$modelValue` as it did previously.
-Now the value is committed only when a trigger specified in an associated
-`ngModelOptions` directive occurs. If `ngModelOptions` also has a `debounce` delay
-specified for the trigger then the change will also be debounced before being
-committed.
-In most cases this should not have a significant impact on how `NgModelController`
-is used: If `updateOn` includes `default` then `$setViewValue` will trigger
-a (potentially debounced) commit immediately.
-* `$cancelUpdate()` - is renamed to `$rollbackViewValue()` and has the same meaning,
-which is to revert the current `$viewValue` back to the `$lastCommittedViewValue`,
-to cancel any pending debounced updates and to re-render the input.
-
-To migrate code that used `$cancelUpdate()` follow the example below:
-
-Before:
-
-```js
-$scope.resetWithCancel = function (e) {
-  if (e.keyCode == 27) {
-    $scope.myForm.myInput1.$cancelUpdate();
-    $scope.myValue = '';
-  }
-};
-```
-
-After:
-
-```js
-$scope.resetWithCancel = function (e) {
-  if (e.keyCode == 27) {
-    $scope.myForm.myInput1.$rollbackViewValue();
-    $scope.myValue = '';
-  }
-}
-```
-
- **$interpolate:** due to [88c2193c](https://github.com/angular/angular.js/commit/88c2193c71954b9e7e7e4bdf636a2b168d36300d),
-  the function returned by `$interpolate`
-  no longer has a `.parts` array set on it.
-
-  Instead it has two arrays:
-  * `.expressions`, an array of the expressions in the
-    interpolated text. The expressions are parsed with
-    `$parse`, with an extra layer converting them to strings
-    when computed
-  * `.separators`, an array of strings representing the
-    separations between interpolations in the text.
-    This array is **always** 1 item longer than the
-    `.expressions` array for easy merging with it
+## Animation (`ngAnimate`)


- **$animate:** due to [1cb8584e](https://github.com/angular/angular.js/commit/1cb8584e8490ecdb1b410a8846c4478c6c2c0e53),
+- due to [1cb8584e](https://github.com/angular/angular.js/commit/1cb8584e8490ecdb1b410a8846c4478c6c2c0e53),
 `$animate` will no longer default the after parameter to the last element of the parent
 container. Instead, when after is not specified, the new element will be inserted as the
 first child of the parent container.
@@ -308,7 +415,7 @@ to:



- **$animate:** due to [1bebe36a](https://github.com/angular/angular.js/commit/1bebe36aa938890d61188762ed618b1b5e193634),
+- due to [1bebe36a](https://github.com/angular/angular.js/commit/1bebe36aa938890d61188762ed618b1b5e193634),

  Any class-based animation code that makes use of transitions
 and uses the setup CSS classes (such as class-add and class-remove) must now
@@ -343,45 +450,13 @@ After:
 Please view the documentation for ngAnimate for more info.


- **$compile:** due to [299b220f](https://github.com/angular/angular.js/commit/299b220f5e05e1d4e26bfd58d0b2fd7329ca76b1),
-  calling `attr.$observe` no longer returns the observer function, but a
-    deregistration function instead. To migrate the code follow the example below:
+## Internet Explorer 8

-Before:
-
-    directive('directiveName', function() {
-      return {
-        link: function(scope, elm, attr) {
-          var observer = attr.$observe('someAttr', function(value) {
-            console.log(value);
-          });
-        }
-      };
-    });
-
-After:
-
-    directive('directiveName', function() {
-      return {
-        link: function(scope, elm, attr) {
-          var observer = function(value) {
-            console.log(value);
-          };
-
-          attr.$observe('someAttr', observer);
-        }
-      };
-    });
-
- **$httpBackend:** due to [6680b7b9](https://github.com/angular/angular.js/commit/6680b7b97c0326a80bdccaf0a35031e4af641e0e), the JSONP behavior for erroneous and empty responses changed:
-    Previously, a JSONP response was regarded as erroneous if it was empty. Now Angular is listening to the
-    correct events to detect errors, i.e. even empty responses can be successful.
-
- **build:** due to [eaa1d00b](https://github.com/angular/angular.js/commit/eaa1d00b24008f590b95ad099241b4003688cdda),
+- due to [eaa1d00b](https://github.com/angular/angular.js/commit/eaa1d00b24008f590b95ad099241b4003688cdda),
  As communicated before, IE8 is no longer supported.
- **input:** types date, time, datetime-local, month, week now always
-  require a `Date` object as model ([46bd6dc8](https://github.com/angular/angular.js/commit/46bd6dc88de252886d75426efc2ce8107a5134e9),
-   [#5864](https://github.com/angular/angular.js/issues/5864))
+
+
+



@@ -345,7 +345,7 @@ access on JavaScript object.
 Dirty checking can be done with three strategies: By reference, by collection contents, and by value. The strategies differ in the kinds of changes they detect, and in their performance characteristics.

   - Watching *by reference* ({@link
-      ng.$rootScope.Scope#$watch scope.$watch} `(watchExpression, listener)`) detects a change when the whole value returned by the watch expression switches to a new value. If the value is an array or an object, changes inside it are not detected. This is the most efficient stategy.
+      ng.$rootScope.Scope#$watch scope.$watch} `(watchExpression, listener)`) detects a change when the whole value returned by the watch expression switches to a new value. If the value is an array or an object, changes inside it are not detected. This is the most efficient strategy.
   - Watching *collection contents* ({@link
      ng.$rootScope.Scope#$watchCollection scope.$watchCollection} `(watchExpression, listener)`) detects changes that occur inside an array or an object: When items are added, removed, or reordered. The detection is shallow - it does not reach into nested collections. Watching collection contents is more expensive than watching by reference, because copies of the collection contents need to be maintained. However, the strategy attempts to minimize the amount of copying required.
   - Watching *by value* ({@link
@@ -8,15 +8,15 @@ comes with almost no help from the compiler. For this reason we feel very strong
 written in JavaScript needs to come with a strong set of tests. We have built many features into
 Angular which makes testing your Angular applications easy. So there is no excuse for not testing.

-# Separation of Concerns
+## Separation of Concerns

-Unit testing as the name implies is about testing individual units of code. Unit tests try to
+Unit testing, as the name implies, is about testing individual units of code. Unit tests try to
 answer questions such as "Did I think about the logic correctly?" or "Does the sort function order
 the list in the right order?"

 In order to answer such a question it is very important that we can isolate the unit of code under test.
 That is because when we are testing the sort function we don't want to be forced into creating
-related pieces such as the DOM elements, or making any XHR calls in getting the data to sort.
+related pieces such as the DOM elements, or making any XHR calls to fetch the data to sort.

 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
@@ -24,12 +24,10 @@ piece of code which does everything. It makes an XHR request, it sorts the respo
 manipulates the DOM.

 With Angular we try to make it easy for you to do the right thing, and so we
-provide dependency injection for your XHR (which you can mock out) and we created abstractions which
-allow you to sort your model without having to resort to manipulating the DOM. So that in the end,
-it is easy to write a sort function which sorts some data, so that your test can create a data set,
-apply the function, and assert that the resulting model is in the correct order. The test does not
-have to wait for the XHR response to arrive, create the right kind of test DOM, nor assert that your
-function has mutated the DOM in the right way.
+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

@@ -38,230 +36,218 @@ We tried to make the right thing easy, but if you ignore these guidelines you ma
 untestable application.

 ## Dependency Injection
-There are several ways in which you can get a hold of a dependency. You can:
-1. Create it using the `new` operator.
-2. Look for it in a well-known place, also known as a global singleton.
-3. Ask a registry (also known as service registry) for it. (But how do you get a hold of
-the registry? Most likely by looking it up in a well known place. See #2.)
-4. Expect it to be handed to you.

-Out of the four options in the list above, only the last one is testable. Let's look at why:
+Angular comes with {@link di dependency injection} built-in, which makes testing components much
+easier, because you can pass in a component's dependencies and stub or mock them as you wish.

-### Using the `new` operator
+Components that have their dependencies injected allow them to be easily mocked on a test by
+test basis, without having to mess with any global variables that could inadvertently affect
+another test.

-While there is nothing wrong with the `new` operator fundamentally, a problem arises when calling `new`
-on a constructor. This permanently binds the call site to the type. For example, let's say that we try to
-instantiate an `XHR` that will retrieve data from the server.
+## Additional tools for testing Angular applications
+
+For testing Angular applications there are certain tools that you should use that will make testing much
+easier to set up and run.
+
+### Karma
+
+[Karma](http://karma-runner.github.io/) is a JavaScript command line tool that can be used to spawn
+a web server which loads your application's source code and executes your tests. You can configure
+Karma to run against a number of browsers, which is useful for being confident that your application
+works on all browsers you need to support. Karma is executed on the command line and will display
+the results of your tests on the command line once they have run in the browser.
+
+Karma is a NodeJS application, and should be installed through npm. Full installation instructions
+are available on [the Karma website](http://karma-runner.github.io/0.12/intro/installation.html).
+
+### Jasmine
+
+[Jasmine](http://jasmine.github.io/1.3/introduction.html) is a test driven development framework for
+JavaScript that has become the most popular choice for testing Angular applications. Jasmine
+provides functions to help with structuring your tests and also making assertions. As your tests
+grow, keeping them well structured and documented is vital, and Jasmine helps achieve this.
+
+In Jasmine we use the `describe` function to group our tests together:

 ```js
-function MyClass() {
-  this.doWork = function() {
-    var xhr = new XHR();
-    xhr.open(method, url, true);
-    xhr.onreadystatechange = function() {...}
-    xhr.send();
-  }
-}
+describe("sorting the list of users", function() {
+  // individual tests go here
+});
 ```

-A problem surfaces in tests when we would like to instantiate a `MockXHR` that would
-allow us to return fake data and simulate network failures. By calling `new XHR()` we are
-permanently bound to the actual XHR and there is no way to replace it. Yes, we could monkey
-patch, but that is a bad idea for many reasons which are outside the scope of this document.
-
-Here's an example of how the class above becomes hard to test when resorting to monkey patching:
+And then each individual test is defined within a call to the `it` function:

 ```js
-var oldXHR = XHR;
-XHR = function MockXHR() {};
-var myClass = new MyClass();
-myClass.doWork();
-// assert that MockXHR got called with the right arguments
-XHR = oldXHR; // if you forget this bad things will happen
+describe('sorting the list of users', function() {
+  it('sorts in descending order by default', function() {
+    // your test assertion goes here
+  });
+});
 ```

+Grouping related tests within `describe` blocks and describing each individual test within an
+`it` call keeps your tests self documenting.

-### Global look-up:
-Another way to approach the problem is to look for the service in a well-known location.
+Finally, Jasmine provides matchers which let you make assertions:

 ```js
-function MyClass() {
-  this.doWork = function() {
-    global.xhr({
-      method:'...',
-      url:'...',
-      complete:function(response){ ... }
-    })
-  }
-}
+describe('sorting the list of users', function() {
+  it('sorts in descending order by default', function() {
+    var users = ['jack', 'igor', 'jeff'];
+    var sorted = sortUsers(users);
+    expect(sorted).toEqual(['jeff', 'jack', 'igor']);
+  });
+});
 ```

-While no new dependency instance is created, it is fundamentally the same as `new` in
-that no way exists to intercept the call to `global.xhr` for testing purposes, other than
-through monkey patching. The basic issue for testing is that a global variable needs to be mutated in
-order to replace it with call to a mock method. For further explanation of why this is bad see: [Brittle Global
-State & Singletons](http://misko.hevery.com/code-reviewers-guide/flaw-brittle-global-state-singletons/)
+Jasmine comes with a number of matchers that help you make a variety of assertions. You should [read
+the Jasmine documentation](http://jasmine.github.io/1.3/introduction.html#section-Matchers) to see
+what they are. To use Jasmine with Karma, we use the
+[karma-jasmine](https://github.com/karma-runner/karma-jasmine) test runner.

-The class above is hard to test since we have to change the global state:
+### angular-mocks
+
+Angular also provides the {@link ngMock} module, which provides mocking for your tests. This is used
+to inject and mock Angular services within unit tests. In addition, it is able to extend other
+modules so they are synchronous. Having tests synchronous keeps them much cleaner and easier to work
+with. One of the most useful parts of ngMock is {@link ngMock.$httpBackend}, which lets us mock XHR
+requests in tests, and return sample data instead.
+
+## Testing a Controller
+
+Because Angular separates logic from the view layer, it keeps controllers easy to test. Let's take a
+look at how we might test the controller below, which provides `$scope.grade`, which sets a property
+on the scope based on the length of the password.

 ```js
-var oldXHR = global.xhr;
-global.xhr = function mockXHR() {};
-var myClass = new MyClass();
-myClass.doWork();
-// assert that mockXHR got called with the right arguments
-global.xhr = oldXHR; // if you forget this bad things will happen
+angular.module('app', [])
+  .controller('PasswordController', function PasswordController($scope) {
+    $scope.password = '';
+    $scope.grade = function() {
+      var size = $scope.password.length;
+      if (size > 8) {
+        $scope.strength = 'strong';
+      } else if (size > 3) {
+        $scope.strength = 'medium';
+      } else {
+        $scope.strength = 'weak';
+      }
+    };
+  });
 ```

-
-### Service Registry:
-
-It may seem that this can be solved by having a registry of all the services and then
-having the tests replace the services as needed.
+Because controllers are not available on the global scope, we need to use {@link
+angular.mock.inject} to inject our controller first. The first step is to use the `module` function,
+which is provided by angular-mocks. This loads in the module it's given, so it is available in your
+tests. We pass this into `beforeEach`, which is a function Jasmine provides that lets us run code
+before each test. Then we can use `inject` to access `$controller`, the service that is responsible
+for instantiating controllers.

 ```js
-function MyClass() {
-  var serviceRegistry = ????;
-  this.doWork = function() {
-    var xhr = serviceRegistry.get('xhr');
-    xhr({
-      method:'...',
-      url:'...',
-      complete:function(response){ ... }
-    })
-}
+describe('PasswordController', function() {
+  beforeEach(module('app'));
+
+  var $controller;
+
+  beforeEach(inject(function(_$controller_){
+    // The injector unwraps the underscores (_) from around the parameter names when matching
+    $controller = _$controller_;
+  }));
+
+  describe('$scope.grade', function() {
+    it('sets the strength to "strong" if the password length is >8 chars', function() {
+      var $scope = {};
+      var controller = $controller('PasswordController', { $scope: $scope });
+      $scope.password = 'longerthaneightchars';
+      $scope.grade();
+      expect($scope.strength).toEqual('strong');
+    });
+  });
+});
 ```

-However, where does the serviceRegistry come from? If it is:
-* `new`-ed up, the test has no chance to reset the services for testing.
-* a global look-up then the service returned is global as well (but resetting is easier, since
-only one global variable exists to be reset).
-
-The class above is hard to test since we have to change the global state:
+Notice how by nesting the `describe` calls and being descriptive when calling them with strings, the
+test is very clear. It documents exactly what it is testing, and at a glance you can quickly see
+what is happening. Now let's add the test for when the password is less than three characters, which
+should see `$scope.strength` set to "weak":

 ```js
-var oldServiceLocator = global.serviceLocator;
-global.serviceLocator.set('xhr', function mockXHR() {});
-var myClass = new MyClass();
-myClass.doWork();
-// assert that mockXHR got called with the right arguments
-global.serviceLocator = oldServiceLocator; // if you forget this bad things will happen
+describe('PasswordController', function() {
+  beforeEach(module('app'));
+
+  var $controller;
+
+  beforeEach(inject(function(_$controller_){
+    // The injector unwraps the underscores (_) from around the parameter names when matching
+    $controller = _$controller_;
+  }));
+
+  describe('$scope.grade', function() {
+    it('sets the strength to "strong" if the password length is >8 chars', function() {
+      var $scope = {};
+      var controller = $controller('PasswordController', { $scope: $scope });
+      $scope.password = 'longerthaneightchars';
+      $scope.grade();
+      expect($scope.strength).toEqual('strong');
+    });
+
+    it('sets the strength to "weak" if the password length <3 chars', function() {
+      var $scope = {};
+      var controller = $controller('PasswordController', { $scope: $scope });
+      $scope.password = 'a';
+      $scope.grade();
+      expect($scope.strength).toEqual('weak');
+    });
+  });
+});
 ```

-
-### Passing in Dependencies:
-Last, the dependency can be passed in.
+Now we have two tests, but notice the duplication between the tests. Both have to
+create the `$scope` variable and create the controller. As we add new tests, this duplication is
+only going to get worse. Thankfully, Jasmine provides `beforeEach`, which lets us run a function
+before each individual test. Let's see how that would tidy up our tests:

 ```js
-function MyClass(xhr) {
-  this.doWork = function() {
-    xhr({
-      method:'...',
-      url:'...',
-      complete:function(response){ ... }
-    })
-}
+describe('PasswordController', function() {
+  beforeEach(module('app'));
+
+  var $controller;
+
+  beforeEach(inject(function(_$controller_){
+    // The injector unwraps the underscores (_) from around the parameter names when matching
+    $controller = _$controller_;
+  }));
+
+  describe('$scope.grade', function() {
+    var $scope, controller;
+
+    beforeEach(function() {
+      $scope = {};
+      controller = $controller('PasswordController', { $scope: $scope });
+    });
+
+    it('sets the strength to "strong" if the password length is >8 chars', function() {
+      $scope.password = 'longerthaneightchars';
+      $scope.grade();
+      expect($scope.strength).toEqual('strong');
+    });
+
+    it('sets the strength to "weak" if the password length <3 chars', function() {
+      $scope.password = 'a';
+      $scope.grade();
+      expect($scope.strength).toEqual('weak');
+    });
+  });
+});
 ```

-This is the preferred method since the code makes no assumptions about the origin of `xhr` and cares
-instead about whoever created the class  responsible for passing it in. Since the creator of the
-class should be different code than the user of the class, it separates the responsibility of
-creation from the logic. This is dependency-injection in a nutshell.
+We've moved the duplication out and into the `beforeEach` block. Each individual test now
+only contains the code specific to that test, and not code that is general across all tests. As you
+expand your tests, keep an eye out for locations where you can use `beforeEach` to tidy up tests.
+`beforeEach` isn't the only function of this sort that Jasmine provides, and the [documentation
+lists the others](http://jasmine.github.io/1.3/introduction.html#section-Setup_and_Teardown).

-The class above is testable, since in the test we can write:
-
-```js
-function xhrMock(args) {...}
-var myClass = new MyClass(xhrMock);
-myClass.doWork();
-// assert that xhrMock got called with the right arguments
-```
-
-Notice that no global variables were harmed in the writing of this test.
-
-Angular comes with {@link di dependency injection} built-in, making the right thing
-easy to do, but you still need to do it if you wish to take advantage of the testability story.
-
-## Controllers
-What makes each application unique is its logic, and the logic is what we would like to test. If the logic
-for your application contains DOM manipulation, it will be hard to test. See the example
-below:
-
-```js
-function PasswordCtrl() {
-  // get references to DOM elements
-  var msg = $('.ex1 span');
-  var input = $('.ex1 input');
-  var strength;
-
-  this.grade = function() {
-    msg.removeClass(strength);
-    var pwd = input.val();
-    password.text(pwd);
-    if (pwd.length > 8) {
-      strength = 'strong';
-    } else if (pwd.length > 3) {
-      strength = 'medium';
-    } else {
-      strength = 'weak';
-    }
-    msg
-     .addClass(strength)
-     .text(strength);
-  }
-}
-```
-
-The code above is problematic from a testability point of view since it requires your test to have the right kind
-of DOM present when the code executes. The test would look like this:
-
-```js
-var input = $('<input type="text"/>');
-var span = $('<span>');
-$('body').html('<div class="ex1">')
-  .find('div')
-    .append(input)
-    .append(span);
-var pc = new PasswordCtrl();
-input.val('abc');
-pc.grade();
-expect(span.text()).toEqual('weak');
-$('body').empty();
-```
-
-In angular the controllers are strictly separated from the DOM manipulation logic and this results in
-a much easier testability story as the following example shows:
-
-```js
-function PasswordCtrl($scope) {
-  $scope.password = '';
-  $scope.grade = function() {
-    var size = $scope.password.length;
-    if (size > 8) {
-      $scope.strength = 'strong';
-    } else if (size > 3) {
-      $scope.strength = 'medium';
-    } else {
-      $scope.strength = 'weak';
-    }
-  };
-}
-```
-
-and the test is straight forward:
-
-```js
-var $scope = {};
-var pc = $controller('PasswordCtrl', { $scope: $scope });
-$scope.password = 'abc';
-$scope.grade();
-expect($scope.strength).toEqual('weak');
-```
-
-Notice that the test is not only much shorter, it is also easier to follow what is happening. We say
-that such a test tells a story, rather than asserting random bits which don't seem to be related.
-
-## Filters
+## Testing Filters
 {@link ng.$filterProvider Filters} are functions which transform the data into a user readable
 format. They are important because they remove the formatting responsibility from the application
 logic, further simplifying the application logic.
@@ -273,12 +259,20 @@ myModule.filter('length', function() {
  }
 });

-var length = $filter('length');
-expect(length(null)).toEqual(0);
-expect(length('abc')).toEqual(3);
+describe('length filter', function() {
+  it('returns 0 when given null', function() {
+    var length = $filter('length');
+    expect(length(null)).toEqual(0);
+  });
+
+  it('returns the correct value when given a string of chars', function() {
+    var length = $filter('length');
+    expect(length('abc')).toEqual(3);
+  });
+});
 ```

-## Directives
+## Testing Directives
 Directives in angular are responsible for encapsulating complex functionality within custom HTML tags,
 attributes, classes or comments. Unit tests are very important for directives because the components
 you create with directives may be used throughout your application and in many different contexts.
@@ -309,28 +303,28 @@ verify this functionality. Note that the expression `{{1 + 1}}` times will also

 ```js
 describe('Unit testing great quotes', function() {
-    var $compile;
-    var $rootScope;
+  var $compile,
+      $rootScope;

-    // Load the myApp module, which contains the directive
-    beforeEach(module('myApp'));
+  // Load the myApp module, which contains the directive
+  beforeEach(module('myApp'));

-    // Store references to $rootScope and $compile
-    // so they are available to all tests in this describe block
-    beforeEach(inject(function(_$compile_, _$rootScope_){
-      // The injector unwraps the underscores (_) from around the parameter names when matching
-      $compile = _$compile_;
-      $rootScope = _$rootScope_;
-    }));
+  // Store references to $rootScope and $compile
+  // so they are available to all tests in this describe block
+  beforeEach(inject(function(_$compile_, _$rootScope_){
+    // The injector unwraps the underscores (_) from around the parameter names when matching
+    $compile = _$compile_;
+    $rootScope = _$rootScope_;
+  }));

-    it('Replaces the element with the appropriate content', function() {
-        // Compile a piece of HTML containing the directive
-        var element = $compile("<a-great-eye></a-great-eye>")($rootScope);
-        // fire all the watches, so the scope expression {{1 + 1}} will be evaluated
-        $rootScope.$digest();
-        // Check that the compiled element contains the templated content
-        expect(element.html()).toContain("lidless, wreathed in flame, 2 times");
-    });
+  it('Replaces the element with the appropriate content', function() {
+    // Compile a piece of HTML containing the directive
+    var element = $compile("<a-great-eye></a-great-eye>")($rootScope);
+    // fire all the watches, so the scope expression {{1 + 1}} will be evaluated
+    $rootScope.$digest();
+    // Check that the compiled element contains the templated content
+    expect(element.html()).toContain("lidless, wreathed in flame, 2 times");
+  });
 });
 ```

@@ -431,4 +425,3 @@ Otherwise you may run into issues if the test directory hierarchy differs from t

 ## Sample project
 See the [angular-seed](https://github.com/angular/angular-seed) project for an example.
-
@@ -116,7 +116,7 @@ npm --version
 ```


-<div class="alert alert-info">If you need to run a different versions of node.js
+<div class="alert alert-info">If you need to run different versions of node.js
  in your local environment, consider installing
  <a href="https://github.com/creationix/nvm" title="Node Version Manager Github Repo link">
    Node Version Manager (nvm)
@@ -267,7 +267,7 @@ goog.i18n.currency.adjustPrecision = function(pattern, currencyCode) {
 * 18: two decimals precision (2), currency sign last (16), no space (0)
 * 50: two decimals precision (2), currency sign last (16), space (32)
 *
- * @type {!Object.<!Array.<?>>}
+ * @const {!Object<!Array<?>>}
 */
 goog.i18n.currency.CurrencyInfo = {
  'AED': [2, 'dh', '\u062f.\u0625.', 'DH'],
@@ -334,7 +334,7 @@ goog.i18n.currency.CurrencyInfo = {

 /**
 * Tier 2 currency information.
- * @type {!Object.<!Array.<?>>}
+ * @const {!Object<!Array<?>>}
 */
 goog.i18n.currency.CurrencyInfoTier2 = {
  'AFN': [48, 'Af.', 'AFN'],
@@ -18,7 +18,7 @@
 * This file is autogenerated by script:
 * http://go/generate_number_constants.py
 * using the --for_closure flag.
- * File generated from CLDR ver. 25
+ * File generated from CLDR ver. 26
 *
 * To reduce the file size (which may cause issues in some JS
 * developing environments), this file will only contain locales
@@ -42,7 +42,6 @@ goog.provide('goog.i18n.NumberFormatSymbols_am_ET');
 goog.provide('goog.i18n.NumberFormatSymbols_ar');
 goog.provide('goog.i18n.NumberFormatSymbols_ar_001');
 goog.provide('goog.i18n.NumberFormatSymbols_az');
-goog.provide('goog.i18n.NumberFormatSymbols_az_Cyrl_AZ');
 goog.provide('goog.i18n.NumberFormatSymbols_az_Latn_AZ');
 goog.provide('goog.i18n.NumberFormatSymbols_bg');
 goog.provide('goog.i18n.NumberFormatSymbols_bg_BG');
@@ -364,13 +363,6 @@ goog.i18n.NumberFormatSymbols_az = {
 };


-/**
- * Number formatting symbols for locale az_Cyrl_AZ.
- * @enum {string}
- */
-goog.i18n.NumberFormatSymbols_az_Cyrl_AZ = goog.i18n.NumberFormatSymbols_az;
-
-
 /**
 * Number formatting symbols for locale az_Latn_AZ.
 * @enum {string}
@@ -455,8 +447,8 @@ goog.i18n.NumberFormatSymbols_br = {
  NAN: 'NaN',
  DECIMAL_PATTERN: '#,##0.###',
  SCIENTIFIC_PATTERN: '#E0',
-  PERCENT_PATTERN: '#,##0%',
-  CURRENCY_PATTERN: '\u00A4\u00A0#,##0.00',
+  PERCENT_PATTERN: '#,##0\u00A0%',
+  CURRENCY_PATTERN: '#,##0.00\u00A0\u00A4',
  DEF_CURRENCY_CODE: 'EUR'
 };

@@ -1063,7 +1055,7 @@ goog.i18n.NumberFormatSymbols_es = {
  NAN: 'NaN',
  DECIMAL_PATTERN: '#,##0.###',
  SCIENTIFIC_PATTERN: '#E0',
-  PERCENT_PATTERN: '#,##0%',
+  PERCENT_PATTERN: '#,##0\u00A0%',
  CURRENCY_PATTERN: '#,##0.00\u00A0\u00A4',
  DEF_CURRENCY_CODE: 'EUR'
 };
@@ -1086,7 +1078,7 @@ goog.i18n.NumberFormatSymbols_es_419 = {
  NAN: 'NaN',
  DECIMAL_PATTERN: '#,##0.###',
  SCIENTIFIC_PATTERN: '#E0',
-  PERCENT_PATTERN: '#,##0%',
+  PERCENT_PATTERN: '#,##0\u00A0%',
  CURRENCY_PATTERN: '\u00A4#,##0.00',
  DEF_CURRENCY_CODE: 'MXN'
 };
@@ -1492,7 +1484,7 @@ goog.i18n.NumberFormatSymbols_gu = {
  INFINITY: '\u221E',
  NAN: 'NaN',
  DECIMAL_PATTERN: '#,##,##0.###',
-  SCIENTIFIC_PATTERN: '#E0',
+  SCIENTIFIC_PATTERN: '[#E0]',
  PERCENT_PATTERN: '#,##,##0%',
  CURRENCY_PATTERN: '\u00A4#,##,##0.00',
  DEF_CURRENCY_CODE: 'INR'
@@ -1582,7 +1574,7 @@ goog.i18n.NumberFormatSymbols_hi = {
  INFINITY: '\u221E',
  NAN: 'NaN',
  DECIMAL_PATTERN: '#,##,##0.###',
-  SCIENTIFIC_PATTERN: '#E0',
+  SCIENTIFIC_PATTERN: '[#E0]',
  PERCENT_PATTERN: '#,##,##0%',
  CURRENCY_PATTERN: '\u00A4#,##,##0.00',
  DEF_CURRENCY_CODE: 'INR'
@@ -1961,7 +1953,7 @@ goog.i18n.NumberFormatSymbols_kn = {
  ZERO_DIGIT: '0',
  PLUS_SIGN: '+',
  MINUS_SIGN: '-',
-  EXP_SYMBOL: '\u0C88',
+  EXP_SYMBOL: 'E',
  PERMILL: '\u2030',
  INFINITY: '\u221E',
  NAN: 'NaN',
@@ -2085,7 +2077,7 @@ goog.i18n.NumberFormatSymbols_lo = {
  PERMILL: '\u2030',
  INFINITY: '\u221E',
  NAN:
-      '\u0E9A\u0ECD\u0EC8\u0EC1\u0EA1\u0EC8\u0E99\u0EC2\u0E95\u0EC0\u0EA5\u0E81',
+      '\u0E9A\u0ECD\u0EC8\u200B\u0EC1\u0EA1\u0EC8\u0E99\u200B\u0EC2\u0E95\u200B\u0EC0\u0EA5\u0E81',
  DECIMAL_PATTERN: '#,##0.###',
  SCIENTIFIC_PATTERN: '#',
  PERCENT_PATTERN: '#,##0%',
@@ -2149,7 +2141,7 @@ goog.i18n.NumberFormatSymbols_lv = {
  DECIMAL_PATTERN: '#,##0.###',
  SCIENTIFIC_PATTERN: '#E0',
  PERCENT_PATTERN: '#,##0%',
-  CURRENCY_PATTERN: '\u00A4#,##0.00',
+  CURRENCY_PATTERN: '\u00A4#0.00',
  DEF_CURRENCY_CODE: 'EUR'
 };

@@ -2208,8 +2200,8 @@ goog.i18n.NumberFormatSymbols_ml = {
  NAN: 'NaN',
  DECIMAL_PATTERN: '#,##,##0.###',
  SCIENTIFIC_PATTERN: '#E0',
-  PERCENT_PATTERN: '#,##,##0%',
-  CURRENCY_PATTERN: '#,##,##0.00\u00A4',
+  PERCENT_PATTERN: '#,##0%',
+  CURRENCY_PATTERN: '\u00A4#,##0.00',
  DEF_CURRENCY_CODE: 'INR'
 };

@@ -2266,7 +2258,7 @@ goog.i18n.NumberFormatSymbols_mr = {
  PERMILL: '\u2030',
  INFINITY: '\u221E',
  NAN: 'NaN',
-  DECIMAL_PATTERN: '#,##0.###',
+  DECIMAL_PATTERN: '#,##,##0.###',
  SCIENTIFIC_PATTERN: '[#E0]',
  PERCENT_PATTERN: '#,##0%',
  CURRENCY_PATTERN: '\u00A4#,##0.00',
@@ -2427,7 +2419,7 @@ goog.i18n.NumberFormatSymbols_ne = {
  DECIMAL_PATTERN: '#,##0.###',
  SCIENTIFIC_PATTERN: '#E0',
  PERCENT_PATTERN: '#,##0%',
-  CURRENCY_PATTERN: '\u00A4#,##0.00',
+  CURRENCY_PATTERN: '\u00A4\u00A0#,##0.00',
  DEF_CURRENCY_CODE: 'NPR'
 };

@@ -2545,7 +2537,7 @@ goog.i18n.NumberFormatSymbols_pa = {
  INFINITY: '\u221E',
  NAN: 'NaN',
  DECIMAL_PATTERN: '#,##,##0.###',
-  SCIENTIFIC_PATTERN: '#E0',
+  SCIENTIFIC_PATTERN: '[#E0]',
  PERCENT_PATTERN: '#,##,##0%',
  CURRENCY_PATTERN: '\u00A4#,##,##0.00',
  DEF_CURRENCY_CODE: 'INR'
@@ -2718,7 +2710,7 @@ goog.i18n.NumberFormatSymbols_si = {
  INFINITY: '\u221E',
  NAN: 'NaN',
  DECIMAL_PATTERN: '#,##0.###',
-  SCIENTIFIC_PATTERN: '#E0',
+  SCIENTIFIC_PATTERN: '#',
  PERCENT_PATTERN: '#,##0%',
  CURRENCY_PATTERN: '\u00A4#,##0.00',
  DEF_CURRENCY_CODE: 'LKR'
@@ -2957,10 +2949,10 @@ goog.i18n.NumberFormatSymbols_te = {
  PERMILL: '\u2030',
  INFINITY: '\u221E',
  NAN: 'NaN',
-  DECIMAL_PATTERN: '#,##0.###',
+  DECIMAL_PATTERN: '#,##,##0.###',
  SCIENTIFIC_PATTERN: '#E0',
  PERCENT_PATTERN: '#,##0%',
-  CURRENCY_PATTERN: '\u00A4#,##0.00',
+  CURRENCY_PATTERN: '\u00A4#,##,##0.00',
  DEF_CURRENCY_CODE: 'INR'
 };

@@ -3102,8 +3094,8 @@ goog.i18n.NumberFormatSymbols_ur = {
  NAN: 'NaN',
  DECIMAL_PATTERN: '#,##0.###',
  SCIENTIFIC_PATTERN: '#E0',
-  PERCENT_PATTERN: '#,##0%',
-  CURRENCY_PATTERN: '\u00A4#,##0.00\u200E',
+  PERCENT_PATTERN: '#,##,##0%',
+  CURRENCY_PATTERN: '\u00A4\u00A0#,##,##0.00',
  DEF_CURRENCY_CODE: 'PKR'
 };

@@ -3321,10 +3313,6 @@ if (goog.LOCALE == 'az') {
  goog.i18n.NumberFormatSymbols = goog.i18n.NumberFormatSymbols_az;
 }

-if (goog.LOCALE == 'az_Cyrl_AZ' || goog.LOCALE == 'az-Cyrl-AZ') {
-  goog.i18n.NumberFormatSymbols = goog.i18n.NumberFormatSymbols_az;
-}
-
 if (goog.LOCALE == 'az_Latn_AZ' || goog.LOCALE == 'az-Latn-AZ') {
  goog.i18n.NumberFormatSymbols = goog.i18n.NumberFormatSymbols_az;
 }
@@ -17,7 +17,7 @@
 *
 * This file is autogenerated by script:
 *   http://go/generate_pluralrules.py
- * File generated from CLDR ver. 25
+ * File generated from CLDR ver. 26
 *
 * Before check in, this file could have been manually edited. This is to
 * incorporate changes before we could fix CLDR. All manual modification must be
@@ -409,6 +409,23 @@ goog.i18n.pluralRules.srSelect_ = function(n, opt_precision) {
  return goog.i18n.pluralRules.Keyword.OTHER;
 };

+/**
+ * Plural select rules for mk locale
+ *
+ * @param {number} n  The count of items.
+ * @param {number=} opt_precision Precision for number formatting, if not default.
+ * @return {goog.i18n.pluralRules.Keyword} Locale-specific plural value.
+ * @private
+ */
+goog.i18n.pluralRules.mkSelect_ = function(n, opt_precision) {
+  var i = n | 0;
+  var vf = goog.i18n.pluralRules.get_vf_(n, opt_precision);
+  if (vf.v == 0 && i % 10 == 1 || vf.f % 10 == 1) {
+    return goog.i18n.pluralRules.Keyword.ONE;
+  }
+  return goog.i18n.pluralRules.Keyword.OTHER;
+};
+
 /**
 * Plural select rules for hi locale
 *
@@ -426,17 +443,15 @@ goog.i18n.pluralRules.hiSelect_ = function(n, opt_precision) {
 };

 /**
- * Plural select rules for mk locale
+ * Plural select rules for pt locale
 *
 * @param {number} n  The count of items.
 * @param {number=} opt_precision Precision for number formatting, if not default.
 * @return {goog.i18n.pluralRules.Keyword} Locale-specific plural value.
 * @private
 */
-goog.i18n.pluralRules.mkSelect_ = function(n, opt_precision) {
-  var i = n | 0;
-  var vf = goog.i18n.pluralRules.get_vf_(n, opt_precision);
-  if (vf.v == 0 && i % 10 == 1 || vf.f % 10 == 1) {
+goog.i18n.pluralRules.ptSelect_ = function(n, opt_precision) {
+  if (n >= 0 && n <= 2 && n != 2) {
    return goog.i18n.pluralRules.Keyword.ONE;
  }
  return goog.i18n.pluralRules.Keyword.OTHER;
@@ -562,24 +577,6 @@ goog.i18n.pluralRules.akSelect_ = function(n, opt_precision) {
  return goog.i18n.pluralRules.Keyword.OTHER;
 };

-/**
- * Plural select rules for pt locale
- *
- * @param {number} n  The count of items.
- * @param {number=} opt_precision Precision for number formatting, if not default.
- * @return {goog.i18n.pluralRules.Keyword} Locale-specific plural value.
- * @private
- */
-goog.i18n.pluralRules.ptSelect_ = function(n, opt_precision) {
-  var i = n | 0;
-  var vf = goog.i18n.pluralRules.get_vf_(n, opt_precision);
-  var wt = goog.i18n.pluralRules.get_wt_(vf.v, vf.f);
-  if (i == 1 && vf.v == 0 || i == 0 && wt.t == 1) {
-    return goog.i18n.pluralRules.Keyword.ONE;
-  }
-  return goog.i18n.pluralRules.Keyword.OTHER;
-};
-
 /**
 * Plural select rules for pl locale
 *
@@ -748,6 +745,29 @@ goog.i18n.pluralRules.gdSelect_ = function(n, opt_precision) {
  return goog.i18n.pluralRules.Keyword.OTHER;
 };

+/**
+ * Plural select rules for dsb locale
+ *
+ * @param {number} n  The count of items.
+ * @param {number=} opt_precision Precision for number formatting, if not default.
+ * @return {goog.i18n.pluralRules.Keyword} Locale-specific plural value.
+ * @private
+ */
+goog.i18n.pluralRules.dsbSelect_ = function(n, opt_precision) {
+  var i = n | 0;
+  var vf = goog.i18n.pluralRules.get_vf_(n, opt_precision);
+  if (vf.v == 0 && i % 100 == 1 || vf.f % 100 == 1) {
+    return goog.i18n.pluralRules.Keyword.ONE;
+  }
+  if (vf.v == 0 && i % 100 == 2 || vf.f % 100 == 2) {
+    return goog.i18n.pluralRules.Keyword.TWO;
+  }
+  if (vf.v == 0 && i % 100 >= 3 && i % 100 <= 4 || vf.f % 100 >= 3 && vf.f % 100 <= 4) {
+    return goog.i18n.pluralRules.Keyword.FEW;
+  }
+  return goog.i18n.pluralRules.Keyword.OTHER;
+};
+
 /**
 * Plural select rules for lv locale
 *
@@ -852,9 +872,6 @@ if (goog.LOCALE == 'en_IE' || goog.LOCALE == 'en-IE') {
 if (goog.LOCALE == 'en_IN' || goog.LOCALE == 'en-IN') {
  goog.i18n.pluralRules.select = goog.i18n.pluralRules.enSelect_;
 }
-if (goog.LOCALE == 'en_ISO' || goog.LOCALE == 'en-ISO') {
-  goog.i18n.pluralRules.select = goog.i18n.pluralRules.enSelect_;
-}
 if (goog.LOCALE == 'en_SG' || goog.LOCALE == 'en-SG') {
  goog.i18n.pluralRules.select = goog.i18n.pluralRules.enSelect_;
 }
@@ -114,26 +114,30 @@ module.exports = function(config, specificOptions) {
    var buildLabel = 'TRAVIS #' + process.env.TRAVIS_BUILD_NUMBER + ' (' + process.env.TRAVIS_BUILD_ID + ')';

    config.logLevel = config.LOG_DEBUG;
-    config.transports = ['websocket', 'xhr-polling'];
-    config.captureTimeout = 0; // rely on SL timeout
+    // Karma (with socket.io 1.x) buffers by 50 and 50 tests can take a long time on IEs;-)
+    config.browserNoActivityTimeout = 120000;

    config.browserStack.build = buildLabel;
    config.browserStack.startTunnel = false;
+    config.browserStack.tunnelIdentifier = process.env.TRAVIS_JOB_NUMBER;

    config.sauceLabs.build = buildLabel;
    config.sauceLabs.startConnect = false;
    config.sauceLabs.tunnelIdentifier = process.env.TRAVIS_JOB_NUMBER;
    config.sauceLabs.recordScreenshots = true;

-    // TODO(vojta): remove once SauceLabs supports websockets.
-    // This speeds up the capturing a bit, as browsers don't even try to use websocket.
-    config.transports = ['xhr-polling'];
-
    // Debug logging into a file, that we print out at the end of the build.
    config.loggers.push({
      type: 'file',
      filename: process.env.LOGS_DIR + '/' + (specificOptions.logFile || 'karma.log')
    });
+
+    if (process.env.BROWSER_PROVIDER === 'saucelabs' || !process.env.BROWSER_PROVIDER) {
+      // Allocating a browser can take pretty long (eg. if we are out of capacity and need to wait
+      // for another build to finish) and so the `captureTimeout` typically kills
+      // an in-queue-pending request, which makes no sense.
+      config.captureTimeout = 0;
+    }
  }


@@ -1 +0,0 @@
-node ./lib/browser-stack/start-tunnel.js &
@@ -5,9 +5,10 @@ var http = require('http');
 var BrowserStackTunnel = require('browserstacktunnel-wrapper');

 var HOSTNAME = 'localhost';
-var PORTS = require('../grunt/utils').availablePorts;
+var PORTS = [9876, 8000];
 var ACCESS_KEY = process.env.BROWSER_STACK_ACCESS_KEY;
-var READY_FILE = process.env.SAUCE_CONNECT_READY_FILE;
+var READY_FILE = process.env.BROWSER_PROVIDER_READY_FILE;
+var TUNNEL_IDENTIFIER = process.env.TRAVIS_JOB_NUMBER;

 // We need to start fake servers, otherwise the tunnel does not start.
 var fakeServers = [];
@@ -24,6 +25,7 @@ PORTS.forEach(function(port) {

 var tunnel = new BrowserStackTunnel({
  key: ACCESS_KEY,
+  tunnelIdentifier: TUNNEL_IDENTIFIER,
  hosts: hosts
 });

@@ -0,0 +1,3 @@
+export BROWSER_STACK_ACCESS_KEY=`echo $BROWSER_STACK_ACCESS_KEY | rev`
+
+node ./lib/browserstack/start_tunnel.js &
@@ -11,21 +11,6 @@ var _ = require('lodash');

 var CSP_CSS_HEADER = '/* Include this file in your html if you are using the CSP mode. */\n\n';

-var PORT_MIN = 8000;
-var PORT_MAX = 9999;
-var TRAVIS_BUILD_NUMBER = parseInt(process.env.TRAVIS_BUILD_NUMBER, 10);
-var getRandomPorts = function() {
-  if (!process.env.TRAVIS) {
-    return [9876, 9877];
-  }
-
-  // Generate two numbers between PORT_MIN and PORT_MAX, based on TRAVIS_BUILD_NUMBER.
-  return [
-    PORT_MIN + (TRAVIS_BUILD_NUMBER % (PORT_MAX - PORT_MIN)),
-    PORT_MIN + ((TRAVIS_BUILD_NUMBER + 100) % (PORT_MAX - PORT_MIN))
-  ];
-};
-

 module.exports = {

@@ -312,32 +297,5 @@ module.exports = {
      }
      next();
    };
-  },
-
-  parallelTask: function(args, options) {
-    var task = {
-      grunt: true,
-      args: args,
-      stream: options && options.stream
-    };
-
-    args.push('--port=' + this.sauceLabsAvailablePorts.pop());
-
-    if (args.indexOf('test:e2e') !== -1 && grunt.option('e2e-browsers')) {
-      args.push('--browsers=' + grunt.option('e2e-browsers'));
-    } else if (grunt.option('browsers')) {
-      args.push('--browsers=' + grunt.option('browsers'));
-    }
-
-    if (grunt.option('reporters')) {
-      args.push('--reporters=' + grunt.option('reporters'));
-    }
-
-    return task;
-  },
-
-  // see http://saucelabs.com/docs/connect#localhost
-  sauceLabsAvailablePorts: [9000, 9001, 9080, 9090, 9876],
-  // pseudo-random port numbers for BrowserStack
-  availablePorts: getRandomPorts()
+  }
 };
@@ -91,15 +91,6 @@ var getTaggedVersion = function() {
  return null;
 };

-/**
- * Stable versions have an even minor version and have no prerelease
- * @param  {SemVer}  version The version to test
- * @return {Boolean}         True if the version is stable
- */
-var isStable = function(version) {
-  return semver.satisfies(version, '1.0 || 1.2') && version.prerelease.length === 0;
-};
-
 /**
 * Get a collection of all the previous versions sorted by semantic version
 * @return {Array.<SemVer>} The collection of previous versions
@@ -119,8 +110,6 @@ var getPreviousVersions =  function() {
      })
      .filter()
      .map(function(version) {
-        version.isStable = isStable(version);
-
        version.docsUrl = 'http://code.angularjs.org/' + version.version + '/docs';
        // Versions before 1.0.2 had a different docs folder name
        if ( version.major < 1 || (version.major === 1 && version.minor === 0 && version.dot < 2 ) ) {
@@ -1395,7 +1395,7 @@
      }
    },
    "dgeni-packages": {
-      "version": "0.10.5",
+      "version": "0.10.7",
      "dependencies": {
        "catharsis": {
          "version": "0.7.1"
@@ -1454,7 +1454,7 @@
          "version": "1.2.2"
        },
        "estraverse": {
-          "version": "1.5.1"
+          "version": "1.7.1"
        },
        "glob": {
          "version": "3.2.11",
@@ -1465,16 +1465,16 @@
          }
        },
        "htmlparser2": {
-          "version": "3.7.3",
+          "version": "3.8.2",
          "dependencies": {
            "domhandler": {
-              "version": "2.2.0"
+              "version": "2.3.0"
            },
            "domutils": {
              "version": "1.5.0"
            },
            "domelementtype": {
-              "version": "1.1.1"
+              "version": "1.1.3"
            },
            "readable-stream": {
              "version": "1.1.13",
@@ -1528,7 +1528,7 @@
              "dependencies": {
                "fsevents": {
                  "version": "0.2.1",
-                  "from": "fsevents@git://github.com/pipobscure/fsevents#7dcdf9fa3f8956610fd6f69f72c67bace2de7138",
+                  "from": "git://github.com/pipobscure/fsevents#7dcdf9fa3f8956610fd6f69f72c67bace2de7138",
                  "resolved": "git://github.com/pipobscure/fsevents#7dcdf9fa3f8956610fd6f69f72c67bace2de7138",
                  "dependencies": {
                    "nan": {
@@ -1596,7 +1596,7 @@
                  "version": "0.0.10",
                  "dependencies": {
                    "combined-stream": {
-                      "version": "0.0.5",
+                      "version": "0.0.7",
                      "dependencies": {
                        "delayed-stream": {
                          "version": "0.0.5"
@@ -25,7 +25,6 @@
    "grunt-jasmine-node": "git://github.com/vojtajina/grunt-jasmine-node.git#fix-grunt-exit-code",
    "grunt-jscs": "~0.7.1",
    "grunt-merge-conflict": "~0.0.1",
-    "grunt-parallel": "~0.3.1",
    "grunt-shell": "~1.1.1",
    "gulp": "~3.8.0",
    "gulp-concat": "^2.4.1",
@@ -38,8 +37,8 @@
    "jasmine-node": "~1.14.5",
    "jasmine-reporters": "~1.0.1",
    "jshint-stylish": "~1.0.0",
-    "karma": "^0.12.0",
-    "karma-browserstack-launcher": "0.1.1",
+    "karma": "vojtajina/karma#socketio_10",
+    "karma-browserstack-launcher": "0.1.2",
    "karma-chrome-launcher": "0.1.5",
    "karma-firefox-launcher": "0.1.3",
    "karma-jasmine": "0.1.5",
@@ -2,32 +2,81 @@

 var config = require('./protractor-shared-conf').config;

-config.sauceUser = process.env.SAUCE_USERNAME;
-config.sauceKey = process.env.SAUCE_ACCESS_KEY;
+if (process.env.BROWSER_PROVIDER === 'browserstack') {
+  // Using BrowserStack.
+  config.seleniumAddress = 'http://hub.browserstack.com/wd/hub';
+  config.multiCapabilities = [
+    capabilitiesForBrowserStack({
+      browserName: 'chrome',
+      platform: 'MAC',
+      version: '34'
+    }),
+    capabilitiesForBrowserStack({
+      browserName: 'firefox',
+      version: '28'
+    }),
+    capabilitiesForBrowserStack({
+      browserName: 'safari',
+      platform: 'MAC',
+      version: '7'
+    })
+  ];
+} else {
+  // Using SauceLabs.
+  config.sauceUser = process.env.SAUCE_USERNAME;
+  config.sauceKey = process.env.SAUCE_ACCESS_KEY;
+  config.multiCapabilities = [
+    capabilitiesForSauceLabs({
+      browserName: 'chrome',
+      platform: 'OS X 10.9',
+      version: '34'
+    }),
+    capabilitiesForSauceLabs({
+      browserName: 'firefox',
+      version: '28'
+    }),
+    capabilitiesForSauceLabs({
+      browserName: 'safari',
+      platform: 'OS X 10.9',
+      version: '7'
+    })
+  ];
+}

-config.multiCapabilities = [{
-  'browserName': 'chrome',
-  'platform': 'OS X 10.9',
-  'name': 'Angular E2E',
-  'tunnel-identifier': process.env.TRAVIS_JOB_NUMBER,
-  'build': process.env.TRAVIS_BUILD_NUMBER,
-  'version': '34'
-}, {
-  'browserName': 'firefox',
-  'name': 'Angular E2E',
-  'tunnel-identifier': process.env.TRAVIS_JOB_NUMBER,
-  'build': process.env.TRAVIS_BUILD_NUMBER,
-  'version': '28'
-}, {
-  browserName: 'safari',
-  'platform': 'OS X 10.9',
-  'version': '7',
-  'name': 'Angular E2E',
-  'tunnel-identifier': process.env.TRAVIS_JOB_NUMBER,
-  'build': process.env.TRAVIS_BUILD_NUMBER
-}];

 config.allScriptsTimeout = 30000;
 config.getPageTimeout = 30000;

 exports.config = config;
+
+
+function capabilitiesForBrowserStack(capabilities) {
+  return {
+    'browserstack.user': process.env.BROWSER_STACK_USERNAME,
+    'browserstack.key': process.env.BROWSER_STACK_ACCESS_KEY,
+    'browserstack.local' : 'true',
+    'browserstack.debug': 'true',
+    'browserstack.tunnelIdentifier': process.env.TRAVIS_JOB_NUMBER,
+    'tunnelIdentifier': process.env.TRAVIS_JOB_NUMBER,
+
+    'name': 'Angular E2E',
+    'build': process.env.TRAVIS_BUILD_NUMBER,
+
+    'browserName': capabilities.browserName,
+    'platform': capabilities.platform,
+    'version': capabilities.version
+  };
+}
+
+function capabilitiesForSauceLabs(capabilities) {
+  return {
+    'tunnel-identifier': process.env.TRAVIS_JOB_NUMBER,
+
+    'name': 'Angular E2E',
+    'build': process.env.TRAVIS_BUILD_NUMBER,
+
+    'browserName': capabilities.browserName,
+    'platform': capabilities.platform,
+    'version': capabilities.version
+  };
+}
@@ -96,8 +96,14 @@ function publish {
    # don't publish every build to npm
    if [ "${NEW_VERSION/+sha}" = "$NEW_VERSION" ] ; then
      if [ "${NEW_VERSION/-}" = "$NEW_VERSION" ] ; then
-        # publish releases as "latest"
-        npm publish
+        if [[ $NEW_VERSION =~ ^1\.2\.[0-9]+$ ]] ; then
+          # publish 1.2.x releases with the appropriate tag
+          # this ensures that `npm install` by default will not grab `1.2.x` releases
+          npm publish --tag=old
+        else
+          # publish releases as "latest"
+          npm publish
+        fi
      else
        # publish prerelease builds with the beta tag
        npm publish --tag=beta
@@ -2,13 +2,20 @@

 set -e

+export BROWSER_STACK_ACCESS_KEY=`echo $BROWSER_STACK_ACCESS_KEY | rev`
 export SAUCE_ACCESS_KEY=`echo $SAUCE_ACCESS_KEY | rev`

 if [ $JOB = "unit" ]; then
+  if [ "$BROWSER_PROVIDER" == "browserstack" ]; then
+    BROWSERS="BS_Chrome,BS_Safari,BS_Firefox,BS_IE_9,BS_IE_10,BS_IE_11"
+  else
+    BROWSERS="SL_Chrome,SL_Safari,SL_Firefox,SL_IE_9,SL_IE_10,SL_IE_11"
+  fi
+
  grunt test:promises-aplus
-  grunt test:unit --browsers SL_Chrome,SL_Safari,SL_Firefox,SL_IE_9,SL_IE_10,SL_IE_11 --reporters dots
+  grunt test:unit --browsers $BROWSERS --reporters dots
  grunt ci-checks
-  grunt tests:docs --browsers SL_Chrome,SL_Safari,SL_Firefox,SL_IE_9,SL_IE_10,SL_IE_11 --reporters dots
+  grunt tests:docs --browsers $BROWSERS --reporters dots
  grunt test:travis-protractor --specs "docs/app/e2e/**/*.scenario.js"
 elif [ $JOB = "e2e" ]; then
  if [ $TEST_TARGET = "jquery" ]; then
@@ -0,0 +1,14 @@
+#!/bin/bash
+# Has to be run from project root directory.
+
+
+if [ "$BROWSER_PROVIDER" == "browserstack" ]; then
+  echo "Using BrowserStack"
+elif [ "$BROWSER_PROVIDER" == "saucelabs" ]; then
+  echo "Using SauceLabs"
+else
+  echo "Invalid BROWSER_PROVIDER. Please set env var BROWSER_PROVIDER to 'saucelabs' or 'browserstack'."
+  exit 1
+fi
+
+./lib/${BROWSER_PROVIDER}/start_tunnel.sh
@@ -162,8 +162,8 @@ if ('i' !== 'I'.toLowerCase()) {
 }


-var /** holds major version number for IE or NaN for real browsers */
-    msie,
+var
+    msie,             // holds major version number for IE, or NaN if UA is not IE.
    jqLite,           // delay binding since jQuery could be loaded after us.
    jQuery,           // delay binding
    slice             = [].slice,
@@ -362,7 +362,7 @@ function int(str) {


 function inherit(parent, extra) {
-  return extend(new (extend(function() {}, {prototype:parent}))(), extra);
+  return extend(Object.create(parent), extra);
 }

 /**
@@ -625,7 +625,7 @@ function makeMap(str) {


 function nodeName_(element) {
-  return lowercase(element.nodeName || element[0].nodeName);
+  return lowercase(element.nodeName || (element[0] && element[0].nodeName));
 }

 function includes(array, obj) {
@@ -964,12 +964,16 @@ function toJsonReplacer(key, value) {
 * stripped since angular uses this notation internally.
 *
 * @param {Object|Array|Date|string|number} obj Input to be serialized into JSON.
- * @param {boolean=} pretty If set to true, the JSON output will contain newlines and whitespace.
+ * @param {boolean|number=} pretty If set to true, the JSON output will contain newlines and whitespace.
+ *    If set to an integer, the JSON output will contain that many spaces per indentation (the default is 2).
 * @returns {string|undefined} JSON-ified string representing `obj`.
 */
 function toJson(obj, pretty) {
  if (typeof obj === 'undefined') return undefined;
-  return JSON.stringify(obj, toJsonReplacer, pretty ? '  ' : null);
+  if (!isNumber(pretty)) {
+    pretty = pretty ? 2 : null;
+  }
+  return JSON.stringify(obj, toJsonReplacer, pretty);
 }


@@ -1331,8 +1335,8 @@ function angularInit(element, bootstrap) {
 * @param {Object=} config an object for defining configuration options for the application. The
 *     following keys are supported:
 *
- *     - `strictDi`: disable automatic function annotation for the application. This is meant to
- *       assist in finding bugs which break minified code.
+ * * `strictDi` - disable automatic function annotation for the application. This is meant to
+ *   assist in finding bugs which break minified code. Defaults to `false`.
 *
 * @returns {auto.$injector} Returns the newly created injector for this app.
 */
@@ -83,7 +83,8 @@
  $TimeoutProvider,
  $$RAFProvider,
  $$AsyncCallbackProvider,
-  $WindowProvider
+  $WindowProvider,
+  $$jqLiteProvider
 */


@@ -236,7 +237,8 @@ function publishExternalAPI(angular) {
        $timeout: $TimeoutProvider,
        $window: $WindowProvider,
        $$rAF: $$RAFProvider,
-        $$asyncCallback: $$AsyncCallbackProvider
+        $$asyncCallback: $$AsyncCallbackProvider,
+        $$jqLite: $$jqLiteProvider
      });
    }
  ]);
@@ -10,9 +10,10 @@
 * Creates an injector object that can be used for retrieving services as well as for
 * dependency injection (see {@link guide/di dependency injection}).
 *
-
 * @param {Array.<string|Function>} modules A list of module functions or their aliases. See
- *        {@link angular.module}. The `ng` module must be explicitly added.
+ *     {@link angular.module}. The `ng` module must be explicitly added.
+ * @param {boolean=} [strictDi=false] Whether the injector should be in strict mode, which
+ *     disallows argument name annotation inference.
 * @returns {injector} Injector object. See {@link auto.$injector $injector}.
 *
 * @example
@@ -158,8 +159,10 @@ function annotate(fn, strictDi, name) {
 * ## Inference
 *
 * In JavaScript calling `toString()` on a function returns the function definition. The definition
- * can then be parsed and the function arguments can be extracted. *NOTE:* This does not work with
- * minification, and obfuscation tools since these tools change the argument names.
+ * can then be parsed and the function arguments can be extracted. This method of discovering
+ * annotations is disallowed when the injector is in strict mode.
+ * *NOTE:* This does not work with minification, and obfuscation tools since these tools change the
+ * argument names.
 *
 * ## `$inject` Annotation
 * By adding an `$inject` property onto a function the injection parameters can be specified.
@@ -176,6 +179,7 @@ function annotate(fn, strictDi, name) {
 * Return an instance of the service.
 *
 * @param {string} name The name of the instance to retrieve.
+ * @param {string} caller An optional string to provide the origin of the function call for error messages.
 * @return {*} The instance.
 */

@@ -244,6 +248,8 @@ function annotate(fn, strictDi, name) {
 *   expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
 * ```
 *
+ * You can disallow this method by using strict injection mode.
+ *
 * This method does not work with code minification / obfuscation. For this reason the following
 * annotation strategies are supported.
 *
@@ -296,6 +302,8 @@ function annotate(fn, strictDi, name) {
 * @param {Function|Array.<string|Function>} fn Function for which dependent service names need to
 * be retrieved as described above.
 *
+ * @param {boolean=} [strictDi=false] Disallow argument name annotation inference.
+ *
 * @returns {Array.<string>} The names of the services which the function requires.
 */

@@ -622,14 +630,17 @@ function createInjector(modulesToLoad, strictDi) {
          }
      },
      providerInjector = (providerCache.$injector =
-          createInternalInjector(providerCache, function() {
+          createInternalInjector(providerCache, function(serviceName, caller) {
+            if (angular.isString(caller)) {
+              path.push(caller);
+            }
            throw $injectorMinErr('unpr', "Unknown provider: {0}", path.join(' <- '));
          })),
      instanceCache = {},
      instanceInjector = (instanceCache.$injector =
-          createInternalInjector(instanceCache, function(servicename) {
-            var provider = providerInjector.get(servicename + providerSuffix);
-            return instanceInjector.invoke(provider.$get, provider, undefined, servicename);
+          createInternalInjector(instanceCache, function(serviceName, caller) {
+            var provider = providerInjector.get(serviceName + providerSuffix, caller);
+            return instanceInjector.invoke(provider.$get, provider, undefined, serviceName);
          }));


@@ -664,7 +675,7 @@ function createInjector(modulesToLoad, strictDi) {

  function enforceReturnValue(name, factory) {
    return function enforcedReturnValue() {
-      var result = instanceInjector.invoke(factory, this, undefined, name);
+      var result = instanceInjector.invoke(factory, this);
      if (isUndefined(result)) {
        throw $injectorMinErr('undef', "Provider '{0}' must return a value from $get factory method.", name);
      }
@@ -759,7 +770,7 @@ function createInjector(modulesToLoad, strictDi) {

  function createInternalInjector(cache, factory) {

-    function getService(serviceName) {
+    function getService(serviceName, caller) {
      if (cache.hasOwnProperty(serviceName)) {
        if (cache[serviceName] === INSTANTIATING) {
          throw $injectorMinErr('cdep', 'Circular dependency found: {0}',
@@ -770,7 +781,7 @@ function createInjector(modulesToLoad, strictDi) {
        try {
          path.unshift(serviceName);
          cache[serviceName] = INSTANTIATING;
-          return cache[serviceName] = factory(serviceName);
+          return cache[serviceName] = factory(serviceName, caller);
        } catch (err) {
          if (cache[serviceName] === INSTANTIATING) {
            delete cache[serviceName];
@@ -802,7 +813,7 @@ function createInjector(modulesToLoad, strictDi) {
        args.push(
          locals && locals.hasOwnProperty(key)
          ? locals[key]
-          : getService(key)
+          : getService(key, serviceName)
        );
      }
      if (isArray(fn)) {
@@ -815,14 +826,11 @@ function createInjector(modulesToLoad, strictDi) {
    }

    function instantiate(Type, locals, serviceName) {
-      var Constructor = function() {},
-          instance, returnedValue;
-
      // Check if Type is annotated and use just the given function at n-1 as parameter
      // e.g. someModule.factory('greeter', ['$window', function(renamed$window) {}]);
-      Constructor.prototype = (isArray(Type) ? Type[Type.length - 1] : Type).prototype;
-      instance = new Constructor();
-      returnedValue = invoke(Type, instance, locals, serviceName);
+      // Object creation: http://jsperf.com/create-constructor/2
+      var instance = Object.create((isArray(Type) ? Type[Type.length - 1] : Type).prototype);
+      var returnedValue = invoke(Type, instance, locals, serviceName);

      return isObject(returnedValue) || isFunction(returnedValue) ? returnedValue : instance;
    }
@@ -87,10 +87,12 @@
 *   `'ngModel'`).
 * - `injector()` - retrieves the injector of the current element or its parent.
 * - `scope()` - retrieves the {@link ng.$rootScope.Scope scope} of the current
- *   element or its parent.
+ *   element or its parent. Requires {@link guide/production#disabling-debug-data Debug Data} to
+ *   be enabled.
 * - `isolateScope()` - retrieves an isolate {@link ng.$rootScope.Scope scope} if one is attached directly to the
 *   current element. This getter should be used only on elements that contain a directive which starts a new isolate
 *   scope. Calling `scope()` on this element always returns the original non-isolate scope.
+ *   Requires {@link guide/production#disabling-debug-data Debug Data} to be enabled.
 * - `inheritedData()` - same as `data()`, but walks up the DOM until a value is found or the top
 *   parent element is reached.
 *
@@ -1001,3 +1003,24 @@ forEach({
  JQLite.prototype.bind = JQLite.prototype.on;
  JQLite.prototype.unbind = JQLite.prototype.off;
 });
+
+
+// Provider for private $$jqLite service
+function $$jqLiteProvider() {
+  this.$get = function $$jqLite() {
+    return extend(JQLite, {
+      hasClass: function(node, classes) {
+        if (node.attr) node = node[0];
+        return jqLiteHasClass(node, classes);
+      },
+      addClass: function(node, classes) {
+        if (node.attr) node = node[0];
+        return jqLiteAddClass(node, classes);
+      },
+      removeClass: function(node, classes) {
+        if (node.attr) node = node[0];
+        return jqLiteRemoveClass(node, classes);
+      }
+    });
+  };
+}
@@ -61,6 +61,11 @@ function Browser(window, document, $log, $sniffer) {
    }
  }

+  function getHash(url) {
+    var index = url.indexOf('#');
+    return index === -1 ? '' : url.substr(index + 1);
+  }
+
  /**
   * @private
   * Note: this method is used only by scenario runner
@@ -170,7 +175,7 @@ function Browser(window, document, $log, $sniffer) {
      // IE<10 from getting into redirect loop when in LocationHashbangInHtml5Url mode.
      // See https://github.com/angular/angular.js/commit/ffb2701
      if (lastBrowserUrl === url && (!$sniffer.history || sameState)) {
-        return;
+        return self;
      }
      var sameBase = lastBrowserUrl && stripHash(lastBrowserUrl) === stripHash(url);
      lastBrowserUrl = url;
@@ -190,8 +195,10 @@ function Browser(window, document, $log, $sniffer) {
        }
        if (replace) {
          location.replace(url);
-        } else {
+        } else if (!sameBase) {
          location.href = url;
+        } else {
+          location.hash = getHash(url);
        }
      }
      return self;
@@ -115,7 +115,7 @@
 * #### `multiElement`
 * When this property is set to true, the HTML compiler will collect DOM nodes between
 * nodes with the attributes `directive-name-start` and `directive-name-end`, and group them
- * together as the directive elements. It is recomended that this feature be used on directives
+ * together as the directive elements. It is recommended that this feature be used on directives
 * which are not strictly behavioural (such as {@link ngClick}), and which
 * do not manipulate or replace child nodes (such as {@link ngInclude}).
 *
@@ -803,7 +803,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
   * Retrieves or overrides the default regular expression that is used for whitelisting of safe
   * urls during a[href] sanitization.
   *
-   * The sanitization is a security measure aimed at prevent XSS attacks via html links.
+   * The sanitization is a security measure aimed at preventing XSS attacks via html links.
   *
   * Any url about to be assigned to a[href] via data-binding is first normalized and turned into
   * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationWhitelist`
@@ -870,7 +870,7 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
   * * `ng-binding` CSS class
   * * `$binding` data property containing an array of the binding expressions
   *
-   * You may want to use this in production for a significant performance boost. See
+   * You may want to disable this in production for a significant performance boost. See
   * {@link guide/production#disabling-debug-data Disabling Debug Data} for more.
   *
   * The default value is true.
@@ -907,6 +907,21 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
    };

    Attributes.prototype = {
+      /**
+       * @ngdoc method
+       * @name $compile.directive.Attributes#$normalize
+       * @kind function
+       *
+       * @description
+       * Converts an attribute name (e.g. dash/colon/underscore-delimited string, optionally prefixed with `x-` or
+       * `data-`) to its normalized, camelCase form.
+       *
+       * Also there is special case for Moz prefix starting with upper case letter.
+       *
+       * For further information check out the guide on {@link guide/directive#matching-directives Matching Directives}
+       *
+       * @param {string} name Name to normalize
+       */
      $normalize: directiveNormalize,


@@ -2227,10 +2242,10 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
        var childBoundTranscludeFn = boundTranscludeFn;
        if (scope.$$destroyed) return;
        if (linkQueue) {
-          linkQueue.push(scope);
-          linkQueue.push(node);
-          linkQueue.push(rootElement);
-          linkQueue.push(childBoundTranscludeFn);
+          linkQueue.push(scope,
+                         node,
+                         rootElement,
+                         childBoundTranscludeFn);
        } else {
          if (afterTemplateNodeLinkFn.transcludeOnThisElement) {
            childBoundTranscludeFn = createBoundTranscludeFn(scope, afterTemplateNodeLinkFn.transclude, boundTranscludeFn);
@@ -2485,13 +2500,6 @@ function $CompileProvider($provide, $$sanitizeUriProvider) {
 var PREFIX_REGEXP = /^((?:x|data)[\:\-_])/i;
 /**
 * Converts all accepted directives format into proper directive name.
- * All of these will become 'myDirective':
- *   my:Directive
- *   my-directive
- *   x-my-directive
- *   data-my:directive
- *
- * Also there is special case for Moz prefix starting with upper case letter.
 * @param name Name to normalize
 */
 function directiveNormalize(name) {
@@ -108,10 +108,10 @@ function $ControllerProvider() {
        //
        // This feature is not intended for use by applications, and is thus not documented
        // publicly.
-        var Constructor = function() {};
-        Constructor.prototype = (isArray(expression) ?
+        // Object creation: http://jsperf.com/create-constructor/2
+        var controllerPrototype = (isArray(expression) ?
          expression[expression.length - 1] : expression).prototype;
-        instance = new Constructor();
+        instance = Object.create(controllerPrototype);

        if (identifier) {
          addIdentifier(locals, identifier, instance, constructor || expression.name);
@@ -11,9 +11,8 @@
 * make the link go to the wrong URL if the user clicks it before
 * Angular has a chance to replace the `{{hash}}` markup with its
 * value. Until Angular replaces the markup the link will be broken
- * and will most likely return a 404 error.
- *
- * The `ngHref` directive solves this problem.
+ * and will most likely return a 404 error. The `ngHref` directive
+ * solves this problem.
 *
 * The wrong way to write it:
 * ```html
@@ -471,9 +471,7 @@ var formDirectiveFactory = function(isNgForm) {
                  controller.$setSubmitted();
                });

-                event.preventDefault
-                  ? event.preventDefault()
-                  : event.returnValue = false; // IE
+                event.preventDefault();
              };

              addEventListenerFn(formElement[0], 'submit', handleFormSubmission);
@@ -41,7 +41,8 @@ var inputType = {
   * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
   *    minlength.
   * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
-   *    maxlength.
+   *    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
+   *    any length.
   * @param {string=} 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.
@@ -589,7 +590,8 @@ var inputType = {
   * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
   *    minlength.
   * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
-   *    maxlength.
+   *    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
+   *    any length.
   * @param {string=} 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.
@@ -676,7 +678,8 @@ var inputType = {
   * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
   *    minlength.
   * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
-   *    maxlength.
+   *    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
+   *    any length.
   * @param {string=} 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.
@@ -764,7 +767,8 @@ var inputType = {
   * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
   *    minlength.
   * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
-   *    maxlength.
+   *    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of
+   *    any length.
   * @param {string=} 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.
@@ -950,7 +954,6 @@ function textInputType(scope, element, attr, ctrl, $sniffer, $browser) {
 }

 function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
-  var placeholder = element[0].placeholder, noevent = {};
  var type = lowercase(element[0].type);

  // In composition mode, users are still inputing intermediate text buffer,
@@ -970,19 +973,14 @@ function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
  }

  var listener = function(ev) {
+    if (timeout) {
+      $browser.defer.cancel(timeout);
+      timeout = null;
+    }
    if (composing) return;
    var value = element.val(),
        event = ev && ev.type;

-    // IE (11 and under) seem to emit an 'input' event if the placeholder value changes.
-    // We don't want to dirty the value when this happens, so we abort here. Unfortunately,
-    // IE also sends input events for other non-input-related things, (such as focusing on a
-    // form control), so this change is not entirely enough to solve this.
-    if (msie && (ev || noevent).type === 'input' && element[0].placeholder !== placeholder) {
-      placeholder = element[0].placeholder;
-      return;
-    }
-
    // By default we will trim the value
    // If the attribute ng-trim exists we will avoid trimming
    // If input type is 'password', the value is never trimmed
@@ -1005,11 +1003,13 @@ function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
  } else {
    var timeout;

-    var deferListener = function(ev) {
+    var deferListener = function(ev, input, origValue) {
      if (!timeout) {
        timeout = $browser.defer(function() {
-          listener(ev);
          timeout = null;
+          if (!input || input.value !== origValue) {
+            listener(ev);
+          }
        });
      }
    };
@@ -1021,7 +1021,7 @@ function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
      //    command            modifiers                   arrows
      if (key === 91 || (15 < key && key < 19) || (37 <= key && key <= 40)) return;

-      deferListener(event);
+      deferListener(event, this, this.value);
    });

    // if user modifies input value using context menu in IE, we need "paste" and "cut" events to catch it
@@ -1035,7 +1035,7 @@ function baseInputType(scope, element, attr, ctrl, $sniffer, $browser) {
  element.on('change', listener);

  ctrl.$render = function() {
-    element.val(ctrl.$isEmpty(ctrl.$modelValue) ? '' : ctrl.$viewValue);
+    element.val(ctrl.$isEmpty(ctrl.$viewValue) ? '' : ctrl.$viewValue);
  };
 }

@@ -1145,10 +1145,10 @@ function createDateInputType(type, regexp, parseDate, format) {
    });

    ctrl.$formatters.push(function(value) {
-      if (!ctrl.$isEmpty(value)) {
-        if (!isDate(value)) {
-          throw $ngModelMinErr('datefmt', 'Expected `{0}` to be a date', value);
-        }
+      if (value && !isDate(value)) {
+        throw $ngModelMinErr('datefmt', 'Expected `{0}` to be a date', value);
+      }
+      if (isValidDate(value)) {
        previousDate = value;
        if (previousDate && timezone === 'UTC') {
          var timezoneOffset = 60000 * previousDate.getTimezoneOffset();
@@ -1157,14 +1157,14 @@ function createDateInputType(type, regexp, parseDate, format) {
        return $filter('date')(value, format, timezone);
      } else {
        previousDate = null;
+        return '';
      }
-      return '';
    });

    if (isDefined(attr.min) || attr.ngMin) {
      var minVal;
      ctrl.$validators.min = function(value) {
-        return ctrl.$isEmpty(value) || isUndefined(minVal) || parseDate(value) >= minVal;
+        return !isValidDate(value) || isUndefined(minVal) || parseDate(value) >= minVal;
      };
      attr.$observe('min', function(val) {
        minVal = parseObservedDateValue(val);
@@ -1175,18 +1175,18 @@ function createDateInputType(type, regexp, parseDate, format) {
    if (isDefined(attr.max) || attr.ngMax) {
      var maxVal;
      ctrl.$validators.max = function(value) {
-        return ctrl.$isEmpty(value) || isUndefined(maxVal) || parseDate(value) <= maxVal;
+        return !isValidDate(value) || isUndefined(maxVal) || parseDate(value) <= maxVal;
      };
      attr.$observe('max', function(val) {
        maxVal = parseObservedDateValue(val);
        ctrl.$validate();
      });
    }
-    // Override the standard $isEmpty to detect invalid dates as well
-    ctrl.$isEmpty = function(value) {
+
+    function isValidDate(value) {
      // Invalid Date: getTime() returns NaN
-      return !value || (value.getTime && value.getTime() !== value.getTime());
-    };
+      return value && !(value.getTime && value.getTime() !== value.getTime());
+    }

    function parseObservedDateValue(val) {
      return isDefined(val) ? (isDate(val) ? val : parseDate(val)) : undefined;
@@ -1270,7 +1270,8 @@ function urlInputType(scope, element, attr, ctrl, $sniffer, $browser) {
  stringBasedInputType(ctrl);

  ctrl.$$parserName = 'url';
-  ctrl.$validators.url = function(value) {
+  ctrl.$validators.url = function(modelValue, viewValue) {
+    var value = modelValue || viewValue;
    return ctrl.$isEmpty(value) || URL_REGEXP.test(value);
  };
 }
@@ -1282,7 +1283,8 @@ function emailInputType(scope, element, attr, ctrl, $sniffer, $browser) {
  stringBasedInputType(ctrl);

  ctrl.$$parserName = 'email';
-  ctrl.$validators.email = function(value) {
+  ctrl.$validators.email = function(modelValue, viewValue) {
+    var value = modelValue || viewValue;
    return ctrl.$isEmpty(value) || EMAIL_REGEXP.test(value);
  };
 }
@@ -1336,9 +1338,11 @@ function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browser, $filt
    element[0].checked = ctrl.$viewValue;
  };

-  // Override the standard `$isEmpty` because an empty checkbox is never equal to the trueValue
+  // Override the standard `$isEmpty` because the $viewValue of an empty checkbox is always set to `false`
+  // This is because of the parser below, which compares the `$modelValue` with `trueValue` to convert
+  // it to a boolean.
  ctrl.$isEmpty = function(value) {
-    return value !== trueValue;
+    return value === false;
  };

  ctrl.$formatters.push(function(value) {
@@ -1370,7 +1374,8 @@ function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browser, $filt
 * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
 *    minlength.
 * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
- *    maxlength.
+ *    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any
+ *    length.
 * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
 *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
 *    patterns defined as scope expressions.
@@ -1402,7 +1407,8 @@ function checkboxInputType(scope, element, attr, ctrl, $sniffer, $browser, $filt
 * @param {number=} ngMinlength Sets `minlength` validation error key if the value is shorter than
 *    minlength.
 * @param {number=} ngMaxlength Sets `maxlength` validation error key if the value is longer than
- *    maxlength.
+ *    maxlength. Setting the attribute to a negative or non-numeric value, allows view values of any
+ *    length.
 * @param {string=} ngPattern Sets `pattern` validation error key if the value does not match the
 *    RegExp pattern expression. Expected value is `/regexp/` for inline patterns or `regexp` for
 *    patterns defined as scope expressions.
@@ -1618,13 +1624,18 @@ is set to `true`. The parse error is stored in `ngModel.$error.parse`.
 *
 * @description
 *
- * `NgModelController` provides API for the `ng-model` directive. The controller contains
- * services for data-binding, validation, CSS updates, and value formatting and parsing. It
- * purposefully does not contain any logic which deals with DOM rendering or listening to
- * DOM events. Such DOM related logic should be provided by other directives which make use of
- * `NgModelController` for data-binding.
+ * `NgModelController` provides API for the {@link ngModel `ngModel`} directive.
+ * The controller contains services for data-binding, validation, CSS updates, and value formatting
+ * and parsing. It purposefully does not contain any logic which deals with DOM rendering or
+ * listening to DOM events.
+ * Such DOM related logic should be provided by other directives which make use of
+ * `NgModelController` for data-binding to control elements.
+ * Angular provides this DOM logic for most {@link input `input`} elements.
+ * At the end of this page you can find a {@link ngModel.NgModelController#custom-control-example
+ * custom control example} that uses `ngModelController` to bind to `contenteditable` elements.
 *
- * ## Custom Control Example
+ * @example
+ * ### Custom Control Example
 * This example shows how to use `NgModelController` with a custom control to achieve
 * data-binding. Notice how different directives (`contenteditable`, `ng-model`, and `required`)
 * collaborate together to achieve the desired result.
@@ -1721,6 +1732,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
    function($scope, $exceptionHandler, $attr, $element, $parse, $animate, $timeout, $rootScope, $q, $interpolate) {
  this.$viewValue = Number.NaN;
  this.$modelValue = Number.NaN;
+  this.$$rawModelValue = undefined; // stores the parsed modelValue / model set from scope regardless of validity.
  this.$validators = {};
  this.$asyncValidators = {};
  this.$parsers = [];
@@ -1739,32 +1751,33 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$


  var parsedNgModel = $parse($attr.ngModel),
+      parsedNgModelAssign = parsedNgModel.assign,
+      ngModelGet = parsedNgModel,
+      ngModelSet = parsedNgModelAssign,
      pendingDebounce = null,
      ctrl = this;

-  var ngModelGet = function ngModelGet() {
-    var modelValue = parsedNgModel($scope);
-    if (ctrl.$options && ctrl.$options.getterSetter && isFunction(modelValue)) {
-      modelValue = modelValue();
-    }
-    return modelValue;
-  };
-
-  var ngModelSet = function ngModelSet(newValue) {
-    var getterSetter;
-    if (ctrl.$options && ctrl.$options.getterSetter &&
-        isFunction(getterSetter = parsedNgModel($scope))) {
-
-      getterSetter(ctrl.$modelValue);
-    } else {
-      parsedNgModel.assign($scope, ctrl.$modelValue);
-    }
-  };
-
  this.$$setOptions = function(options) {
    ctrl.$options = options;
+    if (options && options.getterSetter) {
+      var invokeModelGetter = $parse($attr.ngModel + '()'),
+          invokeModelSetter = $parse($attr.ngModel + '($$$p)');

-    if (!parsedNgModel.assign && (!options || !options.getterSetter)) {
+      ngModelGet = function($scope) {
+        var modelValue = parsedNgModel($scope);
+        if (isFunction(modelValue)) {
+          modelValue = invokeModelGetter($scope);
+        }
+        return modelValue;
+      };
+      ngModelSet = function($scope, newValue) {
+        if (isFunction(parsedNgModel($scope))) {
+          invokeModelSetter($scope, {$$$p: ctrl.$modelValue});
+        } else {
+          parsedNgModelAssign($scope, ctrl.$modelValue);
+        }
+      };
+    } else if (!parsedNgModel.assign) {
      throw $ngModelMinErr('nonassign', "Expression '{0}' is non-assignable. Element: {1}",
          $attr.ngModel, startingTag($element));
    }
@@ -1797,17 +1810,18 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
   * @name ngModel.NgModelController#$isEmpty
   *
   * @description
-   * This is called when we need to determine if the value of the input is empty.
+   * This is called when we need to determine if the value of an input is empty.
   *
   * For instance, the required directive does this to work out if the input has data or not.
+   *
   * The default `$isEmpty` function checks whether the value is `undefined`, `''`, `null` or `NaN`.
   *
   * You can override this for input directives whose concept of being empty is different to the
   * default. The `checkboxInputType` directive does this because in its case a value of `false`
   * implies empty.
   *
-   * @param {*} value Model value to check.
-   * @returns {boolean} True if `value` is empty.
+   * @param {*} value The value of the input to check for emptiness.
+   * @returns {boolean} True if `value` is "empty".
   */
  this.$isEmpty = function(value) {
    return isUndefined(value) || value === '' || value === null || value !== value;
@@ -1858,9 +1872,9 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
   * @description
   * Sets the control to its pristine state.
   *
-   * This method can be called to remove the 'ng-dirty' class and set the control to its pristine
-   * state (ng-pristine class). A model is considered to be pristine when the model has not been changed
-   * from when first compiled within then form.
+   * This method can be called to remove the `ng-dirty` class and set the control to its pristine
+   * state (`ng-pristine` class). A model is considered to be pristine when the control
+   * has not been changed from when first compiled.
   */
  this.$setPristine = function() {
    ctrl.$dirty = false;
@@ -1869,6 +1883,25 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
    $animate.addClass($element, PRISTINE_CLASS);
  };

+  /**
+   * @ngdoc method
+   * @name ngModel.NgModelController#$setDirty
+   *
+   * @description
+   * Sets the control to its dirty state.
+   *
+   * This method can be called to remove the `ng-pristine` class and set the control to its dirty
+   * state (`ng-dirty` class). A model is considered to be dirty when the control has been changed
+   * from when first compiled.
+   */
+  this.$setDirty = function() {
+    ctrl.$dirty = true;
+    ctrl.$pristine = false;
+    $animate.removeClass($element, PRISTINE_CLASS);
+    $animate.addClass($element, DIRTY_CLASS);
+    parentForm.$setDirty();
+  };
+
  /**
   * @ngdoc method
   * @name ngModel.NgModelController#$setUntouched
@@ -1876,8 +1909,8 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
   * @description
   * Sets the control to its untouched state.
   *
-   * This method can be called to remove the 'ng-touched' class and set the control to its
-   * untouched state (ng-untouched class). Upon compilation, a model is set as untouched
+   * This method can be called to remove the `ng-touched` class and set the control to its
+   * untouched state (`ng-untouched` class). Upon compilation, a model is set as untouched
   * by default, however this function can be used to restore that state if the model has
   * already been touched by the user.
   */
@@ -1894,10 +1927,9 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
   * @description
   * Sets the control to its touched state.
   *
-   * This method can be called to remove the 'ng-untouched' class and set the control to its
-   * touched state (ng-touched class). A model is considered to be touched when the user has
-   * first interacted (focussed) on the model input element and then shifted focus away (blurred)
-   * from the input element.
+   * This method can be called to remove the `ng-untouched` class and set the control to its
+   * touched state (`ng-touched` class). A model is considered to be touched when the user has
+   * first focused the control element and then shifted focus away from the control (blur event).
   */
  this.$setTouched = function() {
    ctrl.$touched = true;
@@ -1975,14 +2007,51 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
   * @name ngModel.NgModelController#$validate
   *
   * @description
-   * Runs each of the registered validators (first synchronous validators and then asynchronous validators).
+   * Runs each of the registered validators (first synchronous validators and then
+   * asynchronous validators).
+   * If the validity changes to invalid, the model will be set to `undefined`,
+   * unless {@link ngModelOptions `ngModelOptions.allowInvalid`} is `true`.
+   * If the validity changes to valid, it will set the model to the last available valid
+   * modelValue, i.e. either the last parsed value or the last value set from the scope.
   */
  this.$validate = function() {
    // ignore $validate before model is initialized
    if (isNumber(ctrl.$modelValue) && isNaN(ctrl.$modelValue)) {
      return;
    }
-    this.$$parseAndValidate();
+
+    var viewValue = ctrl.$$lastCommittedViewValue;
+    // Note: we use the $$rawModelValue as $modelValue might have been
+    // set to undefined during a view -> model update that found validation
+    // errors. We can't parse the view here, since that could change
+    // the model although neither viewValue nor the model on the scope changed
+    var modelValue = ctrl.$$rawModelValue;
+
+    // Check if the there's a parse error, so we don't unset it accidentially
+    var parserName = ctrl.$$parserName || 'parse';
+    var parserValid = ctrl.$error[parserName] ? false : undefined;
+
+    var prevValid = ctrl.$valid;
+    var prevModelValue = ctrl.$modelValue;
+
+    var allowInvalid = ctrl.$options && ctrl.$options.allowInvalid;
+
+    ctrl.$$runValidators(parserValid, modelValue, viewValue, function(allValid) {
+      // If there was no change in validity, don't update the model
+      // This prevents changing an invalid modelValue to undefined
+      if (!allowInvalid && prevValid !== allValid) {
+        // Note: Don't check ctrl.$valid here, as we could have
+        // external validators (e.g. calculated on the server),
+        // that just call $setValidity and need the model value
+        // to calculate their validity.
+        ctrl.$modelValue = allValid ? modelValue : undefined;
+
+        if (ctrl.$modelValue !== prevModelValue) {
+          ctrl.$$writeModelToScope();
+        }
+      }
+    });
+
  };

  this.$$runValidators = function(parseValid, modelValue, viewValue, doneCallback) {
@@ -2101,11 +2170,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$

    // change to dirty
    if (ctrl.$pristine) {
-      ctrl.$dirty = true;
-      ctrl.$pristine = false;
-      $animate.removeClass($element, PRISTINE_CLASS);
-      $animate.addClass($element, DIRTY_CLASS);
-      parentForm.$setDirty();
+      this.$setDirty();
    }
    this.$$parseAndValidate();
  };
@@ -2126,15 +2191,20 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
    }
    if (isNumber(ctrl.$modelValue) && isNaN(ctrl.$modelValue)) {
      // ctrl.$modelValue has not been touched yet...
-      ctrl.$modelValue = ngModelGet();
+      ctrl.$modelValue = ngModelGet($scope);
    }
    var prevModelValue = ctrl.$modelValue;
    var allowInvalid = ctrl.$options && ctrl.$options.allowInvalid;
+    ctrl.$$rawModelValue = modelValue;
+
    if (allowInvalid) {
      ctrl.$modelValue = modelValue;
      writeToModelIfNeeded();
    }
-    ctrl.$$runValidators(parserValid, modelValue, viewValue, function(allValid) {
+
+    // Pass the $$lastCommittedViewValue here, because the cached viewValue might be out of date.
+    // This can happen if e.g. $setViewValue is called from inside a parser
+    ctrl.$$runValidators(parserValid, modelValue, ctrl.$$lastCommittedViewValue, function(allValid) {
      if (!allowInvalid) {
        // Note: Don't check ctrl.$valid here, as we could have
        // external validators (e.g. calculated on the server),
@@ -2153,7 +2223,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
  };

  this.$$writeModelToScope = function() {
-    ngModelSet(ctrl.$modelValue);
+    ngModelSet($scope, ctrl.$modelValue);
    forEach(ctrl.$viewChangeListeners, function(listener) {
      try {
        listener();
@@ -2249,12 +2319,12 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
  //       ng-change executes in apply phase
  // 4. view should be changed back to 'a'
  $scope.$watch(function ngModelWatch() {
-    var modelValue = ngModelGet();
+    var modelValue = ngModelGet($scope);

    // if scope model value and ngModel value are out of sync
    // TODO(perf): why not move this to the action fn?
    if (modelValue !== ctrl.$modelValue) {
-      ctrl.$modelValue = modelValue;
+      ctrl.$modelValue = ctrl.$$rawModelValue = modelValue;

      var formatters = ctrl.$formatters,
          idx = formatters.length;
@@ -2439,7 +2509,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
     </file>
 * </example>
 */
-var ngModelDirective = function() {
+var ngModelDirective = ['$rootScope', function($rootScope) {
  return {
    restrict: 'A',
    require: ['ngModel', '^?form', '^?ngModelOptions'],
@@ -2483,15 +2553,17 @@ var ngModelDirective = function() {
          element.on('blur', function(ev) {
            if (modelCtrl.$touched) return;

-            scope.$apply(function() {
-              modelCtrl.$setTouched();
-            });
+            if ($rootScope.$$phase) {
+              scope.$evalAsync(modelCtrl.$setTouched);
+            } else {
+              scope.$apply(modelCtrl.$setTouched);
+            }
          });
        }
      };
    }
  };
-};
+}];


 /**
@@ -2580,8 +2652,8 @@ var requiredDirective = function() {
      if (!ctrl) return;
      attr.required = true; // force truthy in case we are on non input element

-      ctrl.$validators.required = function(value) {
-        return !attr.required || !ctrl.$isEmpty(value);
+      ctrl.$validators.required = function(modelValue, viewValue) {
+        return !attr.required || !ctrl.$isEmpty(viewValue);
      };

      attr.$observe('required', function() {
@@ -2630,13 +2702,14 @@ var maxlengthDirective = function() {
    link: function(scope, elm, attr, ctrl) {
      if (!ctrl) return;

-      var maxlength = 0;
+      var maxlength = -1;
      attr.$observe('maxlength', function(value) {
-        maxlength = int(value) || 0;
+        var intVal = int(value);
+        maxlength = isNaN(intVal) ? -1 : intVal;
        ctrl.$validate();
      });
      ctrl.$validators.maxlength = function(modelValue, viewValue) {
-        return ctrl.$isEmpty(modelValue) || viewValue.length <= maxlength;
+        return (maxlength < 0) || ctrl.$isEmpty(modelValue) || (viewValue.length <= maxlength);
      };
    }
  };
@@ -2655,7 +2728,7 @@ var minlengthDirective = function() {
        ctrl.$validate();
      });
      ctrl.$validators.minlength = function(modelValue, viewValue) {
-        return ctrl.$isEmpty(modelValue) || viewValue.length >= minlength;
+        return ctrl.$isEmpty(viewValue) || viewValue.length >= minlength;
      };
    }
  };
@@ -141,12 +141,11 @@ var ngBindTemplateDirective = ['$interpolate', '$compile', function($interpolate
 * @name ngBindHtml
 *
 * @description
- * Creates a binding that will innerHTML the result of evaluating the `expression` into the current
- * element in a secure way.  By default, the innerHTML-ed content will be sanitized using the {@link
- * ngSanitize.$sanitize $sanitize} service.  To utilize this functionality, ensure that `$sanitize`
- * is available, for example, by including {@link ngSanitize} in your module's dependencies (not in
- * core Angular). In order to use {@link ngSanitize} in your module's dependencies, you need to
- * include "angular-sanitize.js" in your application.
+ * Evaluates the expression and inserts the resulting HTML into the element in a secure way. By default,
+ * the resulting HTML content will be sanitized using the {@link ngSanitize.$sanitize $sanitize} service.
+ * To utilize this functionality, ensure that `$sanitize` is available, for example, by including {@link
+ * ngSanitize} in your module's dependencies (not in core Angular). In order to use {@link ngSanitize}
+ * in your module's dependencies, you need to include "angular-sanitize.js" in your application.
 *
 * You may also bypass sanitization for values you know are safe. To do so, bind to
 * an explicitly trusted value via {@link ng.$sce#trustAsHtml $sce.trustAsHtml}.  See the example
@@ -173,7 +173,9 @@
    </example>
 */
 var ngPluralizeDirective = ['$locale', '$interpolate', function($locale, $interpolate) {
-  var BRACE = /{}/g;
+  var BRACE = /{}/g,
+      IS_WHEN = /^when(Minus)?(.+)$/;
+
  return {
    restrict: 'EA',
    link: function(scope, element, attr) {
@@ -184,34 +186,44 @@ var ngPluralizeDirective = ['$locale', '$interpolate', function($locale, $interp
          whensExpFns = {},
          startSymbol = $interpolate.startSymbol(),
          endSymbol = $interpolate.endSymbol(),
-          isWhen = /^when(Minus)?(.+)$/;
+          braceReplacement = startSymbol + numberExp + '-' + offset + endSymbol,
+          watchRemover = angular.noop,
+          lastCount;

      forEach(attr, function(expression, attributeName) {
-        if (isWhen.test(attributeName)) {
-          whens[lowercase(attributeName.replace('when', '').replace('Minus', '-'))] =
-            element.attr(attr.$attr[attributeName]);
+        var tmpMatch = IS_WHEN.exec(attributeName);
+        if (tmpMatch) {
+          var whenKey = (tmpMatch[1] ? '-' : '') + lowercase(tmpMatch[2]);
+          whens[whenKey] = element.attr(attr.$attr[attributeName]);
        }
      });
      forEach(whens, function(expression, key) {
-        whensExpFns[key] =
-          $interpolate(expression.replace(BRACE, startSymbol + numberExp + '-' +
-            offset + endSymbol));
+        whensExpFns[key] = $interpolate(expression.replace(BRACE, braceReplacement));
+
      });

-      scope.$watch(function ngPluralizeWatch() {
-        var value = parseFloat(scope.$eval(numberExp));
+      scope.$watch(numberExp, function ngPluralizeWatchAction(newVal) {
+        var count = parseFloat(newVal);
+        var countIsNaN = isNaN(count);

-        if (!isNaN(value)) {
-          //if explicit number rule such as 1, 2, 3... is defined, just use it. Otherwise,
-          //check it against pluralization rules in $locale service
-          if (!(value in whens)) value = $locale.pluralCat(value - offset);
-           return whensExpFns[value](scope);
-        } else {
-          return '';
+        if (!countIsNaN && !(count in whens)) {
+          // If an explicit number rule such as 1, 2, 3... is defined, just use it.
+          // Otherwise, check it against pluralization rules in $locale service.
+          count = $locale.pluralCat(count - offset);
+        }
+
+        // If both `count` and `lastCount` are NaN, we don't need to re-register a watch.
+        // In JS `NaN !== NaN`, so we have to exlicitly check.
+        if ((count !== lastCount) && !(countIsNaN && isNaN(lastCount))) {
+          watchRemover();
+          watchRemover = scope.$watch(whensExpFns[count], updateElementText);
+          lastCount = count;
        }
-      }, function ngPluralizeWatchAction(newVal) {
-        element.text(newVal);
      });
+
+      function updateElementText(newText) {
+        element.text(newText || '');
+      }
    }
  };
 }];
@@ -38,17 +38,17 @@ var NG_HIDE_IN_PROGRESS_CLASS = 'ng-hide-animate';
 *
 * ### Overriding `.ng-hide`
 *
- * By default, the `.ng-hide` class will style the element with `display:none!important`. If you wish to change
+ * By default, the `.ng-hide` class will style the element with `display: none!important`. If you wish to change
 * the hide behavior with ngShow/ngHide then this can be achieved by restating the styles for the `.ng-hide`
 * class in CSS:
 *
 * ```css
 * .ng-hide {
 *   /&#42; this is just another form of hiding an element &#42;/
- *   display:block!important;
- *   position:absolute;
- *   top:-9999px;
- *   left:-9999px;
+ *   display: block!important;
+ *   position: absolute;
+ *   top: -9999px;
+ *   left: -9999px;
 * }
 * ```
 *
@@ -68,13 +68,13 @@ var NG_HIDE_IN_PROGRESS_CLASS = 'ng-hide-animate';
 * .my-element.ng-hide-add, .my-element.ng-hide-remove {
 *   /&#42; this is required as of 1.3x to properly
 *      apply all styling in a show/hide animation &#42;/
- *   transition:0s linear all;
+ *   transition: 0s linear all;
 * }
 *
 * .my-element.ng-hide-add-active,
 * .my-element.ng-hide-remove-active {
 *   /&#42; the transition is defined in the active class &#42;/
- *   transition:1s linear all;
+ *   transition: 1s linear all;
 * }
 *
 * .my-element.ng-hide-add { ... }
@@ -116,29 +116,29 @@ var NG_HIDE_IN_PROGRESS_CLASS = 'ng-hide-animate';
    </file>
    <file name="animations.css">
      .animate-show {
-        line-height:20px;
-        opacity:1;
-        padding:10px;
-        border:1px solid black;
-        background:white;
+        line-height: 20px;
+        opacity: 1;
+        padding: 10px;
+        border: 1px solid black;
+        background: white;
      }

      .animate-show.ng-hide-add.ng-hide-add-active,
      .animate-show.ng-hide-remove.ng-hide-remove-active {
-        -webkit-transition:all linear 0.5s;
-        transition:all linear 0.5s;
+        -webkit-transition: all linear 0.5s;
+        transition: all linear 0.5s;
      }

      .animate-show.ng-hide {
-        line-height:0;
-        opacity:0;
-        padding:0 10px;
+        line-height: 0;
+        opacity: 0;
+        padding: 0 10px;
      }

      .check-element {
-        padding:10px;
-        border:1px solid black;
-        background:white;
+        padding: 10px;
+        border: 1px solid black;
+        background: white;
      }
    </file>
    <file name="protractor.js" type="protractor">
@@ -212,17 +212,17 @@ var ngShowDirective = ['$animate', function($animate) {
 *
 * ### Overriding `.ng-hide`
 *
- * By default, the `.ng-hide` class will style the element with `display:none!important`. If you wish to change
+ * By default, the `.ng-hide` class will style the element with `display: none!important`. If you wish to change
 * the hide behavior with ngShow/ngHide then this can be achieved by restating the styles for the `.ng-hide`
 * class in CSS:
 *
 * ```css
 * .ng-hide {
 *   /&#42; this is just another form of hiding an element &#42;/
- *   display:block!important;
- *   position:absolute;
- *   top:-9999px;
- *   left:-9999px;
+ *   display: block!important;
+ *   position: absolute;
+ *   top: -9999px;
+ *   left: -9999px;
 * }
 * ```
 *
@@ -239,7 +239,7 @@ var ngShowDirective = ['$animate', function($animate) {
 * //a working example can be found at the bottom of this page
 * //
 * .my-element.ng-hide-add, .my-element.ng-hide-remove {
- *   transition:0.5s linear all;
+ *   transition: 0.5s linear all;
 * }
 *
 * .my-element.ng-hide-add { ... }
@@ -281,25 +281,25 @@ var ngShowDirective = ['$animate', function($animate) {
    </file>
    <file name="animations.css">
      .animate-hide {
-        -webkit-transition:all linear 0.5s;
-        transition:all linear 0.5s;
-        line-height:20px;
-        opacity:1;
-        padding:10px;
-        border:1px solid black;
-        background:white;
+        -webkit-transition: all linear 0.5s;
+        transition: all linear 0.5s;
+        line-height: 20px;
+        opacity: 1;
+        padding: 10px;
+        border: 1px solid black;
+        background: white;
      }

      .animate-hide.ng-hide {
-        line-height:0;
-        opacity:0;
-        padding:0 10px;
+        line-height: 0;
+        opacity: 0;
+        padding: 0 10px;
      }

      .check-element {
-        padding:10px;
-        border:1px solid black;
-        background:white;
+        padding: 10px;
+        border: 1px solid black;
+        background: white;
      }
    </file>
    <file name="protractor.js" type="protractor">
@@ -34,7 +34,7 @@
         }]);
       </script>
       <div ng-controller="ExampleController">
-         <input ng-model="title"><br>
+         <input ng-model="title"> <br/>
         <textarea ng-model="text"></textarea> <br/>
         <pane title="{{title}}">{{text}}</pane>
       </div>
@@ -40,7 +40,6 @@ var scriptDirective = ['$templateCache', function($templateCache) {
    compile: function(element, attr) {
      if (attr.type == 'text/ng-template') {
        var templateUrl = attr.id,
-            // IE is not consistent, in scripts we have to read .text but in other nodes we have to read .textContent
            text = element[0].text;

        $templateCache.put(templateUrl, text);
@@ -42,9 +42,9 @@ var ngOptionsMinErr = minErr('ngOptions');
 * or property name (for object data sources) of the value within the collection. If a `track by` expression
 * is used, the result of that expression will be set as the value of the `option` and `select` elements.
 *
- * ### `select as` with `trackexpr`
+ * ### `select as` with `track by`
 *
- * Using `select as` together with `trackexpr` is not recommended. Reasoning:
+ * Using `select as` together with `track by` is not recommended. Reasoning:
 *
 * - Example: &lt;select ng-options="item.subItem as item.label for item in values track by item.id" ng-model="selected"&gt;
 *   values: [{id: 1, label: 'aLabel', subItem: {name: 'aSubItem'}}, {id: 2, label: 'bLabel', subItem: {name: 'bSubItem'}}],
@@ -69,8 +69,10 @@ var ngOptionsMinErr = minErr('ngOptions');
 *   * for array data sources:
 *     * `label` **`for`** `value` **`in`** `array`
 *     * `select` **`as`** `label` **`for`** `value` **`in`** `array`
- *     * `label`  **`group by`** `group` **`for`** `value` **`in`** `array`
- *     * `select` **`as`** `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
+ *     * `label` **`group by`** `group` **`for`** `value` **`in`** `array`
+ *     * `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
+ *     * `label` **`for`** `value` **`in`** `array` | orderBy:`orderexpr` **`track by`** `trackexpr`
+ *        (for including a filter with `track by`)
 *   * for object data sources:
 *     * `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
 *     * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
@@ -212,7 +214,7 @@ var selectDirective = ['$compile', '$parse', function($compile,   $parse) {
      self.removeOption = function(value) {
        if (this.hasOption(value)) {
          delete optionsMap[value];
-          if (ngModelCtrl.$viewValue == value) {
+          if (ngModelCtrl.$viewValue === value) {
            this.renderUnknownOption(value);
          }
        }
@@ -679,18 +681,23 @@ var selectDirective = ['$compile', '$parse', function($compile,   $parse) {
              updateLabelMap(labelMap, option.label, false);
              option.element.remove();
            }
-            forEach(labelMap, function(count, label) {
-              if (count > 0) {
-                selectCtrl.addOption(label);
-              } else if (count < 0) {
-                selectCtrl.removeOption(label);
-              }
-            });
          }
          // remove any excessive OPTGROUPs from select
          while (optionGroupsCache.length > groupIndex) {
-            optionGroupsCache.pop()[0].element.remove();
+            // remove all the labels in the option group
+            optionGroup = optionGroupsCache.pop();
+            for (index = 1; index < optionGroup.length; ++index) {
+              updateLabelMap(labelMap, optionGroup[index].label, false);
+            }
+            optionGroup[0].element.remove();
          }
+          forEach(labelMap, function(count, label) {
+            if (count > 0) {
+              selectCtrl.addOption(label);
+            } else if (count < 0) {
+              selectCtrl.removeOption(label);
+            }
+          });
        }
      }
    }
@@ -119,104 +119,101 @@ function filterFilter() {
  return function(array, expression, comparator) {
    if (!isArray(array)) return array;

-    var comparatorType = typeof(comparator),
-        predicates = [];
+    var predicateFn;
+    var matchAgainstAnyProp;

-    predicates.check = function(value, index) {
-      for (var j = 0; j < predicates.length; j++) {
-        if (!predicates[j](value, index)) {
-          return false;
-        }
-      }
-      return true;
-    };
-
-    if (comparatorType !== 'function') {
-      if (comparatorType === 'boolean' && comparator) {
-        comparator = function(obj, text) {
-          return angular.equals(obj, text);
-        };
-      } else {
-        comparator = function(obj, text) {
-          if (obj && text && typeof obj === 'object' && typeof text === 'object') {
-            for (var objKey in obj) {
-              if (objKey.charAt(0) !== '$' && hasOwnProperty.call(obj, objKey) &&
-                  comparator(obj[objKey], text[objKey])) {
-                return true;
-              }
-            }
-            return false;
-          }
-          text = ('' + text).toLowerCase();
-          return ('' + obj).toLowerCase().indexOf(text) > -1;
-        };
-      }
-    }
-
-    var search = function(obj, text) {
-      if (typeof text === 'string' && text.charAt(0) === '!') {
-        return !search(obj, text.substr(1));
-      }
-      switch (typeof obj) {
-        case 'boolean':
-        case 'number':
-        case 'string':
-          return comparator(obj, text);
-        case 'object':
-          switch (typeof text) {
-            case 'object':
-              return comparator(obj, text);
-            default:
-              for (var objKey in obj) {
-                if (objKey.charAt(0) !== '$' && search(obj[objKey], text)) {
-                  return true;
-                }
-              }
-              break;
-          }
-          return false;
-        case 'array':
-          for (var i = 0; i < obj.length; i++) {
-            if (search(obj[i], text)) {
-              return true;
-            }
-          }
-          return false;
-        default:
-          return false;
-      }
-    };
    switch (typeof expression) {
+      case 'function':
+        predicateFn = expression;
+        break;
      case 'boolean':
      case 'number':
      case 'string':
-        // Set up expression object and fall through
-        expression = {$:expression};
-        // jshint -W086
+        matchAgainstAnyProp = true;
+        //jshint -W086
      case 'object':
-        // jshint +W086
-        for (var key in expression) {
-          (function(path) {
-            if (typeof expression[path] === 'undefined') return;
-            predicates.push(function(value) {
-              return search(path == '$' ? value : (value && value[path]), expression[path]);
-            });
-          })(key);
-        }
-        break;
-      case 'function':
-        predicates.push(expression);
+        //jshint +W086
+        predicateFn = createPredicateFn(expression, comparator, matchAgainstAnyProp);
        break;
      default:
        return array;
    }
-    var filtered = [];
-    for (var j = 0; j < array.length; j++) {
-      var value = array[j];
-      if (predicates.check(value, j)) {
-        filtered.push(value);
-      }
-    }
-    return filtered;
+
+    return array.filter(predicateFn);
  };
 }
+
+// Helper functions for `filterFilter`
+function createPredicateFn(expression, comparator, matchAgainstAnyProp) {
+  var predicateFn;
+
+  if (comparator === true) {
+    comparator = equals;
+  } else if (!isFunction(comparator)) {
+    comparator = function(actual, expected) {
+      if (isObject(actual) || isObject(expected)) {
+        // Prevent an object to be considered equal to a string like `'[object'`
+        return false;
+      }
+
+      actual = lowercase('' + actual);
+      expected = lowercase('' + expected);
+      return actual.indexOf(expected) !== -1;
+    };
+  }
+
+  predicateFn = function(item) {
+    return deepCompare(item, expression, comparator, matchAgainstAnyProp);
+  };
+
+  return predicateFn;
+}
+
+function deepCompare(actual, expected, comparator, matchAgainstAnyProp) {
+  var actualType = typeof actual;
+  var expectedType = typeof expected;
+
+  if ((expectedType === 'string') && (expected.charAt(0) === '!')) {
+    return !deepCompare(actual, expected.substring(1), comparator, matchAgainstAnyProp);
+  } else if (actualType === 'array') {
+    // In case `actual` is an array, consider it a match
+    // if ANY of it's items matches `expected`
+    return actual.some(function(item) {
+      return deepCompare(item, expected, comparator, matchAgainstAnyProp);
+    });
+  }
+
+  switch (actualType) {
+    case 'object':
+      var key;
+      if (matchAgainstAnyProp) {
+        for (key in actual) {
+          if ((key.charAt(0) !== '$') && deepCompare(actual[key], expected, comparator)) {
+            return true;
+          }
+        }
+        return false;
+      } else if (expectedType === 'object') {
+        for (key in expected) {
+          var expectedVal = expected[key];
+          if (isFunction(expectedVal)) {
+            continue;
+          }
+
+          var keyIsDollar = key === '$';
+          var actualVal = keyIsDollar ? actual : actual[key];
+          if (!deepCompare(actualVal, expectedVal, comparator, keyIsDollar)) {
+            return false;
+          }
+        }
+        return true;
+      } else {
+        return comparator(actual, expected);
+      }
+      break;
+    case 'function':
+      return false;
+    default:
+      return comparator(actual, expected);
+  }
+}
@@ -11,7 +11,7 @@
 *
 * @param {number} amount Input to filter.
 * @param {string=} symbol Currency symbol or identifier to be displayed.
- * @param {number=} fractionSize Number of decimal places to round the amount to.
+ * @param {number=} fractionSize Number of decimal places to round the amount to, defaults to default max fraction size for current locale
 * @returns {string} Formatted number.
 *
 *
@@ -61,8 +61,7 @@ function currencyFilter($locale) {
    }

    if (isUndefined(fractionSize)) {
-      // TODO: read the default value from the locale file
-      fractionSize = 2;
+      fractionSize = formats.PATTERNS[1].maxFrac;
    }

    // if null or undefined pass it through
@@ -151,7 +150,6 @@ function formatNumber(number, pattern, groupSep, decimalSep, fractionSize) {
  if (numStr.indexOf('e') !== -1) {
    var match = numStr.match(/([\d\.]+)e(-?)(\d+)/);
    if (match && match[2] == '-' && match[3] > fractionSize + 1) {
-      numStr = '0';
      number = 0;
    } else {
      formatedText = numStr;
@@ -172,10 +170,6 @@ function formatNumber(number, pattern, groupSep, decimalSep, fractionSize) {
    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
    number = +(Math.round(+(number.toString() + 'e' + fractionSize)).toString() + 'e' + -fractionSize);

-    if (number === 0) {
-      isNegative = false;
-    }
-
    var fraction = ('' + number).split(DECIMAL_SEP);
    var whole = fraction[0];
    fraction = fraction[1] || '';
@@ -208,15 +202,19 @@ function formatNumber(number, pattern, groupSep, decimalSep, fractionSize) {

    if (fractionSize && fractionSize !== "0") formatedText += decimalSep + fraction.substr(0, fractionSize);
  } else {
-
-    if (fractionSize > 0 && number > -1 && number < 1) {
+    if (fractionSize > 0 && number < 1) {
      formatedText = number.toFixed(fractionSize);
+      number = parseFloat(formatedText);
    }
  }

-  parts.push(isNegative ? pattern.negPre : pattern.posPre);
-  parts.push(formatedText);
-  parts.push(isNegative ? pattern.negSuf : pattern.posSuf);
+  if (number === 0) {
+    isNegative = false;
+  }
+
+  parts.push(isNegative ? pattern.negPre : pattern.posPre,
+             formatedText,
+             isNegative ? pattern.negSuf : pattern.posSuf);
  return parts.join('');
 }

@@ -503,25 +501,31 @@ function dateFilter($locale) {
 *   the binding is automatically converted to JSON.
 *
 * @param {*} object Any JavaScript object (including arrays and primitive types) to filter.
+ * @param {number=} spacing The number of spaces to use per indentation, defaults to 2.
 * @returns {string} JSON string.
 *
 *
 * @example
   <example>
     <file name="index.html">
-       <pre>{{ {'name':'value'} | json }}</pre>
+       <pre id="default-spacing">{{ {'name':'value'} | json }}</pre>
+       <pre id="custom-spacing">{{ {'name':'value'} | json:4 }}</pre>
     </file>
     <file name="protractor.js" type="protractor">
       it('should jsonify filtered objects', function() {
-         expect(element(by.binding("{'name':'value'}")).getText()).toMatch(/\{\n  "name": ?"value"\n}/);
+         expect(element(by.id('default-spacing')).getText()).toMatch(/\{\n  "name": ?"value"\n}/);
+         expect(element(by.id('custom-spacing')).getText()).toMatch(/\{\n    "name": ?"value"\n}/);
       });
     </file>
   </example>
 *
 */
 function jsonFilter() {
-  return function(object) {
-    return toJson(object, true);
+  return function(object, spacing) {
+    if (isUndefined(spacing)) {
+        spacing = 2;
+    }
+    return toJson(object, spacing);
  };
 }

@@ -163,12 +163,29 @@ function orderByFilter($parse) {
    function compare(v1, v2) {
      var t1 = typeof v1;
      var t2 = typeof v2;
-      if (t1 == t2) {
-        if (isDate(v1) && isDate(v2)) {
-          v1 = v1.valueOf();
-          v2 = v2.valueOf();
+      // Prepare values for Abstract Relational Comparison
+      // (http://www.ecma-international.org/ecma-262/5.1/#sec-11.8.5):
+      // If the resulting values are identical, return 0 to prevent
+      // incorrect re-ordering.
+      if (t1 === t2 && t1 === "object") {
+        // If types are both numbers, emulate abstract ToPrimitive() operation
+        // in order to get primitive values suitable for comparison
+        t1 = typeof (v1.valueOf ? v1 = v1.valueOf() : v1);
+        t2 = typeof (v2.valueOf ? v2 = v2.valueOf() : v2);
+        if (t1 === t2 && t1 === "object") {
+          // Object.prototype.valueOf will return the original object, by
+          // default. If we do not receive a primitive value, use ToString()
+          // instead.
+          t1 = typeof (v1.toString ? v1 = v1.toString() : v1);
+          t2 = typeof (v2.toString ? v2 = v2.toString() : v2);
+
+          // If the end result of toString() for each item is the same, do not
+          // perform relational comparison, and do not re-order objects.
+          if (t1 === t2 && v1 === v2 || t1 === "object") return 0;
        }
-        if (t1 == "string") {
+      }
+      if (t1 === t2) {
+        if (t1 === "string") {
           v1 = v1.toLowerCase();
           v2 = v2.toLowerCase();
        }
@@ -26,7 +26,7 @@ function defaultHttpResponseTransform(data, headers) {
 * @returns {Object} Parsed headers as key value object
 */
 function parseHeaders(headers) {
-  var parsed = {}, key, val, i;
+  var parsed = createMap(), key, val, i;

  if (!headers) return parsed;

@@ -63,7 +63,11 @@ function headersGetter(headers) {
    if (!headersObj) headersObj =  parseHeaders(headers);

    if (name) {
-      return headersObj[lowercase(name)] || null;
+      var value = headersObj[lowercase(name)];
+      if (value === void 0) {
+        value = null;
+      }
+      return value;
    }

    return headersObj;
@@ -112,6 +116,11 @@ function $HttpProvider() {
   *
   * Object containing default values for all {@link ng.$http $http} requests.
   *
+   * - **`defaults.cache`** - {Object} - an object built with {@link ng.$cacheFactory `$cacheFactory`}
+   * that will provide the cache for all requests who set their `cache` property to `true`.
+   * If you set the `default.cache = false` then only requests that specify their own custom
+   * cache object will be cached. See {@link $http#caching $http Caching} for more information.
+   *
   * - **`defaults.xsrfCookieName`** - {string} - Name of cookie containing the XSRF token.
   * Defaults value is `'XSRF-TOKEN'`.
   *
@@ -125,6 +134,7 @@ function $HttpProvider() {
   *     - **`defaults.headers.post`**
   *     - **`defaults.headers.put`**
   *     - **`defaults.headers.patch`**
+   *
   **/
  var defaults = this.defaults = {
    // transform incoming response data
@@ -339,6 +349,21 @@ function $HttpProvider() {
     * In addition, you can supply a `headers` property in the config object passed when
     * calling `$http(config)`, which overrides the defaults without changing them globally.
     *
+     * To explicitly remove a header automatically added via $httpProvider.defaults.headers on a per request basis,
+     * Use the `headers` property, setting the desired header to `undefined`. For example:
+     *
+     * ```js
+     * var req = {
+     *  method: 'POST',
+     *  url: 'http://example.com',
+     *  headers: {
+     *    'Content-Type': undefined
+     *  },
+     *  data: { test: 'test' },
+     * }
+     *
+     * $http(req).success(function(){...}).error(function(){...});
+     * ```
     *
     * ## Transforming Requests and Responses
     *
@@ -585,12 +610,14 @@ function $HttpProvider() {
     *      `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
     *      transform function or an array of such functions. The transform function takes the http
     *      request body and headers and returns its transformed (typically serialized) version.
-     *      See {@link #overriding-the-default-transformations-per-request Overriding the Default Transformations}
+     *      See {@link ng.$http#overriding-the-default-transformations-per-request
+     *      Overriding the Default Transformations}
     *    - **transformResponse** –
     *      `{function(data, headersGetter)|Array.<function(data, headersGetter)>}` –
     *      transform function or an array of such functions. The transform function takes the http
     *      response body and headers and returns its transformed (typically deserialized) version.
-     *      See {@link #overriding-the-default-transformations-per-request Overriding the Default Transformations}
+     *      See {@link ng.$http#overriding-the-default-transformations-per-request
+     *      Overriding the Default Transformations}
     *    - **cache** – `{boolean|Cache}` – If true, a default $http cache will be used to cache the
     *      GET request, otherwise if a cache instance built with
     *      {@link ng.$cacheFactory $cacheFactory}, this cache will be used for
@@ -718,6 +745,10 @@ function $HttpProvider() {
      };
      var headers = mergeHeaders(requestConfig);

+      if (!angular.isObject(requestConfig)) {
+        throw minErr('$http')('badreq', 'Http request configuration must be an object.  Received: {0}', requestConfig);
+      }
+
      extend(config, requestConfig);
      config.headers = headers;
      config.method = uppercase(config.method);
@@ -996,8 +1027,7 @@ function $HttpProvider() {
        if (isDefined(cachedResp)) {
          if (isPromiseLike(cachedResp)) {
            // cached request has already been sent, but there is no response yet
-            cachedResp.then(removePendingReq, removePendingReq);
-            return cachedResp;
+            cachedResp.then(resolvePromiseWithResult, resolvePromiseWithResult);
          } else {
            // serving from cache
            if (isArray(cachedResp)) {
@@ -1075,6 +1105,9 @@ function $HttpProvider() {
        });
      }

+      function resolvePromiseWithResult(result) {
+        resolvePromise(result.data, result.status, shallowCopy(result.headers()), result.statusText);
+      }

      function removePendingReq() {
        var idx = $http.pendingRequests.indexOf(config);
@@ -126,7 +126,9 @@ function createHttpBackend($browser, createXhr, $browserDefer, callbacks, rawDoc

    function completeRequest(callback, status, response, headersString, statusText) {
      // cancel timeout and subsequent timeout promise resolution
-      timeoutId && $browserDefer.cancel(timeoutId);
+      if (timeoutId !== undefined) {
+        $browserDefer.cancel(timeoutId);
+      }
      jsonpDone = xhr = null;

      callback(status, response, headersString, statusText);
@@ -57,33 +57,33 @@ function $IntervalProvider() {
      *             // Don't start a new fight if we are already fighting
      *             if ( angular.isDefined(stop) ) return;
      *
-      *           stop = $interval(function() {
-      *             if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
-      *               $scope.blood_1 = $scope.blood_1 - 3;
-      *               $scope.blood_2 = $scope.blood_2 - 4;
-      *             } else {
-      *               $scope.stopFight();
+      *             stop = $interval(function() {
+      *               if ($scope.blood_1 > 0 && $scope.blood_2 > 0) {
+      *                 $scope.blood_1 = $scope.blood_1 - 3;
+      *                 $scope.blood_2 = $scope.blood_2 - 4;
+      *               } else {
+      *                 $scope.stopFight();
+      *               }
+      *             }, 100);
+      *           };
+      *
+      *           $scope.stopFight = function() {
+      *             if (angular.isDefined(stop)) {
+      *               $interval.cancel(stop);
+      *               stop = undefined;
      *             }
-      *           }, 100);
-      *         };
+      *           };
      *
-      *         $scope.stopFight = function() {
-      *           if (angular.isDefined(stop)) {
-      *             $interval.cancel(stop);
-      *             stop = undefined;
-      *           }
-      *         };
+      *           $scope.resetFight = function() {
+      *             $scope.blood_1 = 100;
+      *             $scope.blood_2 = 120;
+      *           };
      *
-      *         $scope.resetFight = function() {
-      *           $scope.blood_1 = 100;
-      *           $scope.blood_2 = 120;
-      *         };
-      *
-      *         $scope.$on('$destroy', function() {
-      *           // Make sure that the interval is destroyed too
-      *           $scope.stopFight();
-      *         });
-      *       }])
+      *           $scope.$on('$destroy', function() {
+      *             // Make sure that the interval is destroyed too
+      *             $scope.stopFight();
+      *           });
+      *         }])
      *       // Register the 'myCurrentTime' directive factory method.
      *       // We inject $interval and dateFilter service since the factory method is DI.
      *       .directive('myCurrentTime', ['$interval', 'dateFilter',
@@ -68,6 +68,10 @@ function stripHash(url) {
  return index == -1 ? url : url.substr(0, index);
 }

+function trimEmptyHash(url) {
+  return url.replace(/(#.+)|#$/, '$1');
+}
+

 function stripFile(url) {
  return url.substr(0, stripHash(url).lastIndexOf('/') + 1);
@@ -179,16 +183,25 @@ function LocationHashbangUrl(appBase, hashPrefix) {
   */
  this.$$parse = function(url) {
    var withoutBaseUrl = beginsWith(appBase, url) || beginsWith(appBaseNoFile, url);
-    var withoutHashUrl = withoutBaseUrl.charAt(0) == '#'
-        ? beginsWith(hashPrefix, withoutBaseUrl)
-        : (this.$$html5)
-          ? withoutBaseUrl
-          : '';
+    var withoutHashUrl;

-    if (!isString(withoutHashUrl)) {
-      throw $locationMinErr('ihshprfx', 'Invalid url "{0}", missing hash prefix "{1}".', url,
-          hashPrefix);
+    if (withoutBaseUrl.charAt(0) === '#') {
+
+      // The rest of the url starts with a hash so we have
+      // got either a hashbang path or a plain hash fragment
+      withoutHashUrl = beginsWith(hashPrefix, withoutBaseUrl);
+      if (isUndefined(withoutHashUrl)) {
+        // There was no hashbang prefix so we just have a hash fragment
+        withoutHashUrl = withoutBaseUrl;
+      }
+
+    } else {
+      // There was no hashbang path nor hash fragment:
+      // If we are in HTML5 mode we use what is left as the path;
+      // Otherwise we ignore what is left
+      withoutHashUrl = this.$$html5 ? withoutBaseUrl : '';
    }
+
    parseAppUrl(withoutHashUrl, this);

    this.$$path = removeWindowsDriveName(this.$$path, withoutHashUrl, appBase);
@@ -327,6 +340,13 @@ var locationPrototype = {
   * Return full url representation with all segments encoded according to rules specified in
   * [RFC 3986](http://www.ietf.org/rfc/rfc3986.txt).
   *
+   *
+   * ```js
+   * // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+   * var absUrl = $location.absUrl();
+   * // => "http://example.com/#/some/path?foo=bar&baz=xoxo"
+   * ```
+   *
   * @return {string} full url
   */
  absUrl: locationGetter('$$absUrl'),
@@ -342,6 +362,13 @@ var locationPrototype = {
   *
   * Change path, search and hash, when called with parameter and return `$location`.
   *
+   *
+   * ```js
+   * // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+   * var url = $location.url();
+   * // => "/some/path?foo=bar&baz=xoxo"
+   * ```
+   *
   * @param {string=} url New url without base prefix (e.g. `/path?a=b#hash`)
   * @return {string} url
   */
@@ -350,8 +377,8 @@ var locationPrototype = {
      return this.$$url;

    var match = PATH_MATCH.exec(url);
-    if (match[1]) this.path(decodeURIComponent(match[1]));
-    if (match[2] || match[1]) this.search(match[3] || '');
+    if (match[1] || url === '') this.path(decodeURIComponent(match[1]));
+    if (match[2] || match[1] || url === '') this.search(match[3] || '');
    this.hash(match[5] || '');

    return this;
@@ -366,6 +393,13 @@ var locationPrototype = {
   *
   * Return protocol of current url.
   *
+   *
+   * ```js
+   * // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+   * var protocol = $location.protocol();
+   * // => "http"
+   * ```
+   *
   * @return {string} protocol of current url
   */
  protocol: locationGetter('$$protocol'),
@@ -379,6 +413,13 @@ var locationPrototype = {
   *
   * Return host of current url.
   *
+   *
+   * ```js
+   * // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+   * var host = $location.host();
+   * // => "example.com"
+   * ```
+   *
   * @return {string} host of current url.
   */
  host: locationGetter('$$host'),
@@ -392,6 +433,13 @@ var locationPrototype = {
   *
   * Return port of current url.
   *
+   *
+   * ```js
+   * // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+   * var port = $location.port();
+   * // => 80
+   * ```
+   *
   * @return {Number} port
   */
  port: locationGetter('$$port'),
@@ -410,6 +458,13 @@ var locationPrototype = {
   * Note: Path should always begin with forward slash (/), this method will add the forward slash
   * if it is missing.
   *
+   *
+   * ```js
+   * // given url http://example.com/#/some/path?foo=bar&baz=xoxo
+   * var path = $location.path();
+   * // => "/some/path"
+   * ```
+   *
   * @param {(string|number)=} path New path
   * @return {string} path
   */
@@ -435,10 +490,9 @@ var locationPrototype = {
   * var searchObject = $location.search();
   * // => {foo: 'bar', baz: 'xoxo'}
   *
-   *
   * // set foo to 'yipee'
   * $location.search('foo', 'yipee');
-   * // => $location
+   * // $location.search() => {foo: 'yipee', baz: 'xoxo'}
   * ```
   *
   * @param {string|Object.<string>|Object.<Array.<string>>} search New search params - string or
@@ -508,6 +562,13 @@ var locationPrototype = {
   *
   * Change hash fragment when called with parameter and return `$location`.
   *
+   *
+   * ```js
+   * // given url http://example.com/#/some/path?foo=bar&baz=xoxo#hashValue
+   * var hash = $location.hash();
+   * // => "hashValue"
+   * ```
+   *
   * @param {(string|number)=} hash New hash fragment
   * @return {string} hash
   */
@@ -855,10 +916,11 @@ function $LocationProvider() {

    // update browser
    $rootScope.$watch(function $locationWatch() {
-      var oldUrl = $browser.url();
+      var oldUrl = trimEmptyHash($browser.url());
+      var newUrl = trimEmptyHash($location.absUrl());
      var oldState = $browser.state();
      var currentReplace = $location.$$replace;
-      var urlOrStateChanged = oldUrl !== $location.absUrl() ||
+      var urlOrStateChanged = oldUrl !== newUrl ||
        ($location.$$html5 && $sniffer.history && oldState !== $location.$$state);

      if (initializing || urlOrStateChanged) {
@@ -598,8 +598,8 @@ Parser.prototype = {
  logicalAND: function() {
    var left = this.equality();
    var token;
-    if ((token = this.expect('&&'))) {
-      left = this.binaryFn(left, token.text, this.logicalAND(), true);
+    while ((token = this.expect('&&'))) {
+      left = this.binaryFn(left, token.text, this.equality(), true);
    }
    return left;
  },
@@ -607,8 +607,8 @@ Parser.prototype = {
  equality: function() {
    var left = this.relational();
    var token;
-    if ((token = this.expect('==','!=','===','!=='))) {
-      left = this.binaryFn(left, token.text, this.equality());
+    while ((token = this.expect('==','!=','===','!=='))) {
+      left = this.binaryFn(left, token.text, this.relational());
    }
    return left;
  },
@@ -616,8 +616,8 @@ Parser.prototype = {
  relational: function() {
    var left = this.additive();
    var token;
-    if ((token = this.expect('<', '>', '<=', '>='))) {
-      left = this.binaryFn(left, token.text, this.relational());
+    while ((token = this.expect('<', '>', '<=', '>='))) {
+      left = this.binaryFn(left, token.text, this.additive());
    }
    return left;
  },
@@ -709,7 +709,7 @@ Parser.prototype = {
    var args = argsFn.length ? [] : null;

    return function $parseFunctionCall(scope, locals) {
-      var context = contextGetter ? contextGetter(scope, locals) : scope;
+      var context = contextGetter ? contextGetter(scope, locals) : isDefined(contextGetter) ? undefined : scope;
      var fn = fnGetter(scope, locals, context) || noop;

      if (args) {
@@ -722,13 +722,13 @@ Parser.prototype = {
      ensureSafeObject(context, expressionText);
      ensureSafeFunction(fn, expressionText);

-      // IE stupidity! (IE doesn't have apply for some native functions)
+      // IE doesn't have apply for some native functions
      var v = fn.apply
            ? fn.apply(context, args)
            : fn(args[0], args[1], args[2], args[3], args[4]);

      return ensureSafeObject(v, expressionText);
-    };
+      };
  },

  // This is used with json array declaration
@@ -7,9 +7,9 @@
 * @description
 * The root element of Angular application. This is either the element where {@link
 * ng.directive:ngApp ngApp} was declared or the element passed into
- * {@link angular.bootstrap}. The element represent the root element of application. It is also the
- * location where the applications {@link auto.$injector $injector} service gets
- * published, it can be retrieved using `$rootElement.injector()`.
+ * {@link angular.bootstrap}. The element represents the root element of application. It is also the
+ * location where the application's {@link auto.$injector $injector} service gets
+ * published, and can be retrieved using `$rootElement.injector()`.
 */


@@ -67,7 +67,9 @@ function $SnifferProvider() {
        // IE9 implements 'input' event it's so fubared that we rather pretend that it doesn't have
        // it. In particular the event is not fired when backspace or delete key are pressed or
        // when cut operation is performed.
-        if (event == 'input' && msie == 9) return false;
+        // IE10+ implements 'input' event but it erroneously fires under various situations,
+        // e.g. when placeholder changes, or a form is focused.
+        if (event === 'input' && msie <= 11) return false;

        if (isUndefined(eventSupport[event])) {
          var divElm = document.createElement('div');
@@ -28,14 +28,9 @@ function $TemplateRequestProvider() {
      var transformResponse = $http.defaults && $http.defaults.transformResponse;

      if (isArray(transformResponse)) {
-        var original = transformResponse;
-        transformResponse = [];
-        for (var i = 0; i < original.length; ++i) {
-          var transformer = original[i];
-          if (transformer !== defaultHttpResponseTransform) {
-            transformResponse.push(transformer);
-          }
-        }
+        transformResponse = transformResponse.filter(function(transformer) {
+          return transformer !== defaultHttpResponseTransform;
+        });
      } else if (transformResponse === defaultHttpResponseTransform) {
        transformResponse = null;
      }
@@ -47,18 +42,16 @@ function $TemplateRequestProvider() {

      return $http.get(tpl, httpOptions)
        .then(function(response) {
-          var html = response.data;
          self.totalPendingRequests--;
-          $templateCache.put(tpl, html);
-          return html;
+          return response.data;
        }, handleError);

-      function handleError() {
+      function handleError(resp) {
        self.totalPendingRequests--;
        if (!ignoreRequestError) {
          throw $compileMinErr('tpload', 'Failed to load template: {0}', tpl);
        }
-        return $q.reject();
+        return $q.reject(resp);
      }
    }

@@ -13,7 +13,7 @@
 * # Usage
 *
 * To see animations in action, all that is required is to define the appropriate CSS classes
- * or to register a JavaScript animation via the myModule.animation() function. The directives that support animation automatically are:
+ * or to register a JavaScript animation via the `myModule.animation()` function. The directives that support animation automatically are:
 * `ngRepeat`, `ngInclude`, `ngIf`, `ngSwitch`, `ngShow`, `ngHide`, `ngView` and `ngClass`. Custom directives can take advantage of animation
 * by using the `$animate` service.
 *
@@ -155,8 +155,8 @@
 * ### Structural transition animations
 *
 * Structural transitions (such as enter, leave and move) will always apply a `0s none` transition
- * value to force the browser into rendering the styles defined in the setup (.ng-enter, .ng-leave
- * or .ng-move) class. This means that any active transition animations operating on the element
+ * value to force the browser into rendering the styles defined in the setup (`.ng-enter`, `.ng-leave`
+ * or `.ng-move`) class. This means that any active transition animations operating on the element
 * will be cut off to make way for the enter, leave or move animation.
 *
 * ### Class-based transition animations
@@ -239,7 +239,7 @@
 * You then configure `$animate` to enforce this prefix:
 *
 * ```js
- * $animateProvider.classNamePrefix(/animate-/);
+ * $animateProvider.classNameFilter(/animate-/);
 * ```
 * </div>
 *
@@ -473,11 +473,12 @@ angular.module('ngAnimate', ['ng'])
    function isMatchingElement(elm1, elm2) {
      return extractElementNode(elm1) == extractElementNode(elm2);
    }
-
+    var $$jqLite;
    $provide.decorator('$animate',
-        ['$delegate', '$$q', '$injector', '$sniffer', '$rootElement', '$$asyncCallback', '$rootScope', '$document', '$templateRequest',
- function($delegate,   $$q,   $injector,   $sniffer,   $rootElement,   $$asyncCallback,   $rootScope,   $document,   $templateRequest) {
+        ['$delegate', '$$q', '$injector', '$sniffer', '$rootElement', '$$asyncCallback', '$rootScope', '$document', '$templateRequest', '$$jqLite',
+ function($delegate,   $$q,   $injector,   $sniffer,   $rootElement,   $$asyncCallback,   $rootScope,   $document,   $templateRequest,   $$$jqLite) {

+      $$jqLite = $$$jqLite;
      $rootElement.data(NG_ANIMATE_STATE, rootAnimateState);

      // Wait until all directive and route-related templates are downloaded and
@@ -871,22 +872,22 @@ angular.module('ngAnimate', ['ng'])
         *
         * Below is a breakdown of each step that occurs during the `animate` animation:
         *
-         * | Animation Step                                                                                                    | What the element class attribute looks like                |
-         * |-------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------|
-         * | 1. $animate.animate(...) is called                                                                                | class="my-animation"                                       |
-         * | 2. $animate waits for the next digest to start the animation                                                      | class="my-animation ng-animate"                            |
-         * | 3. $animate runs the JavaScript-defined animations detected on the element                                        | class="my-animation ng-animate"                            |
-         * | 4. the className class value is added to the element                                                              | class="my-animation ng-animate className"                  |
-         * | 5. $animate scans the element styles to get the CSS transition/animation duration and delay                       | class="my-animation ng-animate className"                  |
-         * | 6. $animate blocks all CSS transitions on the element to ensure the .className class styling is applied right away| class="my-animation ng-animate className"                  |
-         * | 7. $animate applies the provided collection of `from` CSS styles to the element                                   | class="my-animation ng-animate className"                  |
-         * | 8. $animate waits for a single animation frame (this performs a reflow)                                           | class="my-animation ng-animate className"                  |
-         * | 9. $animate removes the CSS transition block placed on the element                                                | class="my-animation ng-animate className"                  |
-         * | 10. the className-active class is added (this triggers the CSS transition/animation)                              | class="my-animation ng-animate className className-active" |
-         * | 11. $animate applies the collection of `to` CSS styles to the element which are then handled by the transition    | class="my-animation ng-animate className className-active" |
-         * | 12. $animate waits for the animation to complete (via events and timeout)                                         | class="my-animation ng-animate className className-active" |
-         * | 13. The animation ends and all generated CSS classes are removed from the element                                 | class="my-animation"                                       |
-         * | 14. The returned promise is resolved.                                                                             | class="my-animation"                                       |
+         * | Animation Step                                                                                                        | What the element class attribute looks like                  |
+         * |-----------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------|
+         * | 1. `$animate.animate(...)` is called                                                                                  | `class="my-animation"`                                       |
+         * | 2. `$animate` waits for the next digest to start the animation                                                        | `class="my-animation ng-animate"`                            |
+         * | 3. `$animate` runs the JavaScript-defined animations detected on the element                                          | `class="my-animation ng-animate"`                            |
+         * | 4. the `className` class value is added to the element                                                                | `class="my-animation ng-animate className"`                  |
+         * | 5. `$animate` scans the element styles to get the CSS transition/animation duration and delay                         | `class="my-animation ng-animate className"`                  |
+         * | 6. `$animate` blocks all CSS transitions on the element to ensure the `.className` class styling is applied right away| `class="my-animation ng-animate className"`                  |
+         * | 7. `$animate` applies the provided collection of `from` CSS styles to the element                                     | `class="my-animation ng-animate className"`                  |
+         * | 8. `$animate` waits for a single animation frame (this performs a reflow)                                             | `class="my-animation ng-animate className"`                  |
+         * | 9. `$animate` removes the CSS transition block placed on the element                                                  | `class="my-animation ng-animate className"`                  |
+         * | 10. the `className-active` class is added (this triggers the CSS transition/animation)                                | `class="my-animation ng-animate className className-active"` |
+         * | 11. `$animate` applies the collection of `to` CSS styles to the element which are then handled by the transition      | `class="my-animation ng-animate className className-active"` |
+         * | 12. `$animate` waits for the animation to complete (via events and timeout)                                           | `class="my-animation ng-animate className className-active"` |
+         * | 13. The animation ends and all generated CSS classes are removed from the element                                     | `class="my-animation"`                                       |
+         * | 14. The returned promise is resolved.                                                                                 | `class="my-animation"`                                       |
         *
         * @param {DOMElement} element the element that will be the focus of the enter animation
         * @param {object} from a collection of CSS styles that will be applied to the element at the start of the animation
@@ -917,21 +918,21 @@ angular.module('ngAnimate', ['ng'])
         *
         * Below is a breakdown of each step that occurs during enter animation:
         *
-         * | Animation Step                                                                                                    | What the element class attribute looks like              |
-         * |-------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------|
-         * | 1. $animate.enter(...) is called                                                                                  | class="my-animation"                                     |
-         * | 2. element is inserted into the parentElement element or beside the afterElement element                          | class="my-animation"                                     |
-         * | 3. $animate waits for the next digest to start the animation                                                      | class="my-animation ng-animate"                          |
-         * | 4. $animate runs the JavaScript-defined animations detected on the element                                        | class="my-animation ng-animate"                          |
-         * | 5. the .ng-enter class is added to the element                                                                    | class="my-animation ng-animate ng-enter"                 |
-         * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay                       | class="my-animation ng-animate ng-enter"                 |
-         * | 7. $animate blocks all CSS transitions on the element to ensure the .ng-enter class styling is applied right away | class="my-animation ng-animate ng-enter"                 |
-         * | 8. $animate waits for a single animation frame (this performs a reflow)                                           | class="my-animation ng-animate ng-enter"                 |
-         * | 9. $animate removes the CSS transition block placed on the element                                                | class="my-animation ng-animate ng-enter"                 |
-         * | 10. the .ng-enter-active class is added (this triggers the CSS transition/animation)                              | class="my-animation ng-animate ng-enter ng-enter-active" |
-         * | 11. $animate waits for the animation to complete (via events and timeout)                                         | class="my-animation ng-animate ng-enter ng-enter-active" |
-         * | 12. The animation ends and all generated CSS classes are removed from the element                                 | class="my-animation"                                     |
-         * | 13. The returned promise is resolved.                                                                             | class="my-animation"                                     |
+         * | Animation Step                                                                                                        | What the element class attribute looks like                |
+         * |-----------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------|
+         * | 1. `$animate.enter(...)` is called                                                                                    | `class="my-animation"`                                     |
+         * | 2. element is inserted into the `parentElement` element or beside the `afterElement` element                          | `class="my-animation"`                                     |
+         * | 3. `$animate` waits for the next digest to start the animation                                                        | `class="my-animation ng-animate"`                          |
+         * | 4. `$animate` runs the JavaScript-defined animations detected on the element                                          | `class="my-animation ng-animate"`                          |
+         * | 5. the `.ng-enter` class is added to the element                                                                      | `class="my-animation ng-animate ng-enter"`                 |
+         * | 6. `$animate` scans the element styles to get the CSS transition/animation duration and delay                         | `class="my-animation ng-animate ng-enter"`                 |
+         * | 7. `$animate` blocks all CSS transitions on the element to ensure the `.ng-enter` class styling is applied right away | `class="my-animation ng-animate ng-enter"`                 |
+         * | 8. `$animate` waits for a single animation frame (this performs a reflow)                                             | `class="my-animation ng-animate ng-enter"`                 |
+         * | 9. `$animate` removes the CSS transition block placed on the element                                                  | `class="my-animation ng-animate ng-enter"`                 |
+         * | 10. the `.ng-enter-active` class is added (this triggers the CSS transition/animation)                                | `class="my-animation ng-animate ng-enter ng-enter-active"` |
+         * | 11. `$animate` waits for the animation to complete (via events and timeout)                                           | `class="my-animation ng-animate ng-enter ng-enter-active"` |
+         * | 12. The animation ends and all generated CSS classes are removed from the element                                     | `class="my-animation"`                                     |
+         * | 13. The returned promise is resolved.                                                                                 | `class="my-animation"`                                     |
         *
         * @param {DOMElement} element the element that will be the focus of the enter animation
         * @param {DOMElement} parentElement the parent element of the element that will be the focus of the enter animation
@@ -963,21 +964,21 @@ angular.module('ngAnimate', ['ng'])
         *
         * Below is a breakdown of each step that occurs during leave animation:
         *
-         * | Animation Step                                                                                                    | What the element class attribute looks like              |
-         * |-------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------|
-         * | 1. $animate.leave(...) is called                                                                                  | class="my-animation"                                     |
-         * | 2. $animate runs the JavaScript-defined animations detected on the element                                        | class="my-animation ng-animate"                          |
-         * | 3. $animate waits for the next digest to start the animation                                                      | class="my-animation ng-animate"                          |
-         * | 4. the .ng-leave class is added to the element                                                                    | class="my-animation ng-animate ng-leave"                 |
-         * | 5. $animate scans the element styles to get the CSS transition/animation duration and delay                       | class="my-animation ng-animate ng-leave"                 |
-         * | 6. $animate blocks all CSS transitions on the element to ensure the .ng-leave class styling is applied right away | class="my-animation ng-animate ng-leave”                 |
-         * | 7. $animate waits for a single animation frame (this performs a reflow)                                           | class="my-animation ng-animate ng-leave"                 |
-         * | 8. $animate removes the CSS transition block placed on the element                                                | class="my-animation ng-animate ng-leave”                 |
-         * | 9. the .ng-leave-active class is added (this triggers the CSS transition/animation)                               | class="my-animation ng-animate ng-leave ng-leave-active" |
-         * | 10. $animate waits for the animation to complete (via events and timeout)                                         | class="my-animation ng-animate ng-leave ng-leave-active" |
-         * | 11. The animation ends and all generated CSS classes are removed from the element                                 | class="my-animation"                                     |
-         * | 12. The element is removed from the DOM                                                                           | ...                                                      |
-         * | 13. The returned promise is resolved.                                                                             | ...                                                      |
+         * | Animation Step                                                                                                        | What the element class attribute looks like                |
+         * |-----------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------|
+         * | 1. `$animate.leave(...)` is called                                                                                    | `class="my-animation"`                                     |
+         * | 2. `$animate` runs the JavaScript-defined animations detected on the element                                          | `class="my-animation ng-animate"`                          |
+         * | 3. `$animate` waits for the next digest to start the animation                                                        | `class="my-animation ng-animate"`                          |
+         * | 4. the `.ng-leave` class is added to the element                                                                      | `class="my-animation ng-animate ng-leave"`                 |
+         * | 5. `$animate` scans the element styles to get the CSS transition/animation duration and delay                         | `class="my-animation ng-animate ng-leave"`                 |
+         * | 6. `$animate` blocks all CSS transitions on the element to ensure the `.ng-leave` class styling is applied right away | `class="my-animation ng-animate ng-leave"`                 |
+         * | 7. `$animate` waits for a single animation frame (this performs a reflow)                                             | `class="my-animation ng-animate ng-leave"`                 |
+         * | 8. `$animate` removes the CSS transition block placed on the element                                                  | `class="my-animation ng-animate ng-leave"`                 |
+         * | 9. the `.ng-leave-active` class is added (this triggers the CSS transition/animation)                                 | `class="my-animation ng-animate ng-leave ng-leave-active"` |
+         * | 10. `$animate` waits for the animation to complete (via events and timeout)                                           | `class="my-animation ng-animate ng-leave ng-leave-active"` |
+         * | 11. The animation ends and all generated CSS classes are removed from the element                                     | `class="my-animation"`                                     |
+         * | 12. The element is removed from the DOM                                                                               | ...                                                        |
+         * | 13. The returned promise is resolved.                                                                                 | ...                                                        |
         *
         * @param {DOMElement} element the element that will be the focus of the leave animation
         * @param {object=} options an optional collection of styles that will be picked up by the CSS transition/animation
@@ -1008,21 +1009,21 @@ angular.module('ngAnimate', ['ng'])
         *
         * Below is a breakdown of each step that occurs during move animation:
         *
-         * | Animation Step                                                                                                   | What the element class attribute looks like            |
-         * |------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------|
-         * | 1. $animate.move(...) is called                                                                                  | class="my-animation"                                   |
-         * | 2. element is moved into the parentElement element or beside the afterElement element                            | class="my-animation"                                   |
-         * | 3. $animate waits for the next digest to start the animation                                                     | class="my-animation ng-animate"                        |
-         * | 4. $animate runs the JavaScript-defined animations detected on the element                                       | class="my-animation ng-animate"                        |
-         * | 5. the .ng-move class is added to the element                                                                    | class="my-animation ng-animate ng-move"                |
-         * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay                      | class="my-animation ng-animate ng-move"                |
-         * | 7. $animate blocks all CSS transitions on the element to ensure the .ng-move class styling is applied right away | class="my-animation ng-animate ng-move”                |
-         * | 8. $animate waits for a single animation frame (this performs a reflow)                                          | class="my-animation ng-animate ng-move"                |
-         * | 9. $animate removes the CSS transition block placed on the element                                               | class="my-animation ng-animate ng-move”                |
-         * | 10. the .ng-move-active class is added (this triggers the CSS transition/animation)                              | class="my-animation ng-animate ng-move ng-move-active" |
-         * | 11. $animate waits for the animation to complete (via events and timeout)                                        | class="my-animation ng-animate ng-move ng-move-active" |
-         * | 12. The animation ends and all generated CSS classes are removed from the element                                | class="my-animation"                                   |
-         * | 13. The returned promise is resolved.                                                                            | class="my-animation"                                   |
+         * | Animation Step                                                                                                       | What the element class attribute looks like              |
+         * |----------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------|
+         * | 1. `$animate.move(...)` is called                                                                                    | `class="my-animation"`                                   |
+         * | 2. element is moved into the parentElement element or beside the afterElement element                                | `class="my-animation"`                                   |
+         * | 3. `$animate` waits for the next digest to start the animation                                                       | `class="my-animation ng-animate"`                        |
+         * | 4. `$animate` runs the JavaScript-defined animations detected on the element                                         | `class="my-animation ng-animate"`                        |
+         * | 5. the `.ng-move` class is added to the element                                                                      | `class="my-animation ng-animate ng-move"`                |
+         * | 6. `$animate` scans the element styles to get the CSS transition/animation duration and delay                        | `class="my-animation ng-animate ng-move"`                |
+         * | 7. `$animate` blocks all CSS transitions on the element to ensure the `.ng-move` class styling is applied right away | `class="my-animation ng-animate ng-move"`                |
+         * | 8. `$animate` waits for a single animation frame (this performs a reflow)                                            | `class="my-animation ng-animate ng-move"`                |
+         * | 9. `$animate` removes the CSS transition block placed on the element                                                 | `class="my-animation ng-animate ng-move"`                |
+         * | 10. the `.ng-move-active` class is added (this triggers the CSS transition/animation)                                | `class="my-animation ng-animate ng-move ng-move-active"` |
+         * | 11. `$animate` waits for the animation to complete (via events and timeout)                                          | `class="my-animation ng-animate ng-move ng-move-active"` |
+         * | 12. The animation ends and all generated CSS classes are removed from the element                                    | `class="my-animation"`                                   |
+         * | 13. The returned promise is resolved.                                                                                | `class="my-animation"`                                   |
         *
         * @param {DOMElement} element the element that will be the focus of the move animation
         * @param {DOMElement} parentElement the parentElement element of the element that will be the focus of the move animation
@@ -1056,18 +1057,18 @@ angular.module('ngAnimate', ['ng'])
         *
         * Below is a breakdown of each step that occurs during addClass animation:
         *
-         * | Animation Step                                                                                     | What the element class attribute looks like                      |
-         * |----------------------------------------------------------------------------------------------------|------------------------------------------------------------------|
-         * | 1. $animate.addClass(element, 'super') is called                                                   | class="my-animation"                                             |
-         * | 2. $animate runs the JavaScript-defined animations detected on the element                         | class="my-animation ng-animate"                                  |
-         * | 3. the .super-add class is added to the element                                                    | class="my-animation ng-animate super-add"                        |
-         * | 4. $animate waits for a single animation frame (this performs a reflow)                            | class="my-animation ng-animate super-add"                        |
-         * | 5. the .super and .super-add-active classes are added (this triggers the CSS transition/animation) | class="my-animation ng-animate super super-add super-add-active" |
-         * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay        | class="my-animation ng-animate super-add"                        |
-         * | 7. $animate waits for the animation to complete (via events and timeout)                           | class="my-animation super super-add super-add-active"            |
-         * | 8. The animation ends and all generated CSS classes are removed from the element                   | class="my-animation super"                                       |
-         * | 9. The super class is kept on the element                                                          | class="my-animation super"                                       |
-         * | 10. The returned promise is resolved.                                                              | class="my-animation super"                                       |
+         * | Animation Step                                                                                         | What the element class attribute looks like                        |
+         * |--------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------|
+         * | 1. `$animate.addClass(element, 'super')` is called                                                     | `class="my-animation"`                                             |
+         * | 2. `$animate` runs the JavaScript-defined animations detected on the element                           | `class="my-animation ng-animate"`                                  |
+         * | 3. the `.super-add` class is added to the element                                                      | `class="my-animation ng-animate super-add"`                        |
+         * | 4. `$animate` waits for a single animation frame (this performs a reflow)                              | `class="my-animation ng-animate super-add"`                        |
+         * | 5. the `.super` and `.super-add-active` classes are added (this triggers the CSS transition/animation) | `class="my-animation ng-animate super super-add super-add-active"` |
+         * | 6. `$animate` scans the element styles to get the CSS transition/animation duration and delay          | `class="my-animation ng-animate super super-add super-add-active"` |
+         * | 7. `$animate` waits for the animation to complete (via events and timeout)                             | `class="my-animation ng-animate super super-add super-add-active"` |
+         * | 8. The animation ends and all generated CSS classes are removed from the element                       | `class="my-animation super"`                                       |
+         * | 9. The super class is kept on the element                                                              | `class="my-animation super"`                                       |
+         * | 10. The returned promise is resolved.                                                                  | `class="my-animation super"`                                       |
         *
         * @param {DOMElement} element the element that will be animated
         * @param {string} className the CSS class that will be added to the element and then animated
@@ -1090,17 +1091,17 @@ angular.module('ngAnimate', ['ng'])
         *
         * Below is a breakdown of each step that occurs during removeClass animation:
         *
-         * | Animation Step                                                                                                   | What the element class attribute looks like                      |
-         * |------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------|
-         * | 1. $animate.removeClass(element, 'super') is called                                                              | class="my-animation super"                                       |
-         * | 2. $animate runs the JavaScript-defined animations detected on the element                                       | class="my-animation super ng-animate"                            |
-         * | 3. the .super-remove class is added to the element                                                               | class="my-animation super ng-animate super-remove"               |
-         * | 4. $animate waits for a single animation frame (this performs a reflow)                                          | class="my-animation super ng-animate super-remove"               |
-         * | 5. the .super-remove-active classes are added and .super is removed (this triggers the CSS transition/animation) | class="my-animation ng-animate super-remove super-remove-active" |
-         * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay                      | class="my-animation super ng-animate super-remove"               |
-         * | 7. $animate waits for the animation to complete (via events and timeout)                                         | class="my-animation ng-animate super-remove super-remove-active" |
-         * | 8. The animation ends and all generated CSS classes are removed from the element                                 | class="my-animation"                                             |
-         * | 9. The returned promise is resolved.                                                                             | class="my-animation"                                             |
+         * | Animation Step                                                                                                       | What the element class attribute looks like                        |
+         * |----------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------|
+         * | 1. `$animate.removeClass(element, 'super')` is called                                                                | `class="my-animation super"`                                       |
+         * | 2. `$animate` runs the JavaScript-defined animations detected on the element                                         | `class="my-animation super ng-animate"`                            |
+         * | 3. the `.super-remove` class is added to the element                                                                 | `class="my-animation super ng-animate super-remove"`               |
+         * | 4. `$animate` waits for a single animation frame (this performs a reflow)                                            | `class="my-animation super ng-animate super-remove"`               |
+         * | 5. the `.super-remove-active` classes are added and `.super` is removed (this triggers the CSS transition/animation) | `class="my-animation ng-animate super-remove super-remove-active"` |
+         * | 6. `$animate` scans the element styles to get the CSS transition/animation duration and delay                        | `class="my-animation ng-animate super-remove super-remove-active"` |
+         * | 7. `$animate` waits for the animation to complete (via events and timeout)                                           | `class="my-animation ng-animate super-remove super-remove-active"` |
+         * | 8. The animation ends and all generated CSS classes are removed from the element                                     | `class="my-animation"`                                             |
+         * | 9. The returned promise is resolved.                                                                                 | `class="my-animation"`                                             |
         *
         *
         * @param {DOMElement} element the element that will be animated
@@ -1118,19 +1119,19 @@ angular.module('ngAnimate', ['ng'])
         * @name $animate#setClass
         *
         * @description Adds and/or removes the given CSS classes to and from the element.
-         * Once complete, the done() callback will be fired (if provided).
+         * Once complete, the `done()` callback will be fired (if provided).
         *
-         * | Animation Step                                                                                                                       | What the element class attribute looks like                                          |
-         * |--------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------|
-         * | 1. $animate.removeClass(element, ‘on’, ‘off’) is called                                                                              | class="my-animation super off”                                                       |
-         * | 2. $animate runs the JavaScript-defined animations detected on the element                                                           | class="my-animation super ng-animate off”                                            |
-         * | 3. the .on-add and .off-remove classes are added to the element                                                                      | class="my-animation ng-animate on-add off-remove off”                                |
-         * | 4. $animate waits for a single animation frame (this performs a reflow)                                                              | class="my-animation ng-animate on-add off-remove off”                                |
-         * | 5. the .on, .on-add-active and .off-remove-active classes are added and .off is removed (this triggers the CSS transition/animation) | class="my-animation ng-animate on on-add on-add-active off-remove off-remove-active” |
-         * | 6. $animate scans the element styles to get the CSS transition/animation duration and delay                                          | class="my-animation ng-animate on on-add on-add-active off-remove off-remove-active" |
-         * | 7. $animate waits for the animation to complete (via events and timeout)                                                             | class="my-animation ng-animate on on-add on-add-active off-remove off-remove-active" |
-         * | 8. The animation ends and all generated CSS classes are removed from the element                                                     | class="my-animation on"                                                              |
-         * | 9. The returned promise is resolved.                                                                                                 | class="my-animation on"                                                              |
+         * | Animation Step                                                                                                                               | What the element class attribute looks like                                            |
+         * |----------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------|
+         * | 1. `$animate.setClass(element, 'on', 'off')` is called                                                                                       | `class="my-animation off"`                                                             |
+         * | 2. `$animate` runs the JavaScript-defined animations detected on the element                                                                 | `class="my-animation ng-animate off"`                                                  |
+         * | 3. the `.on-add` and `.off-remove` classes are added to the element                                                                          | `class="my-animation ng-animate on-add off-remove off"`                                |
+         * | 4. `$animate` waits for a single animation frame (this performs a reflow)                                                                    | `class="my-animation ng-animate on-add off-remove off"`                                |
+         * | 5. the `.on`, `.on-add-active` and `.off-remove-active` classes are added and `.off` is removed (this triggers the CSS transition/animation) | `class="my-animation ng-animate on on-add on-add-active off-remove off-remove-active"` |
+         * | 6. `$animate` scans the element styles to get the CSS transition/animation duration and delay                                                | `class="my-animation ng-animate on on-add on-add-active off-remove off-remove-active"` |
+         * | 7. `$animate` waits for the animation to complete (via events and timeout)                                                                   | `class="my-animation ng-animate on on-add on-add-active off-remove off-remove-active"` |
+         * | 8. The animation ends and all generated CSS classes are removed from the element                                                             | `class="my-animation on"`                                                              |
+         * | 9. The returned promise is resolved.                                                                                                         | `class="my-animation on"`                                                              |
         *
         * @param {DOMElement} element the element which will have its CSS classes changed
         *   removed from it
@@ -1268,7 +1269,7 @@ angular.module('ngAnimate', ['ng'])
        all animations call this shared animation triggering function internally.
        The animationEvent variable refers to the JavaScript animation event that will be triggered
        and the className value is the name of the animation that will be applied within the
-        CSS code. Element, parentElement and afterElement are provided DOM elements for the animation
+        CSS code. Element, `parentElement` and `afterElement` are provided DOM elements for the animation
        and the onComplete callback will be fired once the animation is fully complete.
      */
      function performAnimation(animationEvent, className, element, parentElement, afterElement, domOperation, options, doneCallback) {
@@ -1380,10 +1381,10 @@ angular.module('ngAnimate', ['ng'])

        //the ng-animate class does nothing, but it's here to allow for
        //parent animations to find and cancel child animations when needed
-        element.addClass(NG_ANIMATE_CLASS_NAME);
+        $$jqLite.addClass(element, NG_ANIMATE_CLASS_NAME);
        if (options && options.tempClasses) {
          forEach(options.tempClasses, function(className) {
-            element.addClass(className);
+            $$jqLite.addClass(element, className);
          });
        }

@@ -1461,7 +1462,7 @@ angular.module('ngAnimate', ['ng'])
            closeAnimation.hasBeenRun = true;
            if (options && options.tempClasses) {
              forEach(options.tempClasses, function(className) {
-                element.removeClass(className);
+                $$jqLite.removeClass(element, className);
              });
            }

@@ -1523,7 +1524,7 @@ angular.module('ngAnimate', ['ng'])
          }

          if (removeAnimations || !data.totalActive) {
-            element.removeClass(NG_ANIMATE_CLASS_NAME);
+            $$jqLite.removeClass(element, NG_ANIMATE_CLASS_NAME);
            element.removeData(NG_ANIMATE_STATE);
          }
        }
@@ -1764,14 +1765,14 @@ angular.module('ngAnimate', ['ng'])
          var staggerCacheKey = cacheKey + ' ' + staggerClassName;
          var applyClasses = !lookupCache[staggerCacheKey];

-          applyClasses && element.addClass(staggerClassName);
+          applyClasses && $$jqLite.addClass(element, staggerClassName);

          stagger = getElementAnimationDetails(element, staggerCacheKey);

-          applyClasses && element.removeClass(staggerClassName);
+          applyClasses && $$jqLite.removeClass(element, staggerClassName);
        }

-        element.addClass(className);
+        $$jqLite.addClass(element, className);

        var formerData = element.data(NG_ANIMATE_CSS_DATA_KEY) || {};
        var timings = getElementAnimationDetails(element, eventCacheKey);
@@ -1779,7 +1780,7 @@ angular.module('ngAnimate', ['ng'])
        var animationDuration = timings.animationDuration;

        if (structural && transitionDuration === 0 && animationDuration === 0) {
-          element.removeClass(className);
+          $$jqLite.removeClass(element, className);
          return false;
        }

@@ -1851,7 +1852,7 @@ angular.module('ngAnimate', ['ng'])
        }

        if (!staggerTime) {
-          element.addClass(activeClassName);
+          $$jqLite.addClass(element, activeClassName);
          if (elementData.blockTransition) {
            blockTransitions(node, false);
          }
@@ -1861,7 +1862,7 @@ angular.module('ngAnimate', ['ng'])
        var timings = getElementAnimationDetails(element, eventCacheKey);
        var maxDuration = Math.max(timings.transitionDuration, timings.animationDuration);
        if (maxDuration === 0) {
-          element.removeClass(activeClassName);
+          $$jqLite.removeClass(element, activeClassName);
          animateClose(element, className);
          activeAnimationComplete();
          return;
@@ -1896,7 +1897,7 @@ angular.module('ngAnimate', ['ng'])

        var staggerTimeout;
        if (staggerTime > 0) {
-          element.addClass(pendingClassName);
+          $$jqLite.addClass(element, pendingClassName);
          staggerTimeout = $timeout(function() {
            staggerTimeout = null;

@@ -1907,8 +1908,8 @@ angular.module('ngAnimate', ['ng'])
              blockAnimations(node, false);
            }

-            element.addClass(activeClassName);
-            element.removeClass(pendingClassName);
+            $$jqLite.addClass(element, activeClassName);
+            $$jqLite.removeClass(element, pendingClassName);

            if (styles) {
              if (timings.transitionDuration === 0) {
@@ -1935,8 +1936,8 @@ angular.module('ngAnimate', ['ng'])
        // timeout done method.
        function onEnd() {
          element.off(css3AnimationEvents, onAnimationProgress);
-          element.removeClass(activeClassName);
-          element.removeClass(pendingClassName);
+          $$jqLite.removeClass(element, activeClassName);
+          $$jqLite.removeClass(element, pendingClassName);
          if (staggerTimeout) {
            $timeout.cancel(staggerTimeout);
          }
@@ -2024,7 +2025,7 @@ angular.module('ngAnimate', ['ng'])
      }

      function animateClose(element, className) {
-        element.removeClass(className);
+        $$jqLite.removeClass(element, className);
        var data = element.data(NG_ANIMATE_CSS_DATA_KEY);
        if (data) {
          if (data.running) {
@@ -26,7 +26,7 @@
 * | {@link ng.directive:ngDisabled ngDisabled}  | aria-disabled                                                                          |
 * | {@link ng.directive:ngShow ngShow}          | aria-hidden                                                                            |
 * | {@link ng.directive:ngHide ngHide}          | aria-hidden                                                                            |
- * | {@link ng.directive:ngClick ngClick}        | tabindex                                                                               |
+ * | {@link ng.directive:ngClick ngClick}        | tabindex, keypress event                                                               |
 * | {@link ng.directive:ngDblclick ngDblclick}  | tabindex                                                                               |
 * | {@link module:ngMessages ngMessages}        | aria-live                                                                              |
 *
@@ -82,7 +82,8 @@ function $AriaProvider() {
    ariaInvalid: true,
    ariaMultiline: true,
    ariaValue: true,
-    tabindex: true
+    tabindex: true,
+    bindKeypress: true
  };

  /**
@@ -99,6 +100,7 @@ function $AriaProvider() {
   *  - **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 ng-click
   *
   * @description
   * Enables/disables various ARIA attributes
@@ -107,16 +109,9 @@ function $AriaProvider() {
    config = angular.extend(config, newConfig);
  };

-  function camelCase(input) {
-    return input.replace(/-./g, function(letter, pos) {
-      return letter[1].toUpperCase();
-    });
-  }
-
-
  function watchExpr(attrName, ariaAttr, negate) {
-    var ariaCamelName = camelCase(ariaAttr);
    return function(scope, elem, attr) {
+      var ariaCamelName = attr.$normalize(ariaAttr);
      if (config[ariaCamelName] && !attr[ariaCamelName]) {
        scope.$watch(attr[attrName], function(boolVal) {
          if (negate) {
@@ -176,20 +171,13 @@ function $AriaProvider() {
  this.$get = function() {
    return {
      config: function(key) {
-        return config[camelCase(key)];
+        return config[key];
      },
      $$watchExpr: watchExpr
    };
  };
 }

-var ngAriaTabindex = ['$aria', function($aria) {
-  return function(scope, elem, attr) {
-    if ($aria.config('tabindex') && !elem.attr('tabindex')) {
-      elem.attr('tabindex', 0);
-    }
-  };
-}];

 ngAriaModule.directive('ngShow', ['$aria', function($aria) {
  return $aria.$$watchExpr('ngShow', 'aria-hidden', true);
@@ -199,8 +187,8 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
 }])
 .directive('ngModel', ['$aria', function($aria) {

-  function shouldAttachAttr(attr, elem) {
-    return $aria.config(attr) && !elem.attr(attr);
+  function shouldAttachAttr(attr, normalizedAttr, elem) {
+    return $aria.config(normalizedAttr) && !elem.attr(attr);
  }

  function getShape(attr, elem) {
@@ -218,7 +206,7 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
    require: '?ngModel',
    link: function(scope, elem, attr, ngModel) {
      var shape = getShape(attr, elem);
-      var needsTabIndex = shouldAttachAttr('tabindex', elem);
+      var needsTabIndex = shouldAttachAttr('tabindex', 'tabindex', elem);

      function ngAriaWatchModelValue() {
        return ngModel.$modelValue;
@@ -246,7 +234,7 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
      switch (shape) {
        case 'radio':
        case 'checkbox':
-          if (shouldAttachAttr('aria-checked', elem)) {
+          if (shouldAttachAttr('aria-checked', 'ariaChecked', elem)) {
            scope.$watch(ngAriaWatchModelValue, shape === 'radio' ?
                getRadioReaction() : ngAriaCheckboxReaction);
          }
@@ -267,7 +255,7 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
          }
          break;
        case 'multiline':
-          if (shouldAttachAttr('aria-multiline', elem)) {
+          if (shouldAttachAttr('aria-multiline', 'ariaMultiline', elem)) {
            elem.attr('aria-multiline', true);
          }
          break;
@@ -277,7 +265,7 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
        elem.attr('tabindex', 0);
      }

-      if (ngModel.$validators.required && shouldAttachAttr('aria-required', elem)) {
+      if (ngModel.$validators.required && shouldAttachAttr('aria-required', 'ariaRequired', elem)) {
        scope.$watch(function ngAriaRequiredWatch() {
          return ngModel.$error.required;
        }, function ngAriaRequiredReaction(newVal) {
@@ -285,7 +273,7 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
        });
      }

-      if (shouldAttachAttr('aria-invalid', elem)) {
+      if (shouldAttachAttr('aria-invalid', 'ariaInvalid', elem)) {
        scope.$watch(function ngAriaInvalidWatch() {
          return ngModel.$invalid;
        }, function ngAriaInvalidReaction(newVal) {
@@ -309,5 +297,28 @@ ngAriaModule.directive('ngShow', ['$aria', function($aria) {
    }
  };
 })
-.directive('ngClick', ngAriaTabindex)
-.directive('ngDblclick', ngAriaTabindex);
+.directive('ngClick',['$aria', function($aria) {
+  return {
+    restrict: 'A',
+    link: function(scope, elem, attr) {
+      if ($aria.config('tabindex') && !elem.attr('tabindex')) {
+        elem.attr('tabindex', 0);
+      }
+
+      if ($aria.config('bindKeypress') && !elem.attr('ng-keypress')) {
+        elem.on('keypress', function(event) {
+          if (event.keyCode === 32 || event.keyCode === 13) {
+            scope.$eval(attr.ngClick);
+          }
+        });
+      }
+    }
+  };
+}])
+.directive('ngDblclick', ['$aria', function($aria) {
+  return function(scope, elem, attr) {
+    if ($aria.config('tabindex') && !elem.attr('tabindex')) {
+      elem.attr('tabindex', 0);
+    }
+  };
+}]);
@@ -40,9 +40,9 @@ $provide.value("$locale", {
      "Sa"
    ],
    "SHORTMONTH": [
-      "Jan",
-      "Feb",
-      "Mar",
+      "Jan.",
+      "Feb.",
+      "Mrt.",
      "Apr",
      "Mei",
      "Jun",
@@ -40,9 +40,9 @@ $provide.value("$locale", {
      "Sa"
    ],
    "SHORTMONTH": [
-      "Jan",
-      "Feb",
-      "Mar",
+      "Jan.",
+      "Feb.",
+      "Mrt.",
      "Apr",
      "Mei",
      "Jun",
@@ -53,7 +53,7 @@ $provide.value("$locale", {
      "Nov",
      "Des"
    ],
-    "fullDate": "EEEE dd MMMM y",
+    "fullDate": "EEEE, dd MMMM y",
    "longDate": "dd MMMM y",
    "medium": "dd MMM y h:mm:ss a",
    "mediumDate": "dd MMM y",
@@ -40,9 +40,9 @@ $provide.value("$locale", {
      "Sa"
    ],
    "SHORTMONTH": [
-      "Jan",
-      "Feb",
-      "Mar",
+      "Jan.",
+      "Feb.",
+      "Mrt.",
      "Apr",
      "Mei",
      "Jun",
@@ -53,7 +53,7 @@ $provide.value("$locale", {
      "Nov",
      "Des"
    ],
-    "fullDate": "EEEE dd MMMM y",
+    "fullDate": "EEEE, dd MMMM y",
    "longDate": "dd MMMM y",
    "medium": "dd MMM y h:mm:ss a",
    "mediumDate": "dd MMM y",
@@ -26,7 +26,7 @@ $provide.value("$locale", {
      "\u1301\u120b\u12ed",
      "\u12a6\u1308\u1235\u1275",
      "\u1234\u1355\u1274\u121d\u1260\u122d",
-      "\u12a6\u12ad\u1270\u12cd\u1260\u122d",
+      "\u12a6\u12ad\u1276\u1260\u122d",
      "\u1296\u126c\u121d\u1260\u122d",
      "\u12f2\u1234\u121d\u1260\u122d"
    ],
@@ -49,7 +49,7 @@ $provide.value("$locale", {
      "\u1301\u120b\u12ed",
      "\u12a6\u1308\u1235",
      "\u1234\u1355\u1274",
-      "\u12a6\u12ad\u1270",
+      "\u12a6\u12ad\u1276",
      "\u1296\u126c\u121d",
      "\u12f2\u1234\u121d"
    ],
@@ -26,7 +26,7 @@ $provide.value("$locale", {
      "\u1301\u120b\u12ed",
      "\u12a6\u1308\u1235\u1275",
      "\u1234\u1355\u1274\u121d\u1260\u122d",
-      "\u12a6\u12ad\u1270\u12cd\u1260\u122d",
+      "\u12a6\u12ad\u1276\u1260\u122d",
      "\u1296\u126c\u121d\u1260\u122d",
      "\u12f2\u1234\u121d\u1260\u122d"
    ],
@@ -49,7 +49,7 @@ $provide.value("$locale", {
      "\u1301\u120b\u12ed",
      "\u12a6\u1308\u1235",
      "\u1234\u1355\u1274",
-      "\u12a6\u12ad\u1270",
+      "\u12a6\u12ad\u1276",
      "\u1296\u126c\u121d",
      "\u12f2\u1234\u121d"
    ],
@@ -38,15 +38,15 @@ $provide.value("$locale", {
      "de xineru",
      "de febreru",
      "de marzu",
-      "d'abril",
+      "d\u2019abril",
      "de mayu",
      "de xunu",
      "de xunetu",
-      "d'agostu",
+      "d\u2019agostu",
      "de setiembre",
-      "d'ochobre",
+      "d\u2019ochobre",
      "de payares",
-      "d'avientu"
+      "d\u2019avientu"
    ],
    "SHORTDAY": [
      "dom",
@@ -71,7 +71,7 @@ $provide.value("$locale", {
      "pay",
      "avi"
    ],
-    "fullDate": "EEEE, dd MMMM 'de' y",
+    "fullDate": "EEEE, d MMMM 'de' y",
    "longDate": "d MMMM 'de' y",
    "medium": "d MMM y HH:mm:ss",
    "mediumDate": "d MMM y",
@@ -38,15 +38,15 @@ $provide.value("$locale", {
      "de xineru",
      "de febreru",
      "de marzu",
-      "d'abril",
+      "d\u2019abril",
      "de mayu",
      "de xunu",
      "de xunetu",
-      "d'agostu",
+      "d\u2019agostu",
      "de setiembre",
-      "d'ochobre",
+      "d\u2019ochobre",
      "de payares",
-      "d'avientu"
+      "d\u2019avientu"
    ],
    "SHORTDAY": [
      "dom",
@@ -71,7 +71,7 @@ $provide.value("$locale", {
      "pay",
      "avi"
    ],
-    "fullDate": "EEEE, dd MMMM 'de' y",
+    "fullDate": "EEEE, d MMMM 'de' y",
    "longDate": "d MMMM 'de' y",
    "medium": "d MMM y HH:mm:ss",
    "mediumDate": "d MMM y",
@@ -31,27 +31,27 @@ $provide.value("$locale", {
      "\u0434\u0435\u043a\u0430\u0431\u0440"
    ],
    "SHORTDAY": [
-      "B.",
-      "B.E.",
-      "\u00c7.A.",
-      "\u00c7.",
-      "C.A.",
-      "C",
-      "\u015e."
+      "\u0431\u0430\u0437\u0430\u0440",
+      "\u0431\u0430\u0437\u0430\u0440 \u0435\u0440\u0442\u04d9\u0441\u0438",
+      "\u0447\u04d9\u0440\u0448\u04d9\u043d\u0431\u04d9 \u0430\u0445\u0448\u0430\u043c\u044b",
+      "\u0447\u04d9\u0440\u0448\u04d9\u043d\u0431\u04d9",
+      "\u04b9\u04af\u043c\u04d9 \u0430\u0445\u0448\u0430\u043c\u044b",
+      "\u04b9\u04af\u043c\u04d9",
+      "\u0448\u04d9\u043d\u0431\u04d9"
    ],
    "SHORTMONTH": [
-      "yan",
-      "fev",
-      "mar",
-      "apr",
-      "may",
-      "iyn",
-      "iyl",
-      "avq",
-      "sen",
-      "okt",
-      "noy",
-      "dek"
+      "\u0458\u0430\u043d\u0432\u0430\u0440",
+      "\u0444\u0435\u0432\u0440\u0430\u043b",
+      "\u043c\u0430\u0440\u0442",
+      "\u0430\u043f\u0440\u0435\u043b",
+      "\u043c\u0430\u0439",
+      "\u0438\u0458\u0443\u043d",
+      "\u0438\u0458\u0443\u043b",
+      "\u0430\u0432\u0433\u0443\u0441\u0442",
+      "\u0441\u0435\u043d\u0442\u0458\u0430\u0431\u0440",
+      "\u043e\u043a\u0442\u0458\u0430\u0431\u0440",
+      "\u043d\u043e\u0458\u0430\u0431\u0440",
+      "\u0434\u0435\u043a\u0430\u0431\u0440"
    ],
    "fullDate": "EEEE, d, MMMM, y",
    "longDate": "d MMMM, y",
@@ -31,27 +31,27 @@ $provide.value("$locale", {
      "\u0434\u0435\u043a\u0430\u0431\u0440"
    ],
    "SHORTDAY": [
-      "B.",
-      "B.E.",
-      "\u00c7.A.",
-      "\u00c7.",
-      "C.A.",
-      "C",
-      "\u015e."
+      "\u0431\u0430\u0437\u0430\u0440",
+      "\u0431\u0430\u0437\u0430\u0440 \u0435\u0440\u0442\u04d9\u0441\u0438",
+      "\u0447\u04d9\u0440\u0448\u04d9\u043d\u0431\u04d9 \u0430\u0445\u0448\u0430\u043c\u044b",
+      "\u0447\u04d9\u0440\u0448\u04d9\u043d\u0431\u04d9",
+      "\u04b9\u04af\u043c\u04d9 \u0430\u0445\u0448\u0430\u043c\u044b",
+      "\u04b9\u04af\u043c\u04d9",
+      "\u0448\u04d9\u043d\u0431\u04d9"
    ],
    "SHORTMONTH": [
-      "yan",
-      "fev",
-      "mar",
-      "apr",
-      "may",
-      "iyn",
-      "iyl",
-      "avq",
-      "sen",
-      "okt",
-      "noy",
-      "dek"
+      "\u0458\u0430\u043d\u0432\u0430\u0440",
+      "\u0444\u0435\u0432\u0440\u0430\u043b",
+      "\u043c\u0430\u0440\u0442",
+      "\u0430\u043f\u0440\u0435\u043b",
+      "\u043c\u0430\u0439",
+      "\u0438\u0458\u0443\u043d",
+      "\u0438\u0458\u0443\u043b",
+      "\u0430\u0432\u0433\u0443\u0441\u0442",
+      "\u0441\u0435\u043d\u0442\u0458\u0430\u0431\u0440",
+      "\u043e\u043a\u0442\u0458\u0430\u0431\u0440",
+      "\u043d\u043e\u0458\u0430\u0431\u0440",
+      "\u0434\u0435\u043a\u0430\u0431\u0440"
    ],
    "fullDate": "EEEE, d, MMMM, y",
    "longDate": "d MMMM, y",
@@ -36,7 +36,7 @@ $provide.value("$locale", {
      "\u00c7.A.",
      "\u00c7.",
      "C.A.",
-      "C",
+      "C.",
      "\u015e."
    ],
    "SHORTMONTH": [
@@ -36,7 +36,7 @@ $provide.value("$locale", {
      "\u00c7.A.",
      "\u00c7.",
      "C.A.",
-      "C",
+      "C.",
      "\u015e."
    ],
    "SHORTMONTH": [
@@ -36,7 +36,7 @@ $provide.value("$locale", {
      "\u00c7.A.",
      "\u00c7.",
      "C.A.",
-      "C",
+      "C.",
      "\u015e."
    ],
    "SHORTMONTH": [
@@ -58,8 +58,8 @@ $provide.value("$locale", {
    "medium": "d.MM.y '\u0433'. H:mm:ss",
    "mediumDate": "d.MM.y '\u0433'.",
    "mediumTime": "H:mm:ss",
-    "short": "d.MM.yy H:mm",
-    "shortDate": "d.MM.yy",
+    "short": "d.MM.yy '\u0433'. H:mm",
+    "shortDate": "d.MM.yy '\u0433'.",
    "shortTime": "H:mm"
  },
  "NUMBER_FORMATS": {
@@ -58,8 +58,8 @@ $provide.value("$locale", {
    "medium": "d.MM.y '\u0433'. H:mm:ss",
    "mediumDate": "d.MM.y '\u0433'.",
    "mediumTime": "H:mm:ss",
-    "short": "d.MM.yy H:mm",
-    "shortDate": "d.MM.yy",
+    "short": "d.MM.yy '\u0433'. H:mm",
+    "shortDate": "d.MM.yy '\u0433'.",
    "shortTime": "H:mm"
  },
  "NUMBER_FORMATS": {
@@ -0,0 +1,115 @@
+'use strict';
+angular.module("ngLocale", [], ["$provide", function($provide) {
+var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "many", OTHER: "other"};
+function getDecimals(n) {
+  n = n + '';
+  var i = n.indexOf('.');
+  return (i == -1) ? 0 : n.length - i - 1;
+}
+
+function getVF(n, opt_precision) {
+  var v = opt_precision;
+
+  if (undefined === v) {
+    v = Math.min(getDecimals(n), 3);
+  }
+
+  var base = Math.pow(10, v);
+  var f = ((n * base) | 0) % base;
+  return {v: v, f: f};
+}
+
+$provide.value("$locale", {
+  "DATETIME_FORMATS": {
+    "AMPMS": [
+      "AM",
+      "PM"
+    ],
+    "DAY": [
+      "kari",
+      "nt\u025bn\u025b",
+      "tarata",
+      "araba",
+      "alamisa",
+      "juma",
+      "sibiri"
+    ],
+    "MONTH": [
+      "zanwuye",
+      "feburuye",
+      "marisi",
+      "awirili",
+      "m\u025b",
+      "zuw\u025bn",
+      "zuluye",
+      "uti",
+      "s\u025btanburu",
+      "\u0254kut\u0254buru",
+      "nowanburu",
+      "desanburu"
+    ],
+    "SHORTDAY": [
+      "kar",
+      "nt\u025b",
+      "tar",
+      "ara",
+      "ala",
+      "jum",
+      "sib"
+    ],
+    "SHORTMONTH": [
+      "zan",
+      "feb",
+      "mar",
+      "awi",
+      "m\u025b",
+      "zuw",
+      "zul",
+      "uti",
+      "s\u025bt",
+      "\u0254ku",
+      "now",
+      "des"
+    ],
+    "fullDate": "EEEE d MMMM y",
+    "longDate": "d MMMM y",
+    "medium": "d MMM, y HH:mm:ss",
+    "mediumDate": "d MMM, y",
+    "mediumTime": "HH:mm:ss",
+    "short": "d/M/y HH:mm",
+    "shortDate": "d/M/y",
+    "shortTime": "HH:mm"
+  },
+  "NUMBER_FORMATS": {
+    "CURRENCY_SYM": "CFA",
+    "DECIMAL_SEP": ".",
+    "GROUP_SEP": ",",
+    "PATTERNS": [
+      {
+        "gSize": 3,
+        "lgSize": 3,
+        "maxFrac": 3,
+        "minFrac": 0,
+        "minInt": 1,
+        "negPre": "-",
+        "negSuf": "",
+        "posPre": "",
+        "posSuf": ""
+      },
+      {
+        "gSize": 3,
+        "lgSize": 3,
+        "maxFrac": 2,
+        "minFrac": 2,
+        "minInt": 1,
+        "negPre": "\u00a4-",
+        "negSuf": "",
+        "posPre": "\u00a4",
+        "posSuf": ""
+      }
+    ]
+  },
+  "id": "bm-latn-ml",
+  "pluralCat": function(n, opt_precision) {  var i = n | 0;  var vf = getVF(n, opt_precision);  if (i == 1 && vf.v == 0) {    return PLURAL_CATEGORY.ONE;  }  return PLURAL_CATEGORY.OTHER;}
+});
+}]);
@@ -0,0 +1,115 @@
+'use strict';
+angular.module("ngLocale", [], ["$provide", function($provide) {
+var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "many", OTHER: "other"};
+function getDecimals(n) {
+  n = n + '';
+  var i = n.indexOf('.');
+  return (i == -1) ? 0 : n.length - i - 1;
+}
+
+function getVF(n, opt_precision) {
+  var v = opt_precision;
+
+  if (undefined === v) {
+    v = Math.min(getDecimals(n), 3);
+  }
+
+  var base = Math.pow(10, v);
+  var f = ((n * base) | 0) % base;
+  return {v: v, f: f};
+}
+
+$provide.value("$locale", {
+  "DATETIME_FORMATS": {
+    "AMPMS": [
+      "AM",
+      "PM"
+    ],
+    "DAY": [
+      "kari",
+      "nt\u025bn\u025b",
+      "tarata",
+      "araba",
+      "alamisa",
+      "juma",
+      "sibiri"
+    ],
+    "MONTH": [
+      "zanwuye",
+      "feburuye",
+      "marisi",
+      "awirili",
+      "m\u025b",
+      "zuw\u025bn",
+      "zuluye",
+      "uti",
+      "s\u025btanburu",
+      "\u0254kut\u0254buru",
+      "nowanburu",
+      "desanburu"
+    ],
+    "SHORTDAY": [
+      "kar",
+      "nt\u025b",
+      "tar",
+      "ara",
+      "ala",
+      "jum",
+      "sib"
+    ],
+    "SHORTMONTH": [
+      "zan",
+      "feb",
+      "mar",
+      "awi",
+      "m\u025b",
+      "zuw",
+      "zul",
+      "uti",
+      "s\u025bt",
+      "\u0254ku",
+      "now",
+      "des"
+    ],
+    "fullDate": "EEEE d MMMM y",
+    "longDate": "d MMMM y",
+    "medium": "d MMM, y HH:mm:ss",
+    "mediumDate": "d MMM, y",
+    "mediumTime": "HH:mm:ss",
+    "short": "d/M/y HH:mm",
+    "shortDate": "d/M/y",
+    "shortTime": "HH:mm"
+  },
+  "NUMBER_FORMATS": {
+    "CURRENCY_SYM": "\u20ac",
+    "DECIMAL_SEP": ".",
+    "GROUP_SEP": ",",
+    "PATTERNS": [
+      {
+        "gSize": 3,
+        "lgSize": 3,
+        "maxFrac": 3,
+        "minFrac": 0,
+        "minInt": 1,
+        "negPre": "-",
+        "negSuf": "",
+        "posPre": "",
+        "posSuf": ""
+      },
+      {
+        "gSize": 3,
+        "lgSize": 3,
+        "maxFrac": 2,
+        "minFrac": 2,
+        "minInt": 1,
+        "negPre": "\u00a4-",
+        "negSuf": "",
+        "posPre": "\u00a4",
+        "posSuf": ""
+      }
+    ]
+  },
+  "id": "bm-latn",
+  "pluralCat": function(n, opt_precision) {  var i = n | 0;  var vf = getVF(n, opt_precision);  if (i == 1 && vf.v == 0) {    return PLURAL_CATEGORY.ONE;  }  return PLURAL_CATEGORY.OTHER;}
+});
+}]);
@@ -12,7 +12,7 @@ $provide.value("$locale", {
      "\u09b8\u09cb\u09ae\u09ac\u09be\u09b0",
      "\u09ae\u0999\u09cd\u0997\u09b2\u09ac\u09be\u09b0",
      "\u09ac\u09c1\u09a7\u09ac\u09be\u09b0",
-      "\u09ac\u09c3\u09b9\u09b7\u09cd\u09aa\u09a4\u09bf\u09ac\u09be\u09b0",
+      "\u09ac\u09c3\u09b9\u09b8\u09cd\u09aa\u09a4\u09bf\u09ac\u09be\u09b0",
      "\u09b6\u09c1\u0995\u09cd\u09b0\u09ac\u09be\u09b0",
      "\u09b6\u09a8\u09bf\u09ac\u09be\u09b0"
    ],
@@ -12,7 +12,7 @@ $provide.value("$locale", {
      "\u09b8\u09cb\u09ae\u09ac\u09be\u09b0",
      "\u09ae\u0999\u09cd\u0997\u09b2\u09ac\u09be\u09b0",
      "\u09ac\u09c1\u09a7\u09ac\u09be\u09b0",
-      "\u09ac\u09c3\u09b9\u09b7\u09cd\u09aa\u09a4\u09bf\u09ac\u09be\u09b0",
+      "\u09ac\u09c3\u09b9\u09b8\u09cd\u09aa\u09a4\u09bf\u09ac\u09be\u09b0",
      "\u09b6\u09c1\u0995\u09cd\u09b0\u09ac\u09be\u09b0",
      "\u09b6\u09a8\u09bf\u09ac\u09be\u09b0"
    ],
@@ -12,7 +12,7 @@ $provide.value("$locale", {
      "\u09b8\u09cb\u09ae\u09ac\u09be\u09b0",
      "\u09ae\u0999\u09cd\u0997\u09b2\u09ac\u09be\u09b0",
      "\u09ac\u09c1\u09a7\u09ac\u09be\u09b0",
-      "\u09ac\u09c3\u09b9\u09b7\u09cd\u09aa\u09a4\u09bf\u09ac\u09be\u09b0",
+      "\u09ac\u09c3\u09b9\u09b8\u09cd\u09aa\u09a4\u09bf\u09ac\u09be\u09b0",
      "\u09b6\u09c1\u0995\u09cd\u09b0\u09ac\u09be\u09b0",
      "\u09b6\u09a8\u09bf\u09ac\u09be\u09b0"
    ],
@@ -29,9 +29,9 @@ $provide.value("$locale", {
      "\u0f42\u0f5f\u0f60\u0f0b\u0f49\u0f72\u0f0b\u0f58\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f58\u0f72\u0f42\u0f0b\u0f51\u0f58\u0f62\u0f0b",
-      "\u0f42\u0f5f\u0f60\u0f0b\u0f67\u0fb3\u0f42\u0f0b\u0f54\u0f0b",
+      "\u0f42\u0f5f\u0f60\u0f0b\u0f63\u0fb7\u0f42\u0f0b\u0f54\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f55\u0f74\u0f62\u0f0b\u0f56\u0f74\u0f0b",
-      "\u0f42\u0f5f\u0f60\u0f0b\u0f66\u0f44\u0f66\u0f0b",
+      "\u0f42\u0f5f\u0f60\u0f0b\u0f54\u0f0b\u0f66\u0f44\u0f66\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f66\u0fa4\u0f7a\u0f53\u0f0b\u0f54\u0f0b"
    ],
    "MONTH": [
@@ -52,9 +52,9 @@ $provide.value("$locale", {
      "\u0f49\u0f72\u0f0b\u0f58\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f56\u0f0b",
      "\u0f58\u0f72\u0f42\u0f0b\u0f51\u0f58\u0f62\u0f0b",
-      "\u0f67\u0fb3\u0f42\u0f0b\u0f54\u0f0b",
+      "\u0f63\u0fb7\u0f42\u0f0b\u0f54\u0f0b",
      "\u0f55\u0f74\u0f62\u0f0b\u0f56\u0f74\u0f0b",
-      "\u0f66\u0f44\u0f66\u0f0b",
+      "\u0f54\u0f0b\u0f66\u0f44\u0f66\u0f0b",
      "\u0f66\u0fa4\u0f7a\u0f53\u0f0b\u0f54\u0f0b"
    ],
    "SHORTMONTH": [
@@ -72,7 +72,7 @@ $provide.value("$locale", {
      "\u0f5f\u0fb3\u0f0b\u0f21\u0f22"
    ],
    "fullDate": "y MMMM d, EEEE",
-    "longDate": "\u0f66\u0fa6\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by MMMM\u0f60\u0f72\u0f0b\u0f59\u0f7a\u0f66\u0f0bd\u0f51",
+    "longDate": "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by MMMM\u0f60\u0f72\u0f0b\u0f59\u0f7a\u0f66\u0f0bd\u0f51",
    "medium": "y \u0f63\u0f7c\u0f0b\u0f60\u0f72\u0f0bMMM\u0f59\u0f7a\u0f66\u0f0bd HH:mm:ss",
    "mediumDate": "y \u0f63\u0f7c\u0f0b\u0f60\u0f72\u0f0bMMM\u0f59\u0f7a\u0f66\u0f0bd",
    "mediumTime": "HH:mm:ss",
@@ -29,9 +29,9 @@ $provide.value("$locale", {
      "\u0f42\u0f5f\u0f60\u0f0b\u0f49\u0f72\u0f0b\u0f58\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f58\u0f72\u0f42\u0f0b\u0f51\u0f58\u0f62\u0f0b",
-      "\u0f42\u0f5f\u0f60\u0f0b\u0f67\u0fb3\u0f42\u0f0b\u0f54\u0f0b",
+      "\u0f42\u0f5f\u0f60\u0f0b\u0f63\u0fb7\u0f42\u0f0b\u0f54\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f55\u0f74\u0f62\u0f0b\u0f56\u0f74\u0f0b",
-      "\u0f42\u0f5f\u0f60\u0f0b\u0f66\u0f44\u0f66\u0f0b",
+      "\u0f42\u0f5f\u0f60\u0f0b\u0f54\u0f0b\u0f66\u0f44\u0f66\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f66\u0fa4\u0f7a\u0f53\u0f0b\u0f54\u0f0b"
    ],
    "MONTH": [
@@ -52,9 +52,9 @@ $provide.value("$locale", {
      "\u0f49\u0f72\u0f0b\u0f58\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f56\u0f0b",
      "\u0f58\u0f72\u0f42\u0f0b\u0f51\u0f58\u0f62\u0f0b",
-      "\u0f67\u0fb3\u0f42\u0f0b\u0f54\u0f0b",
+      "\u0f63\u0fb7\u0f42\u0f0b\u0f54\u0f0b",
      "\u0f55\u0f74\u0f62\u0f0b\u0f56\u0f74\u0f0b",
-      "\u0f66\u0f44\u0f66\u0f0b",
+      "\u0f54\u0f0b\u0f66\u0f44\u0f66\u0f0b",
      "\u0f66\u0fa4\u0f7a\u0f53\u0f0b\u0f54\u0f0b"
    ],
    "SHORTMONTH": [
@@ -72,7 +72,7 @@ $provide.value("$locale", {
      "\u0f5f\u0fb3\u0f0b\u0f21\u0f22"
    ],
    "fullDate": "y MMMM d, EEEE",
-    "longDate": "\u0f66\u0fa6\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by MMMM\u0f60\u0f72\u0f0b\u0f59\u0f7a\u0f66\u0f0bd\u0f51",
+    "longDate": "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by MMMM\u0f60\u0f72\u0f0b\u0f59\u0f7a\u0f66\u0f0bd\u0f51",
    "medium": "y \u0f63\u0f7c\u0f0b\u0f60\u0f72\u0f0bMMM\u0f59\u0f7a\u0f66\u0f0bd HH:mm:ss",
    "mediumDate": "y \u0f63\u0f7c\u0f0b\u0f60\u0f72\u0f0bMMM\u0f59\u0f7a\u0f66\u0f0bd",
    "mediumTime": "HH:mm:ss",
@@ -29,9 +29,9 @@ $provide.value("$locale", {
      "\u0f42\u0f5f\u0f60\u0f0b\u0f49\u0f72\u0f0b\u0f58\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f5f\u0fb3\u0f0b\u0f56\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f58\u0f72\u0f42\u0f0b\u0f51\u0f58\u0f62\u0f0b",
-      "\u0f42\u0f5f\u0f60\u0f0b\u0f67\u0fb3\u0f42\u0f0b\u0f54\u0f0b",
+      "\u0f42\u0f5f\u0f60\u0f0b\u0f63\u0fb7\u0f42\u0f0b\u0f54\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f55\u0f74\u0f62\u0f0b\u0f56\u0f74\u0f0b",
-      "\u0f42\u0f5f\u0f60\u0f0b\u0f66\u0f44\u0f66\u0f0b",
+      "\u0f42\u0f5f\u0f60\u0f0b\u0f54\u0f0b\u0f66\u0f44\u0f66\u0f0b",
      "\u0f42\u0f5f\u0f60\u0f0b\u0f66\u0fa4\u0f7a\u0f53\u0f0b\u0f54\u0f0b"
    ],
    "MONTH": [
@@ -52,9 +52,9 @@ $provide.value("$locale", {
      "\u0f49\u0f72\u0f0b\u0f58\u0f0b",
      "\u0f5f\u0fb3\u0f0b\u0f56\u0f0b",
      "\u0f58\u0f72\u0f42\u0f0b\u0f51\u0f58\u0f62\u0f0b",
-      "\u0f67\u0fb3\u0f42\u0f0b\u0f54\u0f0b",
+      "\u0f63\u0fb7\u0f42\u0f0b\u0f54\u0f0b",
      "\u0f55\u0f74\u0f62\u0f0b\u0f56\u0f74\u0f0b",
-      "\u0f66\u0f44\u0f66\u0f0b",
+      "\u0f54\u0f0b\u0f66\u0f44\u0f66\u0f0b",
      "\u0f66\u0fa4\u0f7a\u0f53\u0f0b\u0f54\u0f0b"
    ],
    "SHORTMONTH": [
@@ -72,7 +72,7 @@ $provide.value("$locale", {
      "\u0f5f\u0fb3\u0f0b\u0f21\u0f22"
    ],
    "fullDate": "y MMMM d, EEEE",
-    "longDate": "\u0f66\u0fa6\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by MMMM\u0f60\u0f72\u0f0b\u0f59\u0f7a\u0f66\u0f0bd\u0f51",
+    "longDate": "\u0f66\u0fa4\u0fb1\u0f72\u0f0b\u0f63\u0f7c\u0f0by MMMM\u0f60\u0f72\u0f0b\u0f59\u0f7a\u0f66\u0f0bd\u0f51",
    "medium": "y \u0f63\u0f7c\u0f0b\u0f60\u0f72\u0f0bMMM\u0f59\u0f7a\u0f66\u0f0bd HH:mm:ss",
    "mediumDate": "y \u0f63\u0f7c\u0f0b\u0f60\u0f72\u0f0bMMM\u0f59\u0f7a\u0f66\u0f0bd",
    "mediumTime": "HH:mm:ss",
@@ -4,8 +4,8 @@ var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "
 $provide.value("$locale", {
  "DATETIME_FORMATS": {
    "AMPMS": [
-      "AM",
-      "PM"
+      "A.M.",
+      "G.M."
    ],
    "DAY": [
      "Sul",
@@ -31,13 +31,13 @@ $provide.value("$locale", {
      "Kerzu"
    ],
    "SHORTDAY": [
-      "sul",
-      "lun",
-      "meu.",
-      "mer.",
-      "yaou",
-      "gwe.",
-      "sad."
+      "Sul",
+      "Lun",
+      "Meu.",
+      "Mer.",
+      "Yaou",
+      "Gwe.",
+      "Sad."
    ],
    "SHORTMONTH": [
      "Gen",
@@ -84,10 +84,10 @@ $provide.value("$locale", {
        "maxFrac": 2,
        "minFrac": 2,
        "minInt": 1,
-        "negPre": "\u00a4\u00a0-",
-        "negSuf": "",
-        "posPre": "\u00a4\u00a0",
-        "posSuf": ""
+        "negPre": "-",
+        "negSuf": "\u00a0\u00a4",
+        "posPre": "",
+        "posSuf": "\u00a0\u00a4"
      }
    ]
  },
@@ -4,8 +4,8 @@ var PLURAL_CATEGORY = {ZERO: "zero", ONE: "one", TWO: "two", FEW: "few", MANY: "
 $provide.value("$locale", {
  "DATETIME_FORMATS": {
    "AMPMS": [
-      "AM",
-      "PM"
+      "A.M.",
+      "G.M."
    ],
    "DAY": [
      "Sul",
@@ -31,13 +31,13 @@ $provide.value("$locale", {
      "Kerzu"
    ],
    "SHORTDAY": [
-      "sul",
-      "lun",
-      "meu.",
-      "mer.",
-      "yaou",
-      "gwe.",
-      "sad."
+      "Sul",
+      "Lun",
+      "Meu.",
+      "Mer.",
+      "Yaou",
+      "Gwe.",
+      "Sad."
    ],
    "SHORTMONTH": [
      "Gen",
@@ -84,10 +84,10 @@ $provide.value("$locale", {
        "maxFrac": 2,
        "minFrac": 2,
        "minInt": 1,
-        "negPre": "\u00a4\u00a0-",
-        "negSuf": "",
-        "posPre": "\u00a4\u00a0",
-        "posSuf": ""
+        "negPre": "-",
+        "negSuf": "\u00a0\u00a4",
+        "posPre": "",
+        "posSuf": "\u00a0\u00a4"
      }
    ]
  },
@@ -22,7 +22,7 @@ function getVF(n, opt_precision) {
 $provide.value("$locale", {
  "DATETIME_FORMATS": {
    "AMPMS": [
-      "pre podne",
+      "prije podne",
      "popodne"
    ],
    "DAY": [
@@ -42,7 +42,7 @@ $provide.value("$locale", {
      "maj",
      "juni",
      "juli",
-      "avgust",
+      "august",
      "septembar",
      "oktobar",
      "novembar",
@@ -65,7 +65,7 @@ $provide.value("$locale", {
      "maj",
      "jun",
      "jul",
-      "avg",
+      "aug",
      "sep",
      "okt",
      "nov",
@@ -73,8 +73,8 @@ $provide.value("$locale", {
    ],
    "fullDate": "EEEE, dd. MMMM y.",
    "longDate": "dd. MMMM y.",
-    "medium": "dd.MM.y. HH:mm:ss",
-    "mediumDate": "dd.MM.y.",
+    "medium": "dd. MMM. y. HH:mm:ss",
+    "mediumDate": "dd. MMM. y.",
    "mediumTime": "HH:mm:ss",
    "short": "dd.MM.yy. HH:mm",
    "shortDate": "dd.MM.yy.",
@@ -102,10 +102,10 @@ $provide.value("$locale", {
        "maxFrac": 2,
        "minFrac": 2,
        "minInt": 1,
-        "negPre": "\u00a4\u00a0-",
-        "negSuf": "",
-        "posPre": "\u00a4\u00a0",
-        "posSuf": ""
+        "negPre": "-",
+        "negSuf": "\u00a0\u00a4",
+        "posPre": "",
+        "posSuf": "\u00a0\u00a4"
      }
    ]
  },
@@ -22,7 +22,7 @@ function getVF(n, opt_precision) {
 $provide.value("$locale", {
  "DATETIME_FORMATS": {
    "AMPMS": [
-      "pre podne",
+      "prije podne",
      "popodne"
    ],
    "DAY": [
@@ -42,7 +42,7 @@ $provide.value("$locale", {
      "maj",
      "juni",
      "juli",
-      "avgust",
+      "august",
      "septembar",
      "oktobar",
      "novembar",
@@ -65,7 +65,7 @@ $provide.value("$locale", {
      "maj",
      "jun",
      "jul",
-      "avg",
+      "aug",
      "sep",
      "okt",
      "nov",
@@ -73,8 +73,8 @@ $provide.value("$locale", {
    ],
    "fullDate": "EEEE, dd. MMMM y.",
    "longDate": "dd. MMMM y.",
-    "medium": "dd.MM.y. HH:mm:ss",
-    "mediumDate": "dd.MM.y.",
+    "medium": "dd. MMM. y. HH:mm:ss",
+    "mediumDate": "dd. MMM. y.",
    "mediumTime": "HH:mm:ss",
    "short": "dd.MM.yy. HH:mm",
    "shortDate": "dd.MM.yy.",
@@ -102,10 +102,10 @@ $provide.value("$locale", {
        "maxFrac": 2,
        "minFrac": 2,
        "minInt": 1,
-        "negPre": "\u00a4\u00a0-",
-        "negSuf": "",
-        "posPre": "\u00a4\u00a0",
-        "posSuf": ""
+        "negPre": "-",
+        "negSuf": "\u00a0\u00a4",
+        "posPre": "",
+        "posSuf": "\u00a0\u00a4"
      }
    ]
  },
@@ -22,7 +22,7 @@ function getVF(n, opt_precision) {
 $provide.value("$locale", {
  "DATETIME_FORMATS": {
    "AMPMS": [
-      "pre podne",
+      "prije podne",
      "popodne"
    ],
    "DAY": [
@@ -42,7 +42,7 @@ $provide.value("$locale", {
      "maj",
      "juni",
      "juli",
-      "avgust",
+      "august",
      "septembar",
      "oktobar",
      "novembar",
@@ -65,7 +65,7 @@ $provide.value("$locale", {
      "maj",
      "jun",
      "jul",
-      "avg",
+      "aug",
      "sep",
      "okt",
      "nov",
@@ -73,8 +73,8 @@ $provide.value("$locale", {
    ],
    "fullDate": "EEEE, dd. MMMM y.",
    "longDate": "dd. MMMM y.",
-    "medium": "dd.MM.y. HH:mm:ss",
-    "mediumDate": "dd.MM.y.",
+    "medium": "dd. MMM. y. HH:mm:ss",
+    "mediumDate": "dd. MMM. y.",
    "mediumTime": "HH:mm:ss",
    "short": "dd.MM.yy. HH:mm",
    "shortDate": "dd.MM.yy.",
@@ -102,10 +102,10 @@ $provide.value("$locale", {
        "maxFrac": 2,
        "minFrac": 2,
        "minInt": 1,
-        "negPre": "\u00a4\u00a0-",
-        "negSuf": "",
-        "posPre": "\u00a4\u00a0",
-        "posSuf": ""
+        "negPre": "-",
+        "negSuf": "\u00a0\u00a4",
+        "posPre": "",
+        "posSuf": "\u00a0\u00a4"
      }
    ]
  },
@@ -59,7 +59,7 @@ $provide.value("$locale", {
    ],
    "SHORTMONTH": [
      "gen.",
-      "feb.",
+      "febr.",
      "mar\u00e7",
      "abr.",
      "maig",
@@ -73,8 +73,8 @@ $provide.value("$locale", {
    ],
    "fullDate": "EEEE, d MMMM 'de' y",
    "longDate": "d MMMM 'de' y",
-    "medium": "dd/MM/y H:mm:ss",
-    "mediumDate": "dd/MM/y",
+    "medium": "d MMM y H:mm:ss",
+    "mediumDate": "d MMM y",
    "mediumTime": "H:mm:ss",
    "short": "d/M/yy H:mm",
    "shortDate": "d/M/yy",
@@ -59,7 +59,7 @@ $provide.value("$locale", {
    ],
    "SHORTMONTH": [
      "gen.",
-      "feb.",
+      "febr.",
      "mar\u00e7",
      "abr.",
      "maig",
@@ -73,8 +73,8 @@ $provide.value("$locale", {
    ],
    "fullDate": "EEEE, d MMMM 'de' y",
    "longDate": "d MMMM 'de' y",
-    "medium": "dd/MM/y H:mm:ss",
-    "mediumDate": "dd/MM/y",
+    "medium": "d MMM y H:mm:ss",
+    "mediumDate": "d MMM y",
    "mediumTime": "H:mm:ss",
    "short": "d/M/yy H:mm",
    "shortDate": "d/M/yy",
@@ -59,7 +59,7 @@ $provide.value("$locale", {
    ],
    "SHORTMONTH": [
      "gen.",
-      "feb.",
+      "febr.",
      "mar\u00e7",
      "abr.",
      "maig",
@@ -73,8 +73,8 @@ $provide.value("$locale", {
    ],
    "fullDate": "EEEE, d MMMM 'de' y",
    "longDate": "d MMMM 'de' y",
-    "medium": "dd/MM/y H:mm:ss",
-    "mediumDate": "dd/MM/y",
+    "medium": "d MMM y H:mm:ss",
+    "mediumDate": "d MMM y",
    "mediumTime": "H:mm:ss",
    "short": "d/M/yy H:mm",
    "shortDate": "d/M/yy",
@@ -59,7 +59,7 @@ $provide.value("$locale", {
    ],
    "SHORTMONTH": [
      "gen.",
-      "feb.",
+      "febr.",
      "mar\u00e7",
      "abr.",
      "maig",
@@ -73,8 +73,8 @@ $provide.value("$locale", {
    ],
    "fullDate": "EEEE, d MMMM 'de' y",
    "longDate": "d MMMM 'de' y",
-    "medium": "dd/MM/y H:mm:ss",
-    "mediumDate": "dd/MM/y",
+    "medium": "d MMM y H:mm:ss",
+    "mediumDate": "d MMM y",
    "mediumTime": "H:mm:ss",
    "short": "d/M/yy H:mm",
    "shortDate": "d/M/yy",
--- a/Show More
+++ b/Show More