Use const for const/final top-levels, types, symbols.

lib/runtime/dart/_internal.js

 dart_library.library('dart/_internal', null, /* Imports */[
   "dart/_runtime",
   'dart/core',
   'dart/collection'
 ], /* Lazy imports */[
   'dart/math',
   'dart/_interceptors',
   'dart/_js_primitives'
 ], function(exports, dart, core, collection, math, _interceptors, _js_primitives) {
   'use strict';
   let dartx = dart.dartx;
   class EfficientLength extends core.Object {}
-  let ListIterable$ = dart.generic(function(E) {
+  const ListIterable$ = dart.generic(function(E) {
     class ListIterable extends collection.IterableBase$(E) {
       ListIterable() {
         super.IterableBase();
       }
       get iterator() {
         return new (ListIterator$(E))(this);
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [E]));
         let length = this.length;
@@ skipping 259 matching lines @@
       'toSet',
       'iterator',
       'isEmpty',
       'first',
       'last',
       'single'
     ]);
     return ListIterable;
   });
   let ListIterable = ListIterable$();
-  let _iterable = dart.JsSymbol('_iterable');
-  let _start = dart.JsSymbol('_start');
-  let _endOrLength = dart.JsSymbol('_endOrLength');
-  let _endIndex = dart.JsSymbol('_endIndex');
-  let _startIndex = dart.JsSymbol('_startIndex');
-  let SubListIterable$ = dart.generic(function(E) {
+  const _iterable = dart.JsSymbol('_iterable');
+  const _start = dart.JsSymbol('_start');
+  const _endOrLength = dart.JsSymbol('_endOrLength');
+  const _endIndex = dart.JsSymbol('_endIndex');
+  const _startIndex = dart.JsSymbol('_startIndex');
+  const SubListIterable$ = dart.generic(function(E) {
     class SubListIterable extends ListIterable$(E) {
       SubListIterable(iterable, start, endOrLength) {
         this[_iterable] = iterable;
         this[_start] = start;
         this[_endOrLength] = endOrLength;
         super.ListIterable();
         core.RangeError.checkNotNegative(this[_start], "start");
         if (this[_endOrLength] != null) {
           core.RangeError.checkNotNegative(this[_endOrLength], "end");
           if (dart.notNull(this[_start]) > dart.notNull(this[_endOrLength])) {
@@ skipping 82 matching lines @@
     dart.defineExtensionMembers(SubListIterable, [
       'elementAt',
       'skip',
       'take',
       'toList',
       'length'
     ]);
     return SubListIterable;
   });
   let SubListIterable = SubListIterable$();
-  let _length = dart.JsSymbol('_length');
-  let _index = dart.JsSymbol('_index');
-  let _current = dart.JsSymbol('_current');
-  let ListIterator$ = dart.generic(function(E) {
+  const _length = dart.JsSymbol('_length');
+  const _index = dart.JsSymbol('_index');
+  const _current = dart.JsSymbol('_current');
+  const ListIterator$ = dart.generic(function(E) {
     class ListIterator extends core.Object {
       ListIterator(iterable) {
         this[_iterable] = iterable;
         this[_length] = iterable[dartx.length];
         this[_index] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
@@ skipping 12 matching lines @@
       }
     }
     ListIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(ListIterator, {
       constructors: () => ({ListIterator: [ListIterator$(E), [core.Iterable$(E)]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return ListIterator;
   });
   let ListIterator = ListIterator$();
-  let _Transformation$ = dart.generic(function(S, T) {
-    let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
+  const _Transformation$ = dart.generic(function(S, T) {
+    const _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
     return _Transformation;
   });
   let _Transformation = _Transformation$();
-  let _f = dart.JsSymbol('_f');
-  let MappedIterable$ = dart.generic(function(S, T) {
+  const _f = dart.JsSymbol('_f');
+  const MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       static new(iterable, func) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthMappedIterable$(S, T))(iterable, func);
         }
         return new (MappedIterable$(S, T))._(dart.as(iterable, core.Iterable$(S)), func);
       }
       _(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
@@ skipping 34 matching lines @@
       'iterator',
       'length',
       'isEmpty',
       'first',
       'last',
       'single'
     ]);
     return MappedIterable;
   });
   let MappedIterable = MappedIterable$();
-  let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
+  const EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
     class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
       EfficientLengthMappedIterable(iterable, func) {
         super._(dart.as(iterable, core.Iterable$(S)), func);
       }
     }
     EfficientLengthMappedIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EfficientLengthMappedIterable, {
       constructors: () => ({EfficientLengthMappedIterable: [EfficientLengthMappedIterable$(S, T), [core.Iterable, dart.functionType(T, [S])]]})
     });
     return EfficientLengthMappedIterable;
   });
   let EfficientLengthMappedIterable = EfficientLengthMappedIterable$();
-  let _iterator = dart.JsSymbol('_iterator');
-  let MappedIterator$ = dart.generic(function(S, T) {
+  const _iterator = dart.JsSymbol('_iterator');
+  const MappedIterator$ = dart.generic(function(S, T) {
     class MappedIterator extends core.Iterator$(T) {
       MappedIterator(iterator, f) {
         this[_iterator] = iterator;
         this[_f] = f;
         this[_current] = null;
       }
       moveNext() {
         if (dart.notNull(this[_iterator].moveNext())) {
           this[_current] = this[_f](this[_iterator].current);
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     dart.setSignature(MappedIterator, {
       constructors: () => ({MappedIterator: [MappedIterator$(S, T), [core.Iterator$(S), dart.functionType(T, [S])]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return MappedIterator;
   });
   let MappedIterator = MappedIterator$();
-  let _source = dart.JsSymbol('_source');
-  let MappedListIterable$ = dart.generic(function(S, T) {
+  const _source = dart.JsSymbol('_source');
+  const MappedListIterable$ = dart.generic(function(S, T) {
     class MappedListIterable extends ListIterable$(T) {
       MappedListIterable(source, f) {
         this[_source] = source;
         this[_f] = f;
         super.ListIterable();
       }
       get length() {
         return this[_source][dartx.length];
       }
       elementAt(index) {
         return this[_f](this[_source][dartx.elementAt](index));
       }
     }
     MappedListIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(MappedListIterable, {
       constructors: () => ({MappedListIterable: [MappedListIterable$(S, T), [core.Iterable$(S), dart.functionType(T, [S])]]}),
       methods: () => ({elementAt: [T, [core.int]]})
     });
     dart.defineExtensionMembers(MappedListIterable, ['elementAt', 'length']);
     return MappedListIterable;
   });
   let MappedListIterable = MappedListIterable$();
-  let _ElementPredicate$ = dart.generic(function(E) {
-    let _ElementPredicate = dart.typedef('_ElementPredicate', () => dart.functionType(core.bool, [E]));
+  const _ElementPredicate$ = dart.generic(function(E) {
+    const _ElementPredicate = dart.typedef('_ElementPredicate', () => dart.functionType(core.bool, [E]));
     return _ElementPredicate;
   });
   let _ElementPredicate = _ElementPredicate$();
-  let WhereIterable$ = dart.generic(function(E) {
+  const WhereIterable$ = dart.generic(function(E) {
     class WhereIterable extends collection.IterableBase$(E) {
       WhereIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get iterator() {
         return new (WhereIterator$(E))(this[_iterable][dartx.iterator], this[_f]);
       }
     }
     dart.setSignature(WhereIterable, {
       constructors: () => ({WhereIterable: [WhereIterable$(E), [core.Iterable$(E), dart.functionType(core.bool, [E])]]})
     });
     dart.defineExtensionMembers(WhereIterable, ['iterator']);
     return WhereIterable;
   });
   let WhereIterable = WhereIterable$();
-  let WhereIterator$ = dart.generic(function(E) {
+  const WhereIterator$ = dart.generic(function(E) {
     class WhereIterator extends core.Iterator$(E) {
       WhereIterator(iterator, f) {
         this[_iterator] = iterator;
         this[_f] = f;
       }
       moveNext() {
         while (dart.notNull(this[_iterator].moveNext())) {
           if (dart.notNull(this[_f](this[_iterator].current))) {
             return true;
           }
         }
         return false;
       }
       get current() {
         return this[_iterator].current;
       }
     }
     dart.setSignature(WhereIterator, {
       constructors: () => ({WhereIterator: [WhereIterator$(E), [core.Iterator$(E), dart.functionType(core.bool, [E])]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return WhereIterator;
   });
   let WhereIterator = WhereIterator$();
-  let _ExpandFunction$ = dart.generic(function(S, T) {
-    let _ExpandFunction = dart.typedef('_ExpandFunction', () => dart.functionType(core.Iterable$(T), [S]));
+  const _ExpandFunction$ = dart.generic(function(S, T) {
+    const _ExpandFunction = dart.typedef('_ExpandFunction', () => dart.functionType(core.Iterable$(T), [S]));
     return _ExpandFunction;
   });
   let _ExpandFunction = _ExpandFunction$();
-  let ExpandIterable$ = dart.generic(function(S, T) {
+  const ExpandIterable$ = dart.generic(function(S, T) {
     class ExpandIterable extends collection.IterableBase$(T) {
       ExpandIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get iterator() {
         return new (ExpandIterator$(S, T))(this[_iterable][dartx.iterator], dart.as(this[_f], __CastType0$(S, T)));
       }
     }
     dart.setSignature(ExpandIterable, {
       constructors: () => ({ExpandIterable: [ExpandIterable$(S, T), [core.Iterable$(S), dart.functionType(core.Iterable$(T), [S])]]})
     });
     dart.defineExtensionMembers(ExpandIterable, ['iterator']);
     return ExpandIterable;
   });
   let ExpandIterable = ExpandIterable$();
-  let _currentExpansion = dart.JsSymbol('_currentExpansion');
-  let _nextExpansion = dart.JsSymbol('_nextExpansion');
-  let ExpandIterator$ = dart.generic(function(S, T) {
+  const _currentExpansion = dart.JsSymbol('_currentExpansion');
+  const _nextExpansion = dart.JsSymbol('_nextExpansion');
+  const ExpandIterator$ = dart.generic(function(S, T) {
     class ExpandIterator extends core.Object {
       ExpandIterator(iterator, f) {
         this[_iterator] = iterator;
         this[_f] = f;
         this[_currentExpansion] = dart.const(new (EmptyIterator$(T))());
         this[_current] = null;
       }
       [_nextExpansion]() {}
       get current() {
         return this[_current];
@@ skipping 18 matching lines @@
     dart.setSignature(ExpandIterator, {
       constructors: () => ({ExpandIterator: [ExpandIterator$(S, T), [core.Iterator$(S), dart.functionType(core.Iterable$(T), [S])]]}),
       methods: () => ({
         [_nextExpansion]: [dart.void, []],
         moveNext: [core.bool, []]
       })
     });
     return ExpandIterator;
   });
   let ExpandIterator = ExpandIterator$();
-  let _takeCount = dart.JsSymbol('_takeCount');
-  let TakeIterable$ = dart.generic(function(E) {
+  const _takeCount = dart.JsSymbol('_takeCount');
+  const TakeIterable$ = dart.generic(function(E) {
     class TakeIterable extends collection.IterableBase$(E) {
       static new(iterable, takeCount) {
         if (!(typeof takeCount == 'number') || dart.notNull(takeCount) < 0) {
           dart.throw(new core.ArgumentError(takeCount));
         }
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthTakeIterable$(E))(iterable, takeCount);
         }
         return new (TakeIterable$(E))._(iterable, takeCount);
       }
@@ skipping 10 matching lines @@
     dart.setSignature(TakeIterable, {
       constructors: () => ({
         new: [TakeIterable$(E), [core.Iterable$(E), core.int]],
         _: [TakeIterable$(E), [core.Iterable$(E), core.int]]
       })
     });
     dart.defineExtensionMembers(TakeIterable, ['iterator']);
     return TakeIterable;
   });
   let TakeIterable = TakeIterable$();
-  let EfficientLengthTakeIterable$ = dart.generic(function(E) {
+  const EfficientLengthTakeIterable$ = dart.generic(function(E) {
     class EfficientLengthTakeIterable extends TakeIterable$(E) {
       EfficientLengthTakeIterable(iterable, takeCount) {
         super._(iterable, takeCount);
       }
       get length() {
         let iterableLength = this[_iterable][dartx.length];
         if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
           return this[_takeCount];
         return iterableLength;
       }
     }
     EfficientLengthTakeIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EfficientLengthTakeIterable, {
       constructors: () => ({EfficientLengthTakeIterable: [EfficientLengthTakeIterable$(E), [core.Iterable$(E), core.int]]})
     });
     dart.defineExtensionMembers(EfficientLengthTakeIterable, ['length']);
     return EfficientLengthTakeIterable;
   });
   let EfficientLengthTakeIterable = EfficientLengthTakeIterable$();
-  let _remaining = dart.JsSymbol('_remaining');
-  let TakeIterator$ = dart.generic(function(E) {
+  const _remaining = dart.JsSymbol('_remaining');
+  const TakeIterator$ = dart.generic(function(E) {
     class TakeIterator extends core.Iterator$(E) {
       TakeIterator(iterator, remaining) {
         this[_iterator] = iterator;
         this[_remaining] = remaining;
         dart.assert(typeof this[_remaining] == 'number' && dart.notNull(this[_remaining]) >= 0);
       }
       moveNext() {
         this[_remaining] = dart.notNull(this[_remaining]) - 1;
         if (dart.notNull(this[_remaining]) >= 0) {
           return this[_iterator].moveNext();
         }
         this[_remaining] = -1;
         return false;
       }
       get current() {
         if (dart.notNull(this[_remaining]) < 0)
           return null;
         return this[_iterator].current;
       }
     }
     dart.setSignature(TakeIterator, {
       constructors: () => ({TakeIterator: [TakeIterator$(E), [core.Iterator$(E), core.int]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return TakeIterator;
   });
   let TakeIterator = TakeIterator$();
-  let TakeWhileIterable$ = dart.generic(function(E) {
+  const TakeWhileIterable$ = dart.generic(function(E) {
     class TakeWhileIterable extends collection.IterableBase$(E) {
       TakeWhileIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get iterator() {
         return new (TakeWhileIterator$(E))(this[_iterable][dartx.iterator], this[_f]);
       }
     }
     dart.setSignature(TakeWhileIterable, {
       constructors: () => ({TakeWhileIterable: [TakeWhileIterable$(E), [core.Iterable$(E), dart.functionType(core.bool, [E])]]})
     });
     dart.defineExtensionMembers(TakeWhileIterable, ['iterator']);
     return TakeWhileIterable;
   });
   let TakeWhileIterable = TakeWhileIterable$();
-  let _isFinished = dart.JsSymbol('_isFinished');
-  let TakeWhileIterator$ = dart.generic(function(E) {
+  const _isFinished = dart.JsSymbol('_isFinished');
+  const TakeWhileIterator$ = dart.generic(function(E) {
     class TakeWhileIterator extends core.Iterator$(E) {
       TakeWhileIterator(iterator, f) {
         this[_iterator] = iterator;
         this[_f] = f;
         this[_isFinished] = false;
       }
       moveNext() {
         if (dart.notNull(this[_isFinished]))
           return false;
         if (!dart.notNull(this[_iterator].moveNext()) || !dart.notNull(this[_f](this[_iterator].current))) {
           this[_isFinished] = true;
           return false;
         }
         return true;
       }
       get current() {
         if (dart.notNull(this[_isFinished]))
           return null;
         return this[_iterator].current;
       }
     }
     dart.setSignature(TakeWhileIterator, {
       constructors: () => ({TakeWhileIterator: [TakeWhileIterator$(E), [core.Iterator$(E), dart.functionType(core.bool, [E])]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return TakeWhileIterator;
   });
   let TakeWhileIterator = TakeWhileIterator$();
-  let _skipCount = dart.JsSymbol('_skipCount');
-  let SkipIterable$ = dart.generic(function(E) {
+  const _skipCount = dart.JsSymbol('_skipCount');
+  const SkipIterable$ = dart.generic(function(E) {
     class SkipIterable extends collection.IterableBase$(E) {
       static new(iterable, count) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthSkipIterable$(E))(iterable, count);
         }
         return new (SkipIterable$(E))._(iterable, count);
       }
       _(iterable, skipCount) {
         this[_iterable] = iterable;
         this[_skipCount] = skipCount;
@@ skipping 19 matching lines @@
       constructors: () => ({
         new: [SkipIterable$(E), [core.Iterable$(E), core.int]],
         _: [SkipIterable$(E), [core.Iterable$(E), core.int]]
       }),
       methods: () => ({skip: [core.Iterable$(E), [core.int]]})
     });
     dart.defineExtensionMembers(SkipIterable, ['skip', 'iterator']);
     return SkipIterable;
   });
   let SkipIterable = SkipIterable$();
-  let EfficientLengthSkipIterable$ = dart.generic(function(E) {
+  const EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
         super._(iterable, skipCount);
       }
       get length() {
         let length = dart.notNull(this[_iterable][dartx.length]) - dart.notNull(this[_skipCount]);
         if (dart.notNull(length) >= 0)
           return length;
         return 0;
       }
     }
     EfficientLengthSkipIterable[dart.implements] = () => [EfficientLength];
     dart.setSignature(EfficientLengthSkipIterable, {
       constructors: () => ({EfficientLengthSkipIterable: [EfficientLengthSkipIterable$(E), [core.Iterable$(E), core.int]]})
     });
     dart.defineExtensionMembers(EfficientLengthSkipIterable, ['length']);
     return EfficientLengthSkipIterable;
   });
   let EfficientLengthSkipIterable = EfficientLengthSkipIterable$();
-  let SkipIterator$ = dart.generic(function(E) {
+  const SkipIterator$ = dart.generic(function(E) {
     class SkipIterator extends core.Iterator$(E) {
       SkipIterator(iterator, skipCount) {
         this[_iterator] = iterator;
         this[_skipCount] = skipCount;
         dart.assert(typeof this[_skipCount] == 'number' && dart.notNull(this[_skipCount]) >= 0);
       }
       moveNext() {
         for (let i = 0; dart.notNull(i) < dart.notNull(this[_skipCount]); i = dart.notNull(i) + 1)
           this[_iterator].moveNext();
         this[_skipCount] = 0;
         return this[_iterator].moveNext();
       }
       get current() {
         return this[_iterator].current;
       }
     }
     dart.setSignature(SkipIterator, {
       constructors: () => ({SkipIterator: [SkipIterator$(E), [core.Iterator$(E), core.int]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return SkipIterator;
   });
   let SkipIterator = SkipIterator$();
-  let SkipWhileIterable$ = dart.generic(function(E) {
+  const SkipWhileIterable$ = dart.generic(function(E) {
     class SkipWhileIterable extends collection.IterableBase$(E) {
       SkipWhileIterable(iterable, f) {
         this[_iterable] = iterable;
         this[_f] = f;
         super.IterableBase();
       }
       get iterator() {
         return new (SkipWhileIterator$(E))(this[_iterable][dartx.iterator], this[_f]);
       }
     }
     dart.setSignature(SkipWhileIterable, {
       constructors: () => ({SkipWhileIterable: [SkipWhileIterable$(E), [core.Iterable$(E), dart.functionType(core.bool, [E])]]})
     });
     dart.defineExtensionMembers(SkipWhileIterable, ['iterator']);
     return SkipWhileIterable;
   });
   let SkipWhileIterable = SkipWhileIterable$();
-  let _hasSkipped = dart.JsSymbol('_hasSkipped');
-  let SkipWhileIterator$ = dart.generic(function(E) {
+  const _hasSkipped = dart.JsSymbol('_hasSkipped');
+  const SkipWhileIterator$ = dart.generic(function(E) {
     class SkipWhileIterator extends core.Iterator$(E) {
       SkipWhileIterator(iterator, f) {
         this[_iterator] = iterator;
         this[_f] = f;
         this[_hasSkipped] = false;
       }
       moveNext() {
         if (!dart.notNull(this[_hasSkipped])) {
           this[_hasSkipped] = true;
           while (dart.notNull(this[_iterator].moveNext())) {
             if (!dart.notNull(this[_f](this[_iterator].current)))
               return true;
           }
         }
         return this[_iterator].moveNext();
       }
       get current() {
         return this[_iterator].current;
       }
     }
     dart.setSignature(SkipWhileIterator, {
       constructors: () => ({SkipWhileIterator: [SkipWhileIterator$(E), [core.Iterator$(E), dart.functionType(core.bool, [E])]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return SkipWhileIterator;
   });
   let SkipWhileIterator = SkipWhileIterator$();
-  let EmptyIterable$ = dart.generic(function(E) {
+  const EmptyIterable$ = dart.generic(function(E) {
     class EmptyIterable extends collection.IterableBase$(E) {
       EmptyIterable() {
         super.IterableBase();
       }
       get iterator() {
         return dart.const(new (EmptyIterator$(E))());
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [E]));
       }
@@ skipping 141 matching lines @@
       'iterator',
       'isEmpty',
       'length',
       'first',
       'last',
       'single'
     ]);
     return EmptyIterable;
   });
   let EmptyIterable = EmptyIterable$();
-  let EmptyIterator$ = dart.generic(function(E) {
+  const EmptyIterator$ = dart.generic(function(E) {
     class EmptyIterator extends core.Object {
       EmptyIterator() {
       }
       moveNext() {
         return false;
       }
       get current() {
         return null;
       }
     }
     EmptyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(EmptyIterator, {
       constructors: () => ({EmptyIterator: [EmptyIterator$(E), []]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return EmptyIterator;
   });
   let EmptyIterator = EmptyIterator$();
-  let BidirectionalIterator$ = dart.generic(function(T) {
+  const BidirectionalIterator$ = dart.generic(function(T) {
     class BidirectionalIterator extends core.Object {}
     BidirectionalIterator[dart.implements] = () => [core.Iterator$(T)];
     return BidirectionalIterator;
   });
   let BidirectionalIterator = BidirectionalIterator$();
-  let IterableMixinWorkaround$ = dart.generic(function(T) {
+  const IterableMixinWorkaround$ = dart.generic(function(T) {
     class IterableMixinWorkaround extends core.Object {
       static contains(iterable, element) {
         for (let e of iterable) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       static forEach(iterable, f) {
         dart.as(f, dart.functionType(dart.void, [dart.dynamic]));
@@ skipping 432 matching lines @@
     }
   }
   dart.setSignature(IterableElementError, {
     statics: () => ({
       noElement: [core.StateError, []],
       tooMany: [core.StateError, []],
       tooFew: [core.StateError, []]
     }),
     names: ['noElement', 'tooMany', 'tooFew']
   });
-  let __CastType0$ = dart.generic(function(S, T) {
-    let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Iterable$(T), [S]));
+  const __CastType0$ = dart.generic(function(S, T) {
+    const __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Iterable$(T), [S]));
     return __CastType0;
   });
   let __CastType0 = __CastType0$();
-  let __CastType2$ = dart.generic(function(T) {
-    let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(core.bool, [T]));
+  const __CastType2$ = dart.generic(function(T) {
+    const __CastType2 = dart.typedef('__CastType2', () => dart.functionType(core.bool, [T]));
     return __CastType2;
   });
   let __CastType2 = __CastType2$();
-  let FixedLengthListMixin$ = dart.generic(function(E) {
+  const FixedLengthListMixin$ = dart.generic(function(E) {
     class FixedLengthListMixin extends core.Object {
       set length(newLength) {
         dart.throw(new core.UnsupportedError("Cannot change the length of a fixed-length list"));
       }
       add(value) {
         dart.as(value, E);
         dart.throw(new core.UnsupportedError("Cannot add to a fixed-length list"));
       }
       insert(index, value) {
         dart.as(value, E);
@@ skipping 47 matching lines @@
         clear: [dart.void, []],
         removeAt: [E, [core.int]],
         removeLast: [E, []],
         removeRange: [dart.void, [core.int, core.int]],
         replaceRange: [dart.void, [core.int, core.int, core.Iterable$(E)]]
       })
     });
     return FixedLengthListMixin;
   });
   let FixedLengthListMixin = FixedLengthListMixin$();
-  let UnmodifiableListMixin$ = dart.generic(function(E) {
+  const UnmodifiableListMixin$ = dart.generic(function(E) {
     class UnmodifiableListMixin extends core.Object {
       set(index, value) {
         dart.as(value, E);
         dart.throw(new core.UnsupportedError("Cannot modify an unmodifiable list"));
         return value;
       }
       set length(newLength) {
         dart.throw(new core.UnsupportedError("Cannot change the length of an unmodifiable list"));
       }
       setAll(at, iterable) {
@@ skipping 107 matching lines @@
       'removeLast',
       'setRange',
       'removeRange',
       'replaceRange',
       'fillRange',
       'length'
     ]);
     return UnmodifiableListMixin;
   });
   let UnmodifiableListMixin = UnmodifiableListMixin$();
-  let FixedLengthListBase$ = dart.generic(function(E) {
+  const FixedLengthListBase$ = dart.generic(function(E) {
     class FixedLengthListBase extends dart.mixin(collection.ListBase$(E), FixedLengthListMixin$(E)) {
       FixedLengthListBase() {
         super.ListBase(...arguments);
       }
     }
     return FixedLengthListBase;
   });
   let FixedLengthListBase = FixedLengthListBase$();
-  let UnmodifiableListBase$ = dart.generic(function(E) {
+  const UnmodifiableListBase$ = dart.generic(function(E) {
     class UnmodifiableListBase extends dart.mixin(collection.ListBase$(E), UnmodifiableListMixin$(E)) {
       UnmodifiableListBase() {
         super.ListBase(...arguments);
       }
     }
     return UnmodifiableListBase;
   });
   let UnmodifiableListBase = UnmodifiableListBase$();
-  let _backedList = dart.JsSymbol('_backedList');
+  const _backedList = dart.JsSymbol('_backedList');
   class _ListIndicesIterable extends ListIterable$(core.int) {
     _ListIndicesIterable(backedList) {
       this[_backedList] = backedList;
       super.ListIterable();
     }
     get length() {
       return this[_backedList][dartx.length];
     }
     elementAt(index) {
       core.RangeError.checkValidIndex(index, this);
       return index;
     }
   }
   dart.setSignature(_ListIndicesIterable, {
     constructors: () => ({_ListIndicesIterable: [_ListIndicesIterable, [core.List]]}),
     methods: () => ({elementAt: [core.int, [core.int]]})
   });
   dart.defineExtensionMembers(_ListIndicesIterable, ['elementAt', 'length']);
-  let _values = dart.JsSymbol('_values');
-  let ListMapView$ = dart.generic(function(E) {
+  const _values = dart.JsSymbol('_values');
+  const ListMapView$ = dart.generic(function(E) {
     class ListMapView extends core.Object {
       ListMapView(values) {
         this[_values] = values;
       }
       get(key) {
         return dart.notNull(this.containsKey(key)) ? this[_values][dartx.get](dart.as(key, core.int)) : null;
       }
       get length() {
         return this[_values][dartx.length];
       }
@@ skipping 59 matching lines @@
         set: [dart.void, [core.int, E]],
         putIfAbsent: [E, [core.int, dart.functionType(E, [])]],
         remove: [E, [core.Object]],
         clear: [dart.void, []],
         addAll: [dart.void, [core.Map$(core.int, E)]]
       })
     });
     return ListMapView;
   });
   let ListMapView = ListMapView$();
-  let ReversedListIterable$ = dart.generic(function(E) {
+  const ReversedListIterable$ = dart.generic(function(E) {
     class ReversedListIterable extends ListIterable$(E) {
       ReversedListIterable(source) {
         this[_source] = source;
         super.ListIterable();
       }
       get length() {
         return this[_source][dartx.length];
       }
       elementAt(index) {
         return this[_source][dartx.elementAt](dart.notNull(this[_source][dartx.length]) - 1 - dart.notNull(index));
@@ skipping 398 matching lines @@
     statics: () => ({
       sort: [dart.void, [core.List, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
       sortRange: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
       _doSort: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
       _insertionSort: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]],
       _dualPivotQuicksort: [dart.void, [core.List, core.int, core.int, dart.functionType(core.int, [dart.dynamic, dart.dynamic])]]
     }),
     names: ['sort', 'sortRange', '_doSort', '_insertionSort', '_dualPivotQuicksort']
   });
   Sort._INSERTION_SORT_THRESHOLD = 32;
-  let _name = dart.JsSymbol('_name');
+  const _name = dart.JsSymbol('_name');
   class Symbol extends core.Object {
     Symbol(name) {
       this[_name] = name;
     }
     unvalidated(name) {
       this[_name] = name;
     }
     validated(name) {
       this[_name] = Symbol.validatePublicSymbol(name);
     }
@@ skipping 36 matching lines @@
       getName: [core.String, [Symbol]],
       validatePublicSymbol: [core.String, [core.String]],
       isValidSymbol: [core.bool, [core.String]]
     }),
     names: ['getName', 'validatePublicSymbol', 'isValidSymbol']
   });
   Symbol.reservedWordRE = '(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|' + 'e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|' + 'ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|' + 'v(?:ar|oid)|w(?:hile|ith))';
   Symbol.publicIdentifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$][\\w$]*';
   Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$_][\\w$]*';
   Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
-  let POWERS_OF_TEN = dart.const([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22]);
+  const POWERS_OF_TEN = dart.const([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22]);
   dart.defineLazyProperties(Symbol, {
     get publicSymbolPattern() {
       return core.RegExp.new(`^(?:${Symbol.operatorRE}\$|${Symbol.publicIdentifierRE}(?:=?\$|[.](?!\$)))+?\$`);
     },
     get symbolPattern() {
       return core.RegExp.new(`^(?:${Symbol.operatorRE}\$|${Symbol.identifierRE}(?:=?\$|[.](?!\$)))+?\$`);
     }
   });
   // Exports:
   exports.EfficientLength = EfficientLength;
@@ skipping 62 matching lines @@
   exports.ReversedListIterable = ReversedListIterable;
   exports.UnmodifiableListError = UnmodifiableListError;
   exports.NonGrowableListError = NonGrowableListError;
   exports.makeListFixedLength = makeListFixedLength;
   exports.Lists = Lists;
   exports.printToConsole = printToConsole;
   exports.Sort = Sort;
   exports.Symbol = Symbol;
   exports.POWERS_OF_TEN = POWERS_OF_TEN;
 });