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

lib/runtime/dart/collection.js

 dart_library.library('dart/collection', null, /* Imports */[
   "dart/_runtime",
   'dart/core'
 ], /* Lazy imports */[
   'dart/_internal',
   'dart/_js_helper',
   'dart/math'
 ], function(exports, dart, core, _internal, _js_helper, math) {
   'use strict';
   let dartx = dart.dartx;
-  let _source = Symbol('_source');
-  let UnmodifiableListView$ = dart.generic(function(E) {
+  const _source = Symbol('_source');
+  const UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
       UnmodifiableListView(source) {
         this[_source] = source;
       }
       get length() {
         return this[_source][dartx.length];
       }
       get(index) {
         return this[_source][dartx.elementAt](index);
       }
     }
     dart.setSignature(UnmodifiableListView, {
       constructors: () => ({UnmodifiableListView: [exports.UnmodifiableListView$(E), [core.Iterable$(E)]]}),
       methods: () => ({get: [E, [core.int]]})
     });
     dart.defineExtensionMembers(UnmodifiableListView, ['get', 'length']);
     return UnmodifiableListView;
   });
   dart.defineLazyClassGeneric(exports, 'UnmodifiableListView', {get: UnmodifiableListView$});
   function _defaultEquals(a, b) {
     return dart.equals(a, b);
   }
   dart.fn(_defaultEquals, core.bool, [core.Object, core.Object]);
   function _defaultHashCode(a) {
     return dart.hashCode(a);
   }
   dart.fn(_defaultHashCode, core.int, [core.Object]);
-  let _Equality$ = dart.generic(function(K) {
-    let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [K, K]));
+  const _Equality$ = dart.generic(function(K) {
+    const _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [K, K]));
     return _Equality;
   });
   let _Equality = _Equality$();
-  let _Hasher$ = dart.generic(function(K) {
-    let _Hasher = dart.typedef('_Hasher', () => dart.functionType(core.int, [K]));
+  const _Hasher$ = dart.generic(function(K) {
+    const _Hasher = dart.typedef('_Hasher', () => dart.functionType(core.int, [K]));
     return _Hasher;
   });
   let _Hasher = _Hasher$();
-  let HashMap$ = dart.generic(function(K, V) {
+  const HashMap$ = dart.generic(function(K, V) {
     class HashMap extends core.Object {
       static new(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_HashMap$(K, V))();
             }
@@ skipping 45 matching lines @@
         new: [HashMap$(K, V), [], {equals: dart.functionType(core.bool, [K, K]), hashCode: dart.functionType(core.int, [K]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         identity: [HashMap$(K, V), []],
         from: [HashMap$(K, V), [core.Map]],
         fromIterable: [HashMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.dynamic]), value: dart.functionType(V, [dart.dynamic])}],
         fromIterables: [HashMap$(K, V), [core.Iterable$(K), core.Iterable$(V)]]
       })
     });
     return HashMap;
   });
   let HashMap = HashMap$();
-  let SetMixin$ = dart.generic(function(E) {
+  const SetMixin$ = dart.generic(function(E) {
     class SetMixin extends core.Object {
       [Symbol.iterator]() {
         return new dart.JsIterator(this.iterator);
       }
       get isEmpty() {
         return this.length == 0;
       }
       get isNotEmpty() {
         return this.length != 0;
       }
@@ skipping 309 matching lines @@
       'elementAt',
       'isEmpty',
       'isNotEmpty',
       'single',
       'first',
       'last'
     ]);
     return SetMixin;
   });
   let SetMixin = SetMixin$();
-  let SetBase$ = dart.generic(function(E) {
+  const SetBase$ = dart.generic(function(E) {
     class SetBase extends SetMixin$(E) {
       static setToString(set) {
         return IterableBase.iterableToFullString(set, '{', '}');
       }
     }
     dart.setSignature(SetBase, {
       statics: () => ({setToString: [core.String, [core.Set]]}),
       names: ['setToString']
     });
     return SetBase;
   });
   let SetBase = SetBase$();
-  let _newSet = Symbol('_newSet');
-  let _HashSetBase$ = dart.generic(function(E) {
+  const _newSet = Symbol('_newSet');
+  const _HashSetBase$ = dart.generic(function(E) {
     class _HashSetBase extends SetBase$(E) {
       difference(other) {
         let result = this[_newSet]();
         for (let element of this) {
           if (!dart.notNull(other.contains(element)))
             result.add(element);
         }
         return result;
       }
       intersection(other) {
@@ skipping 16 matching lines @@
       methods: () => ({
         difference: [core.Set$(E), [core.Set$(core.Object)]],
         intersection: [core.Set$(E), [core.Set$(core.Object)]],
         toSet: [core.Set$(E), []]
       })
     });
     dart.defineExtensionMembers(_HashSetBase, ['toSet']);
     return _HashSetBase;
   });
   let _HashSetBase = _HashSetBase$();
-  let HashSet$ = dart.generic(function(E) {
+  const HashSet$ = dart.generic(function(E) {
     class HashSet extends core.Object {
       static new(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_HashSet$(E))();
             }
@@ skipping 33 matching lines @@
     dart.setSignature(HashSet, {
       constructors: () => ({
         new: [HashSet$(E), [], {equals: dart.functionType(core.bool, [E, E]), hashCode: dart.functionType(core.int, [E]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         identity: [HashSet$(E), []],
         from: [HashSet$(E), [core.Iterable]]
       })
     });
     return HashSet;
   });
   let HashSet = HashSet$();
-  let IterableMixin$ = dart.generic(function(E) {
+  const IterableMixin$ = dart.generic(function(E) {
     class IterableMixin extends core.Object {
       map(f) {
         dart.as(f, dart.functionType(dart.dynamic, [E]));
         return _internal.MappedIterable$(E, dart.dynamic).new(this, f);
       }
       where(f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
       }
       expand(f) {
@@ skipping 245 matching lines @@
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last',
       'single'
     ]);
     return IterableMixin;
   });
   let IterableMixin = IterableMixin$();
-  let IterableBase$ = dart.generic(function(E) {
+  const IterableBase$ = dart.generic(function(E) {
     class IterableBase extends core.Object {
       IterableBase() {
       }
       map(f) {
         dart.as(f, dart.functionType(dart.dynamic, [E]));
         return _internal.MappedIterable$(E, dart.dynamic).new(this, f);
       }
       where(f) {
         dart.as(f, dart.functionType(core.bool, [E]));
         return new (_internal.WhereIterable$(E))(this, f);
@@ skipping 390 matching lines @@
       'single'
     ]);
     return IterableBase;
   });
   let IterableBase = IterableBase$();
   dart.defineLazyProperties(IterableBase, {
     get _toStringVisiting() {
       return [];
     }
   });
-  let _iterator = Symbol('_iterator');
-  let _state = Symbol('_state');
-  let _move = Symbol('_move');
-  let HasNextIterator$ = dart.generic(function(E) {
+  const _iterator = Symbol('_iterator');
+  const _state = Symbol('_state');
+  const _move = Symbol('_move');
+  const HasNextIterator$ = dart.generic(function(E) {
     class HasNextIterator extends core.Object {
       HasNextIterator(iterator) {
         this[_iterator] = iterator;
         this[_state] = HasNextIterator$()._NOT_MOVED_YET;
       }
       get hasNext() {
         if (this[_state] == HasNextIterator$()._NOT_MOVED_YET)
           this[_move]();
         return this[_state] == HasNextIterator$()._HAS_NEXT_AND_NEXT_IN_CURRENT;
       }
@@ skipping 19 matching lines @@
         next: [E, []],
         [_move]: [dart.void, []]
       })
     });
     return HasNextIterator;
   });
   let HasNextIterator = HasNextIterator$();
   HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT = 0;
   HasNextIterator._NO_NEXT = 1;
   HasNextIterator._NOT_MOVED_YET = 2;
-  let LinkedHashMap$ = dart.generic(function(K, V) {
+  const LinkedHashMap$ = dart.generic(function(K, V) {
     class LinkedHashMap extends core.Object {
       static new(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_LinkedHashMap$(K, V))();
             }
@@ skipping 53 matching lines @@
         from: [LinkedHashMap$(K, V), [core.Map]],
         fromIterable: [LinkedHashMap$(K, V), [core.Iterable], {key: dart.functionType(K, [dart.dynamic]), value: dart.functionType(V, [dart.dynamic])}],
         fromIterables: [LinkedHashMap$(K, V), [core.Iterable$(K), core.Iterable$(V)]],
         _literal: [LinkedHashMap$(K, V), [core.List]],
         _empty: [LinkedHashMap$(K, V), []]
       })
     });
     return LinkedHashMap;
   });
   let LinkedHashMap = LinkedHashMap$();
-  let LinkedHashSet$ = dart.generic(function(E) {
+  const LinkedHashSet$ = dart.generic(function(E) {
     class LinkedHashSet extends core.Object {
       static new(opts) {
         let equals = opts && 'equals' in opts ? opts.equals : null;
         let hashCode = opts && 'hashCode' in opts ? opts.hashCode : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         if (isValidKey == null) {
           if (hashCode == null) {
             if (equals == null) {
               return new (_LinkedHashSet$(E))();
             }
@@ skipping 34 matching lines @@
     dart.setSignature(LinkedHashSet, {
       constructors: () => ({
         new: [LinkedHashSet$(E), [], {equals: dart.functionType(core.bool, [E, E]), hashCode: dart.functionType(core.int, [E]), isValidKey: dart.functionType(core.bool, [core.Object])}],
         identity: [LinkedHashSet$(E), []],
         from: [LinkedHashSet$(E), [core.Iterable$(E)]]
       })
     });
     return LinkedHashSet;
   });
   let LinkedHashSet = LinkedHashSet$();
-  let _modificationCount = Symbol('_modificationCount');
-  let _length = Symbol('_length');
-  let _next = Symbol('_next');
-  let _previous = Symbol('_previous');
-  let _insertAfter = Symbol('_insertAfter');
-  let _list = Symbol('_list');
-  let _unlink = Symbol('_unlink');
-  let LinkedList$ = dart.generic(function(E) {
+  const _modificationCount = Symbol('_modificationCount');
+  const _length = Symbol('_length');
+  const _next = Symbol('_next');
+  const _previous = Symbol('_previous');
+  const _insertAfter = Symbol('_insertAfter');
+  const _list = Symbol('_list');
+  const _unlink = Symbol('_unlink');
+  const LinkedList$ = dart.generic(function(E) {
     class LinkedList extends IterableBase$(E) {
       LinkedList() {
         this[_modificationCount] = 0;
         this[_length] = 0;
         this[_next] = null;
         this[_previous] = null;
         super.IterableBase();
         this[_next] = this[_previous] = this;
       }
       addFirst(entry) {
@@ skipping 111 matching lines @@
       'iterator',
       'length',
       'first',
       'last',
       'single',
       'isEmpty'
     ]);
     return LinkedList;
   });
   let LinkedList = LinkedList$();
-  let _current = Symbol('_current');
-  let _LinkedListIterator$ = dart.generic(function(E) {
+  const _current = Symbol('_current');
+  const _LinkedListIterator$ = dart.generic(function(E) {
     class _LinkedListIterator extends core.Object {
       _LinkedListIterator(list) {
         this[_list] = list;
         this[_modificationCount] = list[_modificationCount];
         this[_next] = list[_next];
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
@@ skipping 17 matching lines @@
     });
     return _LinkedListIterator;
   });
   let _LinkedListIterator = _LinkedListIterator$();
   class _LinkedListLink extends core.Object {
     _LinkedListLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
-  let LinkedListEntry$ = dart.generic(function(E) {
+  const LinkedListEntry$ = dart.generic(function(E) {
     class LinkedListEntry extends core.Object {
       LinkedListEntry() {
         this[_list] = null;
         this[_next] = null;
         this[_previous] = null;
       }
       get list() {
         return this[_list];
       }
       unlink() {
@@ skipping 23 matching lines @@
     dart.setSignature(LinkedListEntry, {
       methods: () => ({
         unlink: [dart.void, []],
         insertAfter: [dart.void, [E]],
         insertBefore: [dart.void, [E]]
       })
     });
     return LinkedListEntry;
   });
   let LinkedListEntry = LinkedListEntry$();
-  let ListMixin$ = dart.generic(function(E) {
+  const ListMixin$ = dart.generic(function(E) {
     class ListMixin extends core.Object {
       get iterator() {
         return new (_internal.ListIterator$(E))(this);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this.iterator);
       }
       elementAt(index) {
         return this.get(index);
       }
@@ skipping 565 matching lines @@
       'isEmpty',
       'isNotEmpty',
       'first',
       'last',
       'single',
       'reversed'
     ]);
     return ListMixin;
   });
   let ListMixin = ListMixin$();
-  let ListBase$ = dart.generic(function(E) {
+  const ListBase$ = dart.generic(function(E) {
     class ListBase extends dart.mixin(core.Object, ListMixin$(E)) {
       static listToString(list) {
         return IterableBase.iterableToFullString(list, '[', ']');
       }
     }
     dart.setSignature(ListBase, {
       statics: () => ({listToString: [core.String, [core.List]]}),
       names: ['listToString']
     });
     return ListBase;
   });
   let ListBase = ListBase$();
-  let MapMixin$ = dart.generic(function(K, V) {
+  const MapMixin$ = dart.generic(function(K, V) {
     class MapMixin extends core.Object {
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [K, V]));
         for (let key of this.keys) {
           action(key, this.get(key));
         }
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
         for (let key of other.keys) {
@@ skipping 40 matching lines @@
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
         addAll: [dart.void, [core.Map$(K, V)]],
         containsValue: [core.bool, [core.Object]],
         putIfAbsent: [V, [K, dart.functionType(V, [])]],
         containsKey: [core.bool, [core.Object]]
       })
     });
     return MapMixin;
   });
   let MapMixin = MapMixin$();
-  let MapBase$ = dart.generic(function(K, V) {
+  const MapBase$ = dart.generic(function(K, V) {
     class MapBase extends dart.mixin(core.Object, MapMixin$(K, V)) {}
     return MapBase;
   });
   let MapBase = MapBase$();
-  let _UnmodifiableMapMixin$ = dart.generic(function(K, V) {
+  const _UnmodifiableMapMixin$ = dart.generic(function(K, V) {
     class _UnmodifiableMapMixin extends core.Object {
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
         dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
         return value;
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
         dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
@@ skipping 16 matching lines @@
         set: [dart.void, [K, V]],
         addAll: [dart.void, [core.Map$(K, V)]],
         clear: [dart.void, []],
         remove: [V, [core.Object]],
         putIfAbsent: [V, [K, dart.functionType(V, [])]]
       })
     });
     return _UnmodifiableMapMixin;
   });
   let _UnmodifiableMapMixin = _UnmodifiableMapMixin$();
-  let UnmodifiableMapBase$ = dart.generic(function(K, V) {
+  const UnmodifiableMapBase$ = dart.generic(function(K, V) {
     class UnmodifiableMapBase extends dart.mixin(MapBase$(K, V), _UnmodifiableMapMixin$(K, V)) {
       UnmodifiableMapBase() {
         super.MapBase(...arguments);
       }
     }
     return UnmodifiableMapBase;
   });
   let UnmodifiableMapBase = UnmodifiableMapBase$();
-  let _map = Symbol('_map');
-  let _MapBaseValueIterable$ = dart.generic(function(V) {
+  const _map = Symbol('_map');
+  const _MapBaseValueIterable$ = dart.generic(function(V) {
     class _MapBaseValueIterable extends IterableBase$(V) {
       _MapBaseValueIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get length() {
         return this[_map].length;
       }
       get isEmpty() {
         return this[_map].isEmpty;
@@ skipping 23 matching lines @@
       'isEmpty',
       'isNotEmpty',
       'first',
       'single',
       'last',
       'iterator'
     ]);
     return _MapBaseValueIterable;
   });
   let _MapBaseValueIterable = _MapBaseValueIterable$();
-  let _keys = Symbol('_keys');
-  let _MapBaseValueIterator$ = dart.generic(function(V) {
+  const _keys = Symbol('_keys');
+  const _MapBaseValueIterator$ = dart.generic(function(V) {
     class _MapBaseValueIterator extends core.Object {
       _MapBaseValueIterator(map) {
         this[_map] = map;
         this[_keys] = map.keys[dartx.iterator];
         this[_current] = null;
       }
       moveNext() {
         if (dart.notNull(this[_keys].moveNext())) {
           this[_current] = dart.as(this[_map].get(this[_keys].current), V);
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     _MapBaseValueIterator[dart.implements] = () => [core.Iterator$(V)];
     dart.setSignature(_MapBaseValueIterator, {
       constructors: () => ({_MapBaseValueIterator: [_MapBaseValueIterator$(V), [core.Map]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _MapBaseValueIterator;
   });
   let _MapBaseValueIterator = _MapBaseValueIterator$();
-  let MapView$ = dart.generic(function(K, V) {
+  const MapView$ = dart.generic(function(K, V) {
     class MapView extends core.Object {
       MapView(map) {
         this[_map] = map;
       }
       get(key) {
         return this[_map].get(key);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
@@ skipping 55 matching lines @@
         putIfAbsent: [V, [K, dart.functionType(V, [])]],
         containsKey: [core.bool, [core.Object]],
         containsValue: [core.bool, [core.Object]],
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
         remove: [V, [core.Object]]
       })
     });
     return MapView;
   });
   let MapView = MapView$();
-  let UnmodifiableMapView$ = dart.generic(function(K, V) {
+  const UnmodifiableMapView$ = dart.generic(function(K, V) {
     class UnmodifiableMapView extends dart.mixin(MapView$(K, V), _UnmodifiableMapMixin$(K, V)) {
       UnmodifiableMapView() {
         super.MapView(...arguments);
       }
     }
     return UnmodifiableMapView;
   });
   let UnmodifiableMapView = UnmodifiableMapView$();
   class Maps extends core.Object {
     static containsValue(map, value) {
@@ skipping 105 matching lines @@
       length: [core.int, [core.Map]],
       isEmpty: [core.bool, [core.Map]],
       isNotEmpty: [core.bool, [core.Map]],
       mapToString: [core.String, [core.Map]],
       _id: [dart.dynamic, [dart.dynamic]],
       _fillMapWithMappedIterable: [dart.void, [core.Map, core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic]), dart.functionType(dart.dynamic, [dart.dynamic])]],
       _fillMapWithIterables: [dart.void, [core.Map, core.Iterable, core.Iterable]]
     }),
     names: ['containsValue', 'containsKey', 'putIfAbsent', 'clear', 'forEach', 'getValues', 'length', 'isEmpty', 'isNotEmpty', 'mapToString', '_id', '_fillMapWithMappedIterable', '_fillMapWithIterables']
   });
-  let Queue$ = dart.generic(function(E) {
+  const Queue$ = dart.generic(function(E) {
     class Queue extends core.Object {
       static new() {
         return new (ListQueue$(E))();
       }
       static from(elements) {
         return ListQueue$(E).from(elements);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this.iterator);
       }
     }
     Queue[dart.implements] = () => [core.Iterable$(E), _internal.EfficientLength];
     dart.setSignature(Queue, {
       constructors: () => ({
         new: [Queue$(E), []],
         from: [Queue$(E), [core.Iterable]]
       })
     });
     return Queue;
   });
   let Queue = Queue$();
-  let _element = Symbol('_element');
-  let _link = Symbol('_link');
-  let _asNonSentinelEntry = Symbol('_asNonSentinelEntry');
-  let DoubleLinkedQueueEntry$ = dart.generic(function(E) {
+  const _element = Symbol('_element');
+  const _link = Symbol('_link');
+  const _asNonSentinelEntry = Symbol('_asNonSentinelEntry');
+  const DoubleLinkedQueueEntry$ = dart.generic(function(E) {
     class DoubleLinkedQueueEntry extends core.Object {
       DoubleLinkedQueueEntry(e) {
         this[_element] = e;
         this[_previous] = null;
         this[_next] = null;
       }
       [_link](previous, next) {
         dart.as(previous, DoubleLinkedQueueEntry$(E));
         dart.as(next, DoubleLinkedQueueEntry$(E));
         this[_next] = next;
@@ skipping 41 matching lines @@
         prepend: [dart.void, [E]],
         remove: [E, []],
         [_asNonSentinelEntry]: [DoubleLinkedQueueEntry$(E), []],
         previousEntry: [DoubleLinkedQueueEntry$(E), []],
         nextEntry: [DoubleLinkedQueueEntry$(E), []]
       })
     });
     return DoubleLinkedQueueEntry;
   });
   let DoubleLinkedQueueEntry = DoubleLinkedQueueEntry$();
-  let _DoubleLinkedQueueEntrySentinel$ = dart.generic(function(E) {
+  const _DoubleLinkedQueueEntrySentinel$ = dart.generic(function(E) {
     class _DoubleLinkedQueueEntrySentinel extends DoubleLinkedQueueEntry$(E) {
       _DoubleLinkedQueueEntrySentinel() {
         super.DoubleLinkedQueueEntry(null);
         this[_link](this, this);
       }
       remove() {
         dart.throw(_internal.IterableElementError.noElement());
       }
       [_asNonSentinelEntry]() {
         return null;
       }
       set element(e) {
         dart.as(e, E);
         dart.assert(false);
       }
       get element() {
         dart.throw(_internal.IterableElementError.noElement());
       }
     }
     dart.setSignature(_DoubleLinkedQueueEntrySentinel, {
       constructors: () => ({_DoubleLinkedQueueEntrySentinel: [_DoubleLinkedQueueEntrySentinel$(E), []]}),
       methods: () => ({
         remove: [E, []],
         [_asNonSentinelEntry]: [DoubleLinkedQueueEntry$(E), []]
       })
     });
     return _DoubleLinkedQueueEntrySentinel;
   });
   let _DoubleLinkedQueueEntrySentinel = _DoubleLinkedQueueEntrySentinel$();
-  let _sentinel = Symbol('_sentinel');
-  let _elementCount = Symbol('_elementCount');
-  let _filter = Symbol('_filter');
-  let DoubleLinkedQueue$ = dart.generic(function(E) {
+  const _sentinel = Symbol('_sentinel');
+  const _elementCount = Symbol('_elementCount');
+  const _filter = Symbol('_filter');
+  const DoubleLinkedQueue$ = dart.generic(function(E) {
     class DoubleLinkedQueue extends IterableBase$(E) {
       DoubleLinkedQueue() {
         this[_sentinel] = null;
         this[_elementCount] = 0;
         super.IterableBase();
         this[_sentinel] = new (_DoubleLinkedQueueEntrySentinel$(E))();
       }
       static from(elements) {
         let list = new (DoubleLinkedQueue$(E))();
         for (let e of dart.as(elements, core.Iterable$(E))) {
@@ skipping 137 matching lines @@
       'length',
       'first',
       'last',
       'single',
       'isEmpty',
       'iterator'
     ]);
     return DoubleLinkedQueue;
   });
   let DoubleLinkedQueue = DoubleLinkedQueue$();
-  let _nextEntry = Symbol('_nextEntry');
-  let _DoubleLinkedQueueIterator$ = dart.generic(function(E) {
+  const _nextEntry = Symbol('_nextEntry');
+  const _DoubleLinkedQueueIterator$ = dart.generic(function(E) {
     class _DoubleLinkedQueueIterator extends core.Object {
       _DoubleLinkedQueueIterator(sentinel) {
         this[_sentinel] = sentinel;
         this[_nextEntry] = sentinel[_next];
         this[_current] = null;
       }
       moveNext() {
         if (!dart.notNull(core.identical(this[_nextEntry], this[_sentinel]))) {
           this[_current] = this[_nextEntry][_element];
           this[_nextEntry] = this[_nextEntry][_next];
           return true;
         }
         this[_current] = null;
         this[_nextEntry] = this[_sentinel] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     _DoubleLinkedQueueIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(_DoubleLinkedQueueIterator, {
       constructors: () => ({_DoubleLinkedQueueIterator: [_DoubleLinkedQueueIterator$(E), [_DoubleLinkedQueueEntrySentinel$(E)]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _DoubleLinkedQueueIterator;
   });
   let _DoubleLinkedQueueIterator = _DoubleLinkedQueueIterator$();
-  let _head = Symbol('_head');
-  let _tail = Symbol('_tail');
-  let _table = Symbol('_table');
-  let _checkModification = Symbol('_checkModification');
-  let _writeToList = Symbol('_writeToList');
-  let _add = Symbol('_add');
-  let _preGrow = Symbol('_preGrow');
-  let _remove = Symbol('_remove');
-  let _filterWhere = Symbol('_filterWhere');
-  let _grow = Symbol('_grow');
-  let ListQueue$ = dart.generic(function(E) {
+  const _head = Symbol('_head');
+  const _tail = Symbol('_tail');
+  const _table = Symbol('_table');
+  const _checkModification = Symbol('_checkModification');
+  const _writeToList = Symbol('_writeToList');
+  const _add = Symbol('_add');
+  const _preGrow = Symbol('_preGrow');
+  const _remove = Symbol('_remove');
+  const _filterWhere = Symbol('_filterWhere');
+  const _grow = Symbol('_grow');
+  const ListQueue$ = dart.generic(function(E) {
     class ListQueue extends IterableBase$(E) {
       ListQueue(initialCapacity) {
         if (initialCapacity === void 0)
           initialCapacity = null;
         this[_head] = 0;
         this[_tail] = 0;
         this[_table] = null;
         this[_modificationCount] = 0;
         super.IterableBase();
         if (initialCapacity == null || dart.notNull(initialCapacity) < dart.notNull(ListQueue$()._INITIAL_CAPACITY)) {
@@ skipping 312 matching lines @@
       'isEmpty',
       'length',
       'first',
       'last',
       'single'
     ]);
     return ListQueue;
   });
   let ListQueue = ListQueue$();
   ListQueue._INITIAL_CAPACITY = 8;
-  let _queue = Symbol('_queue');
-  let _end = Symbol('_end');
-  let _position = Symbol('_position');
-  let _ListQueueIterator$ = dart.generic(function(E) {
+  const _queue = Symbol('_queue');
+  const _end = Symbol('_end');
+  const _position = Symbol('_position');
+  const _ListQueueIterator$ = dart.generic(function(E) {
     class _ListQueueIterator extends core.Object {
       _ListQueueIterator(queue) {
         this[_queue] = queue;
         this[_end] = queue[_tail];
         this[_modificationCount] = queue[_modificationCount];
         this[_position] = queue[_head];
         this[_current] = null;
       }
       get current() {
         return this[_current];
@@ skipping 10 matching lines @@
       }
     }
     _ListQueueIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(_ListQueueIterator, {
       constructors: () => ({_ListQueueIterator: [_ListQueueIterator$(E), [ListQueue]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _ListQueueIterator;
   });
   let _ListQueueIterator = _ListQueueIterator$();
-  let _Predicate$ = dart.generic(function(T) {
-    let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
+  const _Predicate$ = dart.generic(function(T) {
+    const _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
     return _Predicate;
   });
   let _Predicate = _Predicate$();
-  let _SplayTreeNode$ = dart.generic(function(K) {
+  const _SplayTreeNode$ = dart.generic(function(K) {
     class _SplayTreeNode extends core.Object {
       _SplayTreeNode(key) {
         this.key = key;
         this.left = null;
         this.right = null;
       }
     }
     dart.setSignature(_SplayTreeNode, {
       constructors: () => ({_SplayTreeNode: [_SplayTreeNode$(K), [K]]})
     });
     return _SplayTreeNode;
   });
   let _SplayTreeNode = _SplayTreeNode$();
-  let _SplayTreeMapNode$ = dart.generic(function(K, V) {
+  const _SplayTreeMapNode$ = dart.generic(function(K, V) {
     class _SplayTreeMapNode extends _SplayTreeNode$(K) {
       _SplayTreeMapNode(key, value) {
         this.value = value;
         super._SplayTreeNode(key);
       }
     }
     dart.setSignature(_SplayTreeMapNode, {
       constructors: () => ({_SplayTreeMapNode: [_SplayTreeMapNode$(K, V), [K, V]]})
     });
     return _SplayTreeMapNode;
   });
   let _SplayTreeMapNode = _SplayTreeMapNode$();
-  let _dummy = Symbol('_dummy');
-  let _root = Symbol('_root');
-  let _count = Symbol('_count');
-  let _splayCount = Symbol('_splayCount');
-  let _compare = Symbol('_compare');
-  let _splay = Symbol('_splay');
-  let _splayMin = Symbol('_splayMin');
-  let _splayMax = Symbol('_splayMax');
-  let _addNewRoot = Symbol('_addNewRoot');
-  let _first = Symbol('_first');
-  let _last = Symbol('_last');
-  let _clear = Symbol('_clear');
-  let _SplayTree$ = dart.generic(function(K) {
+  const _dummy = Symbol('_dummy');
+  const _root = Symbol('_root');
+  const _count = Symbol('_count');
+  const _splayCount = Symbol('_splayCount');
+  const _compare = Symbol('_compare');
+  const _splay = Symbol('_splay');
+  const _splayMin = Symbol('_splayMin');
+  const _splayMax = Symbol('_splayMax');
+  const _addNewRoot = Symbol('_addNewRoot');
+  const _first = Symbol('_first');
+  const _last = Symbol('_last');
+  const _clear = Symbol('_clear');
+  const _SplayTree$ = dart.generic(function(K) {
     class _SplayTree extends core.Object {
       _SplayTree() {
         this[_dummy] = new (_SplayTreeNode$(K))(null);
         this[_root] = null;
         this[_count] = 0;
         this[_modificationCount] = 0;
         this[_splayCount] = 0;
       }
       [_splay](key) {
         dart.as(key, K);
@@ skipping 133 matching lines @@
         [_splayMin]: [_SplayTreeNode$(K), [_SplayTreeNode$(K)]],
         [_splayMax]: [_SplayTreeNode$(K), [_SplayTreeNode$(K)]],
         [_remove]: [_SplayTreeNode, [K]],
         [_addNewRoot]: [dart.void, [_SplayTreeNode$(K), core.int]],
         [_clear]: [dart.void, []]
       })
     });
     return _SplayTree;
   });
   let _SplayTree = _SplayTree$();
-  let _comparator = Symbol('_comparator');
-  let _validKey = Symbol('_validKey');
-  let SplayTreeMap$ = dart.generic(function(K, V) {
+  const _comparator = Symbol('_comparator');
+  const _validKey = Symbol('_validKey');
+  const SplayTreeMap$ = dart.generic(function(K, V) {
     class SplayTreeMap extends _SplayTree$(K) {
       SplayTreeMap(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator$(K));
         this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
         super._SplayTree();
       }
@@ skipping 124 matching lines @@
       }
       clear() {
         this[_clear]();
       }
       containsKey(key) {
         return dart.notNull(this[_validKey](key)) && this[_splay](dart.as(key, K)) == 0;
       }
       containsValue(value) {
         let found = false;
         let initialSplayCount = this[_splayCount];
-        let visit = (function(node) {
+        const visit = (function(node) {
           while (node != null) {
             if (dart.equals(node.value, value))
               return true;
             if (initialSplayCount != this[_splayCount]) {
               dart.throw(new core.ConcurrentModificationError(this));
             }
             if (node.right != null && dart.notNull(visit(dart.as(node.right, _SplayTreeMapNode))))
               return true;
             node = dart.as(node.left, _SplayTreeMapNode);
           }
@@ skipping 79 matching lines @@
         containsValue: [core.bool, [core.Object]],
         firstKey: [K, []],
         lastKey: [K, []],
         lastKeyBefore: [K, [K]],
         firstKeyAfter: [K, [K]]
       })
     });
     return SplayTreeMap;
   });
   let SplayTreeMap = SplayTreeMap$();
-  let _workList = Symbol('_workList');
-  let _tree = Symbol('_tree');
-  let _currentNode = Symbol('_currentNode');
-  let _findLeftMostDescendent = Symbol('_findLeftMostDescendent');
-  let _getValue = Symbol('_getValue');
-  let _rebuildWorkList = Symbol('_rebuildWorkList');
-  let _SplayTreeIterator$ = dart.generic(function(T) {
+  const _workList = Symbol('_workList');
+  const _tree = Symbol('_tree');
+  const _currentNode = Symbol('_currentNode');
+  const _findLeftMostDescendent = Symbol('_findLeftMostDescendent');
+  const _getValue = Symbol('_getValue');
+  const _rebuildWorkList = Symbol('_rebuildWorkList');
+  const _SplayTreeIterator$ = dart.generic(function(T) {
     class _SplayTreeIterator extends core.Object {
       _SplayTreeIterator(tree) {
         this[_workList] = dart.list([], _SplayTreeNode);
         this[_tree] = tree;
         this[_modificationCount] = tree[_modificationCount];
         this[_splayCount] = tree[_splayCount];
         this[_currentNode] = null;
         this[_findLeftMostDescendent](tree[_root]);
       }
       startAt(tree, startKey) {
@@ skipping 59 matching lines @@
       }),
       methods: () => ({
         [_findLeftMostDescendent]: [dart.void, [_SplayTreeNode]],
         [_rebuildWorkList]: [dart.void, [_SplayTreeNode]],
         moveNext: [core.bool, []]
       })
     });
     return _SplayTreeIterator;
   });
   let _SplayTreeIterator = _SplayTreeIterator$();
-  let _copyNode = Symbol('_copyNode');
-  let _SplayTreeKeyIterable$ = dart.generic(function(K) {
+  const _copyNode = Symbol('_copyNode');
+  const _SplayTreeKeyIterable$ = dart.generic(function(K) {
     class _SplayTreeKeyIterable extends IterableBase$(K) {
       _SplayTreeKeyIterable(tree) {
         this[_tree] = tree;
         super.IterableBase();
       }
       get length() {
         return this[_tree][_count];
       }
       get isEmpty() {
         return this[_tree][_count] == 0;
@@ skipping 11 matching lines @@
     }
     _SplayTreeKeyIterable[dart.implements] = () => [_internal.EfficientLength];
     dart.setSignature(_SplayTreeKeyIterable, {
       constructors: () => ({_SplayTreeKeyIterable: [_SplayTreeKeyIterable$(K), [_SplayTree$(K)]]}),
       methods: () => ({toSet: [core.Set$(K), []]})
     });
     dart.defineExtensionMembers(_SplayTreeKeyIterable, ['toSet', 'length', 'isEmpty', 'iterator']);
     return _SplayTreeKeyIterable;
   });
   let _SplayTreeKeyIterable = _SplayTreeKeyIterable$();
-  let _SplayTreeValueIterable$ = dart.generic(function(K, V) {
+  const _SplayTreeValueIterable$ = dart.generic(function(K, V) {
     class _SplayTreeValueIterable extends IterableBase$(V) {
       _SplayTreeValueIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get length() {
         return this[_map][_count];
       }
       get isEmpty() {
         return this[_map][_count] == 0;
       }
       get iterator() {
         return new (_SplayTreeValueIterator$(K, V))(this[_map]);
       }
     }
     _SplayTreeValueIterable[dart.implements] = () => [_internal.EfficientLength];
     dart.setSignature(_SplayTreeValueIterable, {
       constructors: () => ({_SplayTreeValueIterable: [_SplayTreeValueIterable$(K, V), [SplayTreeMap$(K, V)]]})
     });
     dart.defineExtensionMembers(_SplayTreeValueIterable, ['length', 'isEmpty', 'iterator']);
     return _SplayTreeValueIterable;
   });
   let _SplayTreeValueIterable = _SplayTreeValueIterable$();
-  let _SplayTreeKeyIterator$ = dart.generic(function(K) {
+  const _SplayTreeKeyIterator$ = dart.generic(function(K) {
     class _SplayTreeKeyIterator extends _SplayTreeIterator$(K) {
       _SplayTreeKeyIterator(map) {
         super._SplayTreeIterator(map);
       }
       [_getValue](node) {
         return dart.as(node.key, K);
       }
     }
     dart.setSignature(_SplayTreeKeyIterator, {
       constructors: () => ({_SplayTreeKeyIterator: [_SplayTreeKeyIterator$(K), [_SplayTree$(K)]]}),
       methods: () => ({[_getValue]: [K, [_SplayTreeNode]]})
     });
     return _SplayTreeKeyIterator;
   });
   let _SplayTreeKeyIterator = _SplayTreeKeyIterator$();
-  let _SplayTreeValueIterator$ = dart.generic(function(K, V) {
+  const _SplayTreeValueIterator$ = dart.generic(function(K, V) {
     class _SplayTreeValueIterator extends _SplayTreeIterator$(V) {
       _SplayTreeValueIterator(map) {
         super._SplayTreeIterator(map);
       }
       [_getValue](node) {
         return dart.as(node.value, V);
       }
     }
     dart.setSignature(_SplayTreeValueIterator, {
       constructors: () => ({_SplayTreeValueIterator: [_SplayTreeValueIterator$(K, V), [SplayTreeMap$(K, V)]]}),
       methods: () => ({[_getValue]: [V, [_SplayTreeMapNode]]})
     });
     return _SplayTreeValueIterator;
   });
   let _SplayTreeValueIterator = _SplayTreeValueIterator$();
-  let _SplayTreeNodeIterator$ = dart.generic(function(K) {
+  const _SplayTreeNodeIterator$ = dart.generic(function(K) {
     class _SplayTreeNodeIterator extends _SplayTreeIterator$(_SplayTreeNode$(K)) {
       _SplayTreeNodeIterator(tree) {
         super._SplayTreeIterator(tree);
       }
       startAt(tree, startKey) {
         super.startAt(tree, startKey);
       }
       [_getValue](node) {
         return dart.as(node, _SplayTreeNode$(K));
       }
     }
     dart.defineNamedConstructor(_SplayTreeNodeIterator, 'startAt');
     dart.setSignature(_SplayTreeNodeIterator, {
       constructors: () => ({
         _SplayTreeNodeIterator: [_SplayTreeNodeIterator$(K), [_SplayTree$(K)]],
         startAt: [_SplayTreeNodeIterator$(K), [_SplayTree$(K), dart.dynamic]]
       }),
       methods: () => ({[_getValue]: [_SplayTreeNode$(K), [_SplayTreeNode]]})
     });
     return _SplayTreeNodeIterator;
   });
   let _SplayTreeNodeIterator = _SplayTreeNodeIterator$();
-  let _clone = Symbol('_clone');
-  let SplayTreeSet$ = dart.generic(function(E) {
+  const _clone = Symbol('_clone');
+  const SplayTreeSet$ = dart.generic(function(E) {
     class SplayTreeSet extends dart.mixin(_SplayTree$(E), IterableMixin$(E), SetMixin$(E)) {
       SplayTreeSet(compare, isValidKey) {
         if (compare === void 0)
           compare = null;
         if (isValidKey === void 0)
           isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator$(E));
         this[_validKey] = isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, E), core.bool, [dart.dynamic]);
         super._SplayTree();
       }
@@ skipping 171 matching lines @@
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last',
       'single'
     ]);
     return SplayTreeSet;
   });
   let SplayTreeSet = SplayTreeSet$();
-  let _strings = Symbol('_strings');
-  let _nums = Symbol('_nums');
-  let _rest = Symbol('_rest');
-  let _containsKey = Symbol('_containsKey');
-  let _getBucket = Symbol('_getBucket');
-  let _findBucketIndex = Symbol('_findBucketIndex');
-  let _computeKeys = Symbol('_computeKeys');
-  let _get = Symbol('_get');
-  let _addHashTableEntry = Symbol('_addHashTableEntry');
-  let _set = Symbol('_set');
-  let _computeHashCode = Symbol('_computeHashCode');
-  let _removeHashTableEntry = Symbol('_removeHashTableEntry');
-  let _HashMap$ = dart.generic(function(K, V) {
+  const _strings = Symbol('_strings');
+  const _nums = Symbol('_nums');
+  const _rest = Symbol('_rest');
+  const _containsKey = Symbol('_containsKey');
+  const _getBucket = Symbol('_getBucket');
+  const _findBucketIndex = Symbol('_findBucketIndex');
+  const _computeKeys = Symbol('_computeKeys');
+  const _get = Symbol('_get');
+  const _addHashTableEntry = Symbol('_addHashTableEntry');
+  const _set = Symbol('_set');
+  const _computeHashCode = Symbol('_computeHashCode');
+  const _removeHashTableEntry = Symbol('_removeHashTableEntry');
+  const _HashMap$ = dart.generic(function(K, V) {
     class _HashMap extends core.Object {
       _HashMap() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
         this[_rest] = null;
         this[_keys] = null;
       }
       get length() {
         return this[_length];
@@ skipping 289 matching lines @@
         _getTableEntry: [dart.dynamic, [dart.dynamic, dart.dynamic]],
         _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
         _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
         _newHashTable: [dart.dynamic, []]
       }),
       names: ['_isStringKey', '_isNumericKey', '_hasTableEntry', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
     return _HashMap;
   });
   let _HashMap = _HashMap$();
-  let _IdentityHashMap$ = dart.generic(function(K, V) {
+  const _IdentityHashMap$ = dart.generic(function(K, V) {
     class _IdentityHashMap extends _HashMap$(K, V) {
       _IdentityHashMap() {
         super._HashMap();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 2) {
           if (dart.notNull(core.identical(bucket[i], key)))
             return i;
         }
         return -1;
       }
     }
     return _IdentityHashMap;
   });
   let _IdentityHashMap = _IdentityHashMap$();
-  let _equals = Symbol('_equals');
-  let _hashCode = Symbol('_hashCode');
-  let _CustomHashMap$ = dart.generic(function(K, V) {
+  const _equals = Symbol('_equals');
+  const _hashCode = Symbol('_hashCode');
+  const _CustomHashMap$ = dart.generic(function(K, V) {
     class _CustomHashMap extends _HashMap$(K, V) {
       _CustomHashMap(equals, hashCode, validKey) {
         this[_equals] = equals;
         this[_hashCode] = hashCode;
         this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
         super._HashMap();
       }
       get(key) {
         if (!dart.notNull(this[_validKey](key)))
           return null;
@@ skipping 36 matching lines @@
       constructors: () => ({_CustomHashMap: [_CustomHashMap$(K, V), [_Equality$(K), _Hasher$(K), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         get: [V, [core.Object]],
         set: [dart.void, [K, V]],
         remove: [V, [core.Object]]
       })
     });
     return _CustomHashMap;
   });
   let _CustomHashMap = _CustomHashMap$();
-  let HashMapKeyIterable$ = dart.generic(function(E) {
+  const HashMapKeyIterable$ = dart.generic(function(E) {
     class HashMapKeyIterable extends IterableBase$(E) {
       HashMapKeyIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get length() {
         return dart.as(dart.dload(this[_map], _length), core.int);
       }
       get isEmpty() {
         return dart.equals(dart.dload(this[_map], _length), 0);
@@ skipping 23 matching lines @@
     dart.defineExtensionMembers(HashMapKeyIterable, [
       'contains',
       'forEach',
       'length',
       'isEmpty',
       'iterator'
     ]);
     return HashMapKeyIterable;
   });
   let HashMapKeyIterable = HashMapKeyIterable$();
-  let _offset = Symbol('_offset');
-  let HashMapKeyIterator$ = dart.generic(function(E) {
+  const _offset = Symbol('_offset');
+  const HashMapKeyIterator$ = dart.generic(function(E) {
     class HashMapKeyIterator extends core.Object {
       HashMapKeyIterator(map, keys) {
         this[_map] = map;
         this[_keys] = keys;
         this[_offset] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
@@ skipping 13 matching lines @@
       }
     }
     HashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(HashMapKeyIterator, {
       constructors: () => ({HashMapKeyIterator: [HashMapKeyIterator$(E), [dart.dynamic, core.List]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return HashMapKeyIterator;
   });
   let HashMapKeyIterator = HashMapKeyIterator$();
-  let _modifications = Symbol('_modifications');
-  let _value = Symbol('_value');
-  let _newLinkedCell = Symbol('_newLinkedCell');
-  let _unlinkCell = Symbol('_unlinkCell');
-  let _modified = Symbol('_modified');
-  let _key = Symbol('_key');
-  let _LinkedHashMap$ = dart.generic(function(K, V) {
+  const _modifications = Symbol('_modifications');
+  const _value = Symbol('_value');
+  const _newLinkedCell = Symbol('_newLinkedCell');
+  const _unlinkCell = Symbol('_unlinkCell');
+  const _modified = Symbol('_modified');
+  const _key = Symbol('_key');
+  const _LinkedHashMap$ = dart.generic(function(K, V) {
     class _LinkedHashMap extends core.Object {
       _LinkedHashMap() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
         this[_rest] = null;
         this[_first] = null;
         this[_last] = null;
         this[_modifications] = 0;
       }
@@ skipping 297 matching lines @@
         _getTableEntry: [dart.dynamic, [dart.dynamic, dart.dynamic]],
         _setTableEntry: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
         _deleteTableEntry: [dart.void, [dart.dynamic, dart.dynamic]],
         _newHashTable: [dart.dynamic, []]
       }),
       names: ['_isStringKey', '_isNumericKey', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
     return _LinkedHashMap;
   });
   let _LinkedHashMap = _LinkedHashMap$();
-  let _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
+  const _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
     class _LinkedIdentityHashMap extends _LinkedHashMap$(K, V) {
       _LinkedIdentityHashMap() {
         super._LinkedHashMap();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, key) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (dart.notNull(core.identical(cell[_key], key)))
             return i;
         }
         return -1;
       }
     }
     return _LinkedIdentityHashMap;
   });
   let _LinkedIdentityHashMap = _LinkedIdentityHashMap$();
-  let _LinkedCustomHashMap$ = dart.generic(function(K, V) {
+  const _LinkedCustomHashMap$ = dart.generic(function(K, V) {
     class _LinkedCustomHashMap extends _LinkedHashMap$(K, V) {
       _LinkedCustomHashMap(equals, hashCode, validKey) {
         this[_equals] = equals;
         this[_hashCode] = hashCode;
         this[_validKey] = validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [dart.dynamic]);
         super._LinkedHashMap();
       }
       get(key) {
         if (!dart.notNull(this[_validKey](key)))
           return null;
@@ skipping 45 matching lines @@
     LinkedHashMapCell(key, value) {
       this[_key] = key;
       this[_value] = value;
       this[_next] = null;
       this[_previous] = null;
     }
   }
   dart.setSignature(LinkedHashMapCell, {
     constructors: () => ({LinkedHashMapCell: [LinkedHashMapCell, [dart.dynamic, dart.dynamic]]})
   });
-  let LinkedHashMapKeyIterable$ = dart.generic(function(E) {
+  const LinkedHashMapKeyIterable$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterable extends IterableBase$(E) {
       LinkedHashMapKeyIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get length() {
         return dart.as(dart.dload(this[_map], _length), core.int);
       }
       get isEmpty() {
         return dart.equals(dart.dload(this[_map], _length), 0);
@@ skipping 25 matching lines @@
     dart.defineExtensionMembers(LinkedHashMapKeyIterable, [
       'contains',
       'forEach',
       'length',
       'isEmpty',
       'iterator'
     ]);
     return LinkedHashMapKeyIterable;
   });
   let LinkedHashMapKeyIterable = LinkedHashMapKeyIterable$();
-  let _cell = Symbol('_cell');
-  let LinkedHashMapKeyIterator$ = dart.generic(function(E) {
+  const _cell = Symbol('_cell');
+  const LinkedHashMapKeyIterator$ = dart.generic(function(E) {
     class LinkedHashMapKeyIterator extends core.Object {
       LinkedHashMapKeyIterator(map, modifications) {
         this[_map] = map;
         this[_modifications] = modifications;
         this[_cell] = null;
         this[_current] = null;
         this[_cell] = dart.as(dart.dload(this[_map], _first), LinkedHashMapCell);
       }
       get current() {
         return this[_current];
@@ skipping 12 matching lines @@
       }
     }
     LinkedHashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(LinkedHashMapKeyIterator, {
       constructors: () => ({LinkedHashMapKeyIterator: [LinkedHashMapKeyIterator$(E), [dart.dynamic, core.int]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return LinkedHashMapKeyIterator;
   });
   let LinkedHashMapKeyIterator = LinkedHashMapKeyIterator$();
-  let _elements = Symbol('_elements');
-  let _computeElements = Symbol('_computeElements');
-  let _contains = Symbol('_contains');
-  let _lookup = Symbol('_lookup');
-  let _HashSet$ = dart.generic(function(E) {
+  const _elements = Symbol('_elements');
+  const _computeElements = Symbol('_computeElements');
+  const _contains = Symbol('_contains');
+  const _lookup = Symbol('_lookup');
+  const _HashSet$ = dart.generic(function(E) {
     class _HashSet extends _HashSetBase$(E) {
       _HashSet() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
         this[_rest] = null;
         this[_elements] = null;
       }
       [_newSet]() {
         return new (_HashSet$(E))();
@@ skipping 250 matching lines @@
     dart.defineExtensionMembers(_HashSet, [
       'contains',
       'iterator',
       'length',
       'isEmpty',
       'isNotEmpty'
     ]);
     return _HashSet;
   });
   let _HashSet = _HashSet$();
-  let _IdentityHashSet$ = dart.generic(function(E) {
+  const _IdentityHashSet$ = dart.generic(function(E) {
     class _IdentityHashSet extends _HashSet$(E) {
       _IdentityHashSet() {
         super._HashSet();
       }
       [_newSet]() {
         return new (_IdentityHashSet$(E))();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (dart.notNull(core.identical(bucket[i], element)))
             return i;
         }
         return -1;
       }
     }
     dart.setSignature(_IdentityHashSet, {
       methods: () => ({[_newSet]: [core.Set$(E), []]})
     });
     return _IdentityHashSet;
   });
   let _IdentityHashSet = _IdentityHashSet$();
-  let _equality = Symbol('_equality');
-  let _hasher = Symbol('_hasher');
-  let _CustomHashSet$ = dart.generic(function(E) {
+  const _equality = Symbol('_equality');
+  const _hasher = Symbol('_hasher');
+  const _CustomHashSet$ = dart.generic(function(E) {
     class _CustomHashSet extends _HashSet$(E) {
       _CustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
         this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [dart.dynamic]);
         super._HashSet();
       }
       [_newSet]() {
         return new (_CustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
@@ skipping 35 matching lines @@
       methods: () => ({
         [_newSet]: [core.Set$(E), []],
         add: [core.bool, [E]],
         lookup: [E, [core.Object]]
       })
     });
     dart.defineExtensionMembers(_CustomHashSet, ['contains']);
     return _CustomHashSet;
   });
   let _CustomHashSet = _CustomHashSet$();
-  let HashSetIterator$ = dart.generic(function(E) {
+  const HashSetIterator$ = dart.generic(function(E) {
     class HashSetIterator extends core.Object {
       HashSetIterator(set, elements) {
         this[_set] = set;
         this[_elements] = elements;
         this[_offset] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
@@ skipping 13 matching lines @@
       }
     }
     HashSetIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(HashSetIterator, {
       constructors: () => ({HashSetIterator: [HashSetIterator$(E), [dart.dynamic, core.List]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return HashSetIterator;
   });
   let HashSetIterator = HashSetIterator$();
-  let _unsupported = Symbol('_unsupported');
-  let _LinkedHashSet$ = dart.generic(function(E) {
+  const _unsupported = Symbol('_unsupported');
+  const _LinkedHashSet$ = dart.generic(function(E) {
     class _LinkedHashSet extends _HashSetBase$(E) {
       _LinkedHashSet() {
         this[_length] = 0;
         this[_strings] = null;
         this[_nums] = null;
         this[_rest] = null;
         this[_first] = null;
         this[_last] = null;
         this[_modifications] = 0;
       }
@@ skipping 303 matching lines @@
       'iterator',
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last'
     ]);
     return _LinkedHashSet;
   });
   let _LinkedHashSet = _LinkedHashSet$();
-  let _LinkedIdentityHashSet$ = dart.generic(function(E) {
+  const _LinkedIdentityHashSet$ = dart.generic(function(E) {
     class _LinkedIdentityHashSet extends _LinkedHashSet$(E) {
       _LinkedIdentityHashSet() {
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedIdentityHashSet$(E))();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
       }
       [_findBucketIndex](bucket, element) {
         if (bucket == null)
           return -1;
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (dart.notNull(core.identical(cell[_element], element)))
             return i;
         }
         return -1;
       }
     }
     dart.setSignature(_LinkedIdentityHashSet, {
       methods: () => ({[_newSet]: [core.Set$(E), []]})
     });
     return _LinkedIdentityHashSet;
   });
   let _LinkedIdentityHashSet = _LinkedIdentityHashSet$();
-  let _LinkedCustomHashSet$ = dart.generic(function(E) {
+  const _LinkedCustomHashSet$ = dart.generic(function(E) {
     class _LinkedCustomHashSet extends _LinkedHashSet$(E) {
       _LinkedCustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
         this[_validKey] = validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [dart.dynamic]);
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedCustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
       }
@@ skipping 60 matching lines @@
   class LinkedHashSetCell extends core.Object {
     LinkedHashSetCell(element) {
       this[_element] = element;
       this[_next] = null;
       this[_previous] = null;
     }
   }
   dart.setSignature(LinkedHashSetCell, {
     constructors: () => ({LinkedHashSetCell: [LinkedHashSetCell, [dart.dynamic]]})
   });
-  let LinkedHashSetIterator$ = dart.generic(function(E) {
+  const LinkedHashSetIterator$ = dart.generic(function(E) {
     class LinkedHashSetIterator extends core.Object {
       LinkedHashSetIterator(set, modifications) {
         this[_set] = set;
         this[_modifications] = modifications;
         this[_cell] = null;
         this[_current] = null;
         this[_cell] = dart.as(dart.dload(this[_set], _first), LinkedHashSetCell);
       }
       get current() {
         return this[_current];
@@ skipping 78 matching lines @@
   exports.LinkedHashMapKeyIterable$ = LinkedHashMapKeyIterable$;
   exports.LinkedHashMapKeyIterable = LinkedHashMapKeyIterable;
   exports.LinkedHashMapKeyIterator$ = LinkedHashMapKeyIterator$;
   exports.LinkedHashMapKeyIterator = LinkedHashMapKeyIterator;
   exports.HashSetIterator$ = HashSetIterator$;
   exports.HashSetIterator = HashSetIterator;
   exports.LinkedHashSetCell = LinkedHashSetCell;
   exports.LinkedHashSetIterator$ = LinkedHashSetIterator$;
   exports.LinkedHashSetIterator = LinkedHashSetIterator;
 });