Add --modules=node support

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;
@@ skipping 23 matching lines @@
   }
   dart.fn(_defaultEquals, core.bool, [core.Object, core.Object]);
   function _defaultHashCode(a) {
     return dart.hashCode(a);
   }
   dart.fn(_defaultHashCode, core.int, [core.Object]);
   const _Equality$ = dart.generic(function(K) {
     const _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [K, K]));
     return _Equality;
   });
-  let _Equality = _Equality$();
+  const _Equality = _Equality$();
   const _Hasher$ = dart.generic(function(K) {
     const _Hasher = dart.typedef('_Hasher', () => dart.functionType(core.int, [K]));
     return _Hasher;
   });
-  let _Hasher = _Hasher$();
+  const _Hasher = _Hasher$();
   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 @@
       constructors: () => ({
         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$();
+  const HashMap = HashMap$();
   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 291 matching lines @@
       'singleWhere',
       'elementAt',
       'isEmpty',
       'isNotEmpty',
       'single',
       'first',
       'last'
     ]);
     return SetMixin;
   });
-  let SetMixin = SetMixin$();
+  const SetMixin = SetMixin$();
   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$();
+  const SetBase = SetBase$();
   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;
       }
@@ skipping 15 matching lines @@
     dart.setSignature(_HashSetBase, {
       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$();
+  const _HashSetBase = _HashSetBase$();
   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 @@
     HashSet[dart.implements] = () => [core.Set$(E)];
     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$();
+  const HashSet = HashSet$();
   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);
       }
@@ skipping 231 matching lines @@
       'elementAt',
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last',
       'single'
     ]);
     return IterableMixin;
   });
-  let IterableMixin = IterableMixin$();
+  const IterableMixin = IterableMixin$();
   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]));
@@ skipping 364 matching lines @@
       'elementAt',
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last',
       'single'
     ]);
     return IterableBase;
   });
-  let IterableBase = IterableBase$();
+  const IterableBase = IterableBase$();
   dart.defineLazyProperties(IterableBase, {
     get _toStringVisiting() {
       return [];
     }
   });
   const _iterator = Symbol('_iterator');
   const _state = Symbol('_state');
   const _move = Symbol('_move');
   const HasNextIterator$ = dart.generic(function(E) {
     class HasNextIterator extends core.Object {
@@ skipping 22 matching lines @@
     }
     dart.setSignature(HasNextIterator, {
       constructors: () => ({HasNextIterator: [HasNextIterator$(E), [core.Iterator]]}),
       methods: () => ({
         next: [E, []],
         [_move]: [dart.void, []]
       })
     });
     return HasNextIterator;
   });
-  let HasNextIterator = HasNextIterator$();
+  const HasNextIterator = HasNextIterator$();
   HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT = 0;
   HasNextIterator._NO_NEXT = 1;
   HasNextIterator._NOT_MOVED_YET = 2;
   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) {
@@ skipping 56 matching lines @@
         identity: [LinkedHashMap$(K, V), []],
         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$();
+  const LinkedHashMap = LinkedHashMap$();
   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 @@
     LinkedHashSet[dart.implements] = () => [HashSet$(E)];
     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$();
+  const LinkedHashSet = LinkedHashSet$();
   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() {
@@ skipping 117 matching lines @@
       'forEach',
       'iterator',
       'length',
       'first',
       'last',
       'single',
       'isEmpty'
     ]);
     return LinkedList;
   });
-  let LinkedList = LinkedList$();
+  const LinkedList = LinkedList$();
   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() {
@@ skipping 12 matching lines @@
         return true;
       }
     }
     _LinkedListIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(_LinkedListIterator, {
       constructors: () => ({_LinkedListIterator: [_LinkedListIterator$(E), [LinkedList$(E)]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _LinkedListIterator;
   });
-  let _LinkedListIterator = _LinkedListIterator$();
+  const _LinkedListIterator = _LinkedListIterator$();
   class _LinkedListLink extends core.Object {
     _LinkedListLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
   const LinkedListEntry$ = dart.generic(function(E) {
     class LinkedListEntry extends core.Object {
       LinkedListEntry() {
         this[_list] = null;
@@ skipping 27 matching lines @@
     LinkedListEntry[dart.implements] = () => [_LinkedListLink];
     dart.setSignature(LinkedListEntry, {
       methods: () => ({
         unlink: [dart.void, []],
         insertAfter: [dart.void, [E]],
         insertBefore: [dart.void, [E]]
       })
     });
     return LinkedListEntry;
   });
-  let LinkedListEntry = LinkedListEntry$();
+  const LinkedListEntry = LinkedListEntry$();
   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 539 matching lines @@
       'iterator',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last',
       'single',
       'reversed'
     ]);
     return ListMixin;
   });
-  let ListMixin = ListMixin$();
+  const ListMixin = ListMixin$();
   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$();
+  const ListBase = ListBase$();
   const __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.int, [dart.dynamic, dart.dynamic]));
   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) {
@@ skipping 40 matching lines @@
       methods: () => ({
         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$();
+  const MapMixin = MapMixin$();
   const MapBase$ = dart.generic(function(K, V) {
     class MapBase extends dart.mixin(core.Object, MapMixin$(K, V)) {}
     return MapBase;
   });
-  let MapBase = MapBase$();
+  const MapBase = MapBase$();
   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));
@@ skipping 16 matching lines @@
       methods: () => ({
         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$();
+  const _UnmodifiableMapMixin = _UnmodifiableMapMixin$();
   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$();
+  const UnmodifiableMapBase = UnmodifiableMapBase$();
   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;
       }
@@ skipping 24 matching lines @@
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'single',
       'last',
       'iterator'
     ]);
     return _MapBaseValueIterable;
   });
-  let _MapBaseValueIterable = _MapBaseValueIterable$();
+  const _MapBaseValueIterable = _MapBaseValueIterable$();
   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$();
+  const _MapBaseValueIterator = _MapBaseValueIterator$();
   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);
@@ skipping 55 matching lines @@
         clear: [dart.void, []],
         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$();
+  const MapView = MapView$();
   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$();
+  const UnmodifiableMapView = UnmodifiableMapView$();
   class Maps extends core.Object {
     static containsValue(map, value) {
       for (let v of map.values) {
         if (dart.equals(value, v)) {
           return true;
         }
       }
       return false;
     }
     static containsKey(map, key) {
@@ skipping 116 matching lines @@
     }
     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$();
+  const Queue = Queue$();
   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;
       }
@@ skipping 44 matching lines @@
         append: [dart.void, [E]],
         prepend: [dart.void, [E]],
         remove: [E, []],
         [_asNonSentinelEntry]: [DoubleLinkedQueueEntry$(E), []],
         previousEntry: [DoubleLinkedQueueEntry$(E), []],
         nextEntry: [DoubleLinkedQueueEntry$(E), []]
       })
     });
     return DoubleLinkedQueueEntry;
   });
-  let DoubleLinkedQueueEntry = DoubleLinkedQueueEntry$();
+  const DoubleLinkedQueueEntry = DoubleLinkedQueueEntry$();
   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$();
+  const _DoubleLinkedQueueEntrySentinel = _DoubleLinkedQueueEntrySentinel$();
   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))();
@@ skipping 140 matching lines @@
     dart.defineExtensionMembers(DoubleLinkedQueue, [
       'length',
       'first',
       'last',
       'single',
       'isEmpty',
       'iterator'
     ]);
     return DoubleLinkedQueue;
   });
-  let DoubleLinkedQueue = DoubleLinkedQueue$();
+  const DoubleLinkedQueue = DoubleLinkedQueue$();
   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$();
+  const _DoubleLinkedQueueIterator = _DoubleLinkedQueueIterator$();
   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');
@@ skipping 311 matching lines @@
       'toList',
       'iterator',
       'isEmpty',
       'length',
       'first',
       'last',
       'single'
     ]);
     return ListQueue;
   });
-  let ListQueue = ListQueue$();
+  const ListQueue = ListQueue$();
   ListQueue._INITIAL_CAPACITY = 8;
   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];
@@ skipping 14 matching lines @@
         return true;
       }
     }
     _ListQueueIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(_ListQueueIterator, {
       constructors: () => ({_ListQueueIterator: [_ListQueueIterator$(E), [ListQueue]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _ListQueueIterator;
   });
-  let _ListQueueIterator = _ListQueueIterator$();
+  const _ListQueueIterator = _ListQueueIterator$();
   const _Predicate$ = dart.generic(function(T) {
     const _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
     return _Predicate;
   });
-  let _Predicate = _Predicate$();
+  const _Predicate = _Predicate$();
   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$();
+  const _SplayTreeNode = _SplayTreeNode$();
   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$();
+  const _SplayTreeMapNode = _SplayTreeMapNode$();
   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');
@@ skipping 136 matching lines @@
         [_splay]: [core.int, [K]],
         [_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$();
+  const _SplayTree = _SplayTree$();
   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] = dart.as(isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, K), core.bool, [core.Object]), _Predicate$(core.Object));
         super._SplayTree();
@@ skipping 202 matching lines @@
         containsKey: [core.bool, [core.Object]],
         containsValue: [core.bool, [core.Object]],
         firstKey: [K, []],
         lastKey: [K, []],
         lastKeyBefore: [K, [K]],
         firstKeyAfter: [K, [K]]
       })
     });
     return SplayTreeMap;
   });
-  let SplayTreeMap = SplayTreeMap$();
+  const SplayTreeMap = SplayTreeMap$();
   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);
@@ skipping 63 matching lines @@
         startAt: [_SplayTreeIterator$(T), [_SplayTree, dart.dynamic]]
       }),
       methods: () => ({
         [_findLeftMostDescendent]: [dart.void, [_SplayTreeNode]],
         [_rebuildWorkList]: [dart.void, [_SplayTreeNode]],
         moveNext: [core.bool, []]
       })
     });
     return _SplayTreeIterator;
   });
-  let _SplayTreeIterator = _SplayTreeIterator$();
+  const _SplayTreeIterator = _SplayTreeIterator$();
   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];
       }
@@ skipping 12 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$();
+  const _SplayTreeKeyIterable = _SplayTreeKeyIterable$();
   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$();
+  const _SplayTreeValueIterable = _SplayTreeValueIterable$();
   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$();
+  const _SplayTreeKeyIterator = _SplayTreeKeyIterator$();
   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$();
+  const _SplayTreeValueIterator = _SplayTreeValueIterator$();
   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$();
+  const _SplayTreeNodeIterator = _SplayTreeNodeIterator$();
   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] = dart.as(isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, E), core.bool, [core.Object]), _Predicate$(core.Object));
         super._SplayTree();
       }
@@ skipping 155 matching lines @@
       'iterator',
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last',
       'single'
     ]);
     return SplayTreeSet;
   });
-  let SplayTreeSet = SplayTreeSet$();
+  const SplayTreeSet = SplayTreeSet$();
   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');
@@ skipping 290 matching lines @@
         _hasTableEntry: [core.bool, [dart.dynamic, dart.dynamic]],
         _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$();
+  const _HashMap = _HashMap$();
   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$();
+  const _IdentityHashMap = _IdentityHashMap$();
   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] = dart.as(validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [core.Object]), _Predicate$(core.Object));
         super._HashMap();
       }
@@ skipping 33 matching lines @@
     dart.setSignature(_CustomHashMap, {
       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$();
+  const _CustomHashMap = _CustomHashMap$();
   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() {
@@ skipping 23 matching lines @@
     });
     dart.defineExtensionMembers(HashMapKeyIterable, [
       'contains',
       'forEach',
       'length',
       'isEmpty',
       'iterator'
     ]);
     return HashMapKeyIterable;
   });
-  let HashMapKeyIterable = HashMapKeyIterable$();
+  const HashMapKeyIterable = HashMapKeyIterable$();
   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() {
@@ skipping 14 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$();
+  const HashMapKeyIterator = HashMapKeyIterator$();
   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;
@@ skipping 286 matching lines @@
         _isNumericKey: [core.bool, [dart.dynamic]],
         _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$();
+  const _LinkedHashMap = _LinkedHashMap$();
   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$();
+  const _LinkedIdentityHashMap = _LinkedIdentityHashMap$();
   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] = dart.as(validKey != null ? validKey : dart.fn(v => dart.is(v, K), core.bool, [core.Object]), _Predicate$(core.Object));
         super._LinkedHashMap();
       }
       get(key) {
         if (!dart.notNull(this[_validKey](key))) return null;
@@ skipping 29 matching lines @@
     dart.setSignature(_LinkedCustomHashMap, {
       constructors: () => ({_LinkedCustomHashMap: [_LinkedCustomHashMap$(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 _LinkedCustomHashMap;
   });
-  let _LinkedCustomHashMap = _LinkedCustomHashMap$();
+  const _LinkedCustomHashMap = _LinkedCustomHashMap$();
   class LinkedHashMapCell extends core.Object {
     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]]})
@@ skipping 36 matching lines @@
     });
     dart.defineExtensionMembers(LinkedHashMapKeyIterable, [
       'contains',
       'forEach',
       'length',
       'isEmpty',
       'iterator'
     ]);
     return LinkedHashMapKeyIterable;
   });
-  let LinkedHashMapKeyIterable = LinkedHashMapKeyIterable$();
+  const LinkedHashMapKeyIterable = LinkedHashMapKeyIterable$();
   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);
       }
@@ skipping 13 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$();
+  const LinkedHashMapKeyIterator = LinkedHashMapKeyIterator$();
   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;
@@ skipping 241 matching lines @@
     });
     dart.defineExtensionMembers(_HashSet, [
       'contains',
       'iterator',
       'length',
       'isEmpty',
       'isNotEmpty'
     ]);
     return _HashSet;
   });
-  let _HashSet = _HashSet$();
+  const _HashSet = _HashSet$();
   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$();
+  const _IdentityHashSet = _IdentityHashSet$();
   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] = dart.as(validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [core.Object]), _Predicate$(core.Object));
         super._HashSet();
       }
@@ skipping 32 matching lines @@
       constructors: () => ({_CustomHashSet: [_CustomHashSet$(E), [_Equality$(E), _Hasher$(E), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         [_newSet]: [core.Set$(E), []],
         add: [core.bool, [E]],
         lookup: [E, [core.Object]]
       })
     });
     dart.defineExtensionMembers(_CustomHashSet, ['contains']);
     return _CustomHashSet;
   });
-  let _CustomHashSet = _CustomHashSet$();
+  const _CustomHashSet = _CustomHashSet$();
   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$();
+  const HashSetIterator = HashSetIterator$();
   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;
@@ skipping 285 matching lines @@
       'forEach',
       'iterator',
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'last'
     ]);
     return _LinkedHashSet;
   });
-  let _LinkedHashSet = _LinkedHashSet$();
+  const _LinkedHashSet = _LinkedHashSet$();
   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$();
+  const _LinkedIdentityHashSet = _LinkedIdentityHashSet$();
   const _LinkedCustomHashSet$ = dart.generic(function(E) {
     class _LinkedCustomHashSet extends _LinkedHashSet$(E) {
       _LinkedCustomHashSet(equality, hasher, validKey) {
         this[_equality] = equality;
         this[_hasher] = hasher;
         this[_validKey] = dart.as(validKey != null ? validKey : dart.fn(x => dart.is(x, E), core.bool, [core.Object]), _Predicate$(core.Object));
         super._LinkedHashSet();
       }
       [_newSet]() {
         return new (_LinkedCustomHashSet$(E))(this[_equality], this[_hasher], this[_validKey]);
@@ skipping 44 matching lines @@
       constructors: () => ({_LinkedCustomHashSet: [_LinkedCustomHashSet$(E), [_Equality$(E), _Hasher$(E), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         [_newSet]: [core.Set$(E), []],
         add: [core.bool, [E]],
         lookup: [E, [core.Object]]
       })
     });
     dart.defineExtensionMembers(_LinkedCustomHashSet, ['contains']);
     return _LinkedCustomHashSet;
   });
-  let _LinkedCustomHashSet = _LinkedCustomHashSet$();
+  const _LinkedCustomHashSet = _LinkedCustomHashSet$();
   class LinkedHashSetCell extends core.Object {
     LinkedHashSetCell(element) {
       this[_element] = element;
       this[_next] = null;
       this[_previous] = null;
     }
   }
   dart.setSignature(LinkedHashSetCell, {
     constructors: () => ({LinkedHashSetCell: [LinkedHashSetCell, [dart.dynamic]]})
   });
@@ skipping 22 matching lines @@
         }
       }
     }
     LinkedHashSetIterator[dart.implements] = () => [core.Iterator$(E)];
     dart.setSignature(LinkedHashSetIterator, {
       constructors: () => ({LinkedHashSetIterator: [LinkedHashSetIterator$(E), [dart.dynamic, core.int]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return LinkedHashSetIterator;
   });
-  let LinkedHashSetIterator = LinkedHashSetIterator$();
+  const LinkedHashSetIterator = LinkedHashSetIterator$();
   // Exports:
   exports.UnmodifiableListView$ = UnmodifiableListView$;
   exports.HashMap$ = HashMap$;
   exports.HashMap = HashMap;
   exports.SetMixin$ = SetMixin$;
   exports.SetMixin = SetMixin;
   exports.SetBase$ = SetBase$;
   exports.SetBase = SetBase;
   exports.HashSet$ = HashSet$;
   exports.HashSet = HashSet;
@@ skipping 46 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;
 });