fix list literal initialization call fix typeof calls for primitive JS types add dart/collection.js…

lib/runtime/dart/_internal.js

 var _internal;
 (function(exports) {
   'use strict';
   class EfficientLength extends core.Object {
   }
   let ListIterable$ = dart.generic(function(E) {
     class ListIterable extends collection.IterableBase$(E) {
       ListIterable() {
         super.IterableBase();
       }
@@ skipping 506 matching lines @@
         return true;
       }
     }
     return ExpandIterator;
   });
   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) {
+        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$;
@@ skipping 22 matching lines @@
     return EfficientLengthTakeIterable;
   });
   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);
+        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() {
@@ skipping 52 matching lines @@
       SkipIterable(iterable, count) {
         if (dart.is(iterable, EfficientLength)) {
           return new EfficientLengthSkipIterable(iterable, count);
         }
         return new SkipIterable._(iterable, count);
       }
       SkipIterable$_(iterable$, skipCount$) {
         this[_iterable] = iterable$;
         this[_skipCount] = skipCount$;
         super.IterableBase();
-        if (!(typeof this[_skipCount] == number)) {
+        if (!(typeof this[_skipCount] == 'number')) {
           throw new core.ArgumentError.value(this[_skipCount], "count is not an integer");
         }
         core.RangeError.checkNotNegative(this[_skipCount], "count");
       }
       skip(count) {
-        if (!(typeof this[_skipCount] == number)) {
+        if (!(typeof this[_skipCount] == 'number')) {
           throw new core.ArgumentError.value(this[_skipCount], "count is not an integer");
         }
         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, '_');
@@ skipping 14 matching lines @@
     }
     return EfficientLengthSkipIterable;
   });
   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);
+        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;
       }
@@ skipping 121 matching lines @@
       }
       take(count) {
         core.RangeError.checkNotNegative(count, "count");
         return this;
       }
       takeWhile(test) {
         return this;
       }
       toList(opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
-        return growable ? new List.from([]) : new core.List(0);
+        return growable ? new core.List$(E).from([]) : new core.List(0);
       }
       toSet() {
         return new core.Set();
       }
     }
     return EmptyIterable;
   });
   let EmptyIterable = EmptyIterable$(dart.dynamic);
   let EmptyIterator$ = dart.generic(function(E) {
     class EmptyIterator extends core.Object {
@@ skipping 54 matching lines @@
         }
         return value;
       }
       static fold(iterable, initialValue, combine) {
         for (let element of iterable) {
           initialValue = dart.dinvokef(combine, initialValue, element);
         }
         return initialValue;
       }
       static removeWhereList(list, test) {
-        let retained = new List.from([]);
+        let retained = new core.List.from([]);
         let length = list.length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           let element = list.get(i);
           if (!dart.notNull(dart.dinvokef(test, element))) {
             retained.add(element);
           }
           if (length !== list.length) {
             throw new core.ConcurrentModificationError(list);
           }
         }
@@ skipping 78 matching lines @@
             }
             result = element;
             foundMatching = true;
           }
         }
         if (foundMatching)
           return result;
         throw IterableElementError.noElement();
       }
       static elementAt(iterable, index) {
-        if (!(typeof index == number))
+        if (!(typeof index == 'number'))
           throw new core.ArgumentError.notNull("index");
         core.RangeError.checkNotNegative(index, "index");
         let elementIndex = 0;
         for (let element of iterable) {
           if (index === elementIndex)
             return element;
           elementIndex = dart.notNull(elementIndex) + 1;
         }
         throw new core.RangeError.index(index, iterable, "index", null, elementIndex);
       }
@@ skipping 372 matching lines @@
       get isEmpty() {
         return this[_values].isEmpty;
       }
       get isNotEmpty() {
         return this[_values].isNotEmpty;
       }
       containsValue(value) {
         return this[_values].contains(value);
       }
       containsKey(key) {
-        return dart.notNull(typeof key == number) && dart.notNull(key) >= 0 && dart.notNull(key) < dart.notNull(this.length);
+        return dart.notNull(typeof key == 'number') && dart.notNull(key) >= 0 && dart.notNull(key) < dart.notNull(this.length);
       }
       forEach(f) {
         let length = this[_values].length;
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
           f(i, this[_values].get(i));
           if (length !== this[_values].length) {
             throw new core.ConcurrentModificationError(this[_values]);
           }
         }
       }
@@ skipping 405 matching lines @@
   Symbol.identifierRE = '(?!' + `${Symbol.reservedWordRE}` + '\\b(?!\\$))[a-zA-Z$_][\\w$]*';
   Symbol.operatorRE = '(?:[\\-+*/%&|^]|\\[\\]=?|==|~/?|<[<=]?|>[>=]?|unary-)';
   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 = /* 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]);
+  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.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 || (_internal = {}));