fixes #131, use before define from variables to classes

lib/runtime/dart/collection.js

 var collection = dart.defineLibrary(collection, {});
 var _internal = dart.lazyImport(_internal);
 var core = dart.import(core);
 var _js_helper = dart.lazyImport(_js_helper);
 var math = dart.lazyImport(math);
 (function(exports, _internal, core, _js_helper, math) {
   'use strict';
   let _source = Symbol('_source');
   let UnmodifiableListView$ = dart.generic(function(E) {
     class UnmodifiableListView extends _internal.UnmodifiableListBase$(E) {
@@ skipping 12 matching lines @@
   dart.defineLazyClassGeneric(exports, 'UnmodifiableListView', {get: UnmodifiableListView$});
   // Function _defaultEquals: (Object, Object) → bool
   function _defaultEquals(a, b) {
     return dart.equals(a, b);
   }
   // Function _defaultHashCode: (Object) → int
   function _defaultHashCode(a) {
     return dart.hashCode(a);
   }
   let _Equality$ = dart.generic(function(K) {
-    let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [K, K]));
+    let _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]));
+    let _Hasher = dart.typedef('_Hasher', dart.functionType(core.int, [K]));
     return _Hasher;
   });
   let _Hasher = _Hasher$();
   let HashMap$ = dart.generic(function(K, V) {
     class HashMap extends core.Object {
       HashMap(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 44 matching lines @@
       }
     }
     HashMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(HashMap, 'identity');
     dart.defineNamedConstructor(HashMap, 'from');
     dart.defineNamedConstructor(HashMap, 'fromIterable');
     dart.defineNamedConstructor(HashMap, 'fromIterables');
     return HashMap;
   });
   let HashMap = HashMap$();
-  let _newSet = Symbol('_newSet');
   let SetMixin$ = dart.generic(function(E) {
     class SetMixin extends core.Object {
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
       get [core.$isEmpty]() {
         return this[core.$length] == 0;
       }
       get [core.$isNotEmpty]() {
         return this[core.$length] != 0;
@@ skipping 262 matching lines @@
   let SetMixin = SetMixin$();
   let SetBase$ = dart.generic(function(E) {
     class SetBase extends SetMixin$(E) {
       static setToString(set) {
         return IterableBase.iterableToFullString(set, '{', '}');
       }
     }
     return SetBase;
   });
   let SetBase = SetBase$();
+  let _newSet = Symbol('_newSet');
   let _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[core.$contains](element)))
             result.add(element);
         }
         return result;
       }
@@ skipping 478 matching lines @@
         core.RangeError.checkNotNegative(index, "index");
         let elementIndex = 0;
         for (let element of this) {
           if (index == elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
         throw new core.RangeError.index(index, this, "index", null, elementIndex);
       }
       toString() {
-        return IterableBase.iterableToShortString(this, '(', ')');
+        return IterableBase$().iterableToShortString(this, '(', ')');
       }
       static iterableToShortString(iterable, leftDelimiter, rightDelimiter) {
         if (leftDelimiter === void 0)
           leftDelimiter = '(';
         if (rightDelimiter === void 0)
           rightDelimiter = ')';
-        if (IterableBase._isToStringVisiting(iterable)) {
+        if (IterableBase$()._isToStringVisiting(iterable)) {
           if (leftDelimiter == "(" && rightDelimiter == ")") {
             return "(...)";
           }
           return `${leftDelimiter}...${rightDelimiter}`;
         }
         let parts = [];
-        IterableBase._toStringVisiting[core.$add](iterable);
+        IterableBase$()._toStringVisiting[core.$add](iterable);
         try {
-          IterableBase._iterablePartsToStrings(iterable, parts);
+          IterableBase$()._iterablePartsToStrings(iterable, parts);
         } finally {
-          dart.assert(core.identical(IterableBase._toStringVisiting[core.$last], iterable));
-          IterableBase._toStringVisiting[core.$removeLast]();
+          dart.assert(core.identical(IterableBase$()._toStringVisiting[core.$last], iterable));
+          IterableBase$()._toStringVisiting[core.$removeLast]();
         }
         return dart.toString((() => {
           let _ = new core.StringBuffer(leftDelimiter);
           _.writeAll(parts, ", ");
           _.write(rightDelimiter);
           return _;
         })());
       }
       static iterableToFullString(iterable, leftDelimiter, rightDelimiter) {
         if (leftDelimiter === void 0)
           leftDelimiter = '(';
         if (rightDelimiter === void 0)
           rightDelimiter = ')';
-        if (IterableBase._isToStringVisiting(iterable)) {
+        if (IterableBase$()._isToStringVisiting(iterable)) {
           return `${leftDelimiter}...${rightDelimiter}`;
         }
         let buffer = new core.StringBuffer(leftDelimiter);
-        IterableBase._toStringVisiting[core.$add](iterable);
+        IterableBase$()._toStringVisiting[core.$add](iterable);
         try {
           buffer.writeAll(iterable, ", ");
         } finally {
-          dart.assert(core.identical(IterableBase._toStringVisiting[core.$last], iterable));
-          IterableBase._toStringVisiting[core.$removeLast]();
+          dart.assert(core.identical(IterableBase$()._toStringVisiting[core.$last], iterable));
+          IterableBase$()._toStringVisiting[core.$removeLast]();
         }
         buffer.write(rightDelimiter);
         return dart.toString(buffer);
       }
       static _isToStringVisiting(o) {
-        for (let i = 0; dart.notNull(i) < dart.notNull(IterableBase._toStringVisiting[core.$length]); i = dart.notNull(i) + 1) {
-          if (core.identical(o, IterableBase._toStringVisiting[core.$get](i)))
+        for (let i = 0; dart.notNull(i) < dart.notNull(IterableBase$()._toStringVisiting[core.$length]); i = dart.notNull(i) + 1) {
+          if (core.identical(o, IterableBase$()._toStringVisiting[core.$get](i)))
             return true;
         }
         return false;
       }
       static _iterablePartsToStrings(iterable, parts) {
         let LENGTH_LIMIT = 80;
         let HEAD_COUNT = 3;
         let TAIL_COUNT = 2;
         let MAX_COUNT = 100;
         let OVERHEAD = 2;
@@ skipping 67 matching lines @@
           parts[core.$add](elision);
         }
         parts[core.$add](penultimateString);
         parts[core.$add](ultimateString);
       }
       [Symbol.iterator]() {
         return new dart.JsIterator(this[core.$iterator]);
       }
     }
     IterableBase[dart.implements] = () => [core.Iterable$(E)];
-    dart.defineLazyProperties(IterableBase, {
-      get _toStringVisiting() {
-        return [];
-      }
-    });
     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) {
     class HasNextIterator extends core.Object {
       HasNextIterator(iterator) {
         this[_iterator] = iterator;
-        this[_state] = HasNextIterator._NOT_MOVED_YET;
+        this[_state] = HasNextIterator$()._NOT_MOVED_YET;

[Jennifer Messerly, 2015/05/12 16:23:45]

this is needed to use the dynamic instantiation for statics consistently.
we were previously broken on static fields: we had different slots for
HasNextIterator<T>._NOT_MOVED_YET, for each T. That's fine if it's final
(although you could observe lazy-init happening more than once), but mutable
static fields in a generic were broken.

       }
       get hasNext() {
-        if (this[_state] == HasNextIterator._NOT_MOVED_YET)
+        if (this[_state] == HasNextIterator$()._NOT_MOVED_YET)
           this[_move]();
-        return this[_state] == HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT;
+        return this[_state] == HasNextIterator$()._HAS_NEXT_AND_NEXT_IN_CURRENT;
       }
       next() {
         if (!dart.notNull(this.hasNext))
           throw new core.StateError("No more elements");
-        dart.assert(this[_state] == HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT);
+        dart.assert(this[_state] == HasNextIterator$()._HAS_NEXT_AND_NEXT_IN_CURRENT);
         let result = dart.as(this[_iterator].current, E);
         this[_move]();
         return result;
       }
       [_move]() {
         if (this[_iterator].moveNext()) {
-          this[_state] = HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT;
+          this[_state] = HasNextIterator$()._HAS_NEXT_AND_NEXT_IN_CURRENT;
         } else {
-          this[_state] = HasNextIterator._NO_NEXT;
+          this[_state] = HasNextIterator$()._NO_NEXT;
         }
       }
     }
-    HasNextIterator._HAS_NEXT_AND_NEXT_IN_CURRENT = 0;
-    HasNextIterator._NO_NEXT = 1;
-    HasNextIterator._NOT_MOVED_YET = 2;
     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) {
     class LinkedHashMap extends core.Object {
       LinkedHashMap(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 535 matching lines @@
           if (dart.equals(this[core.$get](i), element)) {
             this[core.$setRange](i, dart.notNull(this[core.$length]) - 1, this, dart.notNull(i) + 1);
             this[core.$length] = dart.notNull(this[core.$length]) - 1;
             return true;
           }
         }
         return false;
       }
       [core.$removeWhere](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
-        ListMixin._filter(this, test, false);
+        ListMixin$()._filter(this, test, false);
       }
       [core.$retainWhere](test) {
         dart.as(test, dart.functionType(core.bool, [E]));
-        ListMixin._filter(this, test, true);
+        ListMixin$()._filter(this, test, true);
       }
       static _filter(source, test, retainMatching) {
         dart.as(test, dart.functionType(core.bool, [dart.dynamic]));
         let retained = [];
         let length = source[core.$length];
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = source[core.$get](i);
           if (dart.dcall(test, element) == retainMatching) {
             retained[core.$add](element);
           }
@@ skipping 806 matching lines @@
   let 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)) {
-          initialCapacity = ListQueue._INITIAL_CAPACITY;
-        } else if (!dart.notNull(ListQueue._isPowerOf2(initialCapacity))) {
-          initialCapacity = ListQueue._nextPowerOf2(initialCapacity);
+        if (initialCapacity == null || dart.notNull(initialCapacity) < dart.notNull(ListQueue$()._INITIAL_CAPACITY)) {
+          initialCapacity = ListQueue$()._INITIAL_CAPACITY;
+        } else if (!dart.notNull(ListQueue$()._isPowerOf2(initialCapacity))) {
+          initialCapacity = ListQueue$()._nextPowerOf2(initialCapacity);
         }
-        dart.assert(ListQueue._isPowerOf2(initialCapacity));
+        dart.assert(ListQueue$()._isPowerOf2(initialCapacity));
         this[_table] = new (core.List$(E))(initialCapacity);
       }
       from(elements) {
         if (dart.is(elements, core.List)) {
           let length = elements[core.$length];
           let queue = new (ListQueue$(E))(dart.notNull(length) + 1);
           dart.assert(dart.notNull(queue[_table][core.$length]) > dart.notNull(length));
           let sourceList = elements;
           queue[_table][core.$setRange](0, length, dart.as(sourceList, core.Iterable$(E)), 0);
           queue[_tail] = length;
           return queue;
         } else {
-          let capacity = ListQueue._INITIAL_CAPACITY;
+          let capacity = ListQueue$()._INITIAL_CAPACITY;
           if (dart.is(elements, _internal.EfficientLength)) {
             capacity = elements[core.$length];
           }
           let result = new (ListQueue$(E))(capacity);
           for (let element of dart.as(elements, core.Iterable$(E))) {
             result.addLast(element);
           }
           return result;
         }
       }
@@ skipping 228 matching lines @@
         } else {
           let firstPartSize = dart.notNull(this[_table][core.$length]) - dart.notNull(this[_head]);
           target[core.$setRange](0, firstPartSize, this[_table], this[_head]);
           target[core.$setRange](firstPartSize, dart.notNull(firstPartSize) + dart.notNull(this[_tail]), this[_table], 0);
           return dart.notNull(this[_tail]) + dart.notNull(firstPartSize);
         }
       }
       [_preGrow](newElementCount) {
         dart.assert(dart.notNull(newElementCount) >= dart.notNull(this[core.$length]));
         newElementCount = dart.notNull(newElementCount) + (dart.notNull(newElementCount) >> 1);
-        let newCapacity = ListQueue._nextPowerOf2(newElementCount);
+        let newCapacity = ListQueue$()._nextPowerOf2(newElementCount);
         let newTable = new (core.List$(E))(newCapacity);
         this[_tail] = this[_writeToList](newTable);
         this[_table] = newTable;
         this[_head] = 0;
       }
     }
     ListQueue[dart.implements] = () => [Queue$(E)];
     dart.defineNamedConstructor(ListQueue, 'from');
-    ListQueue._INITIAL_CAPACITY = 8;
     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) {
     class _ListQueueIterator extends core.Object {
       _ListQueueIterator(queue) {
         this[_queue] = queue;
         this[_end] = queue[_tail];
         this[_modificationCount] = queue[_modificationCount];
         this[_position] = queue[_head];
@@ skipping 11 matching lines @@
         this[_current] = dart.as(this[_queue][_table][core.$get](this[_position]), E);
         this[_position] = dart.notNull(this[_position]) + 1 & dart.notNull(this[_queue][_table][core.$length]) - 1;
         return true;
       }
     }
     _ListQueueIterator[dart.implements] = () => [core.Iterator$(E)];
     return _ListQueueIterator;
   });
   let _ListQueueIterator = _ListQueueIterator$();
   let _Predicate$ = dart.generic(function(T) {
-    let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
+    let _Predicate = dart.typedef('_Predicate', dart.functionType(core.bool, [T]));
     return _Predicate;
   });
   let _Predicate = _Predicate$();
   let _SplayTreeNode$ = dart.generic(function(K) {
     class _SplayTreeNode extends core.Object {
       _SplayTreeNode(key) {
         this.key = key;
         this.left = null;
         this.right = null;
       }
@@ skipping 709 matching lines @@
       }
       toString() {
         return IterableBase.iterableToFullString(this, '{', '}');
       }
     }
     dart.defineNamedConstructor(SplayTreeSet, 'from');
     return SplayTreeSet;
   });
   let SplayTreeSet = SplayTreeSet$();
   let __CastType0$ = dart.generic(function(K) {
-    let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.int, [K, K]));
+    let __CastType0 = dart.typedef('__CastType0', dart.functionType(core.int, [K, K]));
     return __CastType0;
   });
   let __CastType0 = __CastType0$();
-  let __CastType3 = dart.typedef('__CastType3', () => dart.functionType(core.bool, [core.Object]));
+  let __CastType3 = dart.typedef('__CastType3', dart.functionType(core.bool, [core.Object]));
   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');
@@ skipping 17 matching lines @@
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new (HashMapKeyIterable$(K))(this);
       }
       get values() {
         return new (_internal.MappedIterable$(K, V))(this.keys, (each => this.get(each)).bind(this));
       }
       containsKey(key) {
-        if (_HashMap._isStringKey(key)) {
+        if (_HashMap$()._isStringKey(key)) {
           let strings = this[_strings];
-          return strings == null ? false : _HashMap._hasTableEntry(strings, key);
-        } else if (_HashMap._isNumericKey(key)) {
+          return strings == null ? false : _HashMap$()._hasTableEntry(strings, key);
+        } else if (_HashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
-          return nums == null ? false : _HashMap._hasTableEntry(nums, key);
+          return nums == null ? false : _HashMap$()._hasTableEntry(nums, key);
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
         return this[_computeKeys]()[core.$any]((each => dart.equals(this.get(each), value)).bind(this));
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
         other.forEach(((key, value) => {
           dart.as(key, K);
           dart.as(value, V);
           this.set(key, value);
         }).bind(this));
       }
       get(key) {
-        if (_HashMap._isStringKey(key)) {
+        if (_HashMap$()._isStringKey(key)) {
           let strings = this[_strings];
-          return strings == null ? null : dart.as(_HashMap._getTableEntry(strings, key), V);
-        } else if (_HashMap._isNumericKey(key)) {
+          return strings == null ? null : dart.as(_HashMap$()._getTableEntry(strings, key), V);
+        } else if (_HashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
-          return nums == null ? null : dart.as(_HashMap._getTableEntry(nums, key), V);
+          return nums == null ? null : dart.as(_HashMap$()._getTableEntry(nums, key), V);
         } else {
           return this[_get](key);
         }
       }
       [_get](key) {
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         return dart.notNull(index) < 0 ? null : dart.as(bucket[dart.notNull(index) + 1], V);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
-        if (_HashMap._isStringKey(key)) {
+        if (_HashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
-            this[_strings] = strings = _HashMap._newHashTable();
+            this[_strings] = strings = _HashMap$()._newHashTable();
           this[_addHashTableEntry](strings, key, value);
-        } else if (_HashMap._isNumericKey(key)) {
+        } else if (_HashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           if (nums == null)
-            this[_nums] = nums = _HashMap._newHashTable();
+            this[_nums] = nums = _HashMap$()._newHashTable();
           this[_addHashTableEntry](nums, key, value);
         } else {
           this[_set](key, value);
         }
       }
       [_set](key, value) {
         dart.as(key, K);
         dart.as(value, V);
         let rest = this[_rest];
         if (rest == null)
-          this[_rest] = rest = _HashMap._newHashTable();
+          this[_rest] = rest = _HashMap$()._newHashTable();
         let hash = this[_computeHashCode](key);
         let bucket = rest[hash];
         if (bucket == null) {
-          _HashMap._setTableEntry(rest, hash, [key, value]);
+          _HashMap$()._setTableEntry(rest, hash, [key, value]);
           this[_length] = dart.notNull(this[_length]) + 1;
           this[_keys] = null;
         } else {
           let index = this[_findBucketIndex](bucket, key);
           if (dart.notNull(index) >= 0) {
             bucket[dart.notNull(index) + 1] = value;
           } else {
             bucket.push(key, value);
             this[_length] = dart.notNull(this[_length]) + 1;
             this[_keys] = null;
           }
         }
       }
       putIfAbsent(key, ifAbsent) {
         dart.as(key, K);
         dart.as(ifAbsent, dart.functionType(V, []));
         if (this.containsKey(key))
           return this.get(key);
         let value = ifAbsent();
         this.set(key, value);
         return value;
       }
       remove(key) {
-        if (_HashMap._isStringKey(key)) {
+        if (_HashMap$()._isStringKey(key)) {
           return this[_removeHashTableEntry](this[_strings], key);
-        } else if (_HashMap._isNumericKey(key)) {
+        } else if (_HashMap$()._isNumericKey(key)) {
           return this[_removeHashTableEntry](this[_nums], key);
         } else {
           return this[_remove](key);
         }
       }
       [_remove](key) {
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, key);
@@ skipping 60 matching lines @@
               index = dart.notNull(index) + 1;
             }
           }
         }
         dart.assert(index == this[_length]);
         return this[_keys] = result;
       }
       [_addHashTableEntry](table, key, value) {
         dart.as(key, K);
         dart.as(value, V);
-        if (!dart.notNull(_HashMap._hasTableEntry(table, key))) {
+        if (!dart.notNull(_HashMap$()._hasTableEntry(table, key))) {
           this[_length] = dart.notNull(this[_length]) + 1;
           this[_keys] = null;
         }
-        _HashMap._setTableEntry(table, key, value);
+        _HashMap$()._setTableEntry(table, key, value);
       }
       [_removeHashTableEntry](table, key) {
-        if (dart.notNull(table != null) && dart.notNull(_HashMap._hasTableEntry(table, key))) {
-          let value = dart.as(_HashMap._getTableEntry(table, key), V);
-          _HashMap._deleteTableEntry(table, key);
+        if (dart.notNull(table != null) && dart.notNull(_HashMap$()._hasTableEntry(table, key))) {
+          let value = dart.as(_HashMap$()._getTableEntry(table, key), V);
+          _HashMap$()._deleteTableEntry(table, key);
           this[_length] = dart.notNull(this[_length]) - 1;
           this[_keys] = null;
           return value;
         } else {
           return null;
         }
       }
       static _isStringKey(key) {
         return typeof key == 'string' && dart.notNull(!dart.equals(key, '__proto__'));
       }
@@ skipping 31 matching lines @@
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 2) {
           if (dart.equals(bucket[i], key))
             return i;
         }
         return -1;
       }
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
-        _HashMap._setTableEntry(table, temporaryKey, table);
-        _HashMap._deleteTableEntry(table, temporaryKey);
+        _HashMap$()._setTableEntry(table, temporaryKey, table);
+        _HashMap$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     _HashMap[dart.implements] = () => [HashMap$(K, V)];
     return _HashMap;
   });
   let _HashMap = _HashMap$();
   let _IdentityHashMap$ = dart.generic(function(K, V) {
     class _IdentityHashMap extends _HashMap$(K, V) {
       _IdentityHashMap() {
@@ skipping 156 matching lines @@
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       get keys() {
         return new (LinkedHashMapKeyIterable$(K))(this);
       }
       get values() {
         return new (_internal.MappedIterable$(K, V))(this.keys, (each => this.get(each)).bind(this));
       }
       containsKey(key) {
-        if (_LinkedHashMap._isStringKey(key)) {
+        if (_LinkedHashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
             return false;
-          let cell = dart.as(_LinkedHashMap._getTableEntry(strings, key), LinkedHashMapCell);
+          let cell = dart.as(_LinkedHashMap$()._getTableEntry(strings, key), LinkedHashMapCell);
           return cell != null;
-        } else if (_LinkedHashMap._isNumericKey(key)) {
+        } else if (_LinkedHashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           if (nums == null)
             return false;
-          let cell = dart.as(_LinkedHashMap._getTableEntry(nums, key), LinkedHashMapCell);
+          let cell = dart.as(_LinkedHashMap$()._getTableEntry(nums, key), LinkedHashMapCell);
           return cell != null;
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
         return this.keys[core.$any]((each => dart.equals(this.get(each), value)).bind(this));
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
         other.forEach(((key, value) => {
           dart.as(key, K);
           dart.as(value, V);
           this.set(key, value);
         }).bind(this));
       }
       get(key) {
-        if (_LinkedHashMap._isStringKey(key)) {
+        if (_LinkedHashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
             return null;
-          let cell = dart.as(_LinkedHashMap._getTableEntry(strings, key), LinkedHashMapCell);
+          let cell = dart.as(_LinkedHashMap$()._getTableEntry(strings, key), LinkedHashMapCell);
           return cell == null ? null : dart.as(cell[_value], V);
-        } else if (_LinkedHashMap._isNumericKey(key)) {
+        } else if (_LinkedHashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           if (nums == null)
             return null;
-          let cell = dart.as(_LinkedHashMap._getTableEntry(nums, key), LinkedHashMapCell);
+          let cell = dart.as(_LinkedHashMap$()._getTableEntry(nums, key), LinkedHashMapCell);
           return cell == null ? null : dart.as(cell[_value], V);
         } else {
           return this[_get](key);
         }
       }
       [_get](key) {
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         if (dart.notNull(index) < 0)
           return null;
         let cell = dart.as(bucket[index], LinkedHashMapCell);
         return dart.as(cell[_value], V);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
-        if (_LinkedHashMap._isStringKey(key)) {
+        if (_LinkedHashMap$()._isStringKey(key)) {
           let strings = this[_strings];
           if (strings == null)
-            this[_strings] = strings = _LinkedHashMap._newHashTable();
+            this[_strings] = strings = _LinkedHashMap$()._newHashTable();
           this[_addHashTableEntry](strings, key, value);
-        } else if (_LinkedHashMap._isNumericKey(key)) {
+        } else if (_LinkedHashMap$()._isNumericKey(key)) {
           let nums = this[_nums];
           if (nums == null)
-            this[_nums] = nums = _LinkedHashMap._newHashTable();
+            this[_nums] = nums = _LinkedHashMap$()._newHashTable();
           this[_addHashTableEntry](nums, key, value);
         } else {
           this[_set](key, value);
         }
       }
       [_set](key, value) {
         dart.as(key, K);
         dart.as(value, V);
         let rest = this[_rest];
         if (rest == null)
-          this[_rest] = rest = _LinkedHashMap._newHashTable();
+          this[_rest] = rest = _LinkedHashMap$()._newHashTable();
         let hash = this[_computeHashCode](key);
         let bucket = rest[hash];
         if (bucket == null) {
           let cell = this[_newLinkedCell](key, value);
-          _LinkedHashMap._setTableEntry(rest, hash, [cell]);
+          _LinkedHashMap$()._setTableEntry(rest, hash, [cell]);
         } else {
           let index = this[_findBucketIndex](bucket, key);
           if (dart.notNull(index) >= 0) {
             let cell = dart.as(bucket[index], LinkedHashMapCell);
             cell[_value] = value;
           } else {
             let cell = this[_newLinkedCell](key, value);
             bucket.push(cell);
           }
         }
       }
       putIfAbsent(key, ifAbsent) {
         dart.as(key, K);
         dart.as(ifAbsent, dart.functionType(V, []));
         if (this.containsKey(key))
           return this.get(key);
         let value = ifAbsent();
         this.set(key, value);
         return value;
       }
       remove(key) {
-        if (_LinkedHashMap._isStringKey(key)) {
+        if (_LinkedHashMap$()._isStringKey(key)) {
           return this[_removeHashTableEntry](this[_strings], key);
-        } else if (_LinkedHashMap._isNumericKey(key)) {
+        } else if (_LinkedHashMap$()._isNumericKey(key)) {
           return this[_removeHashTableEntry](this[_nums], key);
         } else {
           return this[_remove](key);
         }
       }
       [_remove](key) {
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, key);
@@ skipping 19 matching lines @@
           action(dart.as(cell[_key], K), dart.as(cell[_value], V));
           if (modifications != this[_modifications]) {
             throw new core.ConcurrentModificationError(this);
           }
           cell = cell[_next];
         }
       }
       [_addHashTableEntry](table, key, value) {
         dart.as(key, K);
         dart.as(value, V);
-        let cell = dart.as(_LinkedHashMap._getTableEntry(table, key), LinkedHashMapCell);
+        let cell = dart.as(_LinkedHashMap$()._getTableEntry(table, key), LinkedHashMapCell);
         if (cell == null) {
-          _LinkedHashMap._setTableEntry(table, key, this[_newLinkedCell](key, value));
+          _LinkedHashMap$()._setTableEntry(table, key, this[_newLinkedCell](key, value));
         } else {
           cell[_value] = value;
         }
       }
       [_removeHashTableEntry](table, key) {
         if (table == null)
           return null;
-        let cell = dart.as(_LinkedHashMap._getTableEntry(table, key), LinkedHashMapCell);
+        let cell = dart.as(_LinkedHashMap$()._getTableEntry(table, key), LinkedHashMapCell);
         if (cell == null)
           return null;
         this[_unlinkCell](cell);
-        _LinkedHashMap._deleteTableEntry(table, key);
+        _LinkedHashMap$()._deleteTableEntry(table, key);
         return dart.as(cell[_value], V);
       }
       [_modified]() {
         this[_modifications] = dart.notNull(this[_modifications]) + 1 & 67108863;
       }
       [_newLinkedCell](key, value) {
         dart.as(key, K);
         dart.as(value, V);
         let cell = new LinkedHashMapCell(key, value);
         if (this[_first] == null) {
@@ skipping 55 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashMapCell);
           if (dart.equals(cell[_key], key))
             return i;
         }
         return -1;
       }
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
-        _LinkedHashMap._setTableEntry(table, temporaryKey, table);
-        _LinkedHashMap._deleteTableEntry(table, temporaryKey);
+        _LinkedHashMap$()._setTableEntry(table, temporaryKey, table);
+        _LinkedHashMap$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
       toString() {
         return Maps.mapToString(this);
       }
     }
     _LinkedHashMap[dart.implements] = () => [LinkedHashMap$(K, V), _js_helper.InternalMap];
     return _LinkedHashMap;
   });
   let _LinkedHashMap = _LinkedHashMap$();
@@ skipping 161 matching lines @@
       get [core.$length]() {
         return this[_length];
       }
       get [core.$isEmpty]() {
         return this[_length] == 0;
       }
       get [core.$isNotEmpty]() {
         return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$contains](object) {
-        if (_HashSet._isStringElement(object)) {
+        if (_HashSet$()._isStringElement(object)) {
           let strings = this[_strings];
-          return strings == null ? false : _HashSet._hasTableEntry(strings, object);
-        } else if (_HashSet._isNumericElement(object)) {
+          return strings == null ? false : _HashSet$()._hasTableEntry(strings, object);
+        } else if (_HashSet$()._isNumericElement(object)) {
           let nums = this[_nums];
-          return nums == null ? false : _HashSet._hasTableEntry(nums, object);
+          return nums == null ? false : _HashSet$()._hasTableEntry(nums, object);
         } else {
           return this[_contains](object);
         }
       }
       [_contains](object) {
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, object);
         return dart.notNull(this[_findBucketIndex](bucket, object)) >= 0;
       }
       lookup(object) {
-        if (dart.notNull(_HashSet._isStringElement(object)) || dart.notNull(_HashSet._isNumericElement(object))) {
+        if (dart.notNull(_HashSet$()._isStringElement(object)) || dart.notNull(_HashSet$()._isNumericElement(object))) {
           return dart.as(this[core.$contains](object) ? object : null, E);
         }
         return this[_lookup](object);
       }
       [_lookup](object) {
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, object);
         let index = this[_findBucketIndex](bucket, object);
         if (dart.notNull(index) < 0)
           return null;
         return dart.as(bucket[core.$get](index), E);
       }
       add(element) {
         dart.as(element, E);
-        if (_HashSet._isStringElement(element)) {
+        if (_HashSet$()._isStringElement(element)) {
           let strings = this[_strings];
           if (strings == null)
-            this[_strings] = strings = _HashSet._newHashTable();
+            this[_strings] = strings = _HashSet$()._newHashTable();
           return this[_addHashTableEntry](strings, element);
-        } else if (_HashSet._isNumericElement(element)) {
+        } else if (_HashSet$()._isNumericElement(element)) {
           let nums = this[_nums];
           if (nums == null)
-            this[_nums] = nums = _HashSet._newHashTable();
+            this[_nums] = nums = _HashSet$()._newHashTable();
           return this[_addHashTableEntry](nums, element);
         } else {
           return this[_add](element);
         }
       }
       [_add](element) {
         dart.as(element, E);
         let rest = this[_rest];
         if (rest == null)
-          this[_rest] = rest = _HashSet._newHashTable();
+          this[_rest] = rest = _HashSet$()._newHashTable();
         let hash = this[_computeHashCode](element);
         let bucket = rest[hash];
         if (bucket == null) {
-          _HashSet._setTableEntry(rest, hash, [element]);
+          _HashSet$()._setTableEntry(rest, hash, [element]);
         } else {
           let index = this[_findBucketIndex](bucket, element);
           if (dart.notNull(index) >= 0)
             return false;
           bucket.push(element);
         }
         this[_length] = dart.notNull(this[_length]) + 1;
         this[_elements] = null;
         return true;
       }
       addAll(objects) {
         dart.as(objects, core.Iterable$(E));
         for (let each of objects) {
           this.add(each);
         }
       }
       remove(object) {
-        if (_HashSet._isStringElement(object)) {
+        if (_HashSet$()._isStringElement(object)) {
           return this[_removeHashTableEntry](this[_strings], object);
-        } else if (_HashSet._isNumericElement(object)) {
+        } else if (_HashSet$()._isNumericElement(object)) {
           return this[_removeHashTableEntry](this[_nums], object);
         } else {
           return this[_remove](object);
         }
       }
       [_remove](object) {
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, object);
@@ skipping 48 matching lines @@
               result[index] = bucket[i];
               index = dart.notNull(index) + 1;
             }
           }
         }
         dart.assert(index == this[_length]);
         return this[_elements] = result;
       }
       [_addHashTableEntry](table, element) {
         dart.as(element, E);
-        if (_HashSet._hasTableEntry(table, element))
+        if (_HashSet$()._hasTableEntry(table, element))
           return false;
-        _HashSet._setTableEntry(table, element, 0);
+        _HashSet$()._setTableEntry(table, element, 0);
         this[_length] = dart.notNull(this[_length]) + 1;
         this[_elements] = null;
         return true;
       }
       [_removeHashTableEntry](table, element) {
-        if (dart.notNull(table != null) && dart.notNull(_HashSet._hasTableEntry(table, element))) {
-          _HashSet._deleteTableEntry(table, element);
+        if (dart.notNull(table != null) && dart.notNull(_HashSet$()._hasTableEntry(table, element))) {
+          _HashSet$()._deleteTableEntry(table, element);
           this[_length] = dart.notNull(this[_length]) - 1;
           this[_elements] = null;
           return true;
         } else {
           return false;
         }
       }
       static _isStringElement(element) {
         return typeof element == 'string' && dart.notNull(!dart.equals(element, '__proto__'));
       }
@@ skipping 24 matching lines @@
         let length = bucket.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           if (dart.equals(bucket[i], element))
             return i;
         }
         return -1;
       }
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
-        _HashSet._setTableEntry(table, temporaryKey, table);
-        _HashSet._deleteTableEntry(table, temporaryKey);
+        _HashSet$()._setTableEntry(table, temporaryKey, table);
+        _HashSet$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     _HashSet[dart.implements] = () => [HashSet$(E)];
     return _HashSet;
   });
   let _HashSet = _HashSet$();
   let _IdentityHashSet$ = dart.generic(function(E) {
     class _IdentityHashSet extends _HashSet$(E) {
       _IdentityHashSet() {
@@ skipping 122 matching lines @@
       get [core.$length]() {
         return this[_length];
       }
       get [core.$isEmpty]() {
         return this[_length] == 0;
       }
       get [core.$isNotEmpty]() {
         return !dart.notNull(this[core.$isEmpty]);
       }
       [core.$contains](object) {
-        if (_LinkedHashSet._isStringElement(object)) {
+        if (_LinkedHashSet$()._isStringElement(object)) {
           let strings = this[_strings];
           if (strings == null)
             return false;
-          let cell = dart.as(_LinkedHashSet._getTableEntry(strings, object), LinkedHashSetCell);
+          let cell = dart.as(_LinkedHashSet$()._getTableEntry(strings, object), LinkedHashSetCell);
           return cell != null;
-        } else if (_LinkedHashSet._isNumericElement(object)) {
+        } else if (_LinkedHashSet$()._isNumericElement(object)) {
           let nums = this[_nums];
           if (nums == null)
             return false;
-          let cell = dart.as(_LinkedHashSet._getTableEntry(nums, object), LinkedHashSetCell);
+          let cell = dart.as(_LinkedHashSet$()._getTableEntry(nums, object), LinkedHashSetCell);
           return cell != null;
         } else {
           return this[_contains](object);
         }
       }
       [_contains](object) {
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, object);
         return dart.notNull(this[_findBucketIndex](bucket, object)) >= 0;
       }
       lookup(object) {
-        if (dart.notNull(_LinkedHashSet._isStringElement(object)) || dart.notNull(_LinkedHashSet._isNumericElement(object))) {
+        if (dart.notNull(_LinkedHashSet$()._isStringElement(object)) || dart.notNull(_LinkedHashSet$()._isNumericElement(object))) {
           return dart.as(this[core.$contains](object) ? object : null, E);
         } else {
           return this[_lookup](object);
         }
       }
       [_lookup](object) {
         let rest = this[_rest];
         if (rest == null)
           return null;
         let bucket = this[_getBucket](rest, object);
@@ skipping 19 matching lines @@
           throw new core.StateError("No elements");
         return dart.as(this[_first][_element], E);
       }
       get [core.$last]() {
         if (this[_last] == null)
           throw new core.StateError("No elements");
         return dart.as(this[_last][_element], E);
       }
       add(element) {
         dart.as(element, E);
-        if (_LinkedHashSet._isStringElement(element)) {
+        if (_LinkedHashSet$()._isStringElement(element)) {
           let strings = this[_strings];
           if (strings == null)
-            this[_strings] = strings = _LinkedHashSet._newHashTable();
+            this[_strings] = strings = _LinkedHashSet$()._newHashTable();
           return this[_addHashTableEntry](strings, element);
-        } else if (_LinkedHashSet._isNumericElement(element)) {
+        } else if (_LinkedHashSet$()._isNumericElement(element)) {
           let nums = this[_nums];
           if (nums == null)
-            this[_nums] = nums = _LinkedHashSet._newHashTable();
+            this[_nums] = nums = _LinkedHashSet$()._newHashTable();
           return this[_addHashTableEntry](nums, element);
         } else {
           return this[_add](element);
         }
       }
       [_add](element) {
         dart.as(element, E);
         let rest = this[_rest];
         if (rest == null)
-          this[_rest] = rest = _LinkedHashSet._newHashTable();
+          this[_rest] = rest = _LinkedHashSet$()._newHashTable();
         let hash = this[_computeHashCode](element);
         let bucket = rest[hash];
         if (bucket == null) {
           let cell = this[_newLinkedCell](element);
-          _LinkedHashSet._setTableEntry(rest, hash, [cell]);
+          _LinkedHashSet$()._setTableEntry(rest, hash, [cell]);
         } else {
           let index = this[_findBucketIndex](bucket, element);
           if (dart.notNull(index) >= 0)
             return false;
           let cell = this[_newLinkedCell](element);
           bucket.push(cell);
         }
         return true;
       }
       remove(object) {
-        if (_LinkedHashSet._isStringElement(object)) {
+        if (_LinkedHashSet$()._isStringElement(object)) {
           return this[_removeHashTableEntry](this[_strings], object);
-        } else if (_LinkedHashSet._isNumericElement(object)) {
+        } else if (_LinkedHashSet$()._isNumericElement(object)) {
           return this[_removeHashTableEntry](this[_nums], object);
         } else {
           return this[_remove](object);
         }
       }
       [_remove](object) {
         let rest = this[_rest];
         if (rest == null)
           return false;
         let bucket = this[_getBucket](rest, object);
@@ skipping 30 matching lines @@
       }
       clear() {
         if (dart.notNull(this[_length]) > 0) {
           this[_strings] = this[_nums] = this[_rest] = this[_first] = this[_last] = null;
           this[_length] = 0;
           this[_modified]();
         }
       }
       [_addHashTableEntry](table, element) {
         dart.as(element, E);
-        let cell = dart.as(_LinkedHashSet._getTableEntry(table, element), LinkedHashSetCell);
+        let cell = dart.as(_LinkedHashSet$()._getTableEntry(table, element), LinkedHashSetCell);
         if (cell != null)
           return false;
-        _LinkedHashSet._setTableEntry(table, element, this[_newLinkedCell](element));
+        _LinkedHashSet$()._setTableEntry(table, element, this[_newLinkedCell](element));
         return true;
       }
       [_removeHashTableEntry](table, element) {
         if (table == null)
           return false;
-        let cell = dart.as(_LinkedHashSet._getTableEntry(table, element), LinkedHashSetCell);
+        let cell = dart.as(_LinkedHashSet$()._getTableEntry(table, element), LinkedHashSetCell);
         if (cell == null)
           return false;
         this[_unlinkCell](cell);
-        _LinkedHashSet._deleteTableEntry(table, element);
+        _LinkedHashSet$()._deleteTableEntry(table, element);
         return true;
       }
       [_modified]() {
         this[_modifications] = dart.notNull(this[_modifications]) + 1 & 67108863;
       }
       [_newLinkedCell](element) {
         dart.as(element, E);
         let cell = new LinkedHashSetCell(element);
         if (this[_first] == null) {
           this[_first] = this[_last] = cell;
@@ skipping 54 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let cell = dart.as(bucket[i], LinkedHashSetCell);
           if (dart.equals(cell[_element], element))
             return i;
         }
         return -1;
       }
       static _newHashTable() {
         let table = Object.create(null);
         let temporaryKey = '<non-identifier-key>';
-        _LinkedHashSet._setTableEntry(table, temporaryKey, table);
-        _LinkedHashSet._deleteTableEntry(table, temporaryKey);
+        _LinkedHashSet$()._setTableEntry(table, temporaryKey, table);
+        _LinkedHashSet$()._deleteTableEntry(table, temporaryKey);
         return table;
       }
     }
     _LinkedHashSet[dart.implements] = () => [LinkedHashSet$(E)];
     return _LinkedHashSet;
   });
   let _LinkedHashSet = _LinkedHashSet$();
   let _LinkedIdentityHashSet$ = dart.generic(function(E) {
     class _LinkedIdentityHashSet extends _LinkedHashSet$(E) {
       _LinkedIdentityHashSet() {
@@ skipping 115 matching lines @@
       }
     }
     LinkedHashSetIterator[dart.implements] = () => [core.Iterator$(E)];
     return LinkedHashSetIterator;
   });
   let 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.SetMixin$ = SetMixin$;
-  exports.SetMixin = SetMixin;
   exports.HashSet$ = HashSet$;
   exports.HashSet = HashSet;
   exports.IterableMixin$ = IterableMixin$;
   exports.IterableMixin = IterableMixin;
   exports.IterableBase$ = IterableBase$;
   exports.IterableBase = IterableBase;
   exports.HasNextIterator$ = HasNextIterator$;
   exports.HasNextIterator = HasNextIterator;
   exports.LinkedHashMap$ = LinkedHashMap$;
   exports.LinkedHashMap = LinkedHashMap;
   exports.LinkedHashSet$ = LinkedHashSet$;
   exports.LinkedHashSet = LinkedHashSet;
   exports.LinkedList$ = LinkedList$;
   exports.LinkedList = LinkedList;
   exports.LinkedListEntry$ = LinkedListEntry$;
   exports.LinkedListEntry = LinkedListEntry;
+  exports.ListMixin$ = ListMixin$;
+  exports.ListMixin = ListMixin;
   exports.ListBase$ = ListBase$;
   exports.ListBase = ListBase;
-  exports.ListMixin$ = ListMixin$;
-  exports.ListMixin = ListMixin;
+  exports.MapMixin$ = MapMixin$;
+  exports.MapMixin = MapMixin;
   exports.MapBase$ = MapBase$;
   exports.MapBase = MapBase;
-  exports.MapMixin$ = MapMixin$;
-  exports.MapMixin = MapMixin;
   exports.UnmodifiableMapBase$ = UnmodifiableMapBase$;
   exports.UnmodifiableMapBase = UnmodifiableMapBase;
   exports.MapView$ = MapView$;
   exports.MapView = MapView;
   exports.UnmodifiableMapView$ = UnmodifiableMapView$;
   exports.UnmodifiableMapView = UnmodifiableMapView;
   exports.Maps = Maps;
   exports.Queue$ = Queue$;
   exports.Queue = Queue;
   exports.DoubleLinkedQueueEntry$ = DoubleLinkedQueueEntry$;
@@ skipping 14 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;
 })(collection, _internal, core, _js_helper, math);