docs(*): fix anchors for members in api docs

13 files changed, 57 insertions, 57 deletions

diff --git a/docs/content/api/index.ngdoc b/docs/content/api/index.ngdoc
index 5fa3cc7a..9233ac71 100644
--- a/docs/content/api/index.ngdoc
+++ b/docs/content/api/index.ngdoc
@@ -156,7 +156,7 @@ or JavaScript callbacks.
       {@link ngAnimate JS-based animations}
     </td>
     <td>
-      Use {@link angular.Module#methods_animation module.animation()} to register a JavaScript animation. Once registered the animation can be triggered by referencing the CSS class within the HTML template code.
+      Use {@link angular.Module#animation module.animation()} to register a JavaScript animation. Once registered the animation can be triggered by referencing the CSS class within the HTML template code.
     </td>
   </tr>
 </table>
diff --git a/docs/content/error/$injector/pget.ngdoc b/docs/content/error/$injector/pget.ngdoc
index 1772d348..5dbf05c7 100644
--- a/docs/content/error/$injector/pget.ngdoc
+++ b/docs/content/error/$injector/pget.ngdoc
@@ -22,5 +22,5 @@ angular.module("myApp", [])
   .provider('good', GoodProvider);
 ```
 
-For more information, refer to the {@link auto.$provide#methods_provider
+For more information, refer to the {@link auto.$provide#provider
 $provide.provider} api doc.
\ No newline at end of file
diff --git a/docs/content/error/$sce/icontext.ngdoc b/docs/content/error/$sce/icontext.ngdoc
index e30b6ad4..3ad0f22d 100644
--- a/docs/content/error/$sce/icontext.ngdoc
+++ b/docs/content/error/$sce/icontext.ngdoc
@@ -3,6 +3,6 @@
 @fullName Invalid / Unknown SCE context
 @description
 
-The context enum passed to {@link ng.$sce#methods_trustAs $sce.trustAs} was not recognized.
+The context enum passed to {@link ng.$sce#trustAs $sce.trustAs} was not recognized.
 
 Please consult the list of {@link ng.$sce#contexts supported Strict Contextual Escaping (SCE) contexts}.
diff --git a/docs/content/error/$sce/imatcher.ngdoc b/docs/content/error/$sce/imatcher.ngdoc
index eabdbc53..5cb816d0 100644
--- a/docs/content/error/$sce/imatcher.ngdoc
+++ b/docs/content/error/$sce/imatcher.ngdoc
@@ -3,7 +3,7 @@
 @fullName Invalid matcher (only string patterns and RegExp instances are supported)
 @description
 
-Please see {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist
+Please see {@link ng.$sceDelegateProvider#resourceUrlWhitelist
 $sceDelegateProvider.resourceUrlWhitelist} and {@link
-api/ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} for the
+api/ng.$sceDelegateProvider#resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} for the
 list of acceptable items.
diff --git a/docs/content/error/$sce/insecurl.ngdoc b/docs/content/error/$sce/insecurl.ngdoc
index 67bbb2b6..9691e2b5 100644
--- a/docs/content/error/$sce/insecurl.ngdoc
+++ b/docs/content/error/$sce/insecurl.ngdoc
@@ -8,16 +8,16 @@ AngularJS' {@link ng.$sce Strict Contextual Escaping (SCE)} mode (enabled by def
 Typically, this would occur if you're attempting to load an Angular template from an untrusted source.
 It's also possible that a custom directive threw this error for a similar reason.
 
-Angular only loads templates from trusted URLs (by calling {@link ng.$sce#methods_getTrustedResourceUrl $sce.getTrustedResourceUrl} on the template URL).
+Angular only loads templates from trusted URLs (by calling {@link ng.$sce#getTrustedResourceUrl $sce.getTrustedResourceUrl} on the template URL).
 
 By default, only URLs that belong to the same origin are trusted. These are urls with the same domain and protocol as the application document.
 
 The {@link ng.directive:ngInclude ngInclude} directive and {@link guide/directive directives} that specify a `templateUrl` require a trusted resource URL.
 
 To load templates from other domains and/or protocols, either adjust the {@link
-api/ng.$sceDelegateProvider#methods_resourceUrlWhitelist whitelist}/ {@link
-api/ng.$sceDelegateProvider#methods_resourceUrlBlacklist blacklist} or wrap the URL with a call to {@link
-api/ng.$sce#methods_trustAsResourceUrl $sce.trustAsResourceUrl}.
+api/ng.$sceDelegateProvider#resourceUrlWhitelist whitelist}/ {@link
+api/ng.$sceDelegateProvider#resourceUrlBlacklist blacklist} or wrap the URL with a call to {@link
+api/ng.$sce#trustAsResourceUrl $sce.trustAsResourceUrl}.
 
 **Note**: The browser's [Same Origin
 Policy](https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest) and
diff --git a/docs/content/error/$sce/itype.ngdoc b/docs/content/error/$sce/itype.ngdoc
index cc2a6f62..80ed8f59 100644
--- a/docs/content/error/$sce/itype.ngdoc
+++ b/docs/content/error/$sce/itype.ngdoc
@@ -3,6 +3,6 @@
 @fullName String Value is Required for SCE Trust Call
 @description
 
-{@link ng.$sce#methods_trustAs $sce.trustAs} requires a string value.
+{@link ng.$sce#trustAs $sce.trustAs} requires a string value.
 
 Read more about {@link ng.$sce Strict Contextual Escaping (SCE)} in AngularJS.
diff --git a/docs/content/error/$sce/iwcard.ngdoc b/docs/content/error/$sce/iwcard.ngdoc
index 83facf1d..43ba802d 100644
--- a/docs/content/error/$sce/iwcard.ngdoc
+++ b/docs/content/error/$sce/iwcard.ngdoc
@@ -3,7 +3,7 @@
 @fullName The sequence *** is not a valid pattern wildcard
 @description
 
-The strings in {@link ng.$sceDelegateProvider#methods_resourceUrlWhitelist
+The strings in {@link ng.$sceDelegateProvider#resourceUrlWhitelist
 $sceDelegateProvider.resourceUrlWhitelist} and {@link
-api/ng.$sceDelegateProvider#methods_resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} may not
+api/ng.$sceDelegateProvider#resourceUrlBlacklist $sceDelegateProvider.resourceUrlBlacklist} may not
 contain the undefined sequence `***`.  Only `*` and `**` wildcard patterns are defined.
diff --git a/docs/content/guide/compiler.ngdoc b/docs/content/guide/compiler.ngdoc
index ee24a05d..d4d77498 100644
--- a/docs/content/guide/compiler.ngdoc
+++ b/docs/content/guide/compiler.ngdoc
@@ -16,7 +16,7 @@ If you want a deeper look into Angular's compilation process, you're in the righ
 Angular's {@link ng.$compile HTML compiler} allows the developer to teach the
 browser new HTML syntax. The compiler allows you to attach behavior to any HTML element or attribute
 and even create new HTML elements or attributes with custom behavior. Angular calls these behavior
-extensions {@link ng.$compileProvider#methods_directive directives}.
+extensions {@link ng.$compileProvider#directive directives}.
 
 HTML has a lot of constructs for formatting the HTML for static documents in a declarative fashion.
 For example if something needs to be centered, there is no need to provide instructions to the
@@ -68,7 +68,7 @@ ng.directive:ngBind `ng-bind`} directive.
 ```
 
 A directive is just a function which executes when the compiler encounters it in the DOM. See {@link
-ng.$compileProvider#methods_directive directive API} for in-depth documentation on how
+ng.$compileProvider#directive directive API} for in-depth documentation on how
 to write directives.
 
 Here is a directive which makes any element draggable. Notice the `draggable` attribute on the
@@ -174,7 +174,7 @@ HTML compilation happens in three phases:
 
   3. `$compile` links the template with the scope by calling the combined linking function from the previous step.
   This in turn will call the linking function of the individual directives, registering listeners on the elements
-  and setting up {@link ng.$rootScope.Scope#methods_$watch `$watch`s} with the {@link ng.$rootScope.Scope `scope`}
+  and setting up {@link ng.$rootScope.Scope#$watch `$watch`s} with the {@link ng.$rootScope.Scope `scope`}
   as each directive is configured to do.
 
 The result of this is a live binding between the scope and the DOM. So at this point, a change in
diff --git a/docs/content/guide/directive.ngdoc b/docs/content/guide/directive.ngdoc
index da270d7e..9af76221 100644
--- a/docs/content/guide/directive.ngdoc
+++ b/docs/content/guide/directive.ngdoc
@@ -131,8 +131,8 @@ directives when possible.
 
 During the compilation process the {@link ng.$compile compiler} matches text and attributes
 using the {@link ng.$interpolate $interpolate} service to see if they contain embedded
-expressions. These expressions are registered as {@link ng.$rootScope.Scope#methods_$watch watches}
-and will update as part of normal {@link ng.$rootScope.Scope#methods_$digest digest} cycle. An
+expressions. These expressions are registered as {@link ng.$rootScope.Scope#$watch watches}
+and will update as part of normal {@link ng.$rootScope.Scope#$digest digest} cycle. An
 example of interpolation is shown below:
 
 ```html
@@ -174,7 +174,7 @@ For example, we could fix the example above by instead writing:
 
 ## Creating Directives
 
-First let's talk about the {@link ng.$compileProvider#methods_directive API for registering directives}. Much like
+First let's talk about the {@link ng.$compileProvider#directive API for registering directives}. Much like
 controllers, directives are registered on modules. To register a directive, you use the
 `module.directive` API. `module.directive` takes the
 {@link guide/directive#creating-custom-directives_matching-directives normalized} directive name
@@ -185,7 +185,7 @@ options to tell `$compile` how the directive should behave when matched.
 The factory function is invoked only once when the
 {@link ng.$compile compiler} matches the directive for the first time. You can perform any
 initialization work here. The function is invoked using
-{@link auto.$injector#methods_invoke $injector.invoke} which makes it injectable just like a
+{@link auto.$injector#invoke $injector.invoke} which makes it injectable just like a
 controller.
 
 <div class="alert alert-success">
diff --git a/docs/content/guide/expression.ngdoc b/docs/content/guide/expression.ngdoc
index 5aa05236..58581047 100644
--- a/docs/content/guide/expression.ngdoc
+++ b/docs/content/guide/expression.ngdoc
@@ -30,7 +30,7 @@ You can think of Angular expressions as JavaScript expressions with following di
 
 If, on the other hand, you do want to run arbitrary JavaScript code, you should make it a
 controller method and call the method. If you want to `eval()` an angular expression from
-JavaScript, use the {@link ng.$rootScope.Scope#methods_$eval `$eval()`} method.
+JavaScript, use the {@link ng.$rootScope.Scope#$eval `$eval()`} method.
 
 ## Example
 <example>
diff --git a/docs/content/guide/forms.ngdoc b/docs/content/guide/forms.ngdoc
index 8a23c8c8..ba2eb499 100644
--- a/docs/content/guide/forms.ngdoc
+++ b/docs/content/guide/forms.ngdoc
@@ -191,11 +191,11 @@ To get a hold of the controller the directive specifies a dependency as shown in
 The validation can occur in two places:
 
   * **Model to View update** -
-    Whenever the bound model changes, all functions in {@link ngModel.NgModelController#properties_$formatters NgModelController#$formatters} array are pipe-lined, so that each of these functions has an opportunity to format the value and change validity state of the form control through {@link ngModel.NgModelController#methods_$setValidity NgModelController#$setValidity}.
+    Whenever the bound model changes, all functions in {@link ngModel.NgModelController#properties_$formatters NgModelController#$formatters} array are pipe-lined, so that each of these functions has an opportunity to format the value and change validity state of the form control through {@link ngModel.NgModelController#$setValidity NgModelController#$setValidity}.
 
   * **View to Model update** -
-    In a similar way, whenever a user interacts with a control it calls {@link ngModel.NgModelController#methods_$setViewValue NgModelController#$setViewValue}.
-This in turn pipelines all functions in the {@link ngModel.NgModelController#properties_$parsers NgModelController#$parsers} array, so that each of these functions has an opportunity to convert the value and change validity state of the form control through {@link ngModel.NgModelController#methods_$setValidity NgModelController#$setValidity}.
+    In a similar way, whenever a user interacts with a control it calls {@link ngModel.NgModelController#$setViewValue NgModelController#$setViewValue}.
+This in turn pipelines all functions in the {@link ngModel.NgModelController#properties_$parsers NgModelController#$parsers} array, so that each of these functions has an opportunity to convert the value and change validity state of the form control through {@link ngModel.NgModelController#$setValidity NgModelController#$setValidity}.
 
 In the following example we create two directives.
 
diff --git a/docs/content/guide/migration.ngdoc b/docs/content/guide/migration.ngdoc
index 2a16c9c7..0695d2db 100644
--- a/docs/content/guide/migration.ngdoc
+++ b/docs/content/guide/migration.ngdoc
@@ -361,7 +361,7 @@ See [05772e15](https://github.com/angular/angular.js/commit/05772e15fbecfdc63d49
 
 ## $location.search supports multiple keys
 
-{@link ng.$location#methods_search `$location.search`} now supports multiple keys with the
+{@link ng.$location#search `$location.search`} now supports multiple keys with the
 same value provided that the values are stored in an array.
 
 Before this change:
diff --git a/docs/content/guide/scope.ngdoc b/docs/content/guide/scope.ngdoc
index 489be82f..ab869f8e 100644
--- a/docs/content/guide/scope.ngdoc
+++ b/docs/content/guide/scope.ngdoc
@@ -11,10 +11,10 @@ watch {@link guide/expression expressions} and propagate events.
 
 ## Scope characteristics
 
-  - Scopes provide APIs ({@link ng.$rootScope.Scope#methods_$watch $watch}) to observe
+  - Scopes provide APIs ({@link ng.$rootScope.Scope#$watch $watch}) to observe
     model mutations.
 
-  - Scopes provide APIs ({@link ng.$rootScope.Scope#methods_$apply $apply}) to
+  - Scopes provide APIs ({@link ng.$rootScope.Scope#$apply $apply}) to
     propagate any model changes through the system into the view from outside of the "Angular
     realm" (controllers, services, Angular event handlers).
 
@@ -32,8 +32,8 @@ watch {@link guide/expression expressions} and propagate events.
 ## Scope as Data-Model
 
 Scope is the glue between application controller and the view. During the template {@link compiler
-linking} phase the {@link ng.$compileProvider#methods_directive directives} set up
-{@link ng.$rootScope.Scope#methods_$watch `$watch`} expressions on the scope. The
+linking} phase the {@link ng.$compileProvider#directive directives} set up
+{@link ng.$rootScope.Scope#$watch `$watch`} expressions on the scope. The
 `$watch` allows the directives to be notified of property changes, which allows the directive to
 render the updated value to the DOM.
 
@@ -187,8 +187,8 @@ To examine the scope in the debugger:
 ## Scope Events Propagation
 
 Scopes can propagate events in similar fashion to DOM events. The event can be {@link
-ng.$rootScope.Scope#methods_$broadcast broadcasted} to the scope children or {@link
-ng.$rootScope.Scope#methods_$emit emitted} to scope parents.
+ng.$rootScope.Scope#$broadcast broadcasted} to the scope children or {@link
+ng.$rootScope.Scope#$emit emitted} to scope parents.
 
 <example>
   <file name="script.js">
@@ -230,14 +230,14 @@ more events.
 When the browser calls into JavaScript the code executes outside the Angular execution context,
 which means that Angular is unaware of model modifications. To properly process model
 modifications the execution has to enter the Angular execution context using the {@link
-ng.$rootScope.Scope#methods_$apply `$apply`} method. Only model modifications which
+ng.$rootScope.Scope#$apply `$apply`} method. Only model modifications which
 execute inside the `$apply` method will be properly accounted for by Angular. For example if a
 directive listens on DOM events, such as {@link
 ng.directive:ngClick `ng-click`} it must evaluate the
 expression inside the `$apply` method.
 
 After evaluating the expression, the `$apply` method performs a {@link
-ng.$rootScope.Scope#methods_$digest `$digest`}. In the $digest phase the scope examines all
+ng.$rootScope.Scope#$digest `$digest`}. In the $digest phase the scope examines all
 of the `$watch` expressions and compares them with the previous value. This dirty checking is done
 asynchronously. This means that assignment such as `$scope.username="angular"` will not
 immediately cause a `$watch` to be notified, instead the `$watch` notification is delayed until
@@ -255,20 +255,20 @@ the `$digest` phase. This delay is desirable, since it coalesces multiple model
   2. **Watcher registration**
 
      During template linking directives register {@link
-     ng.$rootScope.Scope#methods_$watch watches} on the scope. These watches will be
+     ng.$rootScope.Scope#$watch watches} on the scope. These watches will be
      used to propagate model values to the DOM.
 
   3. **Model mutation**
 
      For mutations to be properly observed, you should make them only within the {@link
-     ng.$rootScope.Scope#methods_$apply scope.$apply()}. (Angular APIs do this
+     ng.$rootScope.Scope#$apply scope.$apply()}. (Angular APIs do this
      implicitly, so no extra `$apply` call is needed when doing synchronous work in controllers,
      or asynchronous work with {@link ng.$http $http}, {@link ng.$timeout $timeout}
      or {@link ng.$interval $interval} services.
 
   4. **Mutation observation**
 
-     At the end `$apply`, Angular performs a {@link ng.$rootScope.Scope#methods_$digest
+     At the end `$apply`, Angular performs a {@link ng.$rootScope.Scope#$digest
      $digest} cycle on the root scope, which then propagates throughout all child scopes. During
      the `$digest` cycle, all `$watch`ed expressions or functions are checked for model mutation
      and if a mutation is detected, the `$watch` listener is called.
@@ -276,7 +276,7 @@ the `$digest` phase. This delay is desirable, since it coalesces multiple model
   5. **Scope destruction**
 
      When child scopes are no longer needed, it is the responsibility of the child scope creator
-     to destroy them via {@link ng.$rootScope.Scope#methods_$destroy scope.$destroy()}
+     to destroy them via {@link ng.$rootScope.Scope#$destroy scope.$destroy()}
      API. This will stop propagation of `$digest` calls into the child scope and allow for memory
      used by the child scope models to be reclaimed by the garbage collector.
 
@@ -284,27 +284,27 @@ the `$digest` phase. This delay is desirable, since it coalesces multiple model
 ### Scopes and Directives
 
 During the compilation phase, the {@link compiler compiler} matches {@link
-ng.$compileProvider#methods_directive directives} against the DOM template. The directives
+ng.$compileProvider#directive directives} against the DOM template. The directives
 usually fall into one of two categories:
 
-  - Observing {@link ng.$compileProvider#methods_directive directives}, such as
+  - Observing {@link ng.$compileProvider#directive directives}, such as
     double-curly expressions `{{expression}}`, register listeners using the {@link
-    ng.$rootScope.Scope#methods_$watch $watch()} method. This type of directive needs
+    ng.$rootScope.Scope#$watch $watch()} method. This type of directive needs
     to be notified whenever the expression changes so that it can update the view.
 
   - Listener directives, such as {@link ng.directive:ngClick
     ng-click}, register a listener with the DOM. When the DOM listener fires, the directive
     executes the associated expression and updates the view using the {@link
-    ng.$rootScope.Scope#methods_$apply $apply()} method.
+    ng.$rootScope.Scope#$apply $apply()} method.
 
 When an external event (such as a user action, timer or XHR) is received, the associated {@link
 expression expression} must be applied to the scope through the {@link
-ng.$rootScope.Scope#methods_$apply $apply()} method so that all listeners are updated
+ng.$rootScope.Scope#$apply $apply()} method so that all listeners are updated
 correctly.
 
 ### Directives that Create Scopes
 
-In most cases, {@link ng.$compileProvider#methods_directive directives} and scopes interact
+In most cases, {@link ng.$compileProvider#directive directives} and scopes interact
 but do not create new instances of scope. However, some directives, such as {@link
 ng.directive:ngController ng-controller} and {@link
 ng.directive:ngRepeat ng-repeat}, create new child scopes
@@ -322,7 +322,7 @@ Scopes and controllers interact with each other in the following situations:
 
    - Controllers define methods (behavior) that can mutate the model (properties on the scope).
 
-   - Controllers may register {@link ng.$rootScope.Scope#methods_$watch watches} on
+   - Controllers may register {@link ng.$rootScope.Scope#$watch watches} on
      the model. These watches execute immediately after the controller behavior executes.
 
 See the {@link ng.directive:ngController ng-controller} for more
@@ -357,26 +357,26 @@ directive which is handling the event. An explicit call to $apply is needed only
 implementing custom event callbacks, or when working with third-party library callbacks.
 
   1. Enter Angular execution context by calling {@link guide/scope scope}`.`{@link
-     ng.$rootScope.Scope#methods_$apply $apply}`(stimulusFn)`. Where `stimulusFn` is
+     ng.$rootScope.Scope#$apply $apply}`(stimulusFn)`. Where `stimulusFn` is
      the work you wish to do in Angular execution context.
   2. Angular executes the `stimulusFn()`, which typically modifies application state.
-  3. Angular enters the {@link ng.$rootScope.Scope#methods_$digest $digest} loop. The
+  3. Angular enters the {@link ng.$rootScope.Scope#$digest $digest} loop. The
      loop is made up of two smaller loops which process {@link
-     ng.$rootScope.Scope#methods_$evalAsync $evalAsync} queue and the {@link
-     ng.$rootScope.Scope#methods_$watch $watch} list. The {@link
-     ng.$rootScope.Scope#methods_$digest $digest} loop keeps iterating until the model
-     stabilizes, which means that the {@link ng.$rootScope.Scope#methods_$evalAsync
-     $evalAsync} queue is empty and the {@link ng.$rootScope.Scope#methods_$watch
+     ng.$rootScope.Scope#$evalAsync $evalAsync} queue and the {@link
+     ng.$rootScope.Scope#$watch $watch} list. The {@link
+     ng.$rootScope.Scope#$digest $digest} loop keeps iterating until the model
+     stabilizes, which means that the {@link ng.$rootScope.Scope#$evalAsync
+     $evalAsync} queue is empty and the {@link ng.$rootScope.Scope#$watch
      $watch} list does not detect any changes.
-  4. The {@link ng.$rootScope.Scope#methods_$evalAsync $evalAsync} queue is used to
+  4. The {@link ng.$rootScope.Scope#$evalAsync $evalAsync} queue is used to
      schedule work which needs to occur outside of current stack frame, but before the browser's
      view render. This is usually done with `setTimeout(0)`, but the `setTimeout(0)` approach
      suffers from slowness and may cause view flickering since the browser renders the view after
      each event.
-  5. The {@link ng.$rootScope.Scope#methods_$watch $watch} list is a set of expressions
+  5. The {@link ng.$rootScope.Scope#$watch $watch} list is a set of expressions
      which may have changed since last iteration. If a change is detected then the `$watch`
      function is called which typically updates the DOM with the new value.
-  6. Once the Angular {@link ng.$rootScope.Scope#methods_$digest $digest} loop finishes
+  6. Once the Angular {@link ng.$rootScope.Scope#$digest $digest} loop finishes
      the execution leaves the Angular and JavaScript context. This is followed by the browser
      re-rendering the DOM to reflect any changes.
 
@@ -389,17 +389,17 @@ user enters text into the text field.
         ng.directive:input input} {@link guide/directive
         directive} set up a `keydown` listener on the `<input>` control.
      2. the {@link ng.$interpolate &#123;&#123;name&#125;&#125; } interpolation
-        sets up a {@link ng.$rootScope.Scope#methods_$watch $watch} to be notified of
+        sets up a {@link ng.$rootScope.Scope#$watch $watch} to be notified of
         `name` changes.
   2. During the runtime phase:
      1. Pressing an '`X`' key causes the browser to emit a `keydown` event on the input control.
      2. The {@link ng.directive:input input} directive
         captures the change to the input's value and calls {@link
-        ng.$rootScope.Scope#methods_$apply $apply}`("name = 'X';")` to update the
+        ng.$rootScope.Scope#$apply $apply}`("name = 'X';")` to update the
         application model inside the Angular execution context.
      3. Angular applies the `name = 'X';` to the model.
-     4. The {@link ng.$rootScope.Scope#methods_$digest $digest} loop begins
-     5. The {@link ng.$rootScope.Scope#methods_$watch $watch} list detects a change
+     4. The {@link ng.$rootScope.Scope#$digest $digest} loop begins
+     5. The {@link ng.$rootScope.Scope#$watch $watch} list detects a change
         on the `name` property and notifies the {@link ng.$interpolate
         &#123;&#123;name&#125;&#125; } interpolation, which in turn updates the DOM.
      6. Angular exits the execution context, which in turn exits the `keydown` event and with it