Update all Angular libs (run update_all.sh).

third_party/pkg/angular/lib/formatter/order_by.dart

-part of angular.filter;
+part of angular.formatter_internal;
 
-typedef dynamic Mapper(dynamic e);
+typedef dynamic _Mapper(dynamic e);
 
 /**
  * Orders the provided [Iterable] by the `expression` predicate.
  *
  * Example 1: Simple array and single/empty expression.
  *
  * Assume that you have an array on scope called `colors` and that it has a list
  * of these strings – `['red', 'blue', 'green']`.  You might sort these in
  * ascending order this way:
  *
@@ skipping 83 matching lines @@
  * For example, one might want to sort the authors list, first by last name and
  * then by first name when the last names are equal.  You would do that like
  * this:
  *
  *     <li ng-repeat="author in authors | orderBy:['lastName', 'firstName']">
  *
  * The items in such a list may either be string expressions or callables.  The
  * list itself might be provided as an expression that is looked up on the scope
  * chain.
  */
-@NgFilter(name: 'orderBy')
-class OrderByFilter {
+@Formatter(name: 'orderBy')
+class OrderBy implements Function {
   Parser _parser;
 
-  OrderByFilter(this._parser);
+  OrderBy(this._parser);
 
   static _nop(e) => e;
   static bool _isNonZero(int n) => (n != 0);
   static int _returnZero() => 0;
   static int _defaultComparator(a, b) => Comparable.compare(a, b);
   static int _reverseComparator(a, b) => _defaultComparator(b, a);
 
   static int _compareLists(List a, List b, List<Comparator> comparators) {
     return new Iterable.generate(a.length, (i) => comparators[i](a[i], b[i]))
         .firstWhere(_isNonZero, orElse: _returnZero);
   }
 
   static List _sorted(
-      List items, List<Mapper> mappers, List<Comparator> comparators, bool descending) {
+      List items, List<_Mapper> mappers, List<Comparator> comparators, bool descending) {
     // Do the standard decorate-sort-undecorate aka Schwartzian dance since Dart
     // doesn't support a key/transform parameter to sort().
     // Ref: http://en.wikipedia.org/wiki/Schwartzian_transform
     mapper(e) => mappers.map((m) => m(e)).toList(growable: false);
     List decorated = items.map(mapper).toList(growable: false);
     List<int> indices = new Iterable.generate(decorated.length, _nop).toList(growable: false);
     comparator(i, j) => _compareLists(decorated[i], decorated[j], comparators);
     indices.sort((descending) ? (i, j) => comparator(j, i) : comparator);
     return indices.map((i) => items[i]).toList(growable: false);
   }
 
   /**
    * expression: String/Function or Array of String/Function.
    */
   List call(List items, var expression, [bool descending=false]) {
     if (items == null) {
       return null;
     }
     List expressions = null;
-    if (expression is String || expression is Mapper) {
+    if (expression is String || expression is _Mapper) {
       expressions = [expression];
     } else if (expression is List) {
       expressions = expression as List;
     }
     if (expressions == null || expressions.length == 0) {
       // AngularJS behavior.  You must have an expression to get any work done.
       return items;
     }
     int numExpressions = expressions.length;
-    List<Mapper> mappers = new List(numExpressions);
+    List<_Mapper> mappers = new List(numExpressions);
     List<Comparator> comparators = new List<Comparator>(numExpressions);
     for (int i = 0; i < numExpressions; i++) {
       expression = expressions[i];
       if (expression is String) {
         var strExp = expression as String;
         var desc = false;
         if (strExp.startsWith('-') || strExp.startsWith('+')) {
           desc = strExp.startsWith('-');
           strExp = strExp.substring(1);
         }
         comparators[i] = desc ? _reverseComparator : _defaultComparator;
         if (strExp == '') {
           mappers[i] = _nop;
         } else {
           Expression parsed = _parser(strExp);
           mappers[i] = (e) => parsed.eval(e);
         }
-      } else if (expression is Mapper) {
-        mappers[i] = (expression as Mapper);
+      } else if (expression is _Mapper) {
+        mappers[i] = (expression as _Mapper);
         comparators[i] = _defaultComparator;
       }
     }
     return _sorted(items, mappers, comparators, descending);
   }
 }