fixes #40, extension methods for primitive types

lib/runtime/dart/core.js

 var core = dart.defineLibrary(core, {});
 var _js_helper = dart.lazyImport(_js_helper);
 var _internal = dart.lazyImport(_internal);
 var collection = dart.lazyImport(collection);
 var _interceptors = dart.lazyImport(_interceptors);
-var math = dart.lazyImport(math);
 var convert = dart.lazyImport(convert);
-(function(exports, _js_helper, _internal, collection, _interceptors, math, convert) {
+(function(exports, _js_helper, _internal, collection, _interceptors, convert) {
   'use strict';
   class Object {
     constructor() {
       let name = this.constructor.name;
       let init = this[name];
       let result = void 0;
       if (init)
         result = init.apply(this, arguments);
       return result === void 0 ? this : result;
     }
@@ skipping 14 matching lines @@
     }
   }
   dart.setSignature(Object, {
     constructors: () => ({Object: [Object, []]}),
     methods: () => ({
       '==': [bool, [Object]],
       toString: [String, []],
       noSuchMethod: [Object, [Invocation]]
     })
   });
-  class JsName extends Object {
-    JsName(opts) {
-      let name = opts && 'name' in opts ? opts.name : null;
-      this.name = name;
-    }
-  }
-  dart.setSignature(JsName, {
-    constructors: () => ({JsName: [JsName, [], {name: String}]})
-  });
-  class JsPeerInterface extends Object {
-    JsPeerInterface(opts) {
-      let name = opts && 'name' in opts ? opts.name : null;
-      this.name = name;
-    }
-  }
-  dart.setSignature(JsPeerInterface, {
-    constructors: () => ({JsPeerInterface: [JsPeerInterface, [], {name: String}]})
-  });
-  class SupportJsExtensionMethod extends Object {
-    SupportJsExtensionMethod() {
-    }
-  }
-  dart.setSignature(SupportJsExtensionMethod, {
-    constructors: () => ({SupportJsExtensionMethod: [SupportJsExtensionMethod, []]})
-  });
   class Deprecated extends Object {
     Deprecated(expires) {
       this.expires = expires;
     }
     toString() {
       return `Deprecated feature. Will be removed ${this.expires}`;
     }
   }
   dart.setSignature(Deprecated, {
     constructors: () => ({Deprecated: [Deprecated, [String]]})
@@ skipping 28 matching lines @@
     constructors: () => ({fromEnvironment: [bool, [String], {defaultValue: bool}]})
   });
   let Comparator$ = dart.generic(function(T) {
     let Comparator = dart.typedef('Comparator', () => dart.functionType(int, [T, T]));
     return Comparator;
   });
   let Comparator = Comparator$();
   let Comparable$ = dart.generic(function(T) {
     class Comparable extends Object {
       static compare(a, b) {
-        return a.compareTo(b);
+        return a[dartx.compareTo](b);
       }
     }
     dart.setSignature(Comparable, {
       statics: () => ({compare: [int, [Comparable$(), Comparable$()]]}),
       names: ['compare']
     });
     return Comparable;
   });
   let Comparable = Comparable$();
   class DateTime extends Object {
@@ skipping 46 matching lines @@
           return double.parse(matched);
         };
         dart.fn(parseDoubleOrZero, double, [String]);
         let years = int.parse(match.get(1));
         let month = int.parse(match.get(2));
         let day = int.parse(match.get(3));
         let hour = parseIntOrZero(match.get(4));
         let minute = parseIntOrZero(match.get(5));
         let second = parseIntOrZero(match.get(6));
         let addOneMillisecond = false;
-        let millisecond = (dart.notNull(parseDoubleOrZero(match.get(7))) * 1000).round();
+        let millisecond = (dart.notNull(parseDoubleOrZero(match.get(7))) * 1000)[dartx.round]();
         if (millisecond == 1000) {
           addOneMillisecond = true;
           millisecond = 999;
         }
         let isUtc = false;
         if (match.get(8) != null) {
           isUtc = true;
           if (match.get(9) != null) {
             let sign = match.get(9) == '-' ? -1 : 1;
             let hourDifference = int.parse(match.get(10));
@@ skipping 11 matching lines @@
         }
         return new DateTime.fromMillisecondsSinceEpoch(millisecondsSinceEpoch, {isUtc: isUtc});
       } else {
         throw new FormatException("Invalid date format", formattedString);
       }
     }
     fromMillisecondsSinceEpoch(millisecondsSinceEpoch, opts) {
       let isUtc = opts && 'isUtc' in opts ? opts.isUtc : false;
       this.millisecondsSinceEpoch = millisecondsSinceEpoch;
       this.isUtc = isUtc;
-      if (dart.notNull(millisecondsSinceEpoch.abs()) > dart.notNull(DateTime._MAX_MILLISECONDS_SINCE_EPOCH)) {
+      if (dart.notNull(millisecondsSinceEpoch[dartx.abs]()) > dart.notNull(DateTime._MAX_MILLISECONDS_SINCE_EPOCH)) {
         throw new ArgumentError(millisecondsSinceEpoch);
       }
       if (isUtc == null)
         throw new ArgumentError(isUtc);
     }
     ['=='](other) {
       if (!dart.is(other, DateTime))
         return false;
       return dart.equals(this.millisecondsSinceEpoch, dart.dload(other, 'millisecondsSinceEpoch')) && dart.equals(this.isUtc, dart.dload(other, 'isUtc'));
     }
     isBefore(other) {
       return dart.notNull(this.millisecondsSinceEpoch) < dart.notNull(other.millisecondsSinceEpoch);
     }
     isAfter(other) {
       return dart.notNull(this.millisecondsSinceEpoch) > dart.notNull(other.millisecondsSinceEpoch);
     }
     isAtSameMomentAs(other) {
       return this.millisecondsSinceEpoch == other.millisecondsSinceEpoch;
     }
     compareTo(other) {
-      return this.millisecondsSinceEpoch.compareTo(other.millisecondsSinceEpoch);
+      return this.millisecondsSinceEpoch[dartx.compareTo](other.millisecondsSinceEpoch);
     }
     get hashCode() {
       return this.millisecondsSinceEpoch;
     }
     toLocal() {
       if (this.isUtc) {
         return new DateTime.fromMillisecondsSinceEpoch(this.millisecondsSinceEpoch, {isUtc: false});
       }
       return this;
     }
     toUtc() {
       if (this.isUtc)
         return this;
       return new DateTime.fromMillisecondsSinceEpoch(this.millisecondsSinceEpoch, {isUtc: true});
     }
     static _fourDigits(n) {
-      let absN = n.abs();
+      let absN = n[dartx.abs]();
       let sign = dart.notNull(n) < 0 ? "-" : "";
       if (dart.notNull(absN) >= 1000)
         return `${n}`;
       if (dart.notNull(absN) >= 100)
         return `${sign}0${absN}`;
       if (dart.notNull(absN) >= 10)
         return `${sign}00${absN}`;
       return `${sign}000${absN}`;
     }
     static _sixDigits(n) {
       dart.assert(dart.notNull(n) < -9999 || dart.notNull(n) > 9999);
-      let absN = n.abs();
+      let absN = n[dartx.abs]();
       let sign = dart.notNull(n) < 0 ? "-" : "+";
       if (dart.notNull(absN) >= 100000)
         return `${sign}${absN}`;
       return `${sign}0${absN}`;
     }
     static _threeDigits(n) {
       if (dart.notNull(n) >= 100)
         return `${n}`;
       if (dart.notNull(n) >= 10)
         return `0${n}`;
@@ skipping 85 matching lines @@
       return dart.as(_js_helper.Primitives.getSeconds(this), int);
     }
     get millisecond() {
       return dart.as(_js_helper.Primitives.getMilliseconds(this), int);
     }
     get weekday() {
       return dart.as(_js_helper.Primitives.getWeekday(this), int);
     }
   }
   DateTime[dart.implements] = () => [Comparable];
+  dart.defineExtensionMembers(DateTime, ['compareTo']);
   dart.defineNamedConstructor(DateTime, 'utc');
   dart.defineNamedConstructor(DateTime, 'now');
   dart.defineNamedConstructor(DateTime, 'fromMillisecondsSinceEpoch');
   dart.defineNamedConstructor(DateTime, '_internal');
   dart.defineNamedConstructor(DateTime, '_now');
   dart.setSignature(DateTime, {
     constructors: () => ({
       DateTime: [DateTime, [int], [int, int, int, int, int, int]],
       utc: [DateTime, [int], [int, int, int, int, int, int]],
       now: [DateTime, []],
@@ skipping 42 matching lines @@
   DateTime.SEPTEMBER = 9;
   DateTime.OCTOBER = 10;
   DateTime.NOVEMBER = 11;
   DateTime.DECEMBER = 12;
   DateTime.MONTHS_PER_YEAR = 12;
   DateTime._MAX_MILLISECONDS_SINCE_EPOCH = 8640000000000000;
   class num extends Object {
     static parse(input, onError) {
       if (onError === void 0)
         onError = null;
-      let source = input.trim();
+      let source = input[dartx.trim]();
       num._parseError = false;
       let result = int.parse(source, {onError: num._onParseErrorInt});
       if (!dart.notNull(num._parseError))
         return result;
       num._parseError = false;
       result = double.parse(source, num._onParseErrorDouble);
       if (!dart.notNull(num._parseError))
         return result;
       if (onError == null)
         throw new FormatException(input);
@@ skipping 47 matching lines @@
     _microseconds(duration) {
       this[_duration] = duration;
     }
     ['+'](other) {
       return new Duration._microseconds(dart.notNull(this[_duration]) + dart.notNull(other[_duration]));
     }
     ['-'](other) {
       return new Duration._microseconds(dart.notNull(this[_duration]) - dart.notNull(other[_duration]));
     }
     ['*'](factor) {
-      return new Duration._microseconds((dart.notNull(this[_duration]) * dart.notNull(factor)).round());
+      return new Duration._microseconds((dart.notNull(this[_duration]) * dart.notNull(factor))[dartx.round]());
     }
     ['~/'](quotient) {
       if (quotient == 0)
         throw new IntegerDivisionByZeroException();
       return new Duration._microseconds((dart.notNull(this[_duration]) / dart.notNull(quotient)).truncate());
     }
     ['<'](other) {
       return dart.notNull(this[_duration]) < dart.notNull(other[_duration]);
     }
     ['>'](other) {
@@ skipping 22 matching lines @@
     }
     get inMicroseconds() {
       return this[_duration];
     }
     ['=='](other) {
       if (!dart.is(other, Duration))
         return false;
       return dart.equals(this[_duration], dart.dload(other, _duration));
     }
     get hashCode() {
-      return dart.hashCode(this[_duration]);
+      return dart[dartx.hashCode](this[_duration]);
     }
     compareTo(other) {
-      return this[_duration].compareTo(other[_duration]);
+      return this[_duration][dartx.compareTo](other[_duration]);
     }
     toString() {
       let sixDigits = n => {
         if (dart.notNull(n) >= 100000)
           return `${n}`;
         if (dart.notNull(n) >= 10000)
           return `0${n}`;
         if (dart.notNull(n) >= 1000)
           return `00${n}`;
         if (dart.notNull(n) >= 100)
           return `000${n}`;
         if (dart.notNull(n) >= 10)
           return `0000${n}`;
         return `00000${n}`;
       };
       dart.fn(sixDigits, String, [int]);
       let twoDigits = n => {
         if (dart.notNull(n) >= 10)
           return `${n}`;
         return `0${n}`;
       };
       dart.fn(twoDigits, String, [int]);
       if (dart.notNull(this.inMicroseconds) < 0) {
         return `-${this['unary-']()}`;
       }
-      let twoDigitMinutes = twoDigits(this.inMinutes.remainder(Duration.MINUTES_PER_HOUR));
-      let twoDigitSeconds = twoDigits(this.inSeconds.remainder(Duration.SECONDS_PER_MINUTE));
-      let sixDigitUs = sixDigits(this.inMicroseconds.remainder(Duration.MICROSECONDS_PER_SECOND));
+      let twoDigitMinutes = twoDigits(this.inMinutes[dartx.remainder](Duration.MINUTES_PER_HOUR));
+      let twoDigitSeconds = twoDigits(this.inSeconds[dartx.remainder](Duration.SECONDS_PER_MINUTE));
+      let sixDigitUs = sixDigits(this.inMicroseconds[dartx.remainder](Duration.MICROSECONDS_PER_SECOND));
       return `${this.inHours}:${twoDigitMinutes}:${twoDigitSeconds}.${sixDigitUs}`;
     }
     get isNegative() {
       return dart.notNull(this[_duration]) < 0;
     }
     abs() {
-      return new Duration._microseconds(this[_duration].abs());
+      return new Duration._microseconds(this[_duration][dartx.abs]());
     }
     ['unary-']() {
       return new Duration._microseconds(-dart.notNull(this[_duration]));
     }
   }
   Duration[dart.implements] = () => [Comparable$(Duration)];
+  dart.defineExtensionMembers(Duration, ['compareTo']);
   dart.defineNamedConstructor(Duration, '_microseconds');
   dart.setSignature(Duration, {
     constructors: () => ({
       Duration: [Duration, [], {days: int, hours: int, minutes: int, seconds: int, milliseconds: int, microseconds: int}],
       _microseconds: [Duration, [int]]
     }),
     methods: () => ({
       '+': [Duration, [Duration]],
       '-': [Duration, [Duration]],
       '*': [Duration, [num]],
@@ skipping 290 matching lines @@
     }
   }
   dart.setSignature(AbstractClassInstantiationError, {
     constructors: () => ({AbstractClassInstantiationError: [AbstractClassInstantiationError, [String]]})
   });
   let _receiver = dart.JsSymbol('_receiver');
   let _memberName = dart.JsSymbol('_memberName');
   let _arguments = dart.JsSymbol('_arguments');
   let _namedArguments = dart.JsSymbol('_namedArguments');
   let _existingArgumentNames = dart.JsSymbol('_existingArgumentNames');
-  let $length = dart.JsSymbol('$length');
-  let $get = dart.JsSymbol('$get');
   class NoSuchMethodError extends Error {
     NoSuchMethodError(receiver, memberName, positionalArguments, namedArguments, existingArgumentNames) {
       if (existingArgumentNames === void 0)
         existingArgumentNames = null;
       this[_receiver] = receiver;
       this[_memberName] = memberName;
       this[_arguments] = positionalArguments;
       this[_namedArguments] = namedArguments;
       this[_existingArgumentNames] = existingArgumentNames;
       super.Error();
     }
     toString() {
       let sb = new StringBuffer();
       let i = 0;
       if (this[_arguments] != null) {
-        for (; dart.notNull(i) < dart.notNull(this[_arguments][$length]); i = dart.notNull(i) + 1) {
+        for (; dart.notNull(i) < dart.notNull(this[_arguments].length); i = dart.notNull(i) + 1) {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
-          sb.write(Error.safeToString(this[_arguments][$get](i)));
+          sb.write(Error.safeToString(this[_arguments][dartx.get](i)));
         }
       }
       if (this[_namedArguments] != null) {
         this[_namedArguments].forEach(dart.fn((key, value) => {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
           sb.write(_symbolToString(key));
           sb.write(": ");
           sb.write(Error.safeToString(value));
           i = dart.notNull(i) + 1;
         }, Object, [Symbol, Object]));
       }
       if (this[_existingArgumentNames] == null) {
         return `NoSuchMethodError : method not found: '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Arguments: [${sb}]`;
       } else {
         let actualParameters = dart.toString(sb);
         sb = new StringBuffer();
-        for (let i = 0; dart.notNull(i) < dart.notNull(this[_existingArgumentNames][$length]); i = dart.notNull(i) + 1) {
+        for (let i = 0; dart.notNull(i) < dart.notNull(this[_existingArgumentNames].length); i = dart.notNull(i) + 1) {
           if (dart.notNull(i) > 0) {
             sb.write(", ");
           }
-          sb.write(this[_existingArgumentNames][$get](i));
+          sb.write(this[_existingArgumentNames][dartx.get](i));
         }
         let formalParameters = dart.toString(sb);
         return "NoSuchMethodError: incorrect number of arguments passed to " + `method named '${this[_memberName]}'\n` + `Receiver: ${Error.safeToString(this[_receiver])}\n` + `Tried calling: ${this[_memberName]}(${actualParameters})\n` + `Found: ${this[_memberName]}(${formalParameters})`;
       }
     }
   }
   dart.setSignature(NoSuchMethodError, {
     constructors: () => ({NoSuchMethodError: [NoSuchMethodError, [Object, Symbol, List, Map$(Symbol, Object)], [List]]})
   });
   class UnsupportedError extends Error {
@@ skipping 143 matching lines @@
           report = dart.notNull(report) + ` (at offset ${offset})`;
         }
         return report;
       }
       if (offset != -1 && (dart.notNull(offset) < 0 || dart.notNull(offset) > dart.notNull(dart.as(dart.dload(this.source, 'length'), num)))) {
         offset = -1;
       }
       if (offset == -1) {
         let source = dart.as(this.source, String);
         if (dart.notNull(source.length) > 78) {
-          source = dart.notNull(source.substring(0, 75)) + "...";
+          source = dart.notNull(source[dartx.substring](0, 75)) + "...";
         }
         return `${report}\n${source}`;
       }
       let lineNum = 1;
       let lineStart = 0;
       let lastWasCR = null;
       for (let i = 0; dart.notNull(i) < dart.notNull(offset); i = dart.notNull(i) + 1) {
         let char = dart.as(dart.dsend(this.source, 'codeUnitAt', i), int);
         if (char == 10) {
           if (lineStart != i || !dart.notNull(lastWasCR)) {
@@ skipping 34 matching lines @@
           start = dart.notNull(end) - 75;
           prefix = "...";
         } else {
           start = dart.notNull(offset) - 36;
           end = dart.notNull(offset) + 36;
           prefix = postfix = "...";
         }
       }
       let slice = dart.as(dart.dsend(this.source, 'substring', start, end), String);
       let markOffset = dart.notNull(offset) - dart.notNull(start) + dart.notNull(prefix.length);
-      return `${report}${prefix}${slice}${postfix}\n${" "['*'](markOffset)}^\n`;
+      return `${report}${prefix}${slice}${postfix}\n${" "[dartx['*']](markOffset)}^\n`;
     }
   }
   FormatException[dart.implements] = () => [Exception];
   dart.setSignature(FormatException, {
     constructors: () => ({FormatException: [FormatException, [], [String, Object, int]]})
   });
   class IntegerDivisionByZeroException extends Object {
     IntegerDivisionByZeroException() {
     }
     toString() {
@@ skipping 98 matching lines @@
   dart.setSignature(int, {
     constructors: () => ({fromEnvironment: [int, [String], {defaultValue: int}]}),
     statics: () => ({parse: [int, [String], {radix: int, onError: dart.functionType(int, [String])}]}),
     names: ['parse']
   });
   class Invocation extends Object {
     get isAccessor() {
       return dart.notNull(this.isGetter) || dart.notNull(this.isSetter);
     }
   }
-  let $iterator = dart.JsSymbol('$iterator');
-  let $join = dart.JsSymbol('$join');
   let Iterable$ = dart.generic(function(E) {
     class Iterable extends Object {
       Iterable() {
       }
       static generate(count, generator) {
         if (generator === void 0)
           generator = null;
         if (dart.notNull(count) <= 0)
           return new (_internal.EmptyIterable$(E))();
         return new (exports._GeneratorIterable$(E))(count, generator);
       }
       [dart.JsSymbol.iterator]() {
-        return new dart.JsIterator(this[$iterator]);
+        return new dart.JsIterator(this[dartx.iterator]);
       }
-      [$join](separator) {
+      join(separator) {
         if (separator === void 0)
           separator = "";
         let buffer = new StringBuffer();
         buffer.writeAll(this, separator);
         return dart.toString(buffer);
       }
     }
     dart.setSignature(Iterable, {
       constructors: () => ({
         Iterable: [Iterable$(E), []],
         generate: [Iterable$(E), [int], [dart.functionType(E, [int])]]
       }),
-      methods: () => ({[$join]: [String, [], [String]]})
+      methods: () => ({join: [String, [], [String]]})
     });
     return Iterable;
   });
   let Iterable = Iterable$();
   let _Generator$ = dart.generic(function(E) {
     let _Generator = dart.typedef('_Generator', () => dart.functionType(E, [int]));
     return _Generator;
   });
   let _Generator = _Generator$();
   let _end = dart.JsSymbol('_end');
   let _start = dart.JsSymbol('_start');
   let _generator = dart.JsSymbol('_generator');
-  let $skip = dart.JsSymbol('$skip');
-  let $take = dart.JsSymbol('$take');
   let _GeneratorIterable$ = dart.generic(function(E) {
     class _GeneratorIterable extends collection.IterableBase$(E) {
       _GeneratorIterable(end, generator) {
         this[_end] = end;
         this[_start] = 0;
         this[_generator] = dart.as(generator != null ? generator : exports._GeneratorIterable$()._id, _Generator$(E));
         super.IterableBase();
       }
       slice(start, end, generator) {
         this[_start] = start;
         this[_end] = end;
         this[_generator] = generator;
         super.IterableBase();
       }
-      get [$iterator]() {
+      get iterator() {
         return new (_GeneratorIterator$(E))(this[_start], this[_end], this[_generator]);
       }
-      get [$length]() {
+      get length() {
         return dart.notNull(this[_end]) - dart.notNull(this[_start]);
       }
-      [$skip](count) {
+      skip(count) {
         RangeError.checkNotNegative(count, "count");
         if (count == 0)
           return this;
         let newStart = dart.notNull(this[_start]) + dart.notNull(count);
         if (dart.notNull(newStart) >= dart.notNull(this[_end]))
           return new (_internal.EmptyIterable$(E))();
         return new (exports._GeneratorIterable$(E)).slice(newStart, this[_end], this[_generator]);
       }
-      [$take](count) {
+      take(count) {
         RangeError.checkNotNegative(count, "count");
         if (count == 0)
           return new (_internal.EmptyIterable$(E))();
         let newEnd = dart.notNull(this[_start]) + dart.notNull(count);
         if (dart.notNull(newEnd) >= dart.notNull(this[_end]))
           return this;
         return new (exports._GeneratorIterable$(E)).slice(this[_start], newEnd, this[_generator]);
       }
       static _id(n) {
         return n;
       }
     }
     _GeneratorIterable[dart.implements] = () => [_internal.EfficientLength];
+    dart.defineExtensionMembers(_GeneratorIterable, ['skip', 'take', 'iterator', 'length']);
     dart.defineNamedConstructor(_GeneratorIterable, 'slice');
     dart.setSignature(_GeneratorIterable, {
       constructors: () => ({
         _GeneratorIterable: [exports._GeneratorIterable$(E), [int, dart.functionType(E, [int])]],
         slice: [exports._GeneratorIterable$(E), [int, int, _Generator$(E)]]
       }),
       methods: () => ({
-        [$skip]: [Iterable$(E), [int]],
-        [$take]: [Iterable$(E), [int]]
+        skip: [Iterable$(E), [int]],
+        take: [Iterable$(E), [int]]
       }),
       statics: () => ({_id: [int, [int]]}),
       names: ['_id']
     });
     return _GeneratorIterable;
   });
   dart.defineLazyClassGeneric(exports, '_GeneratorIterable', {get: _GeneratorIterable$});
   let _index = dart.JsSymbol('_index');
   let _current = dart.JsSymbol('_current');
   let _GeneratorIterator$ = dart.generic(function(E) {
@@ skipping 30 matching lines @@
     class BidirectionalIterator extends Object {}
     BidirectionalIterator[dart.implements] = () => [Iterator$(E)];
     return BidirectionalIterator;
   });
   let BidirectionalIterator = BidirectionalIterator$();
   let Iterator$ = dart.generic(function(E) {
     class Iterator extends Object {}
     return Iterator;
   });
   let Iterator = Iterator$();
-  let $set = dart.JsSymbol('$set');
-  let $add = dart.JsSymbol('$add');
-  let $checkMutable = dart.JsSymbol('$checkMutable');
-  let $checkGrowable = dart.JsSymbol('$checkGrowable');
-  let $where = dart.JsSymbol('$where');
-  let $expand = dart.JsSymbol('$expand');
-  let $forEach = dart.JsSymbol('$forEach');
-  let $map = dart.JsSymbol('$map');
-  let $takeWhile = dart.JsSymbol('$takeWhile');
-  let $skipWhile = dart.JsSymbol('$skipWhile');
-  let $reduce = dart.JsSymbol('$reduce');
-  let $fold = dart.JsSymbol('$fold');
-  let $firstWhere = dart.JsSymbol('$firstWhere');
-  let $lastWhere = dart.JsSymbol('$lastWhere');
-  let $singleWhere = dart.JsSymbol('$singleWhere');
-  let $elementAt = dart.JsSymbol('$elementAt');
-  let $first = dart.JsSymbol('$first');
-  let $last = dart.JsSymbol('$last');
-  let $single = dart.JsSymbol('$single');
-  let $any = dart.JsSymbol('$any');
-  let $every = dart.JsSymbol('$every');
-  let $contains = dart.JsSymbol('$contains');
-  let $isEmpty = dart.JsSymbol('$isEmpty');
-  let $isNotEmpty = dart.JsSymbol('$isNotEmpty');
-  let $toString = dart.JsSymbol('$toString');
-  let $toList = dart.JsSymbol('$toList');
-  let $toSet = dart.JsSymbol('$toSet');
-  let $hashCode = dart.JsSymbol('$hashCode');
-  let $addAll = dart.JsSymbol('$addAll');
-  let $reversed = dart.JsSymbol('$reversed');
-  let $sort = dart.JsSymbol('$sort');
-  let $shuffle = dart.JsSymbol('$shuffle');
-  let $indexOf = dart.JsSymbol('$indexOf');
-  let $lastIndexOf = dart.JsSymbol('$lastIndexOf');
-  let $clear = dart.JsSymbol('$clear');
-  let $insert = dart.JsSymbol('$insert');
-  let $insertAll = dart.JsSymbol('$insertAll');
-  let $setAll = dart.JsSymbol('$setAll');
-  let $remove = dart.JsSymbol('$remove');
-  let $removeAt = dart.JsSymbol('$removeAt');
-  let $removeLast = dart.JsSymbol('$removeLast');
-  let $removeWhere = dart.JsSymbol('$removeWhere');
-  let $retainWhere = dart.JsSymbol('$retainWhere');
-  let $sublist = dart.JsSymbol('$sublist');
-  let $getRange = dart.JsSymbol('$getRange');
-  let $setRange = dart.JsSymbol('$setRange');
-  let $removeRange = dart.JsSymbol('$removeRange');
-  let $fillRange = dart.JsSymbol('$fillRange');
-  let $replaceRange = dart.JsSymbol('$replaceRange');
-  let $asMap = dart.JsSymbol('$asMap');
   let List$ = dart.generic(function(E) {
     class List extends Object {
       static new(length) {
         if (length === void 0)
           length = null;
         let list = null;
         if (length == null) {
           list = [];
         } else {
           if (!(typeof length == 'number') || dart.notNull(length) < 0) {
             throw new ArgumentError(`Length must be a non-negative integer: ${length}`);
           }
-          list = new Array(length);
-          list.fixed$length = Array;
+          list = _interceptors.JSArray.markFixedList(dart.as(new Array(length), List$()));
         }
-        dart.setType(list, List$(E));
-        return dart.as(list, List$(E));
+        return _interceptors.JSArray$(E).typed(list);
       }
       static filled(length, fill) {
         let result = List$(E).new(length);
         if (length != 0 && dart.notNull(fill != null)) {
-          for (let i = 0; dart.notNull(i) < dart.notNull(result[$length]); i = dart.notNull(i) + 1) {
-            result[$set](i, fill);
+          for (let i = 0; dart.notNull(i) < dart.notNull(result.length); i = dart.notNull(i) + 1) {
+            result[dartx.set](i, fill);
           }
         }
         return result;
       }
       static from(elements, opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let list = List$(E).new();
         for (let e of elements) {
-          list[$add](dart.as(e, E));
+          list[dartx.add](dart.as(e, E));
         }
         if (growable)
           return list;
         return dart.as(_internal.makeListFixedLength(list), List$(E));
       }
       static generate(length, generator, opts) {
         let growable = opts && 'growable' in opts ? opts.growable : true;
         let result = null;
         if (growable) {
-          result = dart.setType([], List$(E));
-          result[$length] = length;
+          result = dart.list([], E);
+          result.length = length;
         } else {
           result = List$(E).new(length);
         }
         for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          result[$set](i, generator(i));
+          result[dartx.set](i, generator(i));
         }
         return result;
       }
-      [$checkMutable](reason) {}
-      [$checkGrowable](reason) {}
-      [$where](f) {
-        dart.as(f, dart.functionType(bool, [E]));
-        return new (_internal.IterableMixinWorkaround$(E))().where(this, f);
-      }
-      [$expand](f) {
-        dart.as(f, dart.functionType(Iterable, [E]));
-        return _internal.IterableMixinWorkaround.expand(this, f);
-      }
-      [$forEach](f) {
-        dart.as(f, dart.functionType(dart.void, [E]));
-        let length = this[$length];
-        for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
-          f(dart.as(this[i], E));
-          if (length != this[$length]) {
-            throw new ConcurrentModificationError(this);
-          }
-        }
-      }
-      [$map](f) {
-        dart.as(f, dart.functionType(Object, [E]));
-        return _internal.IterableMixinWorkaround.mapList(this, f);
-      }
-      [$join](separator) {
-        if (separator === void 0)
-          separator = "";
-        let list = List$().new(this[$length]);
-        for (let i = 0; dart.notNull(i) < dart.notNull(this[$length]); i = dart.notNull(i) + 1) {
-          list[$set](i, `${this[$get](i)}`);
-        }
-        return list.join(separator);
-      }
-      [$take](n) {
-        return new (_internal.IterableMixinWorkaround$(E))().takeList(this, n);
-      }
-      [$takeWhile](test) {
-        dart.as(test, dart.functionType(bool, [E]));
-        return new (_internal.IterableMixinWorkaround$(E))().takeWhile(this, test);
-      }
-      [$skip](n) {
-        return new (_internal.IterableMixinWorkaround$(E))().skipList(this, n);
-      }
-      [$skipWhile](test) {
-        dart.as(test, dart.functionType(bool, [E]));
-        return new (_internal.IterableMixinWorkaround$(E))().skipWhile(this, test);
-      }
-      [$reduce](combine) {
-        dart.as(combine, dart.functionType(E, [E, E]));
-        return dart.as(_internal.IterableMixinWorkaround.reduce(this, combine), E);
-      }
-      [$fold](initialValue, combine) {
-        dart.as(combine, dart.functionType(Object, [dart.bottom, E]));
-        return _internal.IterableMixinWorkaround.fold(this, initialValue, combine);
-      }
-      [$firstWhere](test, opts) {
-        dart.as(test, dart.functionType(bool, [E]));
-        let orElse = opts && 'orElse' in opts ? opts.orElse : null;
-        dart.as(orElse, dart.functionType(E, []));
-        return dart.as(_internal.IterableMixinWorkaround.firstWhere(this, test, orElse), E);
-      }
-      [$lastWhere](test, opts) {
-        dart.as(test, dart.functionType(bool, [E]));
-        let orElse = opts && 'orElse' in opts ? opts.orElse : null;
-        dart.as(orElse, dart.functionType(E, []));
-        return dart.as(_internal.IterableMixinWorkaround.lastWhereList(this, test, orElse), E);
-      }
-      [$singleWhere](test) {
-        dart.as(test, dart.functionType(bool, [E]));
-        return dart.as(_internal.IterableMixinWorkaround.singleWhere(this, test), E);
-      }
-      [$elementAt](index) {
-        return this[$get](index);
-      }
-      get [$first]() {
-        if (dart.notNull(this[$length]) > 0)
-          return this[$get](0);
-        throw new StateError("No elements");
-      }
-      get [$last]() {
-        if (dart.notNull(this[$length]) > 0)
-          return this[$get](dart.notNull(this[$length]) - 1);
-        throw new StateError("No elements");
-      }
-      get [$single]() {
-        if (this[$length] == 1)
-          return this[$get](0);
-        if (this[$length] == 0)
-          throw new StateError("No elements");
-        throw new StateError("More than one element");
-      }
-      [$any](f) {
-        dart.as(f, dart.functionType(bool, [E]));
-        return _internal.IterableMixinWorkaround.any(this, f);
-      }
-      [$every](f) {
-        dart.as(f, dart.functionType(bool, [E]));
-        return _internal.IterableMixinWorkaround.every(this, f);
-      }
-      [$contains](other) {
-        for (let i = 0; dart.notNull(i) < dart.notNull(this[$length]); i = dart.notNull(i) + 1) {
-          if (dart.equals(this[$get](i), other))
-            return true;
-        }
-        return false;
-      }
-      get [$isEmpty]() {
-        return this[$length] == 0;
-      }
-      get [$isNotEmpty]() {
-        return !dart.notNull(this[$isEmpty]);
-      }
-      [$toString]() {
-        return collection.ListBase.listToString(this);
-      }
-      [$toList](opts) {
-        let growable = opts && 'growable' in opts ? opts.growable : true;
-        return dart.as(dart.setType(this.slice(), core.List$(E)), List$(E));
-      }
-      [$toSet]() {
-        return exports.Set$(E).from(this);
-      }
-      get [$iterator]() {
-        return new (_internal.ListIterator$(E))(this);
-      }
-      get [$hashCode]() {
-        return _js_helper.Primitives.objectHashCode(this);
-      }
-      [$get](index) {
-        if (!(typeof index == 'number'))
-          throw new ArgumentError(index);
-        if (dart.notNull(index) >= dart.notNull(this[$length]) || dart.notNull(index) < 0)
-          throw new RangeError.value(index);
-        return dart.as(this[index], E);
-      }
-      [$set](index, value) {
-        dart.as(value, E);
-        this[$checkMutable]('indexed set');
-        if (!(typeof index == 'number'))
-          throw new ArgumentError(index);
-        if (dart.notNull(index) >= dart.notNull(this[$length]) || dart.notNull(index) < 0)
-          throw new RangeError.value(index);
-        this[index] = value;
-      }
-      get [$length]() {
-        return dart.as(this.length, int);
-      }
-      set [$length](newLength) {
-        if (!(typeof newLength == 'number'))
-          throw new ArgumentError(newLength);
-        if (dart.notNull(newLength) < 0)
-          throw new RangeError.value(newLength);
-        this[$checkGrowable]('set length');
-        this.length = newLength;
-      }
-      [$add](value) {
-        dart.as(value, E);
-        this[$checkGrowable]('add');
-        this.push(value);
-      }
-      [$addAll](iterable) {
-        dart.as(iterable, Iterable$(E));
-        for (let e of iterable) {
-          this[$add](e);
-        }
-      }
-      get [$reversed]() {
-        return new (_internal.IterableMixinWorkaround$(E))().reversedList(this);
-      }
-      [$sort](compare) {
-        if (compare === void 0)
-          compare = null;
-        dart.as(compare, dart.functionType(int, [E, E]));
-        this[$checkMutable]('sort');
-        _internal.IterableMixinWorkaround.sortList(this, compare);
-      }
-      [$shuffle](random) {
-        if (random === void 0)
-          random = null;
-        _internal.IterableMixinWorkaround.shuffleList(this, random);
-      }
-      [$indexOf](element, start) {
-        dart.as(element, E);
-        if (start === void 0)
-          start = 0;
-        return _internal.IterableMixinWorkaround.indexOfList(this, element, start);
-      }
-      [$lastIndexOf](element, start) {
-        dart.as(element, E);
-        if (start === void 0)
-          start = null;
-        return _internal.IterableMixinWorkaround.lastIndexOfList(this, element, start);
-      }
-      [$clear]() {
-        this[$length] = 0;
-      }
-      [$insert](index, element) {
-        dart.as(element, E);
-        if (!(typeof index == 'number'))
-          throw new ArgumentError(index);
-        if (dart.notNull(index) < 0 || dart.notNull(index) > dart.notNull(this[$length])) {
-          throw new RangeError.value(index);
-        }
-        this[$checkGrowable]('insert');
-        this.splice(index, 0, element);
-      }
-      [$insertAll](index, iterable) {
-        dart.as(iterable, Iterable$(E));
-        this[$checkGrowable]('insertAll');
-        _internal.IterableMixinWorkaround.insertAllList(this, index, iterable);
-      }
-      [$setAll](index, iterable) {
-        dart.as(iterable, Iterable$(E));
-        this[$checkMutable]('setAll');
-        _internal.IterableMixinWorkaround.setAllList(this, index, iterable);
-      }
-      [$remove](element) {
-        this[$checkGrowable]('remove');
-        for (let i = 0; dart.notNull(i) < dart.notNull(this[$length]); i = dart.notNull(i) + 1) {
-          if (dart.equals(this[$get](i), /* Unimplemented unknown name */value)) {
-            this.splice(i, 1);
-            return true;
-          }
-        }
-        return false;
-      }
-      [$removeAt](index) {
-        if (!(typeof index == 'number'))
-          throw new ArgumentError(index);
-        if (dart.notNull(index) < 0 || dart.notNull(index) >= dart.notNull(this[$length])) {
-          throw new RangeError.value(index);
-        }
-        this[$checkGrowable]('removeAt');
-        return dart.as(this.splice(index, 1)[0], E);
-      }
-      [$removeLast]() {
-        this[$checkGrowable]('removeLast');
-        if (this[$length] == 0)
-          throw new RangeError.value(-1);
-        return dart.as(this.pop(), E);
-      }
-      [$removeWhere](test) {
-        dart.as(test, dart.functionType(bool, [E]));
-        _internal.IterableMixinWorkaround.removeWhereList(this, test);
-      }
-      [$retainWhere](test) {
-        dart.as(test, dart.functionType(bool, [E]));
-        _internal.IterableMixinWorkaround.removeWhereList(this, dart.fn(element => !dart.notNull(test(element)), bool, [E]));
-      }
-      [$sublist](start, end) {
-        if (end === void 0)
-          end = null;
-        dart.dcall(/* Unimplemented unknown name */checkNull, start);
-        if (!(typeof start == 'number'))
-          throw new ArgumentError(start);
-        if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(this[$length])) {
-          throw new RangeError.range(start, 0, this[$length]);
-        }
-        if (end == null) {
-          end = this[$length];
-        } else {
-          if (!(typeof end == 'number'))
-            throw new ArgumentError(end);
-          if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(this[$length])) {
-            throw new RangeError.range(end, start, this[$length]);
-          }
-        }
-        if (start == end)
-          return dart.setType([], List$(E));
-        return _interceptors.JSArray$(E).markGrowable(this.slice(start, end));
-      }
-      [$getRange](start, end) {
-        return new (_internal.IterableMixinWorkaround$(E))().getRangeList(this, start, end);
-      }
-      [$setRange](start, end, iterable, skipCount) {
-        dart.as(iterable, Iterable$(E));
-        if (skipCount === void 0)
-          skipCount = 0;
-        this[$checkMutable]('set range');
-        _internal.IterableMixinWorkaround.setRangeList(this, start, end, iterable, skipCount);
-      }
-      [$removeRange](start, end) {
-        this[$checkGrowable]('removeRange');
-        let receiverLength = this[$length];
-        if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(receiverLength)) {
-          throw new RangeError.range(start, 0, receiverLength);
-        }
-        if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(receiverLength)) {
-          throw new RangeError.range(end, start, receiverLength);
-        }
-        _internal.Lists.copy(this, end, this, start, dart.notNull(receiverLength) - dart.notNull(end));
-        this[$length] = dart.notNull(receiverLength) - (dart.notNull(end) - dart.notNull(start));
-      }
-      [$fillRange](start, end, fillValue) {
-        if (fillValue === void 0)
-          fillValue = null;
-        dart.as(fillValue, E);
-        this[$checkMutable]('fill range');
-        _internal.IterableMixinWorkaround.fillRangeList(this, start, end, fillValue);
-      }
-      [$replaceRange](start, end, replacement) {
-        dart.as(replacement, Iterable$(E));
-        this[$checkGrowable]('removeRange');
-        _internal.IterableMixinWorkaround.replaceRangeList(this, start, end, replacement);
-      }
-      [$asMap]() {
-        return new (_internal.IterableMixinWorkaround$(E))().asMapList(this);
+      [dart.JsSymbol.iterator]() {
+        return new dart.JsIterator(this[dartx.iterator]);
       }
     }
-    dart.setBaseClass(List, dart.global.Array);
-    List[dart.implements] = () => [Iterable$(E), _internal.EfficientLength];
+    List[dart.implements] = () => [Iterable$(E)];
     dart.setSignature(List, {
       constructors: () => ({
         new: [List$(E), [], [int]],
         filled: [List$(E), [int, E]],
         from: [List$(E), [Iterable], {growable: bool}],
         generate: [List$(E), [int, dart.functionType(E, [int])], {growable: bool}]
-      }),
-      methods: () => ({
-        [$checkMutable]: [Object, [Object]],
-        [$checkGrowable]: [Object, [Object]],
-        [$where]: [Iterable$(E), [dart.functionType(bool, [E])]],
-        [$expand]: [Iterable, [dart.functionType(Iterable, [E])]],
-        [$forEach]: [dart.void, [dart.functionType(dart.void, [E])]],
-        [$map]: [Iterable, [dart.functionType(Object, [E])]],
-        [$join]: [String, [], [String]],
-        [$take]: [Iterable$(E), [int]],
-        [$takeWhile]: [Iterable$(E), [dart.functionType(bool, [E])]],
-        [$skip]: [Iterable$(E), [int]],
-        [$skipWhile]: [Iterable$(E), [dart.functionType(bool, [E])]],
-        [$reduce]: [E, [dart.functionType(E, [E, E])]],
-        [$fold]: [Object, [Object, dart.functionType(Object, [dart.bottom, E])]],
-        [$firstWhere]: [E, [dart.functionType(bool, [E])], {orElse: dart.functionType(E, [])}],
-        [$lastWhere]: [E, [dart.functionType(bool, [E])], {orElse: dart.functionType(E, [])}],
-        [$singleWhere]: [E, [dart.functionType(bool, [E])]],
-        [$elementAt]: [E, [int]],
-        [$any]: [bool, [dart.functionType(bool, [E])]],
-        [$every]: [bool, [dart.functionType(bool, [E])]],
-        [$contains]: [bool, [Object]],
-        [$toList]: [List$(E), [], {growable: bool}],
-        [$toSet]: [exports.Set$(E), []],
-        [$get]: [E, [int]],
-        [$set]: [dart.void, [int, E]],
-        [$add]: [dart.void, [E]],
-        [$addAll]: [dart.void, [Iterable$(E)]],
-        [$sort]: [dart.void, [], [dart.functionType(int, [E, E])]],
-        [$shuffle]: [dart.void, [], [math.Random]],
-        [$indexOf]: [int, [E], [int]],
-        [$lastIndexOf]: [int, [E], [int]],
-        [$clear]: [dart.void, []],
-        [$insert]: [dart.void, [int, E]],
-        [$insertAll]: [dart.void, [int, Iterable$(E)]],
-        [$setAll]: [dart.void, [int, Iterable$(E)]],
-        [$remove]: [bool, [Object]],
-        [$removeAt]: [E, [int]],
-        [$removeLast]: [E, []],
-        [$removeWhere]: [dart.void, [dart.functionType(bool, [E])]],
-        [$retainWhere]: [dart.void, [dart.functionType(bool, [E])]],
-        [$sublist]: [List$(E), [int], [int]],
-        [$getRange]: [Iterable$(E), [int, int]],
-        [$setRange]: [dart.void, [int, int, Iterable$(E)], [int]],
-        [$removeRange]: [dart.void, [int, int]],
-        [$fillRange]: [dart.void, [int, int], [E]],
-        [$replaceRange]: [dart.void, [int, int, Iterable$(E)]],
-        [$asMap]: [Map$(int, E), []]
       })
     });
     return List;
   });
   let List = List$();
-  dart.registerExtension(dart.global.Array, List);
   let Map$ = dart.generic(function(K, V) {
     class Map extends Object {
       static new() {
         return collection.LinkedHashMap$(K, V).new();
       }
       static from(other) {
         return collection.LinkedHashMap$(K, V).from(other);
       }
       static identity() {
         return collection.LinkedHashMap$(K, V).identity();
@@ skipping 156 matching lines @@
   class String extends Object {
     static fromCharCodes(charCodes, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       if (!dart.is(charCodes, _interceptors.JSArray)) {
         return String._stringFromIterable(charCodes, start, end);
       }
       let list = dart.as(charCodes, List);
-      let len = list[$length];
+      let len = list.length;
       if (dart.notNull(start) < 0 || dart.notNull(start) > dart.notNull(len)) {
         throw new RangeError.range(start, 0, len);
       }
       if (end == null) {
         end = len;
       } else if (dart.notNull(end) < dart.notNull(start) || dart.notNull(end) > dart.notNull(len)) {
         throw new RangeError.range(end, start, len);
       }
       if (dart.notNull(start) > 0 || dart.notNull(end) < dart.notNull(len)) {
-        list = list[$sublist](start, end);
+        list = list[dartx.sublist](start, end);
       }
       return _js_helper.Primitives.stringFromCharCodes(list);
     }
     static fromCharCode(charCode) {
       return _js_helper.Primitives.stringFromCharCode(charCode);
     }
     static fromEnvironment(name, opts) {
       let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
       throw new UnsupportedError('String.fromEnvironment can only be used as a const constructor');
     }
     static _stringFromIterable(charCodes, start, end) {
       if (dart.notNull(start) < 0)
-        throw new RangeError.range(start, 0, charCodes[$length]);
+        throw new RangeError.range(start, 0, charCodes.length);
       if (end != null && dart.notNull(end) < dart.notNull(start)) {
-        throw new RangeError.range(end, start, charCodes[$length]);
+        throw new RangeError.range(end, start, charCodes.length);
       }
-      let it = charCodes[$iterator];
+      let it = charCodes[dartx.iterator];
       for (let i = 0; dart.notNull(i) < dart.notNull(start); i = dart.notNull(i) + 1) {
         if (!dart.notNull(it.moveNext())) {
           throw new RangeError.range(start, 0, i);
         }
       }
       let list = [];
       if (end == null) {
         while (it.moveNext())
-          list[$add](it.current);
+          list[dartx.add](it.current);
       } else {
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           if (!dart.notNull(it.moveNext())) {
             throw new RangeError.range(end, start, i);
           }
-          list[$add](it.current);
+          list[dartx.add](it.current);
         }
       }
       return _js_helper.Primitives.stringFromCharCodes(list);
     }
   }
   String[dart.implements] = () => [Comparable$(String), Pattern];
   dart.setSignature(String, {
     constructors: () => ({
       fromCharCodes: [String, [Iterable$(int)], [int, int]],
       fromCharCode: [String, [int]],
       fromEnvironment: [String, [String], {defaultValue: String}]
     }),
     statics: () => ({_stringFromIterable: [String, [Iterable$(int), int, int]]}),
     names: ['_stringFromIterable']
   });
   dart.defineLazyClass(exports, {
     get Runes() {
       class Runes extends collection.IterableBase$(int) {
         Runes(string) {
           this.string = string;
           super.IterableBase();
         }
-        get [$iterator]() {
+        get iterator() {
           return new RuneIterator(this.string);
         }
-        get [$last]() {
+        get last() {
           if (this.string.length == 0) {
             throw new StateError('No elements.');
           }
           let length = this.string.length;
-          let code = this.string.codeUnitAt(dart.notNull(length) - 1);
+          let code = this.string[dartx.codeUnitAt](dart.notNull(length) - 1);
           if (dart.notNull(_isTrailSurrogate(code)) && dart.notNull(this.string.length) > 1) {
-            let previousCode = this.string.codeUnitAt(dart.notNull(length) - 2);
+            let previousCode = this.string[dartx.codeUnitAt](dart.notNull(length) - 2);
             if (_isLeadSurrogate(previousCode)) {
               return _combineSurrogatePair(previousCode, code);
             }
           }
           return code;
         }
       }
       dart.setSignature(Runes, {
         constructors: () => ({Runes: [exports.Runes, [String]]})
       });
@@ skipping 25 matching lines @@
     }
     at(string, index) {
       this.string = string;
       this[_position] = index;
       this[_nextPosition] = index;
       this[_currentCodePoint] = null;
       RangeError.checkValueInInterval(index, 0, string.length);
       this[_checkSplitSurrogate](index);
     }
     [_checkSplitSurrogate](index) {
-      if (dart.notNull(index) > 0 && dart.notNull(index) < dart.notNull(this.string.length) && dart.notNull(_isLeadSurrogate(this.string.codeUnitAt(dart.notNull(index) - 1))) && dart.notNull(_isTrailSurrogate(this.string.codeUnitAt(index)))) {
+      if (dart.notNull(index) > 0 && dart.notNull(index) < dart.notNull(this.string.length) && dart.notNull(_isLeadSurrogate(this.string[dartx.codeUnitAt](dart.notNull(index) - 1))) && dart.notNull(_isTrailSurrogate(this.string[dartx.codeUnitAt](index)))) {
         throw new ArgumentError(`Index inside surrogate pair: ${index}`);
       }
     }
     get rawIndex() {
       return this[_position] != this[_nextPosition] ? this[_position] : null;
     }
     set rawIndex(rawIndex) {
       RangeError.checkValidIndex(rawIndex, this.string, "rawIndex");
       this.reset(rawIndex);
       this.moveNext();
     }
     reset(rawIndex) {
       if (rawIndex === void 0)
         rawIndex = 0;
       RangeError.checkValueInInterval(rawIndex, 0, this.string.length, "rawIndex");
       this[_checkSplitSurrogate](rawIndex);
       this[_position] = this[_nextPosition] = rawIndex;
       this[_currentCodePoint] = null;
     }
     get current() {
       return this[_currentCodePoint];
     }
     get currentSize() {
       return dart.notNull(this[_nextPosition]) - dart.notNull(this[_position]);
     }
     get currentAsString() {
       if (this[_position] == this[_nextPosition])
         return null;
       if (dart.notNull(this[_position]) + 1 == this[_nextPosition])
-        return this.string.get(this[_position]);
-      return this.string.substring(this[_position], this[_nextPosition]);
+        return this.string[dartx.get](this[_position]);
+      return this.string[dartx.substring](this[_position], this[_nextPosition]);
     }
     moveNext() {
       this[_position] = this[_nextPosition];
       if (this[_position] == this.string.length) {
         this[_currentCodePoint] = null;
         return false;
       }
-      let codeUnit = this.string.codeUnitAt(this[_position]);
+      let codeUnit = this.string[dartx.codeUnitAt](this[_position]);
       let nextPosition = dart.notNull(this[_position]) + 1;
       if (dart.notNull(_isLeadSurrogate(codeUnit)) && dart.notNull(nextPosition) < dart.notNull(this.string.length)) {
-        let nextCodeUnit = this.string.codeUnitAt(nextPosition);
+        let nextCodeUnit = this.string[dartx.codeUnitAt](nextPosition);
         if (_isTrailSurrogate(nextCodeUnit)) {
           this[_nextPosition] = dart.notNull(nextPosition) + 1;
           this[_currentCodePoint] = _combineSurrogatePair(codeUnit, nextCodeUnit);
           return true;
         }
       }
       this[_nextPosition] = nextPosition;
       this[_currentCodePoint] = codeUnit;
       return true;
     }
     movePrevious() {
       this[_nextPosition] = this[_position];
       if (this[_position] == 0) {
         this[_currentCodePoint] = null;
         return false;
       }
       let position = dart.notNull(this[_position]) - 1;
-      let codeUnit = this.string.codeUnitAt(position);
+      let codeUnit = this.string[dartx.codeUnitAt](position);
       if (dart.notNull(_isTrailSurrogate(codeUnit)) && dart.notNull(position) > 0) {
-        let prevCodeUnit = this.string.codeUnitAt(dart.notNull(position) - 1);
+        let prevCodeUnit = this.string[dartx.codeUnitAt](dart.notNull(position) - 1);
         if (_isLeadSurrogate(prevCodeUnit)) {
           this[_position] = dart.notNull(position) - 1;
           this[_currentCodePoint] = _combineSurrogatePair(prevCodeUnit, codeUnit);
           return true;
         }
       }
       this[_position] = position;
       this[_currentCodePoint] = codeUnit;
       return true;
     }
@@ skipping 31 matching lines @@
     }
     write(obj) {
       this[_writeString](`${obj}`);
     }
     writeCharCode(charCode) {
       this[_writeString](String.fromCharCode(charCode));
     }
     writeAll(objects, separator) {
       if (separator === void 0)
         separator = "";
-      let iterator = objects[$iterator];
+      let iterator = objects[dartx.iterator];
       if (!dart.notNull(iterator.moveNext()))
         return;
-      if (separator.isEmpty) {
+      if (separator[dartx.isEmpty]) {
         do {
           this.write(iterator.current);
         } while (iterator.moveNext());
       } else {
         this.write(iterator.current);
         while (iterator.moveNext()) {
           this.write(separator);
           this.write(iterator.current);
         }
       }
@@ skipping 58 matching lines @@
       let sb = new StringBuffer();
       this[_writeAuthority](sb);
       return dart.toString(sb);
     }
     get userInfo() {
       return this[_userInfo];
     }
     get host() {
       if (this[_host] == null)
         return "";
-      if (this[_host].startsWith('[')) {
-        return this[_host].substring(1, dart.notNull(this[_host].length) - 1);
+      if (this[_host][dartx.startsWith]('[')) {
+        return this[_host][dartx.substring](1, dart.notNull(this[_host].length) - 1);
       }
       return this[_host];
     }
     get port() {
       if (this[_port] == null)
         return Uri._defaultPort(this.scheme);
       return this[_port];
     }
     static _defaultPort(scheme) {
       if (scheme == "http")
         return 80;
       if (scheme == "https")
         return 443;
       return 0;
     }
     get path() {
       return this[_path];
     }
     get query() {
       return this[_query] == null ? "" : this[_query];
     }
     get fragment() {
       return this[_fragment] == null ? "" : this[_fragment];
     }
     static parse(uri) {
       let isRegName = ch => {
-        return dart.notNull(ch) < 128 && dart.notNull(!dart.equals(dart.dsend(Uri._regNameTable[$get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
+        return dart.notNull(ch) < 128 && dart.notNull(!dart.equals(dart.dsend(Uri._regNameTable[dartx.get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
       };
       dart.fn(isRegName, bool, [int]);
       let EOI = -1;
       let scheme = "";
       let userinfo = "";
       let host = null;
       let port = null;
       let path = null;
       let query = null;
       let fragment = null;
       let index = 0;
       let pathStart = 0;
       let char = EOI;
       let parseAuth = () => {
         if (index == uri.length) {
           char = EOI;
           return;
         }
         let authStart = index;
         let lastColon = -1;
         let lastAt = -1;
-        char = uri.codeUnitAt(index);
+        char = uri[dartx.codeUnitAt](index);
         while (dart.notNull(index) < dart.notNull(uri.length)) {
-          char = uri.codeUnitAt(index);
+          char = uri[dartx.codeUnitAt](index);
           if (char == Uri._SLASH || char == Uri._QUESTION || char == Uri._NUMBER_SIGN) {
             break;
           }
           if (char == Uri._AT_SIGN) {
             lastAt = index;
             lastColon = -1;
           } else if (char == Uri._COLON) {
             lastColon = index;
           } else if (char == Uri._LEFT_BRACKET) {
             lastColon = -1;
-            let endBracket = uri.indexOf(']', dart.notNull(index) + 1);
+            let endBracket = uri[dartx.indexOf](']', dart.notNull(index) + 1);
             if (endBracket == -1) {
               index = uri.length;
               char = EOI;
               break;
             } else {
               index = endBracket;
             }
           }
           index = dart.notNull(index) + 1;
           char = EOI;
         }
         let hostStart = authStart;
         let hostEnd = index;
         if (dart.notNull(lastAt) >= 0) {
           userinfo = Uri._makeUserInfo(uri, authStart, lastAt);
           hostStart = dart.notNull(lastAt) + 1;
         }
         if (dart.notNull(lastColon) >= 0) {
           let portNumber = null;
           if (dart.notNull(lastColon) + 1 < dart.notNull(index)) {
             portNumber = 0;
             for (let i = dart.notNull(lastColon) + 1; dart.notNull(i) < dart.notNull(index); i = dart.notNull(i) + 1) {
-              let digit = uri.codeUnitAt(i);
+              let digit = uri[dartx.codeUnitAt](i);
               if (dart.notNull(Uri._ZERO) > dart.notNull(digit) || dart.notNull(Uri._NINE) < dart.notNull(digit)) {
                 Uri._fail(uri, i, "Invalid port number");
               }
               portNumber = dart.notNull(portNumber) * 10 + (dart.notNull(digit) - dart.notNull(Uri._ZERO));
             }
           }
           port = Uri._makePort(portNumber, scheme);
           hostEnd = lastColon;
         }
         host = Uri._makeHost(uri, hostStart, hostEnd, true);
         if (dart.notNull(index) < dart.notNull(uri.length)) {
-          char = uri.codeUnitAt(index);
+          char = uri[dartx.codeUnitAt](index);
         }
       };
       dart.fn(parseAuth, dart.void, []);
       let NOT_IN_PATH = 0;
       let IN_PATH = 1;
       let ALLOW_AUTH = 2;
       let state = NOT_IN_PATH;
       let i = index;
       while (dart.notNull(i) < dart.notNull(uri.length)) {
-        char = uri.codeUnitAt(i);
+        char = uri[dartx.codeUnitAt](i);
         if (char == Uri._QUESTION || char == Uri._NUMBER_SIGN) {
           state = NOT_IN_PATH;
           break;
         }
         if (char == Uri._SLASH) {
           state = i == 0 ? ALLOW_AUTH : IN_PATH;
           break;
         }
         if (char == Uri._COLON) {
           if (i == 0)
             Uri._fail(uri, 0, "Invalid empty scheme");
           scheme = Uri._makeScheme(uri, i);
           i = dart.notNull(i) + 1;
           pathStart = i;
           if (i == uri.length) {
             char = EOI;
             state = NOT_IN_PATH;
           } else {
-            char = uri.codeUnitAt(i);
+            char = uri[dartx.codeUnitAt](i);
             if (char == Uri._QUESTION || char == Uri._NUMBER_SIGN) {
               state = NOT_IN_PATH;
             } else if (char == Uri._SLASH) {
               state = ALLOW_AUTH;
             } else {
               state = IN_PATH;
             }
           }
           break;
         }
         i = dart.notNull(i) + 1;
         char = EOI;
       }
       index = i;
       if (state == ALLOW_AUTH) {
         dart.assert(char == Uri._SLASH);
         index = dart.notNull(index) + 1;
         if (index == uri.length) {
           char = EOI;
           state = NOT_IN_PATH;
         } else {
-          char = uri.codeUnitAt(index);
+          char = uri[dartx.codeUnitAt](index);
           if (char == Uri._SLASH) {
             index = dart.notNull(index) + 1;
             parseAuth();
             pathStart = index;
           }
           if (char == Uri._QUESTION || char == Uri._NUMBER_SIGN || char == EOI) {
             state = NOT_IN_PATH;
           } else {
             state = IN_PATH;
           }
         }
       }
       dart.assert(state == IN_PATH || state == NOT_IN_PATH);
       if (state == IN_PATH) {
         while ((index = dart.notNull(index) + 1) < dart.notNull(uri.length)) {
-          char = uri.codeUnitAt(index);
+          char = uri[dartx.codeUnitAt](index);
           if (char == Uri._QUESTION || char == Uri._NUMBER_SIGN) {
             break;
           }
           char = EOI;
         }
         state = NOT_IN_PATH;
       }
       dart.assert(state == NOT_IN_PATH);
       let isFile = scheme == "file";
       let ensureLeadingSlash = host != null;
       path = Uri._makePath(uri, pathStart, index, null, ensureLeadingSlash, isFile);
       if (char == Uri._QUESTION) {
-        let numberSignIndex = uri.indexOf('#', dart.notNull(index) + 1);
+        let numberSignIndex = uri[dartx.indexOf]('#', dart.notNull(index) + 1);
         if (dart.notNull(numberSignIndex) < 0) {
           query = Uri._makeQuery(uri, dart.notNull(index) + 1, uri.length, null);
         } else {
           query = Uri._makeQuery(uri, dart.notNull(index) + 1, numberSignIndex, null);
           fragment = Uri._makeFragment(uri, dart.notNull(numberSignIndex) + 1, uri.length);
         }
       } else if (char == Uri._NUMBER_SIGN) {
         fragment = Uri._makeFragment(uri, dart.notNull(index) + 1, uri.length);
       }
       return new Uri._internal(scheme, userinfo, host, port, path, query, fragment);
@@ skipping 24 matching lines @@
       let fragment = opts && 'fragment' in opts ? opts.fragment : null;
       scheme = Uri._makeScheme(scheme, Uri._stringOrNullLength(scheme));
       userInfo = Uri._makeUserInfo(userInfo, 0, Uri._stringOrNullLength(userInfo));
       host = Uri._makeHost(host, 0, Uri._stringOrNullLength(host), false);
       if (query == "")
         query = null;
       query = Uri._makeQuery(query, 0, Uri._stringOrNullLength(query), queryParameters);
       fragment = Uri._makeFragment(fragment, 0, Uri._stringOrNullLength(fragment));
       port = Uri._makePort(port, scheme);
       let isFile = scheme == "file";
-      if (host == null && (dart.notNull(userInfo.isNotEmpty) || port != null || dart.notNull(isFile))) {
+      if (host == null && (dart.notNull(userInfo[dartx.isNotEmpty]) || port != null || dart.notNull(isFile))) {
         host = "";
       }
       let ensureLeadingSlash = host != null;
       path = Uri._makePath(path, 0, Uri._stringOrNullLength(path), pathSegments, ensureLeadingSlash, isFile);
       return new Uri._internal(scheme, userInfo, host, port, path, query, fragment);
     }
     static http(authority, unencodedPath, queryParameters) {
       if (queryParameters === void 0)
         queryParameters = null;
       return Uri._makeHttpUri("http", authority, unencodedPath, queryParameters);
     }
     static https(authority, unencodedPath, queryParameters) {
       if (queryParameters === void 0)
         queryParameters = null;
       return Uri._makeHttpUri("https", authority, unencodedPath, queryParameters);
     }
     static _makeHttpUri(scheme, authority, unencodedPath, queryParameters) {
       let userInfo = "";
       let host = null;
       let port = null;
-      if (authority != null && dart.notNull(authority.isNotEmpty)) {
+      if (authority != null && dart.notNull(authority[dartx.isNotEmpty])) {
         let hostStart = 0;
         let hasUserInfo = false;
         for (let i = 0; dart.notNull(i) < dart.notNull(authority.length); i = dart.notNull(i) + 1) {
-          if (authority.codeUnitAt(i) == Uri._AT_SIGN) {
+          if (authority[dartx.codeUnitAt](i) == Uri._AT_SIGN) {
             hasUserInfo = true;
-            userInfo = authority.substring(0, i);
+            userInfo = authority[dartx.substring](0, i);
             hostStart = dart.notNull(i) + 1;
             break;
           }
         }
         let hostEnd = hostStart;
-        if (dart.notNull(hostStart) < dart.notNull(authority.length) && authority.codeUnitAt(hostStart) == Uri._LEFT_BRACKET) {
+        if (dart.notNull(hostStart) < dart.notNull(authority.length) && authority[dartx.codeUnitAt](hostStart) == Uri._LEFT_BRACKET) {
           for (; dart.notNull(hostEnd) < dart.notNull(authority.length); hostEnd = dart.notNull(hostEnd) + 1) {
-            if (authority.codeUnitAt(hostEnd) == Uri._RIGHT_BRACKET)
+            if (authority[dartx.codeUnitAt](hostEnd) == Uri._RIGHT_BRACKET)
               break;
           }
           if (hostEnd == authority.length) {
             throw new FormatException("Invalid IPv6 host entry.", authority, hostStart);
           }
           Uri.parseIPv6Address(authority, dart.notNull(hostStart) + 1, hostEnd);
           hostEnd = dart.notNull(hostEnd) + 1;
-          if (hostEnd != authority.length && authority.codeUnitAt(hostEnd) != Uri._COLON) {
+          if (hostEnd != authority.length && authority[dartx.codeUnitAt](hostEnd) != Uri._COLON) {
             throw new FormatException("Invalid end of authority", authority, hostEnd);
           }
         }
         let hasPort = false;
         for (; dart.notNull(hostEnd) < dart.notNull(authority.length); hostEnd = dart.notNull(hostEnd) + 1) {
-          if (authority.codeUnitAt(hostEnd) == Uri._COLON) {
-            let portString = authority.substring(dart.notNull(hostEnd) + 1);
-            if (portString.isNotEmpty)
+          if (authority[dartx.codeUnitAt](hostEnd) == Uri._COLON) {
+            let portString = authority[dartx.substring](dart.notNull(hostEnd) + 1);
+            if (portString[dartx.isNotEmpty])
               port = int.parse(portString);
             break;
           }
         }
-        host = authority.substring(hostStart, hostEnd);
+        host = authority[dartx.substring](hostStart, hostEnd);
       }
-      return Uri.new({scheme: scheme, userInfo: userInfo, host: dart.as(host, String), port: dart.as(port, int), pathSegments: unencodedPath.split("/"), queryParameters: queryParameters});
+      return Uri.new({scheme: scheme, userInfo: userInfo, host: dart.as(host, String), port: dart.as(port, int), pathSegments: unencodedPath[dartx.split]("/"), queryParameters: queryParameters});
     }
     static file(path, opts) {
       let windows = opts && 'windows' in opts ? opts.windows : null;
       windows = windows == null ? Uri._isWindows : windows;
       return windows ? dart.as(Uri._makeWindowsFileUrl(path), Uri) : dart.as(Uri._makeFileUri(path), Uri);
     }
     static get base() {
       let uri = _js_helper.Primitives.currentUri();
       if (uri != null)
         return Uri.parse(uri);
       throw new UnsupportedError("'Uri.base' is not supported");
     }
     static get _isWindows() {
       return false;
     }
     static _checkNonWindowsPathReservedCharacters(segments, argumentError) {
-      segments[$forEach](dart.fn(segment => {
+      segments[dartx.forEach](dart.fn(segment => {
         if (dart.dsend(segment, 'contains', "/")) {
           if (argumentError) {
             throw new ArgumentError(`Illegal path character ${segment}`);
           } else {
             throw new UnsupportedError(`Illegal path character ${segment}`);
           }
         }
       }));
     }
     static _checkWindowsPathReservedCharacters(segments, argumentError, firstSegment) {
       if (firstSegment === void 0)
         firstSegment = 0;
-      segments[$skip](firstSegment)[$forEach](dart.fn(segment => {
+      segments[dartx.skip](firstSegment)[dartx.forEach](dart.fn(segment => {
         if (dart.dsend(segment, 'contains', RegExp.new('["*/:<>?\\\\|]'))) {
           if (argumentError) {
             throw new ArgumentError("Illegal character in path");
           } else {
             throw new UnsupportedError("Illegal character in path");
           }
         }
       }));
     }
     static _checkWindowsDriveLetter(charCode, argumentError) {
       if (dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._UPPER_CASE_Z) || dart.notNull(Uri._LOWER_CASE_A) <= dart.notNull(charCode) && dart.notNull(charCode) <= dart.notNull(Uri._LOWER_CASE_Z)) {
         return;
       }
       if (argumentError) {
         throw new ArgumentError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode)));
       } else {
         throw new UnsupportedError("Illegal drive letter " + dart.notNull(String.fromCharCode(charCode)));
       }
     }
     static _makeFileUri(path) {
       let sep = "/";
-      if (path.startsWith(sep)) {
-        return Uri.new({scheme: "file", pathSegments: path.split(sep)});
+      if (path[dartx.startsWith](sep)) {
+        return Uri.new({scheme: "file", pathSegments: path[dartx.split](sep)});
       } else {
-        return Uri.new({pathSegments: path.split(sep)});
+        return Uri.new({pathSegments: path[dartx.split](sep)});
       }
     }
     static _makeWindowsFileUrl(path) {
-      if (path.startsWith("\\\\?\\")) {
-        if (path.startsWith("\\\\?\\UNC\\")) {
-          path = `\\${path.substring(7)}`;
+      if (path[dartx.startsWith]("\\\\?\\")) {
+        if (path[dartx.startsWith]("\\\\?\\UNC\\")) {
+          path = `\\${path[dartx.substring](7)}`;
         } else {
-          path = path.substring(4);
-          if (dart.notNull(path.length) < 3 || path.codeUnitAt(1) != Uri._COLON || path.codeUnitAt(2) != Uri._BACKSLASH) {
+          path = path[dartx.substring](4);
+          if (dart.notNull(path.length) < 3 || path[dartx.codeUnitAt](1) != Uri._COLON || path[dartx.codeUnitAt](2) != Uri._BACKSLASH) {
             throw new ArgumentError("Windows paths with \\\\?\\ prefix must be absolute");
           }
         }
       } else {
-        path = path.replaceAll("/", "\\");
+        path = path[dartx.replaceAll]("/", "\\");
       }
       let sep = "\\";
-      if (dart.notNull(path.length) > 1 && path.get(1) == ":") {
-        Uri._checkWindowsDriveLetter(path.codeUnitAt(0), true);
-        if (path.length == 2 || path.codeUnitAt(2) != Uri._BACKSLASH) {
+      if (dart.notNull(path.length) > 1 && path[dartx.get](1) == ":") {
+        Uri._checkWindowsDriveLetter(path[dartx.codeUnitAt](0), true);
+        if (path.length == 2 || path[dartx.codeUnitAt](2) != Uri._BACKSLASH) {
           throw new ArgumentError("Windows paths with drive letter must be absolute");
         }
-        let pathSegments = path.split(sep);
+        let pathSegments = path[dartx.split](sep);
         Uri._checkWindowsPathReservedCharacters(pathSegments, true, 1);
         return Uri.new({scheme: "file", pathSegments: pathSegments});
       }
-      if (dart.notNull(path.length) > 0 && path.get(0) == sep) {
-        if (dart.notNull(path.length) > 1 && path.get(1) == sep) {
-          let pathStart = path.indexOf("\\", 2);
-          let hostPart = pathStart == -1 ? path.substring(2) : path.substring(2, pathStart);
-          let pathPart = pathStart == -1 ? "" : path.substring(dart.notNull(pathStart) + 1);
-          let pathSegments = pathPart.split(sep);
+      if (dart.notNull(path.length) > 0 && path[dartx.get](0) == sep) {
+        if (dart.notNull(path.length) > 1 && path[dartx.get](1) == sep) {
+          let pathStart = path[dartx.indexOf]("\\", 2);
+          let hostPart = pathStart == -1 ? path[dartx.substring](2) : path[dartx.substring](2, pathStart);
+          let pathPart = pathStart == -1 ? "" : path[dartx.substring](dart.notNull(pathStart) + 1);
+          let pathSegments = pathPart[dartx.split](sep);
           Uri._checkWindowsPathReservedCharacters(pathSegments, true);
           return Uri.new({scheme: "file", host: hostPart, pathSegments: pathSegments});
         } else {
-          let pathSegments = path.split(sep);
+          let pathSegments = path[dartx.split](sep);
           Uri._checkWindowsPathReservedCharacters(pathSegments, true);
           return Uri.new({scheme: "file", pathSegments: pathSegments});
         }
       } else {
-        let pathSegments = path.split(sep);
+        let pathSegments = path[dartx.split](sep);
         Uri._checkWindowsPathReservedCharacters(pathSegments, true);
         return Uri.new({pathSegments: pathSegments});
       }
     }
     replace(opts) {
       let scheme = opts && 'scheme' in opts ? opts.scheme : null;
       let userInfo = opts && 'userInfo' in opts ? opts.userInfo : null;
       let host = opts && 'host' in opts ? opts.host : null;
       let port = opts && 'port' in opts ? opts.port : null;
       let path = opts && 'path' in opts ? opts.path : null;
@@ skipping 19 matching lines @@
       } else {
         port = this[_port];
         if (schemeChanged) {
           port = Uri._makePort(port, scheme);
         }
       }
       if (host != null) {
         host = Uri._makeHost(host, 0, host.length, false);
       } else if (this.hasAuthority) {
         host = this.host;
-      } else if (dart.notNull(userInfo.isNotEmpty) || port != null || dart.notNull(isFile)) {
+      } else if (dart.notNull(userInfo[dartx.isNotEmpty]) || port != null || dart.notNull(isFile)) {
         host = "";
       }
       let ensureLeadingSlash = host != null;
       if (path != null || dart.notNull(pathSegments != null)) {
         path = Uri._makePath(path, 0, Uri._stringOrNullLength(path), pathSegments, ensureLeadingSlash, isFile);
       } else {
         path = this.path;
-        if ((dart.notNull(isFile) || dart.notNull(ensureLeadingSlash) && !dart.notNull(path.isEmpty)) && !dart.notNull(path.startsWith('/'))) {
+        if ((dart.notNull(isFile) || dart.notNull(ensureLeadingSlash) && !dart.notNull(path[dartx.isEmpty])) && !dart.notNull(path[dartx.startsWith]('/'))) {
           path = `/${path}`;
         }
       }
       if (query != null || dart.notNull(queryParameters != null)) {
         query = Uri._makeQuery(query, 0, Uri._stringOrNullLength(query), queryParameters);
       } else if (this.hasQuery) {
         query = this.query;
       }
       if (fragment != null) {
         fragment = Uri._makeFragment(fragment, 0, fragment.length);
       } else if (this.hasFragment) {
         fragment = this.fragment;
       }
       return new Uri._internal(scheme, userInfo, host, port, path, query, fragment);
     }
     get pathSegments() {
       if (this[_pathSegments] == null) {
-        let pathToSplit = !dart.notNull(this.path.isEmpty) && this.path.codeUnitAt(0) == Uri._SLASH ? this.path.substring(1) : this.path;
-        this[_pathSegments] = new (collection.UnmodifiableListView$(String))(pathToSplit == "" ? dart.const(dart.setType([], List$(String))) : List$(String).from(pathToSplit.split("/")[$map](Uri.decodeComponent), {growable: false}));
+        let pathToSplit = !dart.notNull(this.path[dartx.isEmpty]) && this.path[dartx.codeUnitAt](0) == Uri._SLASH ? this.path[dartx.substring](1) : this.path;
+        this[_pathSegments] = new (collection.UnmodifiableListView$(String))(pathToSplit == "" ? dart.const(dart.list([], String)) : List$(String).from(pathToSplit[dartx.split]("/")[dartx.map](Uri.decodeComponent), {growable: false}));
       }
       return this[_pathSegments];
     }
     get queryParameters() {
       if (this[_queryParameters] == null) {
         this[_queryParameters] = new (collection.UnmodifiableMapView$(String, String))(Uri.splitQueryString(this.query));
       }
       return this[_queryParameters];
     }
     static _makePort(port, scheme) {
       if (port != null && port == Uri._defaultPort(scheme))
         return null;
       return port;
     }
     static _makeHost(host, start, end, strictIPv6) {
       if (host == null)
         return null;
       if (start == end)
         return "";
-      if (host.codeUnitAt(start) == Uri._LEFT_BRACKET) {
-        if (host.codeUnitAt(dart.notNull(end) - 1) != Uri._RIGHT_BRACKET) {
+      if (host[dartx.codeUnitAt](start) == Uri._LEFT_BRACKET) {
+        if (host[dartx.codeUnitAt](dart.notNull(end) - 1) != Uri._RIGHT_BRACKET) {
           Uri._fail(host, start, 'Missing end `]` to match `[` in host');
         }
         Uri.parseIPv6Address(host, dart.notNull(start) + 1, dart.notNull(end) - 1);
-        return host.substring(start, end).toLowerCase();
+        return host[dartx.substring](start, end)[dartx.toLowerCase]();
       }
       if (!dart.notNull(strictIPv6)) {
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-          if (host.codeUnitAt(i) == Uri._COLON) {
+          if (host[dartx.codeUnitAt](i) == Uri._COLON) {
             Uri.parseIPv6Address(host, start, end);
             return `[${host}]`;
           }
         }
       }
       return Uri._normalizeRegName(host, start, end);
     }
     static _isRegNameChar(char) {
-      return dart.notNull(char) < 127 && dart.notNull(!dart.equals(dart.dsend(Uri._regNameTable[$get](dart.notNull(char) >> 4), '&', 1 << (dart.notNull(char) & 15)), 0));
+      return dart.notNull(char) < 127 && dart.notNull(!dart.equals(dart.dsend(Uri._regNameTable[dartx.get](dart.notNull(char) >> 4), '&', 1 << (dart.notNull(char) & 15)), 0));
     }
     static _normalizeRegName(host, start, end) {
       let buffer = null;
       let sectionStart = start;
       let index = start;
       let isNormalized = true;
       while (dart.notNull(index) < dart.notNull(end)) {
-        let char = host.codeUnitAt(index);
+        let char = host[dartx.codeUnitAt](index);
         if (char == Uri._PERCENT) {
           let replacement = Uri._normalizeEscape(host, index, true);
           if (replacement == null && dart.notNull(isNormalized)) {
             index = dart.notNull(index) + 3;
             continue;
           }
           if (buffer == null)
             buffer = new StringBuffer();
-          let slice = host.substring(sectionStart, index);
+          let slice = host[dartx.substring](sectionStart, index);
           if (!dart.notNull(isNormalized))
-            slice = slice.toLowerCase();
+            slice = slice[dartx.toLowerCase]();
           buffer.write(slice);
           let sourceLength = 3;
           if (replacement == null) {
-            replacement = host.substring(index, dart.notNull(index) + 3);
+            replacement = host[dartx.substring](index, dart.notNull(index) + 3);
           } else if (replacement == "%") {
             replacement = "%25";
             sourceLength = 1;
           }
           buffer.write(replacement);
           index = dart.notNull(index) + dart.notNull(sourceLength);
           sectionStart = index;
           isNormalized = true;
         } else if (Uri._isRegNameChar(char)) {
           if (dart.notNull(isNormalized) && dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(char) && dart.notNull(Uri._UPPER_CASE_Z) >= dart.notNull(char)) {
             if (buffer == null)
               buffer = new StringBuffer();
             if (dart.notNull(sectionStart) < dart.notNull(index)) {
-              buffer.write(host.substring(sectionStart, index));
+              buffer.write(host[dartx.substring](sectionStart, index));
               sectionStart = index;
             }
             isNormalized = false;
           }
           index = dart.notNull(index) + 1;
         } else if (Uri._isGeneralDelimiter(char)) {
           Uri._fail(host, index, "Invalid character");
         } else {
           let sourceLength = 1;
           if ((dart.notNull(char) & 64512) == 55296 && dart.notNull(index) + 1 < dart.notNull(end)) {
-            let tail = host.codeUnitAt(dart.notNull(index) + 1);
+            let tail = host[dartx.codeUnitAt](dart.notNull(index) + 1);
             if ((dart.notNull(tail) & 64512) == 56320) {
               char = 65536 | (dart.notNull(char) & 1023) << 10 | dart.notNull(tail) & 1023;
               sourceLength = 2;
             }
           }
           if (buffer == null)
             buffer = new StringBuffer();
-          let slice = host.substring(sectionStart, index);
+          let slice = host[dartx.substring](sectionStart, index);
           if (!dart.notNull(isNormalized))
-            slice = slice.toLowerCase();
+            slice = slice[dartx.toLowerCase]();
           buffer.write(slice);
           buffer.write(Uri._escapeChar(char));
           index = dart.notNull(index) + dart.notNull(sourceLength);
           sectionStart = index;
         }
       }
       if (buffer == null)
-        return host.substring(start, end);
+        return host[dartx.substring](start, end);
       if (dart.notNull(sectionStart) < dart.notNull(end)) {
-        let slice = host.substring(sectionStart, end);
+        let slice = host[dartx.substring](sectionStart, end);
         if (!dart.notNull(isNormalized))
-          slice = slice.toLowerCase();
+          slice = slice[dartx.toLowerCase]();
         buffer.write(slice);
       }
       return dart.toString(buffer);
     }
     static _makeScheme(scheme, end) {
       if (end == 0)
         return "";
-      let firstCodeUnit = scheme.codeUnitAt(0);
+      let firstCodeUnit = scheme[dartx.codeUnitAt](0);
       if (!dart.notNull(Uri._isAlphabeticCharacter(firstCodeUnit))) {
         Uri._fail(scheme, 0, "Scheme not starting with alphabetic character");
       }
       let allLowercase = dart.notNull(firstCodeUnit) >= dart.notNull(Uri._LOWER_CASE_A);
       for (let i = 0; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-        let codeUnit = scheme.codeUnitAt(i);
+        let codeUnit = scheme[dartx.codeUnitAt](i);
         if (!dart.notNull(Uri._isSchemeCharacter(codeUnit))) {
           Uri._fail(scheme, i, "Illegal scheme character");
         }
         if (dart.notNull(codeUnit) < dart.notNull(Uri._LOWER_CASE_A) || dart.notNull(codeUnit) > dart.notNull(Uri._LOWER_CASE_Z)) {
           allLowercase = false;
         }
       }
-      scheme = scheme.substring(0, end);
+      scheme = scheme[dartx.substring](0, end);
       if (!dart.notNull(allLowercase))
-        scheme = scheme.toLowerCase();
+        scheme = scheme[dartx.toLowerCase]();
       return scheme;
     }
     static _makeUserInfo(userInfo, start, end) {
       if (userInfo == null)
         return "";
       return Uri._normalize(userInfo, start, end, dart.as(Uri._userinfoTable, List$(int)));
     }
     static _makePath(path, start, end, pathSegments, ensureLeadingSlash, isFile) {
       if (path == null && dart.notNull(pathSegments == null))
         return isFile ? "/" : "";
       if (path != null && dart.notNull(pathSegments != null)) {
         throw new ArgumentError('Both path and pathSegments specified');
       }
       let result = null;
       if (path != null) {
         result = Uri._normalize(path, start, end, dart.as(Uri._pathCharOrSlashTable, List$(int)));
       } else {
-        result = pathSegments[$map](dart.fn(s => Uri._uriEncode(dart.as(Uri._pathCharTable, List$(int)), dart.as(s, String)), String, [Object]))[$join]("/");
+        result = pathSegments[dartx.map](dart.fn(s => Uri._uriEncode(dart.as(Uri._pathCharTable, List$(int)), dart.as(s, String)), String, [Object]))[dartx.join]("/");
       }
       if (dart.dload(result, 'isEmpty')) {
         if (isFile)
           return "/";
       } else if ((dart.notNull(isFile) || dart.notNull(ensureLeadingSlash)) && dart.notNull(!dart.equals(dart.dsend(result, 'codeUnitAt', 0), Uri._SLASH))) {
         return `/${result}`;
       }
       return dart.as(result, String);
     }
     static _makeQuery(query, start, end, queryParameters) {
@@ skipping 34 matching lines @@
       return dart.notNull(Uri._LOWER_CASE_A) <= dart.notNull(char) && dart.notNull(Uri._LOWER_CASE_F) >= dart.notNull(char);
     }
     static _hexValue(char) {
       dart.assert(Uri._isHexDigit(char));
       if (dart.notNull(Uri._NINE) >= dart.notNull(char))
         return dart.notNull(char) - dart.notNull(Uri._ZERO);
       char = dart.notNull(char) | 32;
       return dart.notNull(char) - (dart.notNull(Uri._LOWER_CASE_A) - 10);
     }
     static _normalizeEscape(source, index, lowerCase) {
-      dart.assert(source.codeUnitAt(index) == Uri._PERCENT);
+      dart.assert(source[dartx.codeUnitAt](index) == Uri._PERCENT);
       if (dart.notNull(index) + 2 >= dart.notNull(source.length)) {
         return "%";
       }
-      let firstDigit = source.codeUnitAt(dart.notNull(index) + 1);
-      let secondDigit = source.codeUnitAt(dart.notNull(index) + 2);
+      let firstDigit = source[dartx.codeUnitAt](dart.notNull(index) + 1);
+      let secondDigit = source[dartx.codeUnitAt](dart.notNull(index) + 2);
       if (!dart.notNull(Uri._isHexDigit(firstDigit)) || !dart.notNull(Uri._isHexDigit(secondDigit))) {
         return "%";
       }
       let value = dart.notNull(Uri._hexValue(firstDigit)) * 16 + dart.notNull(Uri._hexValue(secondDigit));
       if (Uri._isUnreservedChar(value)) {
         if (dart.notNull(lowerCase) && dart.notNull(Uri._UPPER_CASE_A) <= dart.notNull(value) && dart.notNull(Uri._UPPER_CASE_Z) >= dart.notNull(value)) {
           value = dart.notNull(value) | 32;
         }
         return String.fromCharCode(value);
       }
       if (dart.notNull(firstDigit) >= dart.notNull(Uri._LOWER_CASE_A) || dart.notNull(secondDigit) >= dart.notNull(Uri._LOWER_CASE_A)) {
-        return source.substring(index, dart.notNull(index) + 3).toUpperCase();
+        return source[dartx.substring](index, dart.notNull(index) + 3)[dartx.toUpperCase]();
       }
       return null;
     }
     static _isUnreservedChar(ch) {
-      return dart.notNull(ch) < 127 && dart.notNull(!dart.equals(dart.dsend(Uri._unreservedTable[$get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
+      return dart.notNull(ch) < 127 && dart.notNull(!dart.equals(dart.dsend(Uri._unreservedTable[dartx.get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
     }
     static _escapeChar(char) {
       dart.assert(dart.dsend(char, '<=', 1114111));
       let hexDigits = "0123456789ABCDEF";
       let codeUnits = null;
       if (dart.dsend(char, '<', 128)) {
         codeUnits = List.new(3);
-        codeUnits[$set](0, Uri._PERCENT);
-        codeUnits[$set](1, hexDigits.codeUnitAt(dart.as(dart.dsend(char, '>>', 4), int)));
-        codeUnits[$set](2, hexDigits.codeUnitAt(dart.as(dart.dsend(char, '&', 15), int)));
+        codeUnits[dartx.set](0, Uri._PERCENT);
+        codeUnits[dartx.set](1, hexDigits[dartx.codeUnitAt](dart.as(dart.dsend(char, '>>', 4), int)));
+        codeUnits[dartx.set](2, hexDigits[dartx.codeUnitAt](dart.as(dart.dsend(char, '&', 15), int)));
       } else {
         let flag = 192;
         let encodedBytes = 2;
         if (dart.dsend(char, '>', 2047)) {
           flag = 224;
           encodedBytes = 3;
           if (dart.dsend(char, '>', 65535)) {
             encodedBytes = 4;
             flag = 240;
           }
         }
         codeUnits = List.new(3 * dart.notNull(encodedBytes));
         let index = 0;
         while ((encodedBytes = dart.notNull(encodedBytes) - 1) >= 0) {
           let byte = dart.as(dart.dsend(dart.dsend(dart.dsend(char, '>>', 6 * dart.notNull(encodedBytes)), '&', 63), '|', flag), int);
-          codeUnits[$set](index, Uri._PERCENT);
-          codeUnits[$set](dart.notNull(index) + 1, hexDigits.codeUnitAt(dart.notNull(byte) >> 4));
-          codeUnits[$set](dart.notNull(index) + 2, hexDigits.codeUnitAt(dart.notNull(byte) & 15));
+          codeUnits[dartx.set](index, Uri._PERCENT);
+          codeUnits[dartx.set](dart.notNull(index) + 1, hexDigits[dartx.codeUnitAt](dart.notNull(byte) >> 4));
+          codeUnits[dartx.set](dart.notNull(index) + 2, hexDigits[dartx.codeUnitAt](dart.notNull(byte) & 15));
           index = dart.notNull(index) + 3;
           flag = 128;
         }
       }
       return String.fromCharCodes(dart.as(codeUnits, Iterable$(int)));
     }
     static _normalize(component, start, end, charTable) {
       let buffer = null;
       let sectionStart = start;
       let index = start;
       while (dart.notNull(index) < dart.notNull(end)) {
-        let char = component.codeUnitAt(index);
-        if (dart.notNull(char) < 127 && (dart.notNull(charTable[$get](dart.notNull(char) >> 4)) & 1 << (dart.notNull(char) & 15)) != 0) {
+        let char = component[dartx.codeUnitAt](index);
+        if (dart.notNull(char) < 127 && (dart.notNull(charTable[dartx.get](dart.notNull(char) >> 4)) & 1 << (dart.notNull(char) & 15)) != 0) {
           index = dart.notNull(index) + 1;
         } else {
           let replacement = null;
           let sourceLength = null;
           if (char == Uri._PERCENT) {
             replacement = Uri._normalizeEscape(component, index, false);
             if (replacement == null) {
               index = dart.notNull(index) + 3;
               continue;
             }
             if ("%" == replacement) {
               replacement = "%25";
               sourceLength = 1;
             } else {
               sourceLength = 3;
             }
           } else if (Uri._isGeneralDelimiter(char)) {
             Uri._fail(component, index, "Invalid character");
           } else {
             sourceLength = 1;
             if ((dart.notNull(char) & 64512) == 55296) {
               if (dart.notNull(index) + 1 < dart.notNull(end)) {
-                let tail = component.codeUnitAt(dart.notNull(index) + 1);
+                let tail = component[dartx.codeUnitAt](dart.notNull(index) + 1);
                 if ((dart.notNull(tail) & 64512) == 56320) {
                   sourceLength = 2;
                   char = 65536 | (dart.notNull(char) & 1023) << 10 | dart.notNull(tail) & 1023;
                 }
               }
             }
             replacement = Uri._escapeChar(char);
           }
           if (buffer == null)
             buffer = new StringBuffer();
-          buffer.write(component.substring(sectionStart, index));
+          buffer.write(component[dartx.substring](sectionStart, index));
           buffer.write(replacement);
           index = dart.notNull(index) + dart.notNull(sourceLength);
           sectionStart = index;
         }
       }
       if (buffer == null) {
-        return component.substring(start, end);
+        return component[dartx.substring](start, end);
       }
       if (dart.notNull(sectionStart) < dart.notNull(end)) {
-        buffer.write(component.substring(sectionStart, end));
+        buffer.write(component[dartx.substring](sectionStart, end));
       }
       return dart.toString(buffer);
     }
     static _isSchemeCharacter(ch) {
-      return dart.notNull(ch) < 128 && dart.notNull(!dart.equals(dart.dsend(Uri._schemeTable[$get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
+      return dart.notNull(ch) < 128 && dart.notNull(!dart.equals(dart.dsend(Uri._schemeTable[dartx.get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
     }
     static _isGeneralDelimiter(ch) {
-      return dart.notNull(ch) <= dart.notNull(Uri._RIGHT_BRACKET) && dart.notNull(!dart.equals(dart.dsend(Uri._genDelimitersTable[$get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
+      return dart.notNull(ch) <= dart.notNull(Uri._RIGHT_BRACKET) && dart.notNull(!dart.equals(dart.dsend(Uri._genDelimitersTable[dartx.get](dart.notNull(ch) >> 4), '&', 1 << (dart.notNull(ch) & 15)), 0));
     }
     get isAbsolute() {
       return this.scheme != "" && this.fragment == "";
     }
     [_merge](base, reference) {
-      if (base.isEmpty)
+      if (base[dartx.isEmpty])
         return `/${reference}`;
       let backCount = 0;
       let refStart = 0;
-      while (reference.startsWith("../", refStart)) {
+      while (reference[dartx.startsWith]("../", refStart)) {
         refStart = dart.notNull(refStart) + 3;
         backCount = dart.notNull(backCount) + 1;
       }
-      let baseEnd = base.lastIndexOf('/');
+      let baseEnd = base[dartx.lastIndexOf]('/');
       while (dart.notNull(baseEnd) > 0 && dart.notNull(backCount) > 0) {
-        let newEnd = base.lastIndexOf('/', dart.notNull(baseEnd) - 1);
+        let newEnd = base[dartx.lastIndexOf]('/', dart.notNull(baseEnd) - 1);
         if (dart.notNull(newEnd) < 0) {
           break;
         }
         let delta = dart.notNull(baseEnd) - dart.notNull(newEnd);
-        if ((delta == 2 || delta == 3) && base.codeUnitAt(dart.notNull(newEnd) + 1) == Uri._DOT && (delta == 2 || base.codeUnitAt(dart.notNull(newEnd) + 2) == Uri._DOT)) {
+        if ((delta == 2 || delta == 3) && base[dartx.codeUnitAt](dart.notNull(newEnd) + 1) == Uri._DOT && (delta == 2 || base[dartx.codeUnitAt](dart.notNull(newEnd) + 2) == Uri._DOT)) {
           break;
         }
         baseEnd = newEnd;
         backCount = dart.notNull(backCount) - 1;
       }
-      return dart.notNull(base.substring(0, dart.notNull(baseEnd) + 1)) + dart.notNull(reference.substring(dart.notNull(refStart) - 3 * dart.notNull(backCount)));
+      return dart.notNull(base[dartx.substring](0, dart.notNull(baseEnd) + 1)) + dart.notNull(reference[dartx.substring](dart.notNull(refStart) - 3 * dart.notNull(backCount)));
     }
     [_hasDotSegments](path) {
-      if (dart.notNull(path.length) > 0 && path.codeUnitAt(0) == Uri._DOT)
+      if (dart.notNull(path.length) > 0 && path[dartx.codeUnitAt](0) == Uri._DOT)
         return true;
-      let index = path.indexOf("/.");
+      let index = path[dartx.indexOf]("/.");
       return index != -1;
     }
     [_removeDotSegments](path) {
       if (!dart.notNull(this[_hasDotSegments](path)))
         return path;
-      let output = dart.setType([], List$(String));
+      let output = dart.list([], String);
       let appendSlash = false;
-      for (let segment of path.split("/")) {
+      for (let segment of path[dartx.split]("/")) {
         appendSlash = false;
         if (segment == "..") {
-          if (!dart.notNull(output[$isEmpty]) && (output[$length] != 1 || output[$get](0) != ""))
-            output[$removeLast]();
+          if (!dart.notNull(output[dartx.isEmpty]) && (output.length != 1 || output[dartx.get](0) != ""))
+            output[dartx.removeLast]();
           appendSlash = true;
         } else if ("." == segment) {
           appendSlash = true;
         } else {
-          output[$add](segment);
+          output[dartx.add](segment);
         }
       }
       if (appendSlash)
-        output[$add]("");
-      return output[$join]("/");
+        output[dartx.add]("");
+      return output[dartx.join]("/");
     }
     resolve(reference) {
       return this.resolveUri(Uri.parse(reference));
     }
     resolveUri(reference) {
       let targetScheme = null;
       let targetUserInfo = "";
       let targetHost = null;
       let targetPort = null;
       let targetPath = null;
       let targetQuery = null;
-      if (reference.scheme.isNotEmpty) {
+      if (reference.scheme[dartx.isNotEmpty]) {
         targetScheme = reference.scheme;
         if (reference.hasAuthority) {
           targetUserInfo = reference.userInfo;
           targetHost = reference.host;
           targetPort = reference.hasPort ? reference.port : null;
         }
         targetPath = this[_removeDotSegments](reference.path);
         if (reference.hasQuery) {
           targetQuery = reference.query;
         }
       } else {
         targetScheme = this.scheme;
         if (reference.hasAuthority) {
           targetUserInfo = reference.userInfo;
           targetHost = reference.host;
           targetPort = Uri._makePort(reference.hasPort ? reference.port : null, targetScheme);
           targetPath = this[_removeDotSegments](reference.path);
           if (reference.hasQuery)
             targetQuery = reference.query;
         } else {
           if (reference.path == "") {
             targetPath = this[_path];
             if (reference.hasQuery) {
               targetQuery = reference.query;
             } else {
               targetQuery = this[_query];
             }
           } else {
-            if (reference.path.startsWith("/")) {
+            if (reference.path[dartx.startsWith]("/")) {
               targetPath = this[_removeDotSegments](reference.path);
             } else {
               targetPath = this[_removeDotSegments](this[_merge](this[_path], reference.path));
             }
             if (reference.hasQuery)
               targetQuery = reference.query;
           }
           targetUserInfo = this[_userInfo];
           targetHost = this[_host];
           targetPort = this[_port];
@@ skipping 47 matching lines @@
       Uri._checkNonWindowsPathReservedCharacters(this.pathSegments, false);
       let result = new StringBuffer();
       if (this[_isPathAbsolute])
         result.write("/");
       result.writeAll(this.pathSegments, "/");
       return dart.toString(result);
     }
     [_toWindowsFilePath]() {
       let hasDriveLetter = false;
       let segments = this.pathSegments;
-      if (dart.notNull(segments[$length]) > 0 && segments[$get](0).length == 2 && segments[$get](0).codeUnitAt(1) == Uri._COLON) {
-        Uri._checkWindowsDriveLetter(segments[$get](0).codeUnitAt(0), false);
+      if (dart.notNull(segments.length) > 0 && segments[dartx.get](0).length == 2 && segments[dartx.get](0)[dartx.codeUnitAt](1) == Uri._COLON) {
+        Uri._checkWindowsDriveLetter(segments[dartx.get](0)[dartx.codeUnitAt](0), false);
         Uri._checkWindowsPathReservedCharacters(segments, false, 1);
         hasDriveLetter = true;
       } else {
         Uri._checkWindowsPathReservedCharacters(segments, false);
       }
       let result = new StringBuffer();
       if (dart.notNull(this[_isPathAbsolute]) && !dart.notNull(hasDriveLetter))
         result.write("\\");
       if (this.host != "") {
         result.write("\\");
         result.write(this.host);
         result.write("\\");
       }
       result.writeAll(segments, "\\");
-      if (dart.notNull(hasDriveLetter) && segments[$length] == 1)
+      if (dart.notNull(hasDriveLetter) && segments.length == 1)
         result.write("\\");
       return dart.toString(result);
     }
     get [_isPathAbsolute]() {
-      if (this.path == null || dart.notNull(this.path.isEmpty))
+      if (this.path == null || dart.notNull(this.path[dartx.isEmpty]))
         return false;
-      return this.path.startsWith('/');
+      return this.path[dartx.startsWith]('/');
     }
     [_writeAuthority](ss) {
-      if (this[_userInfo].isNotEmpty) {
+      if (this[_userInfo][dartx.isNotEmpty]) {
         ss.write(this[_userInfo]);
         ss.write("@");
       }
       if (this[_host] != null)
         ss.write(this[_host]);
       if (this[_port] != null) {
         ss.write(":");
         ss.write(this[_port]);
       }
     }
     toString() {
       let sb = new StringBuffer();
       Uri._addIfNonEmpty(sb, this.scheme, this.scheme, ':');
-      if (dart.notNull(this.hasAuthority) || dart.notNull(this.path.startsWith("//")) || this.scheme == "file") {
+      if (dart.notNull(this.hasAuthority) || dart.notNull(this.path[dartx.startsWith]("//")) || this.scheme == "file") {
         sb.write("//");
         this[_writeAuthority](sb);
       }
       sb.write(this.path);
       if (this[_query] != null) {
         sb.write("?");
         sb.write(this[_query]);
       }
       if (this[_fragment] != null) {
         sb.write("#");
@@ skipping 35 matching lines @@
       return Uri._uriDecode(encodedComponent, {plusToSpace: true, encoding: encoding});
     }
     static encodeFull(uri) {
       return Uri._uriEncode(dart.as(Uri._encodeFullTable, List$(int)), uri);
     }
     static decodeFull(uri) {
       return Uri._uriDecode(uri);
     }
     static splitQueryString(query, opts) {
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
-      return dart.as(query.split("&")[$fold](dart.map(), dart.fn((map, element) => {
+      return dart.as(query[dartx.split]("&")[dartx.fold](dart.map(), dart.fn((map, element) => {
         let index = dart.as(dart.dsend(element, 'indexOf', "="), int);
         if (index == -1) {
           if (!dart.equals(element, "")) {
             dart.dsetindex(map, Uri.decodeQueryComponent(dart.as(element, String), {encoding: encoding}), "");
           }
         } else if (index != 0) {
           let key = dart.dsend(element, 'substring', 0, index);
           let value = dart.dsend(element, 'substring', dart.notNull(index) + 1);
           dart.dsetindex(map, Uri.decodeQueryComponent(dart.as(key, String), {encoding: encoding}), Uri.decodeQueryComponent(dart.as(value, String), {encoding: encoding}));
         }
         return map;
       })), Map$(String, String));
     }
     static parseIPv4Address(host) {
       let error = msg => {
         throw new FormatException(`Illegal IPv4 address, ${msg}`);
       };
       dart.fn(error, dart.void, [String]);
-      let bytes = host.split('.');
-      if (bytes[$length] != 4) {
+      let bytes = host[dartx.split]('.');
+      if (bytes.length != 4) {
         error('IPv4 address should contain exactly 4 parts');
       }
-      return dart.as(bytes[$map](dart.fn(byteString => {
+      return dart.as(bytes[dartx.map](dart.fn(byteString => {
         let byte = int.parse(dart.as(byteString, String));
         if (dart.notNull(byte) < 0 || dart.notNull(byte) > 255) {
           error('each part must be in the range of `0..255`');
         }
         return byte;
-      }))[$toList](), List$(int));
+      }))[dartx.toList](), List$(int));
     }
     static parseIPv6Address(host, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       if (end == null)
         end = host.length;
       let error = (msg, position) => {
         if (position === void 0)
           position = null;
         throw new FormatException(`Illegal IPv6 address, ${msg}`, host, dart.as(position, int));
       };
       dart.fn(error, dart.void, [String], [Object]);
       let parseHex = (start, end) => {
         if (dart.notNull(end) - dart.notNull(start) > 4) {
           error('an IPv6 part can only contain a maximum of 4 hex digits', start);
         }
-        let value = int.parse(host.substring(start, end), {radix: 16});
+        let value = int.parse(host[dartx.substring](start, end), {radix: 16});
         if (dart.notNull(value) < 0 || dart.notNull(value) > (1 << 16) - 1) {
           error('each part must be in the range of `0x0..0xFFFF`', start);
         }
         return value;
       };
       dart.fn(parseHex, int, [int, int]);
       if (dart.notNull(host.length) < 2)
         error('address is too short');
-      let parts = dart.setType([], List$(int));
+      let parts = dart.list([], int);
       let wildcardSeen = false;
       let partStart = start;
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
-        if (host.codeUnitAt(i) == Uri._COLON) {
+        if (host[dartx.codeUnitAt](i) == Uri._COLON) {
           if (i == start) {
             i = dart.notNull(i) + 1;
-            if (host.codeUnitAt(i) != Uri._COLON) {
+            if (host[dartx.codeUnitAt](i) != Uri._COLON) {
               error('invalid start colon.', i);
             }
             partStart = i;
           }
           if (i == partStart) {
             if (wildcardSeen) {
               error('only one wildcard `::` is allowed', i);
             }
             wildcardSeen = true;
-            parts[$add](-1);
+            parts[dartx.add](-1);
           } else {
-            parts[$add](parseHex(partStart, i));
+            parts[dartx.add](parseHex(partStart, i));
           }
           partStart = dart.notNull(i) + 1;
         }
       }
-      if (parts[$length] == 0)
+      if (parts.length == 0)
         error('too few parts');
       let atEnd = partStart == end;
-      let isLastWildcard = parts[$last] == -1;
+      let isLastWildcard = parts[dartx.last] == -1;
       if (dart.notNull(atEnd) && !dart.notNull(isLastWildcard)) {
         error('expected a part after last `:`', end);
       }
       if (!dart.notNull(atEnd)) {
         try {
-          parts[$add](parseHex(partStart, end));
+          parts[dartx.add](parseHex(partStart, end));
         } catch (e) {
           try {
-            let last = Uri.parseIPv4Address(host.substring(partStart, end));
-            parts[$add](dart.notNull(last[$get](0)) << 8 | dart.notNull(last[$get](1)));
-            parts[$add](dart.notNull(last[$get](2)) << 8 | dart.notNull(last[$get](3)));
+            let last = Uri.parseIPv4Address(host[dartx.substring](partStart, end));
+            parts[dartx.add](dart.notNull(last[dartx.get](0)) << 8 | dart.notNull(last[dartx.get](1)));
+            parts[dartx.add](dart.notNull(last[dartx.get](2)) << 8 | dart.notNull(last[dartx.get](3)));
           } catch (e) {
             error('invalid end of IPv6 address.', partStart);
           }
 
         }
 
       }
       if (wildcardSeen) {
-        if (dart.notNull(parts[$length]) > 7) {
+        if (dart.notNull(parts.length) > 7) {
           error('an address with a wildcard must have less than 7 parts');
         }
-      } else if (parts[$length] != 8) {
+      } else if (parts.length != 8) {
         error('an address without a wildcard must contain exactly 8 parts');
       }
       let bytes = List$(int).new(16);
-      for (let i = 0, index = 0; dart.notNull(i) < dart.notNull(parts[$length]); i = dart.notNull(i) + 1) {
-        let value = parts[$get](i);
+      for (let i = 0, index = 0; dart.notNull(i) < dart.notNull(parts.length); i = dart.notNull(i) + 1) {
+        let value = parts[dartx.get](i);
         if (value == -1) {
-          let wildCardLength = 9 - dart.notNull(parts[$length]);
+          let wildCardLength = 9 - dart.notNull(parts.length);
           for (let j = 0; dart.notNull(j) < dart.notNull(wildCardLength); j = dart.notNull(j) + 1) {
-            bytes[$set](index, 0);
-            bytes[$set](dart.notNull(index) + 1, 0);
+            bytes[dartx.set](index, 0);
+            bytes[dartx.set](dart.notNull(index) + 1, 0);
             index = dart.notNull(index) + 2;
           }
         } else {
-          bytes[$set](index, dart.notNull(value) >> 8);
-          bytes[$set](dart.notNull(index) + 1, dart.notNull(value) & 255);
+          bytes[dartx.set](index, dart.notNull(value) >> 8);
+          bytes[dartx.set](dart.notNull(index) + 1, dart.notNull(value) & 255);
           index = dart.notNull(index) + 2;
         }
       }
       return dart.as(bytes, List$(int));
     }
     static _uriEncode(canonicalTable, text, opts) {
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
       let spaceToPlus = opts && 'spaceToPlus' in opts ? opts.spaceToPlus : false;
       let byteToHex = (byte, buffer) => {
         let hex = '0123456789ABCDEF';
-        dart.dsend(buffer, 'writeCharCode', hex.codeUnitAt(dart.as(dart.dsend(byte, '>>', 4), int)));
-        dart.dsend(buffer, 'writeCharCode', hex.codeUnitAt(dart.as(dart.dsend(byte, '&', 15), int)));
+        dart.dsend(buffer, 'writeCharCode', hex[dartx.codeUnitAt](dart.as(dart.dsend(byte, '>>', 4), int)));
+        dart.dsend(buffer, 'writeCharCode', hex[dartx.codeUnitAt](dart.as(dart.dsend(byte, '&', 15), int)));
       };
       dart.fn(byteToHex);
       let result = new StringBuffer();
       let bytes = encoding.encode(text);
-      for (let i = 0; dart.notNull(i) < dart.notNull(bytes[$length]); i = dart.notNull(i) + 1) {
-        let byte = bytes[$get](i);
-        if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[$get](dart.notNull(byte) >> 4)) & 1 << (dart.notNull(byte) & 15)) != 0) {
+      for (let i = 0; dart.notNull(i) < dart.notNull(bytes.length); i = dart.notNull(i) + 1) {
+        let byte = bytes[dartx.get](i);
+        if (dart.notNull(byte) < 128 && (dart.notNull(canonicalTable[dartx.get](dart.notNull(byte) >> 4)) & 1 << (dart.notNull(byte) & 15)) != 0) {
           result.writeCharCode(byte);
         } else if (dart.notNull(spaceToPlus) && byte == Uri._SPACE) {
           result.writeCharCode(Uri._PLUS);
         } else {
           result.writeCharCode(Uri._PERCENT);
           byteToHex(byte, result);
         }
       }
       return dart.toString(result);
     }
     static _hexCharPairToByte(s, pos) {
       let byte = 0;
       for (let i = 0; dart.notNull(i) < 2; i = dart.notNull(i) + 1) {
-        let charCode = s.codeUnitAt(dart.notNull(pos) + dart.notNull(i));
+        let charCode = s[dartx.codeUnitAt](dart.notNull(pos) + dart.notNull(i));
         if (48 <= dart.notNull(charCode) && dart.notNull(charCode) <= 57) {
           byte = dart.notNull(byte) * 16 + dart.notNull(charCode) - 48;
         } else {
           charCode = dart.notNull(charCode) | 32;
           if (97 <= dart.notNull(charCode) && dart.notNull(charCode) <= 102) {
             byte = dart.notNull(byte) * 16 + dart.notNull(charCode) - 87;
           } else {
             throw new ArgumentError("Invalid URL encoding");
           }
         }
       }
       return byte;
     }
     static _uriDecode(text, opts) {
       let plusToSpace = opts && 'plusToSpace' in opts ? opts.plusToSpace : false;
       let encoding = opts && 'encoding' in opts ? opts.encoding : convert.UTF8;
       let simple = true;
       for (let i = 0; dart.notNull(i) < dart.notNull(text.length) && dart.notNull(simple); i = dart.notNull(i) + 1) {
-        let codeUnit = text.codeUnitAt(i);
+        let codeUnit = text[dartx.codeUnitAt](i);
         simple = codeUnit != Uri._PERCENT && codeUnit != Uri._PLUS;
       }
       let bytes = null;
       if (simple) {
         if (dart.notNull(dart.equals(encoding, convert.UTF8)) || dart.notNull(dart.equals(encoding, convert.LATIN1))) {
           return text;
         } else {
-          bytes = text.codeUnits;
+          bytes = text[dartx.codeUnits];
         }
       } else {
         bytes = List$(int).new();
         for (let i = 0; dart.notNull(i) < dart.notNull(text.length); i = dart.notNull(i) + 1) {
-          let codeUnit = text.codeUnitAt(i);
+          let codeUnit = text[dartx.codeUnitAt](i);
           if (dart.notNull(codeUnit) > 127) {
             throw new ArgumentError("Illegal percent encoding in URI");
           }
           if (codeUnit == Uri._PERCENT) {
             if (dart.notNull(i) + 3 > dart.notNull(text.length)) {
               throw new ArgumentError('Truncated URI');
             }
-            bytes[$add](Uri._hexCharPairToByte(text, dart.notNull(i) + 1));
+            bytes[dartx.add](Uri._hexCharPairToByte(text, dart.notNull(i) + 1));
             i = dart.notNull(i) + 2;
           } else if (dart.notNull(plusToSpace) && codeUnit == Uri._PLUS) {
-            bytes[$add](Uri._SPACE);
+            bytes[dartx.add](Uri._SPACE);
           } else {
-            bytes[$add](codeUnit);
+            bytes[dartx.add](codeUnit);
           }
         }
       }
       return encoding.decode(bytes);
     }
     static _isAlphabeticCharacter(codeUnit) {
       return dart.notNull(codeUnit) >= dart.notNull(Uri._LOWER_CASE_A) && dart.notNull(codeUnit) <= dart.notNull(Uri._LOWER_CASE_Z) || dart.notNull(codeUnit) >= dart.notNull(Uri._UPPER_CASE_A) && dart.notNull(codeUnit) <= dart.notNull(Uri._UPPER_CASE_Z);
     }
   }
   dart.defineNamedConstructor(Uri, '_internal');
@@ skipping 96 matching lines @@
   Uri._genDelimitersTable = dart.const([0, 0, 32776, 33792, 1, 10240, 0, 0]);
   Uri._userinfoTable = dart.const([0, 0, 32722, 12287, 65534, 34815, 65534, 18431]);
   Uri._regNameTable = dart.const([0, 0, 32754, 11263, 65534, 34815, 65534, 18431]);
   Uri._pathCharTable = dart.const([0, 0, 32722, 12287, 65535, 34815, 65534, 18431]);
   Uri._pathCharOrSlashTable = dart.const([0, 0, 65490, 12287, 65535, 34815, 65534, 18431]);
   Uri._queryCharTable = dart.const([0, 0, 65490, 45055, 65535, 34815, 65534, 18431]);
   function _symbolToString(symbol) {
     return _internal.Symbol.getName(dart.as(symbol, _internal.Symbol));
   }
   dart.fn(_symbolToString, String, [Symbol]);
-  function _symbolMapToStringMap(map) {
-    if (map == null)
-      return null;
-    let result = Map$(String, Object).new();
-    map.forEach(dart.fn((key, value) => {
-      result.set(_symbolToString(key), value);
-    }, Object, [Symbol, Object]));
-    return result;
-  }
-  dart.fn(_symbolMapToStringMap, Object, [Map$(Symbol, Object)]);
-  class SupportJsExtensionMethods extends Object {
-    SupportJsExtensionMethods() {
-    }
-  }
-  dart.setSignature(SupportJsExtensionMethods, {
-    constructors: () => ({SupportJsExtensionMethods: [SupportJsExtensionMethods, []]})
-  });
-  class _ListConstructorSentinel extends Object {
-    _ListConstructorSentinel() {
-    }
-  }
-  dart.setSignature(_ListConstructorSentinel, {
-    constructors: () => ({_ListConstructorSentinel: [_ListConstructorSentinel, []]})
-  });
   // Exports:
   exports.Object = Object;
-  exports.JsName = JsName;
-  exports.JsPeerInterface = JsPeerInterface;
-  exports.SupportJsExtensionMethod = SupportJsExtensionMethod;
   exports.Deprecated = Deprecated;
   exports.deprecated = deprecated;
   exports.override = override;
   exports.proxy = proxy;
   exports.bool = bool;
   exports.Comparator$ = Comparator$;
   exports.Comparator = Comparator;
   exports.Comparable$ = Comparable$;
   exports.Comparable = Comparable;
   exports.DateTime = DateTime;
   exports.num = num;
   exports.double = double;
   exports.Duration = Duration;
   exports.Error = Error;
   exports.AssertionError = AssertionError;
   exports.TypeError = TypeError;
   exports.CastError = CastError;
   exports.NullThrownError = NullThrownError;
   exports.ArgumentError = ArgumentError;
   exports.RangeError = RangeError;
   exports.IndexError = IndexError;
   exports.FallThroughError = FallThroughError;
   exports.AbstractClassInstantiationError = AbstractClassInstantiationError;
-  exports.$length = $length;
-  exports.$get = $get;
   exports.NoSuchMethodError = NoSuchMethodError;
   exports.UnsupportedError = UnsupportedError;
   exports.UnimplementedError = UnimplementedError;
   exports.StateError = StateError;
   exports.ConcurrentModificationError = ConcurrentModificationError;
   exports.OutOfMemoryError = OutOfMemoryError;
   exports.StackOverflowError = StackOverflowError;
   exports.CyclicInitializationError = CyclicInitializationError;
   exports.Exception = Exception;
   exports.FormatException = FormatException;
   exports.IntegerDivisionByZeroException = IntegerDivisionByZeroException;
   exports.Expando$ = Expando$;
   exports.Expando = Expando;
   exports.Function = Function;
   exports.identical = identical;
   exports.identityHashCode = identityHashCode;
   exports.int = int;
   exports.Invocation = Invocation;
-  exports.$iterator = $iterator;
-  exports.$join = $join;
   exports.Iterable$ = Iterable$;
   exports.Iterable = Iterable;
-  exports.$skip = $skip;
-  exports.$take = $take;
   exports.BidirectionalIterator$ = BidirectionalIterator$;
   exports.BidirectionalIterator = BidirectionalIterator;
   exports.Iterator$ = Iterator$;
   exports.Iterator = Iterator;
-  exports.$set = $set;
-  exports.$add = $add;
-  exports.$checkMutable = $checkMutable;
-  exports.$checkGrowable = $checkGrowable;
-  exports.$where = $where;
-  exports.$expand = $expand;
-  exports.$forEach = $forEach;
-  exports.$map = $map;
-  exports.$takeWhile = $takeWhile;
-  exports.$skipWhile = $skipWhile;
-  exports.$reduce = $reduce;
-  exports.$fold = $fold;
-  exports.$firstWhere = $firstWhere;
-  exports.$lastWhere = $lastWhere;
-  exports.$singleWhere = $singleWhere;
-  exports.$elementAt = $elementAt;
-  exports.$first = $first;
-  exports.$last = $last;
-  exports.$single = $single;
-  exports.$any = $any;
-  exports.$every = $every;
-  exports.$contains = $contains;
-  exports.$isEmpty = $isEmpty;
-  exports.$isNotEmpty = $isNotEmpty;
-  exports.$toString = $toString;
-  exports.$toList = $toList;
-  exports.$toSet = $toSet;
-  exports.$hashCode = $hashCode;
-  exports.$addAll = $addAll;
-  exports.$reversed = $reversed;
-  exports.$sort = $sort;
-  exports.$shuffle = $shuffle;
-  exports.$indexOf = $indexOf;
-  exports.$lastIndexOf = $lastIndexOf;
-  exports.$clear = $clear;
-  exports.$insert = $insert;
-  exports.$insertAll = $insertAll;
-  exports.$setAll = $setAll;
-  exports.$remove = $remove;
-  exports.$removeAt = $removeAt;
-  exports.$removeLast = $removeLast;
-  exports.$removeWhere = $removeWhere;
-  exports.$retainWhere = $retainWhere;
-  exports.$sublist = $sublist;
-  exports.$getRange = $getRange;
-  exports.$setRange = $setRange;
-  exports.$removeRange = $removeRange;
-  exports.$fillRange = $fillRange;
-  exports.$replaceRange = $replaceRange;
-  exports.$asMap = $asMap;
   exports.List$ = List$;
   exports.List = List;
   exports.Map$ = Map$;
   exports.Map = Map;
   exports.Null = Null;
   exports.Pattern = Pattern;
   exports.print = print;
   exports.Match = Match;
   exports.RegExp = RegExp;
   exports.Set$ = Set$;
   exports.Sink$ = Sink$;
   exports.Sink = Sink;
   exports.StackTrace = StackTrace;
   exports.Stopwatch = Stopwatch;
   exports.String = String;
   exports.RuneIterator = RuneIterator;
   exports.StringBuffer = StringBuffer;
   exports.StringSink = StringSink;
   exports.Symbol = Symbol;
   exports.Type = Type;
   exports.Uri = Uri;
-  exports.SupportJsExtensionMethods = SupportJsExtensionMethods;
-})(core, _js_helper, _internal, collection, _interceptors, math, convert);
+})(core, _js_helper, _internal, collection, _interceptors, convert);