implement mixins in subtype checks, more codegen fixes

lib/runtime/dart/_internal.js

 var _internal;
 (function(exports) {
   'use strict';
-  class EfficientLength extends core.Object {
-  }
+  class EfficientLength extends core.Object {}
   let ListIterable$ = dart.generic(function(E) {
     class ListIterable extends collection.IterableBase$(E) {
       ListIterable() {
         super.IterableBase();
       }
       get iterator() {
         return new (ListIterator$(E))(this);
       }
       forEach(action) {
         let length = this.length;
@@ skipping 201 matching lines @@
         let result = new (core.Set$(E))();
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           result.add(this.elementAt(i));
         }
         return result;
       }
     }
     ListIterable[dart.implements] = () => [EfficientLength];
     return ListIterable;
   });
-  let ListIterable = ListIterable$(dart.dynamic);
+  let ListIterable = ListIterable$();
   let _iterable = dart.JsSymbol('_iterable');
   let _start = dart.JsSymbol('_start');
   let _endOrLength = dart.JsSymbol('_endOrLength');
   let _endIndex = dart.JsSymbol('_endIndex');
   let _startIndex = dart.JsSymbol('_startIndex');
   let SubListIterable$ = dart.generic(function(E) {
     class SubListIterable extends ListIterable$(E) {
       SubListIterable(iterable$, start$, endOrLength) {
         this[_iterable] = iterable$;
         this[_start] = start$;
@@ skipping 70 matching lines @@
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           result.set(i, this[_iterable].elementAt(dart.notNull(start) + dart.notNull(i)));
           if (dart.notNull(this[_iterable].length) < dart.notNull(end))
             throw new core.ConcurrentModificationError(this);
         }
         return dart.as(result, core.List$(E));
       }
     }
     return SubListIterable;
   });
-  let SubListIterable = SubListIterable$(dart.dynamic);
+  let SubListIterable = SubListIterable$();
   let _length = dart.JsSymbol('_length');
   let _index = dart.JsSymbol('_index');
   let _current = dart.JsSymbol('_current');
   let ListIterator$ = dart.generic(function(E) {
     class ListIterator extends core.Object {
       ListIterator(iterable) {
         this[_iterable] = iterable;
         this[_length] = iterable.length;
         this[_index] = 0;
         this[_current] = null;
@@ skipping 11 matching lines @@
           return false;
         }
         this[_current] = this[_iterable].elementAt(this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
       }
     }
     ListIterator[dart.implements] = () => [core.Iterator$(E)];
     return ListIterator;
   });
-  let ListIterator = ListIterator$(dart.dynamic);
+  let ListIterator = ListIterator$();
+  let _Transformation$ = dart.generic(function(S, T) {
+    class _Transformation extends core.Function {}
+    return _Transformation;
+  });
+  let _Transformation = _Transformation$();
   let _ = dart.JsSymbol('_');
   let _f = dart.JsSymbol('_f');
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       MappedIterable(iterable, func) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthMappedIterable$(S, T))(iterable, func);
         }
         return new MappedIterable$(S, T)[_](dart.as(iterable, core.Iterable$(S)), func);
       }
@@ skipping 20 matching lines @@
       get single() {
         return this[_f](this[_iterable].single);
       }
       elementAt(index) {
         return this[_f](this[_iterable].elementAt(index));
       }
     }
     dart.defineNamedConstructor(MappedIterable, _);
     return MappedIterable;
   });
-  let MappedIterable = MappedIterable$(dart.dynamic, dart.dynamic);
+  let MappedIterable = MappedIterable$();
   let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
     class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
       EfficientLengthMappedIterable(iterable, func) {
         super[_](dart.as(iterable, core.Iterable$(S)), func);
       }
     }
     EfficientLengthMappedIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthMappedIterable;
   });
-  let EfficientLengthMappedIterable = EfficientLengthMappedIterable$(dart.dynamic, dart.dynamic);
+  let EfficientLengthMappedIterable = EfficientLengthMappedIterable$();
   let _iterator = dart.JsSymbol('_iterator');
   let MappedIterator$ = dart.generic(function(S, T) {
     class MappedIterator extends core.Iterator$(T) {
       MappedIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
         this[_current] = null;
         super.Iterator();
       }
       moveNext() {
         if (this[_iterator].moveNext()) {
           this[_current] = this[_f](this[_iterator].current);
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     return MappedIterator;
   });
-  let MappedIterator = MappedIterator$(dart.dynamic, dart.dynamic);
+  let MappedIterator = MappedIterator$();
   let _source = dart.JsSymbol('_source');
   let MappedListIterable$ = dart.generic(function(S, T) {
     class MappedListIterable extends ListIterable$(T) {
       MappedListIterable(source, f$) {
         this[_source] = source;
         this[_f] = f$;
         super.ListIterable();
       }
       get length() {
         return this[_source].length;
       }
       elementAt(index) {
         return this[_f](this[_source].elementAt(index));
       }
     }
     MappedListIterable[dart.implements] = () => [EfficientLength];
     return MappedListIterable;
   });
-  let MappedListIterable = MappedListIterable$(dart.dynamic, dart.dynamic);
+  let MappedListIterable = MappedListIterable$();
+  let _ElementPredicate$ = dart.generic(function(E) {
+    class _ElementPredicate extends core.Function {}
+    return _ElementPredicate;
+  });
+  let _ElementPredicate = _ElementPredicate$();
   let WhereIterable$ = dart.generic(function(E) {
     class WhereIterable extends collection.IterableBase$(E) {
       WhereIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get iterator() {
         return new (WhereIterator$(E))(this[_iterable].iterator, this[_f]);
       }
     }
     return WhereIterable;
   });
-  let WhereIterable = WhereIterable$(dart.dynamic);
+  let WhereIterable = WhereIterable$();
   let WhereIterator$ = dart.generic(function(E) {
     class WhereIterator extends core.Iterator$(E) {
       WhereIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
         super.Iterator();
       }
       moveNext() {
         while (this[_iterator].moveNext()) {
           if (this[_f](this[_iterator].current)) {
             return true;
           }
         }
         return false;
       }
       get current() {
         return this[_iterator].current;
       }
     }
     return WhereIterator;
   });
-  let WhereIterator = WhereIterator$(dart.dynamic);
+  let WhereIterator = WhereIterator$();
+  let _ExpandFunction$ = dart.generic(function(S, T) {
+    class _ExpandFunction extends core.Function {}
+    return _ExpandFunction;
+  });
+  let _ExpandFunction = _ExpandFunction$();
   let ExpandIterable$ = dart.generic(function(S, T) {
     class ExpandIterable extends collection.IterableBase$(T) {
       ExpandIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get iterator() {
         return new (ExpandIterator$(S, T))(this[_iterable].iterator, dart.closureWrap(this[_f], "(S) → Iterable<T>"));
       }
     }
     return ExpandIterable;
   });
-  let ExpandIterable = ExpandIterable$(dart.dynamic, dart.dynamic);
+  let ExpandIterable = ExpandIterable$();
   let _currentExpansion = dart.JsSymbol('_currentExpansion');
   let _nextExpansion = dart.JsSymbol('_nextExpansion');
   let ExpandIterator$ = dart.generic(function(S, T) {
     class ExpandIterator extends core.Object {
       ExpandIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
         this[_currentExpansion] = dart.as(new EmptyIterator(), core.Iterator$(T));
         this[_current] = null;
       }
@@ skipping 13 matching lines @@
             return false;
           }
         }
         this[_current] = this[_currentExpansion].current;
         return true;
       }
     }
     ExpandIterator[dart.implements] = () => [core.Iterator$(T)];
     return ExpandIterator;
   });
-  let ExpandIterator = ExpandIterator$(dart.dynamic, dart.dynamic);
+  let ExpandIterator = ExpandIterator$();
   let _takeCount = dart.JsSymbol('_takeCount');
   let TakeIterable$ = dart.generic(function(E) {
     class TakeIterable extends collection.IterableBase$(E) {
       TakeIterable(iterable, takeCount) {
         if (dart.notNull(!(typeof takeCount == 'number')) || dart.notNull(takeCount) < 0) {
           throw new core.ArgumentError(takeCount);
         }
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthTakeIterable$(E))(iterable, takeCount);
         }
         return new TakeIterable$(E)[_](iterable, takeCount);
       }
       [_](iterable$, takeCount$) {
         this[_iterable] = iterable$;
         this[_takeCount] = takeCount$;
         super.IterableBase();
       }
       get iterator() {
         return new (TakeIterator$(E))(this[_iterable].iterator, this[_takeCount]);
       }
     }
     dart.defineNamedConstructor(TakeIterable, _);
     return TakeIterable;
   });
-  let TakeIterable = TakeIterable$(dart.dynamic);
+  let TakeIterable = TakeIterable$();
   let EfficientLengthTakeIterable$ = dart.generic(function(E) {
     class EfficientLengthTakeIterable extends TakeIterable$(E) {
       EfficientLengthTakeIterable(iterable, takeCount) {
         super[_](iterable, takeCount);
       }
       get length() {
         let iterableLength = this[_iterable].length;
         if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
           return this[_takeCount];
         return iterableLength;
       }
     }
     EfficientLengthTakeIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthTakeIterable;
   });
-  let EfficientLengthTakeIterable = EfficientLengthTakeIterable$(dart.dynamic);
+  let EfficientLengthTakeIterable = EfficientLengthTakeIterable$();
   let _remaining = dart.JsSymbol('_remaining');
   let TakeIterator$ = dart.generic(function(E) {
     class TakeIterator extends core.Iterator$(E) {
       TakeIterator(iterator$, remaining) {
         this[_iterator] = iterator$;
         this[_remaining] = remaining;
         super.Iterator();
         dart.assert(dart.notNull(typeof this[_remaining] == 'number') && dart.notNull(this[_remaining]) >= 0);
       }
       moveNext() {
         this[_remaining] = dart.notNull(this[_remaining]) - 1;
         if (dart.notNull(this[_remaining]) >= 0) {
           return this[_iterator].moveNext();
         }
         this[_remaining] = -1;
         return false;
       }
       get current() {
         if (dart.notNull(this[_remaining]) < 0)
           return null;
         return this[_iterator].current;
       }
     }
     return TakeIterator;
   });
-  let TakeIterator = TakeIterator$(dart.dynamic);
+  let TakeIterator = TakeIterator$();
   let TakeWhileIterable$ = dart.generic(function(E) {
     class TakeWhileIterable extends collection.IterableBase$(E) {
       TakeWhileIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get iterator() {
         return new (TakeWhileIterator$(E))(this[_iterable].iterator, dart.closureWrap(this[_f], "(E) → bool"));
       }
     }
     return TakeWhileIterable;
   });
-  let TakeWhileIterable = TakeWhileIterable$(dart.dynamic);
+  let TakeWhileIterable = TakeWhileIterable$();
   let _isFinished = dart.JsSymbol('_isFinished');
   let TakeWhileIterator$ = dart.generic(function(E) {
     class TakeWhileIterator extends core.Iterator$(E) {
       TakeWhileIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
         this[_isFinished] = false;
         super.Iterator();
       }
       moveNext() {
         if (this[_isFinished])
           return false;
         if (!dart.notNull(this[_iterator].moveNext()) || !dart.notNull(dart.dinvokef(this[_f], this[_iterator].current))) {
           this[_isFinished] = true;
           return false;
         }
         return true;
       }
       get current() {
         if (this[_isFinished])
           return null;
         return this[_iterator].current;
       }
     }
     return TakeWhileIterator;
   });
-  let TakeWhileIterator = TakeWhileIterator$(dart.dynamic);
+  let TakeWhileIterator = TakeWhileIterator$();
   let _skipCount = dart.JsSymbol('_skipCount');
   let SkipIterable$ = dart.generic(function(E) {
     class SkipIterable extends collection.IterableBase$(E) {
       SkipIterable(iterable, count) {
         if (dart.is(iterable, EfficientLength)) {
           return new (EfficientLengthSkipIterable$(E))(iterable, count);
         }
         return new SkipIterable$(E)[_](iterable, count);
       }
       [_](iterable$, skipCount$) {
@@ skipping 12 matching lines @@
         core.RangeError.checkNotNegative(this[_skipCount], "count");
         return new SkipIterable$(E)[_](this[_iterable], dart.notNull(this[_skipCount]) + dart.notNull(count));
       }
       get iterator() {
         return new (SkipIterator$(E))(this[_iterable].iterator, this[_skipCount]);
       }
     }
     dart.defineNamedConstructor(SkipIterable, _);
     return SkipIterable;
   });
-  let SkipIterable = SkipIterable$(dart.dynamic);
+  let SkipIterable = SkipIterable$();
   let EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
         super[_](iterable, skipCount);
       }
       get length() {
         let length = dart.notNull(this[_iterable].length) - dart.notNull(this[_skipCount]);
         if (dart.notNull(length) >= 0)
           return length;
         return 0;
       }
     }
     EfficientLengthSkipIterable[dart.implements] = () => [EfficientLength];
     return EfficientLengthSkipIterable;
   });
-  let EfficientLengthSkipIterable = EfficientLengthSkipIterable$(dart.dynamic);
+  let EfficientLengthSkipIterable = EfficientLengthSkipIterable$();
   let SkipIterator$ = dart.generic(function(E) {
     class SkipIterator extends core.Iterator$(E) {
       SkipIterator(iterator$, skipCount$) {
         this[_iterator] = iterator$;
         this[_skipCount] = skipCount$;
         super.Iterator();
         dart.assert(dart.notNull(typeof this[_skipCount] == 'number') && dart.notNull(this[_skipCount]) >= 0);
       }
       moveNext() {
         for (let i = 0; dart.notNull(i) < dart.notNull(this[_skipCount]); i = dart.notNull(i) + 1)
           this[_iterator].moveNext();
         this[_skipCount] = 0;
         return this[_iterator].moveNext();
       }
       get current() {
         return this[_iterator].current;
       }
     }
     return SkipIterator;
   });
-  let SkipIterator = SkipIterator$(dart.dynamic);
+  let SkipIterator = SkipIterator$();
   let SkipWhileIterable$ = dart.generic(function(E) {
     class SkipWhileIterable extends collection.IterableBase$(E) {
       SkipWhileIterable(iterable$, f$) {
         this[_iterable] = iterable$;
         this[_f] = f$;
         super.IterableBase();
       }
       get iterator() {
         return new (SkipWhileIterator$(E))(this[_iterable].iterator, dart.closureWrap(this[_f], "(E) → bool"));
       }
     }
     return SkipWhileIterable;
   });
-  let SkipWhileIterable = SkipWhileIterable$(dart.dynamic);
+  let SkipWhileIterable = SkipWhileIterable$();
   let _hasSkipped = dart.JsSymbol('_hasSkipped');
   let SkipWhileIterator$ = dart.generic(function(E) {
     class SkipWhileIterator extends core.Iterator$(E) {
       SkipWhileIterator(iterator$, f$) {
         this[_iterator] = iterator$;
         this[_f] = f$;
         this[_hasSkipped] = false;
         super.Iterator();
       }
       moveNext() {
         if (!dart.notNull(this[_hasSkipped])) {
           this[_hasSkipped] = true;
           while (this[_iterator].moveNext()) {
             if (!dart.notNull(dart.dinvokef(this[_f], this[_iterator].current)))
               return true;
           }
         }
         return this[_iterator].moveNext();
       }
       get current() {
         return this[_iterator].current;
       }
     }
     return SkipWhileIterator;
   });
-  let SkipWhileIterator = SkipWhileIterator$(dart.dynamic);
+  let SkipWhileIterator = SkipWhileIterator$();
   let EmptyIterable$ = dart.generic(function(E) {
     class EmptyIterable extends collection.IterableBase$(E) {
       EmptyIterable() {
         super.IterableBase();
       }
       get iterator() {
         return dart.as(new EmptyIterator(), core.Iterator$(E));
       }
       forEach(action) {}
       get isEmpty() {
@@ skipping 76 matching lines @@
         let growable = opts && 'growable' in opts ? opts.growable : true;
         return growable ? new core.List$(E).from([]) : new (core.List$(E))(0);
       }
       toSet() {
         return new (core.Set$(E))();
       }
     }
     EmptyIterable[dart.implements] = () => [EfficientLength];
     return EmptyIterable;
   });
-  let EmptyIterable = EmptyIterable$(dart.dynamic);
+  let EmptyIterable = EmptyIterable$();
   let EmptyIterator$ = dart.generic(function(E) {
     class EmptyIterator extends core.Object {
       EmptyIterator() {
       }
       moveNext() {
         return false;
       }
       get current() {
         return null;
       }
     }
     EmptyIterator[dart.implements] = () => [core.Iterator$(E)];
     return EmptyIterator;
   });
-  let EmptyIterator = EmptyIterator$(dart.dynamic);
+  let EmptyIterator = EmptyIterator$();
   let BidirectionalIterator$ = dart.generic(function(T) {
-    class BidirectionalIterator extends core.Object {
-    }
+    class BidirectionalIterator extends core.Object {}
     BidirectionalIterator[dart.implements] = () => [core.Iterator$(T)];
     return BidirectionalIterator;
   });
-  let BidirectionalIterator = BidirectionalIterator$(dart.dynamic);
+  let BidirectionalIterator = BidirectionalIterator$();
   let _rangeCheck = dart.JsSymbol('_rangeCheck');
   let IterableMixinWorkaround$ = dart.generic(function(T) {
     class IterableMixinWorkaround extends core.Object {
       static contains(iterable, element) {
         for (let e of iterable) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
@@ skipping 336 matching lines @@
         for (let element of set) {
           if (!dart.notNull(other.contains(element))) {
             result.add(element);
           }
         }
         return result;
       }
     }
     return IterableMixinWorkaround;
   });
-  let IterableMixinWorkaround = IterableMixinWorkaround$(dart.dynamic);
+  let IterableMixinWorkaround = IterableMixinWorkaround$();
   class IterableElementError extends core.Object {
     static noElement() {
       return new core.StateError("No element");
     }
     static tooMany() {
       return new core.StateError("Too many elements");
     }
     static tooFew() {
       return new core.StateError("Too few elements");
     }
@@ skipping 35 matching lines @@
       }
       removeRange(start, end) {
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
       replaceRange(start, end, iterable) {
         throw new core.UnsupportedError("Cannot remove from a fixed-length list");
       }
     }
     return FixedLengthListMixin;
   });
-  let FixedLengthListMixin = FixedLengthListMixin$(dart.dynamic);
+  let FixedLengthListMixin = FixedLengthListMixin$();
   let UnmodifiableListMixin$ = dart.generic(function(E) {
     class UnmodifiableListMixin extends core.Object {
       set(index, value) {
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
       set length(newLength) {
         throw new core.UnsupportedError("Cannot change the length of an unmodifiable list");
       }
       setAll(at, iterable) {
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
@@ skipping 51 matching lines @@
       }
       fillRange(start, end, fillValue) {
         if (fillValue === void 0)
           fillValue = null;
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
     }
     UnmodifiableListMixin[dart.implements] = () => [core.List$(E)];
     return UnmodifiableListMixin;
   });
-  let UnmodifiableListMixin = UnmodifiableListMixin$(dart.dynamic);
+  let UnmodifiableListMixin = UnmodifiableListMixin$();
   let FixedLengthListBase$ = dart.generic(function(E) {
-    class FixedLengthListBase extends dart.mixin(FixedLengthListMixin$(E)) {
-    }
+    class FixedLengthListBase extends dart.mixin(FixedLengthListMixin$(E)) {}
     return FixedLengthListBase;
   });
-  let FixedLengthListBase = FixedLengthListBase$(dart.dynamic);
+  let FixedLengthListBase = FixedLengthListBase$();
   let UnmodifiableListBase$ = dart.generic(function(E) {
-    class UnmodifiableListBase extends dart.mixin(UnmodifiableListMixin$(E)) {
-    }
+    class UnmodifiableListBase extends dart.mixin(UnmodifiableListMixin$(E)) {}
     return UnmodifiableListBase;
   });
-  let UnmodifiableListBase = UnmodifiableListBase$(dart.dynamic);
+  let UnmodifiableListBase = UnmodifiableListBase$();
   let _backedList = dart.JsSymbol('_backedList');
   class _ListIndicesIterable extends ListIterable$(core.int) {
     _ListIndicesIterable(backedList) {
       this[_backedList] = backedList;
       super.ListIterable();
     }
     get length() {
       return this[_backedList].length;
     }
     elementAt(index) {
@@ skipping 55 matching lines @@
       addAll(other) {
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       toString() {
         return collection.Maps.mapToString(this);
       }
     }
     ListMapView[dart.implements] = () => [core.Map$(core.int, E)];
     return ListMapView;
   });
-  let ListMapView = ListMapView$(dart.dynamic);
+  let ListMapView = ListMapView$();
   let ReversedListIterable$ = dart.generic(function(E) {
     class ReversedListIterable extends ListIterable$(E) {
       ReversedListIterable(source) {
         this[_source] = source;
         super.ListIterable();
       }
       get length() {
         return this[_source].length;
       }
       elementAt(index) {
         return this[_source].elementAt(dart.notNull(this[_source].length) - 1 - dart.notNull(index));
       }
     }
     return ReversedListIterable;
   });
-  let ReversedListIterable = ReversedListIterable$(dart.dynamic);
+  let ReversedListIterable = ReversedListIterable$();
   class UnmodifiableListError extends core.Object {
     static add() {
       return new core.UnsupportedError("Cannot add to unmodifiable List");
     }
     static change() {
       return new core.UnsupportedError("Cannot change the content of an unmodifiable List");
     }
     static length() {
       return new core.UnsupportedError("Cannot change length of unmodifiable List");
     }
@@ skipping 362 matching lines @@
     get publicSymbolPattern() {
       return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifierRE}(?:=?$|[.](?!$)))+?$`);
     },
     get symbolPattern() {
       return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.identifierRE}(?:=?$|[.](?!$)))+?$`);
     }
   });
   let POWERS_OF_TEN = /* Unimplemented const */new core.List.from([1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 100000000000000000.0, 1000000000000000000.0, 10000000000000000000.0, 100000000000000000000.0, 1e+21, 1e+22]);
   // Exports:
   exports.EfficientLength = EfficientLength;
+  exports.ListIterable$ = ListIterable$;
   exports.ListIterable = ListIterable;
-  exports.ListIterable$ = ListIterable$;
+  exports.SubListIterable$ = SubListIterable$;
   exports.SubListIterable = SubListIterable;
-  exports.SubListIterable$ = SubListIterable$;
+  exports.ListIterator$ = ListIterator$;
   exports.ListIterator = ListIterator;
-  exports.ListIterator$ = ListIterator$;
+  exports.MappedIterable$ = MappedIterable$;
   exports.MappedIterable = MappedIterable;
-  exports.MappedIterable$ = MappedIterable$;
+  exports.EfficientLengthMappedIterable$ = EfficientLengthMappedIterable$;
   exports.EfficientLengthMappedIterable = EfficientLengthMappedIterable;
-  exports.EfficientLengthMappedIterable$ = EfficientLengthMappedIterable$;
+  exports.MappedIterator$ = MappedIterator$;
   exports.MappedIterator = MappedIterator;
-  exports.MappedIterator$ = MappedIterator$;
+  exports.MappedListIterable$ = MappedListIterable$;
   exports.MappedListIterable = MappedListIterable;
-  exports.MappedListIterable$ = MappedListIterable$;
+  exports.WhereIterable$ = WhereIterable$;
   exports.WhereIterable = WhereIterable;
-  exports.WhereIterable$ = WhereIterable$;
+  exports.WhereIterator$ = WhereIterator$;
   exports.WhereIterator = WhereIterator;
-  exports.WhereIterator$ = WhereIterator$;
+  exports.ExpandIterable$ = ExpandIterable$;
   exports.ExpandIterable = ExpandIterable;
-  exports.ExpandIterable$ = ExpandIterable$;
+  exports.ExpandIterator$ = ExpandIterator$;
   exports.ExpandIterator = ExpandIterator;
-  exports.ExpandIterator$ = ExpandIterator$;
+  exports.TakeIterable$ = TakeIterable$;
   exports.TakeIterable = TakeIterable;
-  exports.TakeIterable$ = TakeIterable$;
+  exports.EfficientLengthTakeIterable$ = EfficientLengthTakeIterable$;
   exports.EfficientLengthTakeIterable = EfficientLengthTakeIterable;
-  exports.EfficientLengthTakeIterable$ = EfficientLengthTakeIterable$;
+  exports.TakeIterator$ = TakeIterator$;
   exports.TakeIterator = TakeIterator;
-  exports.TakeIterator$ = TakeIterator$;
+  exports.TakeWhileIterable$ = TakeWhileIterable$;
   exports.TakeWhileIterable = TakeWhileIterable;
-  exports.TakeWhileIterable$ = TakeWhileIterable$;
+  exports.TakeWhileIterator$ = TakeWhileIterator$;
   exports.TakeWhileIterator = TakeWhileIterator;
-  exports.TakeWhileIterator$ = TakeWhileIterator$;
+  exports.SkipIterable$ = SkipIterable$;
   exports.SkipIterable = SkipIterable;
-  exports.SkipIterable$ = SkipIterable$;
+  exports.EfficientLengthSkipIterable$ = EfficientLengthSkipIterable$;
   exports.EfficientLengthSkipIterable = EfficientLengthSkipIterable;
-  exports.EfficientLengthSkipIterable$ = EfficientLengthSkipIterable$;
+  exports.SkipIterator$ = SkipIterator$;
   exports.SkipIterator = SkipIterator;
-  exports.SkipIterator$ = SkipIterator$;
+  exports.SkipWhileIterable$ = SkipWhileIterable$;
   exports.SkipWhileIterable = SkipWhileIterable;
-  exports.SkipWhileIterable$ = SkipWhileIterable$;
+  exports.SkipWhileIterator$ = SkipWhileIterator$;
   exports.SkipWhileIterator = SkipWhileIterator;
-  exports.SkipWhileIterator$ = SkipWhileIterator$;
+  exports.EmptyIterable$ = EmptyIterable$;
   exports.EmptyIterable = EmptyIterable;
-  exports.EmptyIterable$ = EmptyIterable$;
+  exports.EmptyIterator$ = EmptyIterator$;
   exports.EmptyIterator = EmptyIterator;
-  exports.EmptyIterator$ = EmptyIterator$;
+  exports.BidirectionalIterator$ = BidirectionalIterator$;
   exports.BidirectionalIterator = BidirectionalIterator;
-  exports.BidirectionalIterator$ = BidirectionalIterator$;
+  exports.IterableMixinWorkaround$ = IterableMixinWorkaround$;
   exports.IterableMixinWorkaround = IterableMixinWorkaround;
-  exports.IterableMixinWorkaround$ = IterableMixinWorkaround$;
   exports.IterableElementError = IterableElementError;
+  exports.FixedLengthListMixin$ = FixedLengthListMixin$;
   exports.FixedLengthListMixin = FixedLengthListMixin;
-  exports.FixedLengthListMixin$ = FixedLengthListMixin$;
+  exports.UnmodifiableListMixin$ = UnmodifiableListMixin$;
   exports.UnmodifiableListMixin = UnmodifiableListMixin;
-  exports.UnmodifiableListMixin$ = UnmodifiableListMixin$;
+  exports.FixedLengthListBase$ = FixedLengthListBase$;
   exports.FixedLengthListBase = FixedLengthListBase;
-  exports.FixedLengthListBase$ = FixedLengthListBase$;
+  exports.UnmodifiableListBase$ = UnmodifiableListBase$;
   exports.UnmodifiableListBase = UnmodifiableListBase;
-  exports.UnmodifiableListBase$ = UnmodifiableListBase$;
+  exports.ListMapView$ = ListMapView$;
   exports.ListMapView = ListMapView;
-  exports.ListMapView$ = ListMapView$;
+  exports.ReversedListIterable$ = ReversedListIterable$;
   exports.ReversedListIterable = ReversedListIterable;
-  exports.ReversedListIterable$ = ReversedListIterable$;
   exports.UnmodifiableListError = UnmodifiableListError;
   exports.NonGrowableListError = NonGrowableListError;
   exports.makeListFixedLength = makeListFixedLength;
   exports.Lists = Lists;
   exports.printToConsole = printToConsole;
   exports.Sort = Sort;
   exports.Symbol = Symbol;
   exports.POWERS_OF_TEN = POWERS_OF_TEN;
 })(_internal || (_internal = {}));