fixes #131, use before define from variables to classes

lib/runtime/dart/_internal.js

 var _internal = dart.defineLibrary(_internal, {});
 var core = dart.import(core);
 var collection = dart.import(collection);
 var math = dart.lazyImport(math);
 var _interceptors = dart.lazyImport(_interceptors);
 var _js_primitives = dart.lazyImport(_js_primitives);
 (function(exports, core, collection, math, _interceptors, _js_primitives) {
   'use strict';
   class EfficientLength extends core.Object {}
   let ListIterable$ = dart.generic(function(E) {
@@ skipping 348 matching lines @@
         this[_current] = this[_iterable][core.$elementAt](this[_index]);
         this[_index] = dart.notNull(this[_index]) + 1;
         return true;
       }
     }
     ListIterator[dart.implements] = () => [core.Iterator$(E)];
     return ListIterator;
   });
   let ListIterator = ListIterator$();
   let _Transformation$ = dart.generic(function(S, T) {
-    let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
+    let _Transformation = dart.typedef('_Transformation', dart.functionType(T, [S]));
     return _Transformation;
   });
   let _Transformation = _Transformation$();
   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);
         }
@@ skipping 76 matching lines @@
       }
       [core.$elementAt](index) {
         return this[_f](this[_source][core.$elementAt](index));
       }
     }
     MappedListIterable[dart.implements] = () => [EfficientLength];
     return MappedListIterable;
   });
   let MappedListIterable = MappedListIterable$();
   let _ElementPredicate$ = dart.generic(function(E) {
-    let _ElementPredicate = dart.typedef('_ElementPredicate', () => dart.functionType(core.bool, [E]));
+    let _ElementPredicate = dart.typedef('_ElementPredicate', dart.functionType(core.bool, [E]));
     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();
       }
@@ skipping 19 matching lines @@
         return false;
       }
       get current() {
         return this[_iterator].current;
       }
     }
     return WhereIterator;
   });
   let WhereIterator = WhereIterator$();
   let _ExpandFunction$ = dart.generic(function(S, T) {
-    let _ExpandFunction = dart.typedef('_ExpandFunction', () => dart.functionType(core.Iterable$(T), [S]));
+    let _ExpandFunction = dart.typedef('_ExpandFunction', dart.functionType(core.Iterable$(T), [S]));
     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();
       }
@@ skipping 638 matching lines @@
       }
       static lastIndexOfList(list, element, start) {
         if (start == null)
           start = dart.notNull(list[core.$length]) - 1;
         return Lists.lastIndexOf(list, element, start);
       }
       static _rangeCheck(list, start, end) {
         core.RangeError.checkValidRange(start, end, list[core.$length]);
       }
       getRangeList(list, start, end) {
-        IterableMixinWorkaround._rangeCheck(list, start, end);
+        IterableMixinWorkaround$()._rangeCheck(list, start, end);
         return new (SubListIterable$(T))(dart.as(list, core.Iterable$(T)), start, end);
       }
       static setRangeList(list, start, end, from, skipCount) {
-        IterableMixinWorkaround._rangeCheck(list, start, end);
+        IterableMixinWorkaround$()._rangeCheck(list, start, end);
         let length = dart.notNull(end) - dart.notNull(start);
         if (length == 0)
           return;
         if (dart.notNull(skipCount) < 0)
           throw new core.ArgumentError(skipCount);
         let otherList = null;
         let otherStart = null;
         if (dart.is(from, core.List)) {
           otherList = from;
           otherStart = skipCount;
         } else {
           otherList = from[core.$skip](skipCount)[core.$toList]({growable: false});
           otherStart = 0;
         }
         if (dart.notNull(otherStart) + dart.notNull(length) > dart.notNull(otherList[core.$length])) {
           throw IterableElementError.tooFew();
         }
         Lists.copy(otherList, otherStart, list, start, length);
       }
       static replaceRangeList(list, start, end, iterable) {
-        IterableMixinWorkaround._rangeCheck(list, start, end);
+        IterableMixinWorkaround$()._rangeCheck(list, start, end);
         if (!dart.is(iterable, EfficientLength)) {
           iterable = iterable[core.$toList]();
         }
         let removeLength = dart.notNull(end) - dart.notNull(start);
         let insertLength = iterable[core.$length];
         if (dart.notNull(removeLength) >= dart.notNull(insertLength)) {
           let delta = dart.notNull(removeLength) - dart.notNull(insertLength);
           let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
           let newEnd = dart.notNull(list[core.$length]) - dart.notNull(delta);
           list[core.$setRange](start, insertEnd, iterable);
           if (delta != 0) {
             list[core.$setRange](insertEnd, newEnd, list, end);
             list[core.$length] = newEnd;
           }
         } else {
           let delta = dart.notNull(insertLength) - dart.notNull(removeLength);
           let newLength = dart.notNull(list[core.$length]) + dart.notNull(delta);
           let insertEnd = dart.notNull(start) + dart.notNull(insertLength);
           list[core.$length] = newLength;
           list[core.$setRange](insertEnd, newLength, list, end);
           list[core.$setRange](start, insertEnd, iterable);
         }
       }
       static fillRangeList(list, start, end, fillValue) {
-        IterableMixinWorkaround._rangeCheck(list, start, end);
+        IterableMixinWorkaround$()._rangeCheck(list, start, end);
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           list[core.$set](i, fillValue);
         }
       }
       static insertAllList(list, index, iterable) {
         core.RangeError.checkValueInInterval(index, 0, list[core.$length], "index");
         if (!dart.is(iterable, EfficientLength)) {
           iterable = iterable[core.$toList]({growable: false});
         }
         let insertionLength = iterable[core.$length];
@@ skipping 66 matching lines @@
       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 __CastType0$ = dart.generic(function(S, T) {
-    let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Iterable$(T), [S]));
+    let __CastType0 = dart.typedef('__CastType0', dart.functionType(core.Iterable$(T), [S]));
     return __CastType0;
   });
   let __CastType0 = __CastType0$();
   let __CastType2$ = dart.generic(function(E) {
-    let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(core.bool, [E]));
+    let __CastType2 = dart.typedef('__CastType2', dart.functionType(core.bool, [E]));
     return __CastType2;
   });
   let __CastType2 = __CastType2$();
   let __CastType4$ = dart.generic(function(E) {
-    let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(core.bool, [E]));
+    let __CastType4 = dart.typedef('__CastType4', dart.functionType(core.bool, [E]));
     return __CastType4;
   });
   let __CastType4 = __CastType4$();
   let __CastType6$ = dart.generic(function(T) {
-    let __CastType6 = dart.typedef('__CastType6', () => dart.functionType(core.bool, [T]));
+    let __CastType6 = dart.typedef('__CastType6', dart.functionType(core.bool, [T]));
     return __CastType6;
   });
   let __CastType6 = __CastType6$();
   let FixedLengthListMixin$ = dart.generic(function(E) {
     class FixedLengthListMixin extends core.Object {
       set length(newLength) {
         throw new core.UnsupportedError("Cannot change the length of a fixed-length list");
       }
       add(value) {
         dart.as(value, E);
@@ skipping 628 matching lines @@
       return dart.notNull(name.isEmpty) || dart.notNull(Symbol.symbolPattern.hasMatch(name));
     }
   }
   Symbol[dart.implements] = () => [core.Symbol];
   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 = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$][\\w$]*';
   Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$_][\\w$]*';
   Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
+  let POWERS_OF_TEN = dart.const([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]);
   dart.defineLazyProperties(Symbol, {
     get publicSymbolPattern() {
       return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.publicIdentifierRE}(?:=?$|[.](?!$)))+?$`);
     },
     get symbolPattern() {
       return new core.RegExp(`^(?:${Symbol.operatorRE}$|${Symbol.identifierRE}(?:=?$|[.](?!$)))+?$`);
     }
   });
-  let POWERS_OF_TEN = dart.const([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.SubListIterable$ = SubListIterable$;
   exports.SubListIterable = SubListIterable;
   exports.ListIterator$ = ListIterator$;
   exports.ListIterator = ListIterator;
   exports.MappedIterable$ = MappedIterable$;
   exports.MappedIterable = MappedIterable;
@@ skipping 54 matching lines @@
   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, core, collection, math, _interceptors, _js_primitives);