js: fix core.Object, output order, static const fields

test/codegen/expect/dart/_internal.js

 var _internal;
 (function(exports) {
   'use strict';
-  let POWERS_OF_TEN = /* Unimplemented const */new 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]);
-  class EfficientLength extends dart.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(this);
       }
       forEach(action) {
@@ skipping 201 matching lines @@
       toSet() {
         let result = new core.Set();
         for (let i = 0; dart.notNull(i) < dart.notNull(this.length); i = dart.notNull(i) + 1) {
           result.add(this.elementAt(i));
         }
         return result;
       }
     }
     return ListIterable;
   });
-  let ListIterable = ListIterable$(dynamic);
+  let ListIterable = ListIterable$(dart.dynamic);
   let _iterable = Symbol('_iterable');
   let _start = Symbol('_start');
   let _endOrLength = Symbol('_endOrLength');
   let _endIndex = Symbol('_endIndex');
   let _startIndex = Symbol('_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$(dynamic);
+  let SubListIterable = SubListIterable$(dart.dynamic);
   let _length = Symbol('_length');
   let _index = Symbol('_index');
   let _current = Symbol('_current');
   let ListIterator$ = dart.generic(function(E) {
-    class ListIterator extends dart.Object {
+    class ListIterator extends core.Object {
       ListIterator(iterable) {
         this[_iterable] = iterable;
         this[_length] = iterable.length;
         this[_index] = 0;
         this[_current] = null;
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         let length = this[_iterable].length;
         if (this[_length] !== length) {
           throw new core.ConcurrentModificationError(this[_iterable]);
         }
         if (dart.notNull(this[_index]) >= dart.notNull(length)) {
           this[_current] = null;
           return false;
         }
         this[_current] = this[_iterable].elementAt(this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
       }
     }
     return ListIterator;
   });
-  let ListIterator = ListIterator$(dynamic);
+  let ListIterator = ListIterator$(dart.dynamic);
   let _f = Symbol('_f');
   let MappedIterable$ = dart.generic(function(S, T) {
     class MappedIterable extends collection.IterableBase$(T) {
       MappedIterable(iterable, function) {
         if (dart.is(iterable, EfficientLength)) {
           return new EfficientLengthMappedIterable(iterable, function);
         }
         return new MappedIterable._(dart.as(iterable, core.Iterable$(S)), function);
       }
       MappedIterable$_($_iterable, $_f) {
@@ skipping 19 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$(dynamic, dynamic);
+  let MappedIterable = MappedIterable$(dart.dynamic, dart.dynamic);
   let EfficientLengthMappedIterable$ = dart.generic(function(S, T) {
     class EfficientLengthMappedIterable extends MappedIterable$(S, T) {
       EfficientLengthMappedIterable(iterable, function) {
         super.MappedIterable$_(dart.as(iterable, core.Iterable$(S)), function);
       }
     }
     return EfficientLengthMappedIterable;
   });
-  let EfficientLengthMappedIterable = EfficientLengthMappedIterable$(dynamic, dynamic);
+  let EfficientLengthMappedIterable = EfficientLengthMappedIterable$(dart.dynamic, dart.dynamic);
   let _iterator = Symbol('_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$(dynamic, dynamic);
+  let MappedIterator = MappedIterator$(dart.dynamic, dart.dynamic);
   let _source = Symbol('_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));
       }
     }
     return MappedListIterable;
   });
-  let MappedListIterable = MappedListIterable$(dynamic, dynamic);
+  let MappedListIterable = MappedListIterable$(dart.dynamic, dart.dynamic);
   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(this[_iterable].iterator, this[_f]);
       }
     }
     return WhereIterable;
   });
-  let WhereIterable = WhereIterable$(dynamic);
+  let WhereIterable = WhereIterable$(dart.dynamic);
   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$(dynamic);
+  let WhereIterator = WhereIterator$(dart.dynamic);
   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(this[_iterable].iterator, dart.as(this[_f], dart.throw_("Unimplemented type (S) → Iterable<T>")));
       }
     }
     return ExpandIterable;
   });
-  let ExpandIterable = ExpandIterable$(dynamic, dynamic);
+  let ExpandIterable = ExpandIterable$(dart.dynamic, dart.dynamic);
   let _currentExpansion = Symbol('_currentExpansion');
   let _nextExpansion = Symbol('_nextExpansion');
   let ExpandIterator$ = dart.generic(function(S, T) {
-    class ExpandIterator extends dart.Object {
+    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;
       }
       [_nextExpansion]() {}
       get current() {
         return this[_current];
       }
       moveNext() {
         if (this[_currentExpansion] === null)
           return false;
         while (!dart.notNull(this[_currentExpansion].moveNext())) {
           this[_current] = null;
           if (this[_iterator].moveNext()) {
             this[_currentExpansion] = null;
             this[_currentExpansion] = dart.as(this[_f](this[_iterator].current).iterator, core.Iterator$(T));
           } else {
             return false;
           }
         }
         this[_current] = this[_currentExpansion].current;
         return true;
       }
     }
     return ExpandIterator;
   });
-  let ExpandIterator = ExpandIterator$(dynamic, dynamic);
+  let ExpandIterator = ExpandIterator$(dart.dynamic, dart.dynamic);
   let _takeCount = Symbol('_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(iterable, takeCount);
         }
         return new TakeIterable._(iterable, takeCount);
       }
       TakeIterable$_($_iterable, $_takeCount) {
         this[_iterable] = $_iterable;
         this[_takeCount] = $_takeCount;
         super.IterableBase();
       }
       get iterator() {
         return new TakeIterator(this[_iterable].iterator, this[_takeCount]);
       }
     }
     dart.defineNamedConstructor(TakeIterable, '_');
     return TakeIterable;
   });
-  let TakeIterable = TakeIterable$(dynamic);
+  let TakeIterable = TakeIterable$(dart.dynamic);
   let EfficientLengthTakeIterable$ = dart.generic(function(E) {
     class EfficientLengthTakeIterable extends TakeIterable$(E) {
       EfficientLengthTakeIterable(iterable, takeCount) {
         super.TakeIterable$_(iterable, takeCount);
       }
       get length() {
         let iterableLength = this[_iterable].length;
         if (dart.notNull(iterableLength) > dart.notNull(this[_takeCount]))
           return this[_takeCount];
         return iterableLength;
       }
     }
     return EfficientLengthTakeIterable;
   });
-  let EfficientLengthTakeIterable = EfficientLengthTakeIterable$(dynamic);
+  let EfficientLengthTakeIterable = EfficientLengthTakeIterable$(dart.dynamic);
   let _remaining = Symbol('_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$(dynamic);
+  let TakeIterator = TakeIterator$(dart.dynamic);
   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(this[_iterable].iterator, this[_f]);
       }
     }
     return TakeWhileIterable;
   });
-  let TakeWhileIterable = TakeWhileIterable$(dynamic);
+  let TakeWhileIterable = TakeWhileIterable$(dart.dynamic);
   let _isFinished = Symbol('_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(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$(dynamic);
+  let TakeWhileIterator = TakeWhileIterator$(dart.dynamic);
   let _skipCount = Symbol('_skipCount');
   let SkipIterable$ = dart.generic(function(E) {
     class SkipIterable extends collection.IterableBase$(E) {
       SkipIterable(iterable, count) {
         if (dart.is(iterable, EfficientLength)) {
           return new EfficientLengthSkipIterable(iterable, count);
         }
         return new SkipIterable._(iterable, count);
       }
       SkipIterable$_($_iterable, $_skipCount) {
@@ skipping 12 matching lines @@
         core.RangeError.checkNotNegative(this[_skipCount], "count");
         return new SkipIterable._(this[_iterable], dart.notNull(this[_skipCount]) + dart.notNull(count));
       }
       get iterator() {
         return new SkipIterator(this[_iterable].iterator, this[_skipCount]);
       }
     }
     dart.defineNamedConstructor(SkipIterable, '_');
     return SkipIterable;
   });
-  let SkipIterable = SkipIterable$(dynamic);
+  let SkipIterable = SkipIterable$(dart.dynamic);
   let EfficientLengthSkipIterable$ = dart.generic(function(E) {
     class EfficientLengthSkipIterable extends SkipIterable$(E) {
       EfficientLengthSkipIterable(iterable, skipCount) {
         super.SkipIterable$_(iterable, skipCount);
       }
       get length() {
         let length = dart.notNull(this[_iterable].length) - dart.notNull(this[_skipCount]);
         if (dart.notNull(length) >= 0)
           return length;
         return 0;
       }
     }
     return EfficientLengthSkipIterable;
   });
-  let EfficientLengthSkipIterable = EfficientLengthSkipIterable$(dynamic);
+  let EfficientLengthSkipIterable = EfficientLengthSkipIterable$(dart.dynamic);
   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$(dynamic);
+  let SkipIterator = SkipIterator$(dart.dynamic);
   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(this[_iterable].iterator, this[_f]);
       }
     }
     return SkipWhileIterable;
   });
-  let SkipWhileIterable = SkipWhileIterable$(dynamic);
+  let SkipWhileIterable = SkipWhileIterable$(dart.dynamic);
   let _hasSkipped = Symbol('_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(this[_f](this[_iterator].current)))
               return true;
           }
         }
         return this[_iterator].moveNext();
       }
       get current() {
         return this[_iterator].current;
       }
     }
     return SkipWhileIterator;
   });
-  let SkipWhileIterator = SkipWhileIterator$(dynamic);
+  let SkipWhileIterator = SkipWhileIterator$(dart.dynamic);
   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 75 matching lines @@
       toList(opt$) {
         let growable = opt$.growable === void 0 ? true : opt$.growable;
         return growable ? new List.from([]) : new core.List(0);
       }
       toSet() {
         return new core.Set();
       }
     }
     return EmptyIterable;
   });
-  let EmptyIterable = EmptyIterable$(dynamic);
+  let EmptyIterable = EmptyIterable$(dart.dynamic);
   let EmptyIterator$ = dart.generic(function(E) {
-    class EmptyIterator extends dart.Object {
+    class EmptyIterator extends core.Object {
       EmptyIterator() {
       }
       moveNext() {
         return false;
       }
       get current() {
         return null;
       }
     }
     return EmptyIterator;
   });
-  let EmptyIterator = EmptyIterator$(dynamic);
+  let EmptyIterator = EmptyIterator$(dart.dynamic);
   let BidirectionalIterator$ = dart.generic(function(T) {
-    class BidirectionalIterator extends dart.Object {
+    class BidirectionalIterator extends core.Object {
     }
     return BidirectionalIterator;
   });
-  let BidirectionalIterator = BidirectionalIterator$(dynamic);
+  let BidirectionalIterator = BidirectionalIterator$(dart.dynamic);
   let _rangeCheck = Symbol('_rangeCheck');
   let IterableMixinWorkaround$ = dart.generic(function(T) {
-    class IterableMixinWorkaround extends dart.Object {
+    class IterableMixinWorkaround extends core.Object {
       static contains(iterable, element) {
         for (let e of iterable) {
           if (dart.equals(e, element))
             return true;
         }
         return false;
       }
       static forEach(iterable, f) {
         for (let e of iterable) {
           f(e);
@@ skipping 333 matching lines @@
         for (let element of set) {
           if (!dart.notNull(other.contains(element))) {
             result.add(element);
           }
         }
         return result;
       }
     }
     return IterableMixinWorkaround;
   });
-  let IterableMixinWorkaround = IterableMixinWorkaround$(dynamic);
-  class IterableElementError extends dart.Object {
+  let IterableMixinWorkaround = IterableMixinWorkaround$(dart.dynamic);
+  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");
     }
   }
   let FixedLengthListMixin$ = dart.generic(function(E) {
-    class FixedLengthListMixin extends dart.Object {
+    class FixedLengthListMixin extends core.Object {
       set length(newLength) {
         throw new core.UnsupportedError("Cannot change the length of a fixed-length list");
       }
       add(value) {
         throw new core.UnsupportedError("Cannot add to a fixed-length list");
       }
       insert(index, value) {
         throw new core.UnsupportedError("Cannot add to a fixed-length list");
       }
       insertAll(at, iterable) {
@@ skipping 22 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$(dynamic);
+  let FixedLengthListMixin = FixedLengthListMixin$(dart.dynamic);
   let UnmodifiableListMixin$ = dart.generic(function(E) {
-    class UnmodifiableListMixin extends dart.Object {
+    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");
       }
       add(value) {
@@ skipping 48 matching lines @@
         throw new core.UnsupportedError("Cannot remove from an unmodifiable list");
       }
       fillRange(start, end, fillValue) {
         if (fillValue === void 0)
           fillValue = null;
         throw new core.UnsupportedError("Cannot modify an unmodifiable list");
       }
     }
     return UnmodifiableListMixin;
   });
-  let UnmodifiableListMixin = UnmodifiableListMixin$(dynamic);
+  let UnmodifiableListMixin = UnmodifiableListMixin$(dart.dynamic);
   let FixedLengthListBase$ = dart.generic(function(E) {
     class FixedLengthListBase extends dart.mixin(FixedLengthListMixin$(E)) {
     }
     return FixedLengthListBase;
   });
-  let FixedLengthListBase = FixedLengthListBase$(dynamic);
+  let FixedLengthListBase = FixedLengthListBase$(dart.dynamic);
   let UnmodifiableListBase$ = dart.generic(function(E) {
     class UnmodifiableListBase extends dart.mixin(UnmodifiableListMixin$(E)) {
     }
     return UnmodifiableListBase;
   });
-  let UnmodifiableListBase = UnmodifiableListBase$(dynamic);
+  let UnmodifiableListBase = UnmodifiableListBase$(dart.dynamic);
   let _backedList = Symbol('_backedList');
   class _ListIndicesIterable extends ListIterable$(core.int) {
     _ListIndicesIterable($_backedList) {
       this[_backedList] = $_backedList;
       super.ListIterable();
     }
     get length() {
       return this[_backedList].length;
     }
     elementAt(index) {
       core.RangeError.checkValidIndex(index, this);
       return index;
     }
   }
   let _values = Symbol('_values');
   let ListMapView$ = dart.generic(function(E) {
-    class ListMapView extends dart.Object {
+    class ListMapView extends core.Object {
       ListMapView($_values) {
         this[_values] = $_values;
       }
       get(key) {
         return this.containsKey(key) ? this[_values].get(key) : null;
       }
       get length() {
         return this[_values].length;
       }
       get values() {
@@ skipping 37 matching lines @@
       }
       addAll(other) {
         throw new core.UnsupportedError("Cannot modify an unmodifiable map");
       }
       toString() {
         return collection.Maps.mapToString(this);
       }
     }
     return ListMapView;
   });
-  let ListMapView = ListMapView$(dynamic);
+  let ListMapView = ListMapView$(dart.dynamic);
   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$(dynamic);
-  class UnmodifiableListError extends dart.Object {
+  let ReversedListIterable = ReversedListIterable$(dart.dynamic);
+  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");
     }
     static remove() {
       return new core.UnsupportedError("Cannot remove from unmodifiable List");
     }
   }
-  class NonGrowableListError extends dart.Object {
+  class NonGrowableListError extends core.Object {
     static add() {
       return new core.UnsupportedError("Cannot add to non-growable List");
     }
     static length() {
       return new core.UnsupportedError("Cannot change length of non-growable List");
     }
     static remove() {
       return new core.UnsupportedError("Cannot remove from non-growable List");
     }
   }
   // Function makeListFixedLength: (List<dynamic>) → List
   function makeListFixedLength(growableList) {
     _interceptors.JSArray.markFixedList(growableList);
     return growableList;
   }
-  class Lists extends dart.Object {
+  class Lists extends core.Object {
     static copy(src, srcStart, dst, dstStart, count) {
       if (dart.notNull(srcStart) < dart.notNull(dstStart)) {
         for (let i = dart.notNull(srcStart) + dart.notNull(count) - 1, j = dart.notNull(dstStart) + dart.notNull(count) - 1; dart.notNull(i) >= dart.notNull(srcStart); i = dart.notNull(i) - 1, j = dart.notNull(j) - 1) {
           dst.set(j, src.get(i));
         }
       } else {
         for (let i = srcStart, j = dstStart; dart.notNull(i) < dart.notNull(srcStart) + dart.notNull(count); i = dart.notNull(i) + 1, j = dart.notNull(j) + 1) {
           dst.set(j, src.get(i));
         }
       }
@@ skipping 53 matching lines @@
     }
   }
   exports.printToZone = null;
   // Function printToConsole: (String) → void
   function printToConsole(line) {
     _js_primitives.printString(`${line}`);
   }
   let _doSort = Symbol('_doSort');
   let _insertionSort = Symbol('_insertionSort');
   let _dualPivotQuicksort = Symbol('_dualPivotQuicksort');
-  class Sort extends dart.Object {
+  class Sort extends core.Object {
     static sort(a, compare) {
       _doSort(a, 0, dart.notNull(a.length) - 1, compare);
     }
     static sortRange(a, from, to, compare) {
       if (dart.notNull(from) < 0 || dart.notNull(to) > dart.notNull(a.length) || dart.notNull(to) < dart.notNull(from)) {
         throw "OutOfRange";
       }
       _doSort(a, from, dart.notNull(to) - 1, compare);
     }
     static [_doSort](a, left, right, compare) {
-      if (dart.notNull(right) - dart.notNull(left) <= dart.notNull(_INSERTION_SORT_THRESHOLD)) {
+      if (dart.notNull(right) - dart.notNull(left) <= dart.notNull(Sort._INSERTION_SORT_THRESHOLD)) {
         _insertionSort(a, left, right, compare);
       } else {
         _dualPivotQuicksort(a, left, right, compare);
       }
     }
     static [_insertionSort](a, left, right, compare) {
       for (let i = dart.notNull(left) + 1; dart.notNull(i) <= dart.notNull(right); i = dart.notNull(i) + 1) {
         let el = a.get(i);
         let j = i;
         while (dart.notNull(j) > dart.notNull(left) && dart.notNull(compare(a.get(dart.notNull(j) - 1), el)) > 0) {
           a.set(j, a.get(dart.notNull(j) - 1));
           j = dart.notNull(j) - 1;
         }
         a.set(j, el);
       }
     }
     static [_dualPivotQuicksort](a, left, right, compare) {
-      dart.assert(dart.notNull(right) - dart.notNull(left) > dart.notNull(_INSERTION_SORT_THRESHOLD));
+      dart.assert(dart.notNull(right) - dart.notNull(left) > dart.notNull(Sort._INSERTION_SORT_THRESHOLD));
       let sixth = ((dart.notNull(right) - dart.notNull(left) + 1) / 6).truncate();
       let index1 = dart.notNull(left) + dart.notNull(sixth);
       let index5 = dart.notNull(right) - dart.notNull(sixth);
       let index3 = ((dart.notNull(left) + dart.notNull(right)) / 2).truncate();
       let index2 = dart.notNull(index3) - dart.notNull(sixth);
       let index4 = dart.notNull(index3) + dart.notNull(sixth);
       let el1 = a.get(index1);
       let el2 = a.get(index2);
       let el3 = a.get(index3);
       let el4 = a.get(index4);
@@ skipping 174 matching lines @@
           }
         }
         _doSort(a, less, great, compare);
       } else {
         _doSort(a, less, great, compare);
       }
     }
   }
   Sort._INSERTION_SORT_THRESHOLD = 32;
   let _name = Symbol('_name');
-  class Symbol extends dart.Object {
+  class Symbol extends core.Object {
     Symbol(name) {
       this[_name] = name;
     }
     Symbol$unvalidated($_name) {
       this[_name] = $_name;
     }
     Symbol$validated(name) {
       this[_name] = validatePublicSymbol(name);
     }
     ['=='](other) {
@@ skipping 17 matching lines @@
       }
       throw new core.ArgumentError(`"${name}" is not a valid (qualified) symbol name`);
     }
     static isValidSymbol(name) {
       return dart.notNull(name.isEmpty) || dart.notNull(symbolPattern.hasMatch(name));
     }
   }
   dart.defineNamedConstructor(Symbol, 'unvalidated');
   dart.defineNamedConstructor(Symbol, 'validated');
   Symbol.reservedWordRE = '(?:assert|break|c(?:a(?:se|tch)|lass|on(?:st|tinue))|d(?:efault|o)|' + 'e(?:lse|num|xtends)|f(?:alse|inal(?:ly)?|or)|i[fns]|n(?:ew|ull)|' + 'ret(?:hrow|urn)|s(?:uper|witch)|t(?:h(?:is|row)|r(?:ue|y))|' + 'v(?:ar|oid)|w(?:hile|ith))';
-  Symbol.publicIdentifierRE = '(?!' + `${reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$][\\w$]*';
-  Symbol.identifierRE = '(?!' + `${reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$_][\\w$]*';
+  Symbol.publicIdentifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$][\\w$]*';
+  Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$_][\\w$]*';
   Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
   dart.defineLazyProperties(Symbol, {
     get publicSymbolPattern() {
-      return new core.RegExp(`^(?:${operatorRE}$|${publicIdentifierRE}(?:=?$|[.](?!$)))+?$`);
+      return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifierRE}(?:=?$|[.](?!$)))+?$`);
     },
     get symbolPattern() {
-      return new core.RegExp(`^(?:${operatorRE}$|${identifierRE}(?:=?$|[.](?!$)))+?$`);
+      return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.identifierRE}(?:=?$|[.](?!$)))+?$`);
     }
   });
+  let POWERS_OF_TEN = /* Unimplemented const */new 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.POWERS_OF_TEN = POWERS_OF_TEN;
   exports.EfficientLength = EfficientLength;
   exports.ListIterable = ListIterable;
   exports.ListIterable$ = ListIterable$;
   exports.SubListIterable = SubListIterable;
   exports.SubListIterable$ = SubListIterable$;
   exports.ListIterator = ListIterator;
   exports.ListIterator$ = ListIterator$;
   exports.MappedIterable = MappedIterable;
   exports.MappedIterable$ = MappedIterable$;
   exports.EfficientLengthMappedIterable = EfficientLengthMappedIterable;
@@ skipping 51 matching lines @@
   exports.ListMapView$ = ListMapView$;
   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 = {}));