update Map

lib/runtime/dart_sdk.js

Index: lib/runtime/dart_sdk.js
diff --git a/lib/runtime/dart_sdk.js b/lib/runtime/dart_sdk.js
index 7bebddbe1f53ac6ef51e643b016676f83af01784..61a40d3d2d4516b5ed31799381fb454d87d9f0b8 100644
--- a/lib/runtime/dart_sdk.js
+++ b/lib/runtime/dart_sdk.js
@@ -9792,6 +9792,916 @@ dart_library.library('dart_sdk', null, /* Imports */[
   dart.setSignature(_js_helper.SupportJsExtensionMethods, {
     constructors: () => ({SupportJsExtensionMethods: [_js_helper.SupportJsExtensionMethods, []]})
   });
+  const _map = Symbol('_map');
+  collection.MapView$ = dart.generic((K, V) => {
+    class MapView extends core.Object {
+      MapView(map) {
+        this[_map] = map;
+      }
+      get(key) {
+        return this[_map][dartx.get](key);
+      }
+      set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
+        this[_map][dartx.set](key, value);
+        return value;
+      }
+      addAll(other) {
+        dart.as(other, core.Map$(K, V));
+        this[_map][dartx.addAll](other);
+      }
+      clear() {
+        this[_map][dartx.clear]();
+      }
+      putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
+        return this[_map][dartx.putIfAbsent](key, ifAbsent);
+      }
+      containsKey(key) {
+        return this[_map][dartx.containsKey](key);
+      }
+      containsValue(value) {
+        return this[_map][dartx.containsValue](value);
+      }
+      forEach(action) {
+        dart.as(action, dart.functionType(dart.void, [K, V]));
+        this[_map][dartx.forEach](action);
+      }
+      get isEmpty() {
+        return this[_map][dartx.isEmpty];
+      }
+      get isNotEmpty() {
+        return this[_map][dartx.isNotEmpty];
+      }
+      get length() {
+        return this[_map][dartx.length];
+      }
+      get keys() {
+        return this[_map][dartx.keys];
+      }
+      remove(key) {
+        return this[_map][dartx.remove](key);
+      }
+      toString() {
+        return dart.toString(this[_map]);
+      }
+      get values() {
+        return this[_map][dartx.values];
+      }
+    }
+    MapView[dart.implements] = () => [core.Map$(K, V)];
+    dart.setSignature(MapView, {
+      constructors: () => ({MapView: [collection.MapView$(K, V), [core.Map$(K, V)]]}),
+      methods: () => ({
+        get: [V, [core.Object]],
+        set: [dart.void, [K, V]],
+        addAll: [dart.void, [core.Map$(K, V)]],
+        clear: [dart.void, []],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]],
+        containsKey: [core.bool, [core.Object]],
+        containsValue: [core.bool, [core.Object]],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
+        remove: [V, [core.Object]]
+      })
+    });
+    dart.defineExtensionMembers(MapView, [
+      'get',
+      'set',
+      'addAll',
+      'clear',
+      'putIfAbsent',
+      'containsKey',
+      'containsValue',
+      'forEach',
+      'remove',
+      'isEmpty',
+      'isNotEmpty',
+      'length',
+      'keys',
+      'values'
+    ]);
+    return MapView;
+  });
+  collection.MapView = collection.MapView$();
+  collection._UnmodifiableMapMixin$ = dart.generic((K, V) => {
+    class _UnmodifiableMapMixin extends core.Object {
+      set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
+        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
+        return value;
+      }
+      addAll(other) {
+        dart.as(other, core.Map$(K, V));
+        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
+      }
+      clear() {
+        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
+      }
+      remove(key) {
+        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
+      }
+      putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
+        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
+      }
+    }
+    _UnmodifiableMapMixin[dart.implements] = () => [core.Map$(K, V)];
+    dart.setSignature(_UnmodifiableMapMixin, {
+      methods: () => ({
+        set: [dart.void, [K, V]],
+        addAll: [dart.void, [core.Map$(K, V)]],
+        clear: [dart.void, []],
+        remove: [V, [core.Object]],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]]
+      })
+    });
+    dart.defineExtensionMembers(_UnmodifiableMapMixin, [
+      'set',
+      'addAll',
+      'clear',
+      'remove',
+      'putIfAbsent'
+    ]);
+    return _UnmodifiableMapMixin;
+  });
+  collection._UnmodifiableMapMixin = collection._UnmodifiableMapMixin$();
+  collection.UnmodifiableMapView$ = dart.generic((K, V) => {
+    class UnmodifiableMapView extends dart.mixin(collection.MapView$(K, V), collection._UnmodifiableMapMixin$(K, V)) {
+      UnmodifiableMapView() {
+        super.MapView(...arguments);
+      }
+    }
+    return UnmodifiableMapView;
+  });
+  collection.UnmodifiableMapView = collection.UnmodifiableMapView$();
+  _js_helper.ConstantMapView$ = dart.generic((K, V) => {
+    class ConstantMapView extends collection.UnmodifiableMapView$(K, V) {
+      ConstantMapView(base) {
+      }
+    }
+    ConstantMapView[dart.implements] = () => [_js_helper.ConstantMap$(K, V)];
+    dart.setSignature(ConstantMapView, {
+      constructors: () => ({ConstantMapView: [_js_helper.ConstantMapView$(K, V), [core.Map$(K, V)]]})
+    });
+    return ConstantMapView;
+  });
+  _js_helper.ConstantMapView = _js_helper.ConstantMapView$();
+  _js_helper.ConstantMap$ = dart.generic((K, V) => {
+    class ConstantMap extends core.Object {
+      static from(other) {
+        let keys = other[dartx.keys][dartx.toList]();
+        let allStrings = true;
+        for (let k of keys) {
+          if (!(typeof k == 'string')) {
+            allStrings = false;
+            break;
+          }
+        }
+        if (allStrings) {
+          let containsProto = false;
+          let protoValue = null;
+          let object = {};
+          let length = 0;
+          for (let k of keys) {
+            let v = other[dartx.get](k);
+            if (!dart.equals(k, "__proto__")) {
+              if (!dart.notNull(_js_helper.jsHasOwnProperty(object, dart.as(k, core.String)))) length++;
+              object[k] = v;
+            } else {
+              containsProto = true;
+              protoValue = v;
+            }
+          }
+          if (containsProto) {
+            length++;
+            return new (_js_helper.ConstantProtoMap$(K, V))._(length, object, keys, dart.as(protoValue, V));
+          }
+          return new (_js_helper.ConstantStringMap$(K, V))._(length, object, dart.as(keys, core.List$(K)));
+        }
+        return new (_js_helper.ConstantMapView$(K, V))(core.Map$(K, V).from(other));
+      }
+      _() {
+      }
+      get isEmpty() {
+        return this[dartx.length] == 0;
+      }
+      get isNotEmpty() {
+        return !dart.notNull(this.isEmpty);
+      }
+      toString() {
+        return collection.Maps.mapToString(this);
+      }
+      static _throwUnmodifiable() {
+        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable Map"));
+      }
+      set(key, val) {
+        (() => {
+          dart.as(key, K);
+          dart.as(val, V);
+          return _js_helper.ConstantMap._throwUnmodifiable();
+        })();
+        return val;
+      }
+      putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
+        return dart.as(_js_helper.ConstantMap._throwUnmodifiable(), V);
+      }
+      remove(key) {
+        return dart.as(_js_helper.ConstantMap._throwUnmodifiable(), V);
+      }
+      clear() {
+        return _js_helper.ConstantMap._throwUnmodifiable();
+      }
+      addAll(other) {
+        dart.as(other, core.Map$(K, V));
+        return _js_helper.ConstantMap._throwUnmodifiable();
+      }
+    }
+    dart.defineNamedConstructor(ConstantMap, '_');
+    ConstantMap[dart.implements] = () => [core.Map$(K, V)];
+    dart.setSignature(ConstantMap, {
+      constructors: () => ({
+        from: [_js_helper.ConstantMap$(K, V), [core.Map]],
+        _: [_js_helper.ConstantMap$(K, V), []]
+      }),
+      methods: () => ({
+        set: [dart.void, [K, V]],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]],
+        remove: [V, [core.Object]],
+        clear: [dart.void, []],
+        addAll: [dart.void, [core.Map$(K, V)]]
+      }),
+      statics: () => ({_throwUnmodifiable: [dart.dynamic, []]}),
+      names: ['_throwUnmodifiable']
+    });
+    dart.defineExtensionMembers(ConstantMap, [
+      'set',
+      'putIfAbsent',
+      'remove',
+      'clear',
+      'addAll',
+      'isEmpty',
+      'isNotEmpty'
+    ]);
+    return ConstantMap;
+  });
+  _js_helper.ConstantMap = _js_helper.ConstantMap$();
+  const _length$0 = Symbol('_length');
+  const _jsObject = Symbol('_jsObject');
+  const _keys = Symbol('_keys');
+  const _keysArray = Symbol('_keysArray');
+  const _fetch = Symbol('_fetch');
+  _js_helper.ConstantStringMap$ = dart.generic((K, V) => {
+    class ConstantStringMap extends _js_helper.ConstantMap$(K, V) {
+      _(length, jsObject, keys) {
+        this[_length$0] = length;
+        this[_jsObject] = jsObject;
+        this[_keys] = keys;
+        super._();
+      }
+      get length() {
+        return this[_length$0];
+      }
+      get [_keysArray]() {
+        return this[_keys];
+      }
+      containsValue(needle) {
+        return this.values[dartx.any](dart.fn(value => {
+          dart.as(value, V);
+          return dart.equals(value, needle);
+        }, core.bool, [V]));
+      }
+      containsKey(key) {
+        if (!(typeof key == 'string')) return false;
+        if (dart.equals('__proto__', key)) return false;
+        return _js_helper.jsHasOwnProperty(this[_jsObject], dart.as(key, core.String));
+      }
+      get(key) {
+        if (!dart.notNull(this.containsKey(key))) return null;
+        return dart.as(this[_fetch](key), V);
+      }
+      [_fetch](key) {
+        return _js_helper.jsPropertyAccess(this[_jsObject], dart.as(key, core.String));
+      }
+      forEach(f) {
+        dart.as(f, dart.functionType(dart.void, [K, V]));
+        let keys = this[_keysArray];
+        for (let i = 0; i < dart.notNull(keys[dartx.length]); i++) {
+          let key = keys[dartx.get](i);
+          f(dart.as(key, K), dart.as(this[_fetch](key), V));
+        }
+      }
+      get keys() {
+        return new (_js_helper._ConstantMapKeyIterable$(K))(this);
+      }
+      get values() {
+        return _internal.MappedIterable$(K, V).new(dart.as(this[_keysArray], core.Iterable$(K)), dart.fn(key => {
+          dart.as(key, K);
+          return dart.as(this[_fetch](key), V);
+        }, V, [K]));
+      }
+    }
+    dart.defineNamedConstructor(ConstantStringMap, '_');
+    dart.setSignature(ConstantStringMap, {
+      constructors: () => ({_: [_js_helper.ConstantStringMap$(K, V), [core.int, dart.dynamic, core.List$(K)]]}),
+      methods: () => ({
+        containsValue: [core.bool, [core.Object]],
+        containsKey: [core.bool, [core.Object]],
+        get: [V, [core.Object]],
+        [_fetch]: [dart.dynamic, [dart.dynamic]],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]]
+      })
+    });
+    dart.defineExtensionMembers(ConstantStringMap, [
+      'containsValue',
+      'containsKey',
+      'get',
+      'forEach',
+      'length',
+      'keys',
+      'values'
+    ]);
+    return ConstantStringMap;
+  });
+  _js_helper.ConstantStringMap = _js_helper.ConstantStringMap$();
+  const _protoValue = Symbol('_protoValue');
+  _js_helper.ConstantProtoMap$ = dart.generic((K, V) => {
+    class ConstantProtoMap extends _js_helper.ConstantStringMap$(K, V) {
+      _(length, jsObject, keys, protoValue) {
+        this[_protoValue] = protoValue;
+        super._(dart.as(length, core.int), jsObject, dart.as(keys, core.List$(K)));
+      }
+      containsKey(key) {
+        if (!(typeof key == 'string')) return false;
+        if (dart.equals('__proto__', key)) return true;
+        return _js_helper.jsHasOwnProperty(this[_jsObject], dart.as(key, core.String));
+      }
+      [_fetch](key) {
+        return dart.equals('__proto__', key) ? this[_protoValue] : _js_helper.jsPropertyAccess(this[_jsObject], dart.as(key, core.String));
+      }
+    }
+    dart.defineNamedConstructor(ConstantProtoMap, '_');
+    dart.setSignature(ConstantProtoMap, {
+      constructors: () => ({_: [_js_helper.ConstantProtoMap$(K, V), [dart.dynamic, dart.dynamic, dart.dynamic, V]]})
+    });
+    dart.defineExtensionMembers(ConstantProtoMap, ['containsKey']);
+    return ConstantProtoMap;
+  });
+  _js_helper.ConstantProtoMap = _js_helper.ConstantProtoMap$();
+  const _map$ = Symbol('_map');
+  _js_helper._ConstantMapKeyIterable$ = dart.generic(K => {
+    class _ConstantMapKeyIterable extends core.Iterable$(K) {
+      _ConstantMapKeyIterable(map) {
+        this[_map$] = map;
+        super.Iterable();
+      }
+      get iterator() {
+        return dart.as(this[_map$][_keysArray][dartx.iterator], core.Iterator$(K));
+      }
+      get length() {
+        return this[_map$][_keysArray][dartx.length];
+      }
+    }
+    dart.setSignature(_ConstantMapKeyIterable, {
+      constructors: () => ({_ConstantMapKeyIterable: [_js_helper._ConstantMapKeyIterable$(K), [_js_helper.ConstantStringMap$(K, dart.dynamic)]]})
+    });
+    dart.defineExtensionMembers(_ConstantMapKeyIterable, ['iterator', 'length']);
+    return _ConstantMapKeyIterable;
+  });
+  _js_helper._ConstantMapKeyIterable = _js_helper._ConstantMapKeyIterable$();
+  const _jsData = Symbol('_jsData');
+  const _getMap = Symbol('_getMap');
+  _js_helper.GeneralConstantMap$ = dart.generic((K, V) => {
+    class GeneralConstantMap extends _js_helper.ConstantMap$(K, V) {
+      GeneralConstantMap(jsData) {
+        this[_jsData] = jsData;
+        super._();
+      }
+      [_getMap]() {
+        let backingMap = this.$map;
+        if (backingMap == null) {
+          backingMap = new (_js_helper.JsLinkedHashMap$(K, V))();
+          _js_helper.fillLiteralMap(this[_jsData], backingMap);
+          this.$map = backingMap;
+        }
+        return backingMap;
+      }
+      containsValue(needle) {
+        return this[_getMap]()[dartx.containsValue](needle);
+      }
+      containsKey(key) {
+        return this[_getMap]()[dartx.containsKey](key);
+      }
+      get(key) {
+        return this[_getMap]()[dartx.get](key);
+      }
+      forEach(f) {
+        dart.as(f, dart.functionType(dart.void, [K, V]));
+        this[_getMap]()[dartx.forEach](f);
+      }
+      get keys() {
+        return this[_getMap]()[dartx.keys];
+      }
+      get values() {
+        return this[_getMap]()[dartx.values];
+      }
+      get length() {
+        return this[_getMap]()[dartx.length];
+      }
+    }
+    dart.setSignature(GeneralConstantMap, {
+      constructors: () => ({GeneralConstantMap: [_js_helper.GeneralConstantMap$(K, V), [dart.dynamic]]}),
+      methods: () => ({
+        [_getMap]: [core.Map$(K, V), []],
+        containsValue: [core.bool, [core.Object]],
+        containsKey: [core.bool, [core.Object]],
+        get: [V, [core.Object]],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]]
+      })
+    });
+    dart.defineExtensionMembers(GeneralConstantMap, [
+      'containsValue',
+      'containsKey',
+      'get',
+      'forEach',
+      'keys',
+      'values',
+      'length'
+    ]);
+    return GeneralConstantMap;
+  });
+  _js_helper.GeneralConstantMap = _js_helper.GeneralConstantMap$();
+  const _strings = Symbol('_strings');
+  const _nums = Symbol('_nums');
+  const _rest = Symbol('_rest');
+  const _first = Symbol('_first');
+  const _last = Symbol('_last');
+  const _modifications = Symbol('_modifications');
+  const _containsTableEntry = Symbol('_containsTableEntry');
+  const _getBucket = Symbol('_getBucket');
+  const _getTableEntry = Symbol('_getTableEntry');
+  const _newHashTable = Symbol('_newHashTable');
+  const _addHashTableEntry = Symbol('_addHashTableEntry');
+  const _newLinkedCell = Symbol('_newLinkedCell');
+  const _setTableEntry = Symbol('_setTableEntry');
+  const _removeHashTableEntry = Symbol('_removeHashTableEntry');
+  const _unlinkCell = Symbol('_unlinkCell');
+  const _modified = Symbol('_modified');
+  const _next = Symbol('_next');
+  const _deleteTableEntry = Symbol('_deleteTableEntry');
+  const _previous = Symbol('_previous');
+  _js_helper.JsLinkedHashMap$ = dart.generic((K, V) => {
+    class JsLinkedHashMap extends core.Object {
+      JsLinkedHashMap() {
+        this[_length$0] = 0;
+        this[_strings] = null;
+        this[_nums] = null;
+        this[_rest] = null;
+        this[_first] = null;
+        this[_last] = null;
+        this[_modifications] = 0;
+      }
+      static es6() {
+        return new (_js_helper.JsLinkedHashMap$(K, V))();
+      }
+      get length() {
+        return this[_length$0];
+      }
+      get isEmpty() {
+        return this[_length$0] == 0;
+      }
+      get isNotEmpty() {
+        return !dart.notNull(this.isEmpty);
+      }
+      get keys() {
+        return new (_js_helper.LinkedHashMapKeyIterable$(K))(this);
+      }
+      get values() {
+        return _internal.MappedIterable$(K, V).new(this.keys, dart.fn(each => {
+          dart.as(each, K);
+          return this.get(each);
+        }, V, [K]));
+      }
+      containsKey(key) {
+        if (dart.notNull(_js_helper.JsLinkedHashMap._isStringKey(key))) {
+          let strings = this[_strings];
+          if (strings == null) return false;
+          return this[_containsTableEntry](strings, key);
+        } else if (dart.notNull(_js_helper.JsLinkedHashMap._isNumericKey(key))) {
+          let nums = this[_nums];
+          if (nums == null) return false;
+          return this[_containsTableEntry](nums, key);
+        } else {
+          return this.internalContainsKey(key);
+        }
+      }
+      internalContainsKey(key) {
+        let rest = this[_rest];
+        if (rest == null) return false;
+        let bucket = this[_getBucket](rest, key);
+        return dart.notNull(this.internalFindBucketIndex(bucket, key)) >= 0;
+      }
+      containsValue(value) {
+        return this.keys[dartx.any](dart.fn(each => {
+          dart.as(each, K);
+          return dart.equals(this.get(each), value);
+        }, core.bool, [K]));
+      }
+      addAll(other) {
+        dart.as(other, core.Map$(K, V));
+        other[dartx.forEach](dart.fn((key, value) => {
+          dart.as(key, K);
+          dart.as(value, V);
+          this.set(key, value);
+        }, dart.void, [K, V]));
+      }
+      get(key) {
+        if (dart.notNull(_js_helper.JsLinkedHashMap._isStringKey(key))) {
+          let strings = this[_strings];
+          if (strings == null) return null;
+          let cell = dart.as(this[_getTableEntry](strings, key), _js_helper.LinkedHashMapCell);

[sra1, 2016/05/09 23:16:40]

[B] get rid of this dart.as(..., LinkedHashMapCell)

+          return dart.as(cell == null ? null : cell.hashMapCellValue, V);

[sra1, 2016/05/09 23:16:40]

[A] get rid of this dart.as(..., V)

+        } else if (dart.notNull(_js_helper.JsLinkedHashMap._isNumericKey(key))) {
+          let nums = this[_nums];
+          if (nums == null) return null;
+          let cell = dart.as(this[_getTableEntry](nums, key), _js_helper.LinkedHashMapCell);
+          return dart.as(cell == null ? null : cell.hashMapCellValue, V);
+        } else {
+          return this.internalGet(key);
+        }
+      }
+      internalGet(key) {
+        let rest = this[_rest];
+        if (rest == null) return null;
+        let bucket = this[_getBucket](rest, key);
+        let index = this.internalFindBucketIndex(bucket, key);
+        if (dart.notNull(index) < 0) return null;
+        let cell = bucket[index];
+        return dart.as(cell.hashMapCellValue, V);
+      }
+      set(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
+        if (dart.notNull(_js_helper.JsLinkedHashMap._isStringKey(key))) {
+          let strings = this[_strings];
+          if (strings == null) this[_strings] = strings = this[_newHashTable]();
+          this[_addHashTableEntry](strings, key, value);
+        } else if (dart.notNull(_js_helper.JsLinkedHashMap._isNumericKey(key))) {
+          let nums = this[_nums];
+          if (nums == null) this[_nums] = nums = this[_newHashTable]();
+          this[_addHashTableEntry](nums, key, value);
+        } else {
+          this.internalSet(key, value);
+        }
+        return value;
+      }
+      internalSet(key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
+        let rest = this[_rest];
+        if (rest == null) this[_rest] = rest = this[_newHashTable]();
+        let hash = this.internalComputeHashCode(key);
+        let bucket = this[_getTableEntry](rest, hash);
+        if (bucket == null) {
+          let cell = this[_newLinkedCell](key, value);
+          this[_setTableEntry](rest, hash, [cell]);
+        } else {
+          let index = this.internalFindBucketIndex(bucket, key);
+          if (dart.notNull(index) >= 0) {
+            let cell = bucket[index];
+            cell.hashMapCellValue = value;
+          } else {
+            let cell = this[_newLinkedCell](key, value);
+            bucket.push(cell);
+          }
+        }
+      }
+      putIfAbsent(key, ifAbsent) {
+        dart.as(key, K);
+        dart.as(ifAbsent, dart.functionType(V, []));
+        if (dart.notNull(this.containsKey(key))) return this.get(key);
+        let value = ifAbsent();
+        this.set(key, value);
+        return value;
+      }
+      remove(key) {
+        if (dart.notNull(_js_helper.JsLinkedHashMap._isStringKey(key))) {
+          return this[_removeHashTableEntry](this[_strings], key);
+        } else if (dart.notNull(_js_helper.JsLinkedHashMap._isNumericKey(key))) {
+          return this[_removeHashTableEntry](this[_nums], key);
+        } else {
+          return this.internalRemove(key);
+        }
+      }
+      internalRemove(key) {
+        let rest = this[_rest];
+        if (rest == null) return null;
+        let bucket = this[_getBucket](rest, key);
+        let index = this.internalFindBucketIndex(bucket, key);
+        if (dart.notNull(index) < 0) return null;
+        let cell = bucket.splice(index, 1)[0];
+        this[_unlinkCell](cell);
+        return dart.as(cell.hashMapCellValue, V);
+      }
+      clear() {
+        if (dart.notNull(this[_length$0]) > 0) {
+          this[_strings] = this[_nums] = this[_rest] = this[_first] = this[_last] = null;
+          this[_length$0] = 0;
+          this[_modified]();
+        }
+      }
+      forEach(action) {
+        dart.as(action, dart.functionType(dart.void, [K, V]));
+        let cell = this[_first];
+        let modifications = this[_modifications];
+        while (cell != null) {
+          action(dart.as(cell.hashMapCellKey, K), dart.as(cell.hashMapCellValue, V));
+          if (modifications != this[_modifications]) {
+            dart.throw(new core.ConcurrentModificationError(this));
+          }
+          cell = cell[_next];
+        }
+      }
+      [_addHashTableEntry](table, key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
+        let cell = dart.as(this[_getTableEntry](table, key), _js_helper.LinkedHashMapCell);
+        if (cell == null) {
+          this[_setTableEntry](table, key, this[_newLinkedCell](key, value));
+        } else {
+          cell.hashMapCellValue = value;
+        }
+      }
+      [_removeHashTableEntry](table, key) {
+        if (table == null) return null;
+        let cell = dart.as(this[_getTableEntry](table, key), _js_helper.LinkedHashMapCell);
+        if (cell == null) return null;
+        this[_unlinkCell](cell);
+        this[_deleteTableEntry](table, key);
+        return dart.as(cell.hashMapCellValue, V);
+      }
+      [_modified]() {
+        this[_modifications] = dart.notNull(this[_modifications]) + 1 & 67108863;
+      }
+      [_newLinkedCell](key, value) {
+        dart.as(key, K);
+        dart.as(value, V);
+        let cell = new _js_helper.LinkedHashMapCell(key, value);
+        if (this[_first] == null) {
+          this[_first] = this[_last] = cell;
+        } else {
+          let last = this[_last];
+          cell[_previous] = last;
+          this[_last] = last[_next] = cell;
+        }
+        this[_length$0] = dart.notNull(this[_length$0]) + 1;
+        this[_modified]();
+        return cell;
+      }
+      [_unlinkCell](cell) {
+        let previous = cell[_previous];
+        let next = cell[_next];
+        if (previous == null) {
+          dart.assert(dart.equals(cell, this[_first]));
+          this[_first] = next;
+        } else {
+          previous[_next] = next;
+        }
+        if (next == null) {
+          dart.assert(dart.equals(cell, this[_last]));
+          this[_last] = previous;
+        } else {
+          next[_previous] = previous;
+        }
+        this[_length$0] = dart.notNull(this[_length$0]) - 1;
+        this[_modified]();
+      }
+      static _isStringKey(key) {
+        return typeof key == 'string';
+      }
+      static _isNumericKey(key) {
+        return typeof key == 'number' && (key & 0x3ffffff) === key;
+      }
+      internalComputeHashCode(key) {
+        return dart.hashCode(key) & 0x3ffffff;
+      }
+      [_getBucket](table, key) {
+        let hash = this.internalComputeHashCode(key);
+        return dart.as(this[_getTableEntry](table, hash), core.List);
+      }
+      internalFindBucketIndex(bucket, key) {
+        if (bucket == null) return -1;
+        let length = bucket.length;
+        for (let i = 0; i < length; i++) {
+          let cell = bucket[i];
+          if (dart.equals(cell.hashMapCellKey, key)) return i;
+        }
+        return -1;
+      }
+      toString() {
+        return collection.Maps.mapToString(this);
+      }
+      [_getTableEntry](table, key) {
+        return table[key];
+      }
+      [_setTableEntry](table, key, value) {
+        dart.assert(value != null);
+        table[key] = value;
+      }
+      [_deleteTableEntry](table, key) {
+        delete table[key];
+      }
+      [_containsTableEntry](table, key) {
+        let cell = dart.as(this[_getTableEntry](table, key), _js_helper.LinkedHashMapCell);
+        return cell != null;
+      }
+      [_newHashTable]() {
+        let table = Object.create(null);
+        let temporaryKey = '<non-identifier-key>';
+        this[_setTableEntry](table, temporaryKey, table);
+        this[_deleteTableEntry](table, temporaryKey);
+        return table;
+      }
+    }
+    JsLinkedHashMap[dart.implements] = () => [collection.LinkedHashMap$(K, V), _js_helper.InternalMap];
+    dart.setSignature(JsLinkedHashMap, {
+      constructors: () => ({
+        JsLinkedHashMap: [_js_helper.JsLinkedHashMap$(K, V), []],
+        es6: [_js_helper.JsLinkedHashMap$(K, V), []]
+      }),
+      methods: () => ({
+        containsKey: [core.bool, [core.Object]],
+        internalContainsKey: [core.bool, [core.Object]],
+        containsValue: [core.bool, [core.Object]],
+        addAll: [dart.void, [core.Map$(K, V)]],
+        get: [V, [core.Object]],
+        internalGet: [V, [core.Object]],
+        set: [dart.void, [K, V]],
+        internalSet: [dart.void, [K, V]],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]],
+        remove: [V, [core.Object]],
+        internalRemove: [V, [core.Object]],
+        clear: [dart.void, []],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
+        [_addHashTableEntry]: [dart.void, [dart.dynamic, K, V]],
+        [_removeHashTableEntry]: [V, [dart.dynamic, core.Object]],
+        [_modified]: [dart.void, []],
+        [_newLinkedCell]: [_js_helper.LinkedHashMapCell, [K, V]],
+        [_unlinkCell]: [dart.void, [_js_helper.LinkedHashMapCell]],
+        internalComputeHashCode: [core.int, [dart.dynamic]],
+        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        internalFindBucketIndex: [core.int, [dart.dynamic, dart.dynamic]],
+        [_getTableEntry]: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+        [_setTableEntry]: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+        [_deleteTableEntry]: [dart.void, [dart.dynamic, dart.dynamic]],
+        [_containsTableEntry]: [core.bool, [dart.dynamic, dart.dynamic]],
+        [_newHashTable]: [dart.dynamic, []]
+      }),
+      statics: () => ({
+        _isStringKey: [core.bool, [dart.dynamic]],
+        _isNumericKey: [core.bool, [dart.dynamic]]
+      }),
+      names: ['_isStringKey', '_isNumericKey']
+    });
+    dart.defineExtensionMembers(JsLinkedHashMap, [
+      'containsKey',
+      'containsValue',
+      'addAll',
+      'get',
+      'set',
+      'putIfAbsent',
+      'remove',
+      'clear',
+      'forEach',
+      'length',
+      'isEmpty',
+      'isNotEmpty',
+      'keys',
+      'values'
+    ]);
+    return JsLinkedHashMap;
+  });
+  _js_helper.JsLinkedHashMap = _js_helper.JsLinkedHashMap$();
+  _js_helper.Es6LinkedHashMap$ = dart.generic((K, V) => {
+    class Es6LinkedHashMap extends _js_helper.JsLinkedHashMap$(K, V) {
+      Es6LinkedHashMap() {
+        super.JsLinkedHashMap();
+      }
+      [_getTableEntry](table, key) {
+        return table.get(key);
+      }
+      [_setTableEntry](table, key, value) {
+        table.set(key, value);
+      }
+      [_deleteTableEntry](table, key) {
+        table.delete(key);
+      }
+      [_containsTableEntry](table, key) {
+        return table.has(key);
+      }
+      [_newHashTable]() {
+        return new Map();
+      }
+    }
+    return Es6LinkedHashMap;
+  });
+  _js_helper.Es6LinkedHashMap = _js_helper.Es6LinkedHashMap$();
+  _js_helper.LinkedHashMapCell = class LinkedHashMapCell extends core.Object {
+    LinkedHashMapCell(hashMapCellKey, hashMapCellValue) {
+      this.hashMapCellKey = hashMapCellKey;
+      this.hashMapCellValue = hashMapCellValue;
+      this[_next] = null;
+      this[_previous] = null;
+    }
+  };
+  dart.setSignature(_js_helper.LinkedHashMapCell, {
+    constructors: () => ({LinkedHashMapCell: [_js_helper.LinkedHashMapCell, [dart.dynamic, dart.dynamic]]})
+  });
+  _js_helper.LinkedHashMapKeyIterable$ = dart.generic(E => {
+    class LinkedHashMapKeyIterable extends core.Iterable$(E) {
+      LinkedHashMapKeyIterable(map) {
+        this[_map$] = map;
+        super.Iterable();
+      }
+      get length() {
+        return dart.as(dart.dload(this[_map$], _length$0), core.int);
+      }
+      get isEmpty() {
+        return dart.equals(dart.dload(this[_map$], _length$0), 0);
+      }
+      get iterator() {
+        return new (_js_helper.LinkedHashMapKeyIterator$(E))(this[_map$], dart.as(dart.dload(this[_map$], _modifications), core.int));
+      }
+      contains(element) {
+        return dart.as(dart.dsend(this[_map$], 'containsKey', element), core.bool);
+      }
+      forEach(f) {
+        dart.as(f, dart.functionType(dart.void, [E]));
+        let cell = dart.as(dart.dload(this[_map$], _first), _js_helper.LinkedHashMapCell);
+        let modifications = dart.as(dart.dload(this[_map$], _modifications), core.int);
+        while (cell != null) {
+          f(dart.as(cell.hashMapCellKey, E));
+          if (!dart.equals(modifications, dart.dload(this[_map$], _modifications))) {
+            dart.throw(new core.ConcurrentModificationError(this[_map$]));
+          }
+          cell = cell[_next];
+        }
+      }
+    }
+    LinkedHashMapKeyIterable[dart.implements] = () => [_internal.EfficientLength];
+    dart.setSignature(LinkedHashMapKeyIterable, {
+      constructors: () => ({LinkedHashMapKeyIterable: [_js_helper.LinkedHashMapKeyIterable$(E), [dart.dynamic]]}),
+      methods: () => ({forEach: [dart.void, [dart.functionType(dart.void, [E])]]})
+    });
+    dart.defineExtensionMembers(LinkedHashMapKeyIterable, [
+      'contains',
+      'forEach',
+      'length',
+      'isEmpty',
+      'iterator'
+    ]);
+    return LinkedHashMapKeyIterable;
+  });
+  _js_helper.LinkedHashMapKeyIterable = _js_helper.LinkedHashMapKeyIterable$();
+  const _cell = Symbol('_cell');
+  _js_helper.LinkedHashMapKeyIterator$ = dart.generic(E => {
+    class LinkedHashMapKeyIterator extends core.Object {
+      LinkedHashMapKeyIterator(map, modifications) {
+        this[_map$] = map;
+        this[_modifications] = modifications;
+        this[_cell] = null;
+        this[_current$0] = null;
+        this[_cell] = dart.as(dart.dload(this[_map$], _first), _js_helper.LinkedHashMapCell);
+      }
+      get current() {
+        return this[_current$0];
+      }
+      moveNext() {
+        if (!dart.equals(this[_modifications], dart.dload(this[_map$], _modifications))) {
+          dart.throw(new core.ConcurrentModificationError(this[_map$]));
+        } else if (this[_cell] == null) {
+          this[_current$0] = null;
+          return false;
+        } else {
+          this[_current$0] = dart.as(this[_cell].hashMapCellKey, E);
+          this[_cell] = this[_cell][_next];
+          return true;
+        }
+      }
+    }
+    LinkedHashMapKeyIterator[dart.implements] = () => [core.Iterator$(E)];
+    dart.setSignature(LinkedHashMapKeyIterator, {
+      constructors: () => ({LinkedHashMapKeyIterator: [_js_helper.LinkedHashMapKeyIterator$(E), [dart.dynamic, core.int]]}),
+      methods: () => ({moveNext: [core.bool, []]})
+    });
+    return LinkedHashMapKeyIterator;
+  });
+  _js_helper.LinkedHashMapKeyIterator = _js_helper.LinkedHashMapKeyIterator$();
   _js_helper.defineProperty = function(obj, property, value) {
     Object.defineProperty(obj, property, {value: value, enumerable: false, writable: true, configurable: true});
   };
@@ -13523,8 +14433,8 @@ dart_library.library('dart_sdk', null, /* Imports */[
   });
   async._BroadcastStream = async._BroadcastStream$();
   const _eventState = Symbol('_eventState');
-  const _next = Symbol('_next');
-  const _previous = Symbol('_previous');
+  const _next$ = Symbol('_next');
+  const _previous$ = Symbol('_previous');
   const _expectsEvent = Symbol('_expectsEvent');
   const _toggleEventId = Symbol('_toggleEventId');
   const _isFiring = Symbol('_isFiring');
@@ -13910,10 +14820,10 @@ dart_library.library('dart_sdk', null, /* Imports */[
     class _BroadcastSubscription extends async._ControllerSubscription$(T) {
       _BroadcastSubscription(controller, onData, onError, onDone, cancelOnError) {
         this[_eventState] = 0;
-        this[_next] = null;
-        this[_previous] = null;
+        this[_next$] = null;
+        this[_previous$] = null;
         super._ControllerSubscription(controller, onData, onError, onDone, cancelOnError);
-        this[_next] = this[_previous] = this;
+        this[_next$] = this[_previous$] = this;
       }
       [_expectsEvent](eventId) {
         return (dart.notNull(this[_eventState]) & dart.notNull(async._BroadcastSubscription._STATE_EVENT_ID)) >>> 0 == eventId;
@@ -14026,35 +14936,35 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       [_addListener](subscription) {
         dart.as(subscription, async._BroadcastSubscription$(T));
-        dart.assert(core.identical(subscription[_next], subscription));
+        dart.assert(core.identical(subscription[_next$], subscription));
         subscription[_eventState] = (dart.notNull(this[_state]) & dart.notNull(async._BroadcastStreamController._STATE_EVENT_ID)) >>> 0;
         let oldLast = this[_lastSubscription];
         this[_lastSubscription] = subscription;
-        subscription[_next] = null;
-        subscription[_previous] = oldLast;
+        subscription[_next$] = null;
+        subscription[_previous$] = oldLast;
         if (oldLast == null) {
           this[_firstSubscription] = subscription;
         } else {
-          oldLast[_next] = subscription;
+          oldLast[_next$] = subscription;
         }
       }
       [_removeListener](subscription) {
         dart.as(subscription, async._BroadcastSubscription$(T));
         dart.assert(core.identical(subscription[_controller$], this));
-        dart.assert(!core.identical(subscription[_next], subscription));
-        let previous = subscription[_previous];
-        let next = subscription[_next];
+        dart.assert(!core.identical(subscription[_next$], subscription));
+        let previous = subscription[_previous$];
+        let next = subscription[_next$];
         if (previous == null) {
           this[_firstSubscription] = next;
         } else {
-          previous[_next] = next;
+          previous[_next$] = next;
         }
         if (next == null) {
           this[_lastSubscription] = previous;
         } else {
-          next[_previous] = previous;
+          next[_previous$] = previous;
         }
-        subscription[_next] = subscription[_previous] = subscription;
+        subscription[_next$] = subscription[_previous$] = subscription;
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
@@ -14073,7 +14983,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
       [_recordCancel](sub) {
         dart.as(sub, async.StreamSubscription$(T));
         let subscription = dart.as(sub, async._BroadcastSubscription$(T));
-        if (core.identical(subscription[_next], subscription)) return null;
+        if (core.identical(subscription[_next$], subscription)) return null;
         if (dart.notNull(subscription[_isFiring])) {
           subscription[_setRemoveAfterFiring]();
         } else {
@@ -14163,14 +15073,14 @@ dart_library.library('dart_sdk', null, /* Imports */[
             subscription[_eventState] = (dart.notNull(subscription[_eventState]) | dart.notNull(async._BroadcastSubscription._STATE_FIRING)) >>> 0;
             action(subscription);
             subscription[_toggleEventId]();
-            let next = subscription[_next];
+            let next = subscription[_next$];
             if (dart.notNull(subscription[_removeAfterFiring])) {
               this[_removeListener](subscription);
             }
             subscription[_eventState] = (dart.notNull(subscription[_eventState]) & ~dart.notNull(async._BroadcastSubscription._STATE_FIRING)) >>> 0;
             subscription = next;
           } else {
-            subscription = subscription[_next];
+            subscription = subscription[_next$];
           }
         }
         this[_state] = (dart.notNull(this[_state]) & ~dart.notNull(async._BroadcastStreamController._STATE_FIRING)) >>> 0;
@@ -14288,18 +15198,18 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       [_sendData](data) {
         dart.as(data, T);
-        for (let subscription = this[_firstSubscription]; subscription != null; subscription = subscription[_next]) {
+        for (let subscription = this[_firstSubscription]; subscription != null; subscription = subscription[_next$]) {
           subscription[_addPending](new (async._DelayedData$(T))(data));
         }
       }
       [_sendError](error, stackTrace) {
-        for (let subscription = this[_firstSubscription]; subscription != null; subscription = subscription[_next]) {
+        for (let subscription = this[_firstSubscription]; subscription != null; subscription = subscription[_next$]) {
           subscription[_addPending](new async._DelayedError(error, stackTrace));
         }
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
-          for (let subscription = this[_firstSubscription]; subscription != null; subscription = subscription[_next]) {
+          for (let subscription = this[_firstSubscription]; subscription != null; subscription = subscription[_next$]) {
             subscription[_addPending](dart.const(new async._DelayedDone()));
           }
         } else {
@@ -16455,20 +17365,20 @@ dart_library.library('dart_sdk', null, /* Imports */[
   const _insertBefore = Symbol('_insertBefore');
   async._BroadcastLinkedList = class _BroadcastLinkedList extends core.Object {
     _BroadcastLinkedList() {
-      this[_next] = null;
-      this[_previous] = null;
+      this[_next$] = null;
+      this[_previous$] = null;
     }
     [_unlink]() {
-      this[_previous][_next] = this[_next];
-      this[_next][_previous] = this[_previous];
-      this[_next] = this[_previous] = this;
+      this[_previous$][_next$] = this[_next$];
+      this[_next$][_previous$] = this[_previous$];
+      this[_next$] = this[_previous$] = this;
     }
     [_insertBefore](newNext) {
-      let newPrevious = newNext[_previous];
-      newPrevious[_next] = this;
-      newNext[_previous] = this[_previous];
-      this[_previous][_next] = newNext;
-      this[_previous] = newPrevious;
+      let newPrevious = newNext[_previous$];
+      newPrevious[_next$] = this;
+      newNext[_previous$] = this[_previous$];
+      this[_previous$][_next$] = newNext;
+      this[_previous$] = newPrevious;
     }
   };
   dart.setSignature(async._BroadcastLinkedList, {
@@ -17366,23 +18276,23 @@ dart_library.library('dart_sdk', null, /* Imports */[
   async._DistinctStream$ = dart.generic(T => {
     class _DistinctStream extends async._ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
-        this[_previous] = async._DistinctStream._SENTINEL;
+        this[_previous$] = async._DistinctStream._SENTINEL;
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, async._EventSink$(T));
-        if (core.identical(this[_previous], async._DistinctStream._SENTINEL)) {
-          this[_previous] = inputEvent;
+        if (core.identical(this[_previous$], async._DistinctStream._SENTINEL)) {
+          this[_previous$] = inputEvent;
           return sink[_add$](inputEvent);
         } else {
           let isEqual = null;
           try {
             if (this[_equals] == null) {
-              isEqual = dart.equals(this[_previous], inputEvent);
+              isEqual = dart.equals(this[_previous$], inputEvent);
             } else {
-              isEqual = this[_equals](dart.as(this[_previous], T), inputEvent);
+              isEqual = this[_equals](dart.as(this[_previous$], T), inputEvent);
             }
           } catch (e) {
             let s = dart.stackTrace(e);
@@ -17392,7 +18302,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
 
           if (!dart.notNull(isEqual)) {
             sink[_add$](inputEvent);
-            this[_previous] = inputEvent;
+            this[_previous$] = inputEvent;
           }
         }
       }
@@ -18069,7 +18979,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
       fork: [async.Zone, [async.Zone, async.ZoneSpecification, core.Map]]
     })
   });
-  const _map = Symbol('_map');
+  const _map$0 = Symbol('_map');
   async._Zone = class _Zone extends core.Object {
     _Zone() {
     }
@@ -18091,7 +19001,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
     }
     _CustomZone(parent, specification, map) {
       this.parent = parent;
-      this[_map] = map;
+      this[_map$0] = map;
       this[_run] = null;
       this[_runUnary] = null;
       this[_runBinary] = null;
@@ -18191,12 +19101,12 @@ dart_library.library('dart_sdk', null, /* Imports */[
       };
     }
     get(key) {
-      let result = this[_map][dartx.get](key);
-      if (result != null || dart.notNull(this[_map][dartx.containsKey](key))) return result;
+      let result = this[_map$0][dartx.get](key);
+      if (result != null || dart.notNull(this[_map$0][dartx.containsKey](key))) return result;
       if (this.parent != null) {
         let value = this.parent.get(key);
         if (value != null) {
-          this[_map][dartx.set](key, value);
+          this[_map$0][dartx.set](key, value);
         }
         return value;
       }
@@ -18452,7 +19362,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
     let valueMap = null;
     if (zoneValues == null) {
       if (dart.is(zone, async._Zone)) {
-        valueMap = zone[_map];
+        valueMap = zone[_map$0];
       } else {
         valueMap = collection.HashMap.new();
       }
@@ -18508,7 +19418,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
     get parent() {
       return null;
     }
-    get [_map]() {
+    get [_map$0]() {
       return async._RootZone._rootMap;
     }
     get [_delegate]() {
@@ -18723,35 +19633,35 @@ dart_library.library('dart_sdk', null, /* Imports */[
     };
   };
   dart.lazyFn(async.runZoned, () => [R => [R, [dart.functionType(R, [])], {zoneValues: core.Map, zoneSpecification: async.ZoneSpecification, onError: core.Function}]]);
-  const _length$0 = Symbol('_length');
-  const _strings = Symbol('_strings');
-  const _nums = Symbol('_nums');
-  const _rest = Symbol('_rest');
-  const _keys = Symbol('_keys');
+  const _length$1 = Symbol('_length');
+  const _strings$ = Symbol('_strings');
+  const _nums$ = Symbol('_nums');
+  const _rest$ = Symbol('_rest');
+  const _keys$ = Symbol('_keys');
   const _containsKey = Symbol('_containsKey');
-  const _getBucket = Symbol('_getBucket');
+  const _getBucket$ = Symbol('_getBucket');
   const _findBucketIndex = Symbol('_findBucketIndex');
   const _computeKeys = Symbol('_computeKeys');
   const _get = Symbol('_get');
-  const _addHashTableEntry = Symbol('_addHashTableEntry');
+  const _addHashTableEntry$ = Symbol('_addHashTableEntry');
   const _set = Symbol('_set');
   const _computeHashCode = Symbol('_computeHashCode');
-  const _removeHashTableEntry = Symbol('_removeHashTableEntry');
+  const _removeHashTableEntry$ = Symbol('_removeHashTableEntry');
   const _remove = Symbol('_remove');
   collection._HashMap$ = dart.generic((K, V) => {
     class _HashMap extends core.Object {
       _HashMap() {
-        this[_length$0] = 0;
-        this[_strings] = null;
-        this[_nums] = null;
-        this[_rest] = null;
-        this[_keys] = null;
+        this[_length$1] = 0;
+        this[_strings$] = null;
+        this[_nums$] = null;
+        this[_rest$] = null;
+        this[_keys$] = null;
       }
       get length() {
-        return this[_length$0];
+        return this[_length$1];
       }
       get isEmpty() {
-        return this[_length$0] == 0;
+        return this[_length$1] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
@@ -18767,19 +19677,19 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       containsKey(key) {
         if (dart.notNull(collection._HashMap._isStringKey(key))) {
-          let strings = this[_strings];
+          let strings = this[_strings$];
           return strings == null ? false : collection._HashMap._hasTableEntry(strings, key);
         } else if (dart.notNull(collection._HashMap._isNumericKey(key))) {
-          let nums = this[_nums];
+          let nums = this[_nums$];
           return nums == null ? false : collection._HashMap._hasTableEntry(nums, key);
         } else {
           return this[_containsKey](key);
         }
       }
       [_containsKey](key) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return false;
-        let bucket = this[_getBucket](rest, key);
+        let bucket = this[_getBucket$](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
@@ -18795,19 +19705,19 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       get(key) {
         if (dart.notNull(collection._HashMap._isStringKey(key))) {
-          let strings = this[_strings];
+          let strings = this[_strings$];
           return dart.as(strings == null ? null : collection._HashMap._getTableEntry(strings, key), V);
         } else if (dart.notNull(collection._HashMap._isNumericKey(key))) {
-          let nums = this[_nums];
+          let nums = this[_nums$];
           return dart.as(nums == null ? null : collection._HashMap._getTableEntry(nums, key), V);
         } else {
           return this[_get](key);
         }
       }
       [_get](key) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return null;
-        let bucket = this[_getBucket](rest, key);
+        let bucket = this[_getBucket$](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         return dart.as(dart.notNull(index) < 0 ? null : bucket[dart.notNull(index) + 1], V);
       }
@@ -18815,13 +19725,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
         dart.as(key, K);
         dart.as(value, V);
         if (dart.notNull(collection._HashMap._isStringKey(key))) {
-          let strings = this[_strings];
-          if (strings == null) this[_strings] = strings = collection._HashMap._newHashTable();
-          this[_addHashTableEntry](strings, key, value);
+          let strings = this[_strings$];
+          if (strings == null) this[_strings$] = strings = collection._HashMap._newHashTable();
+          this[_addHashTableEntry$](strings, key, value);
         } else if (dart.notNull(collection._HashMap._isNumericKey(key))) {
-          let nums = this[_nums];
-          if (nums == null) this[_nums] = nums = collection._HashMap._newHashTable();
-          this[_addHashTableEntry](nums, key, value);
+          let nums = this[_nums$];
+          if (nums == null) this[_nums$] = nums = collection._HashMap._newHashTable();
+          this[_addHashTableEntry$](nums, key, value);
         } else {
           this[_set](key, value);
         }
@@ -18830,22 +19740,22 @@ dart_library.library('dart_sdk', null, /* Imports */[
       [_set](key, value) {
         dart.as(key, K);
         dart.as(value, V);
-        let rest = this[_rest];
-        if (rest == null) this[_rest] = rest = collection._HashMap._newHashTable();
+        let rest = this[_rest$];
+        if (rest == null) this[_rest$] = rest = collection._HashMap._newHashTable();
         let hash = this[_computeHashCode](key);
         let bucket = rest[hash];
         if (bucket == null) {
           collection._HashMap._setTableEntry(rest, hash, [key, value]);
-          this[_length$0] = dart.notNull(this[_length$0]) + 1;
-          this[_keys] = null;
+          this[_length$1] = dart.notNull(this[_length$1]) + 1;
+          this[_keys$] = null;
         } else {
           let index = this[_findBucketIndex](bucket, key);
           if (dart.notNull(index) >= 0) {
             bucket[dart.notNull(index) + 1] = value;
           } else {
             bucket.push(key, value);
-            this[_length$0] = dart.notNull(this[_length$0]) + 1;
-            this[_keys] = null;
+            this[_length$1] = dart.notNull(this[_length$1]) + 1;
+            this[_keys$] = null;
           }
         }
       }
@@ -18859,27 +19769,27 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       remove(key) {
         if (dart.notNull(collection._HashMap._isStringKey(key))) {
-          return this[_removeHashTableEntry](this[_strings], key);
+          return this[_removeHashTableEntry$](this[_strings$], key);
         } else if (dart.notNull(collection._HashMap._isNumericKey(key))) {
-          return this[_removeHashTableEntry](this[_nums], key);
+          return this[_removeHashTableEntry$](this[_nums$], key);
         } else {
           return this[_remove](key);
         }
       }
       [_remove](key) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return null;
-        let bucket = this[_getBucket](rest, key);
+        let bucket = this[_getBucket$](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         if (dart.notNull(index) < 0) return null;
-        this[_length$0] = dart.notNull(this[_length$0]) - 1;
-        this[_keys] = null;
+        this[_length$1] = dart.notNull(this[_length$1]) - 1;
+        this[_keys$] = null;
         return bucket.splice(index, 2)[1];
       }
       clear() {
-        if (dart.notNull(this[_length$0]) > 0) {
-          this[_strings] = this[_nums] = this[_rest] = this[_keys] = null;
-          this[_length$0] = 0;
+        if (dart.notNull(this[_length$1]) > 0) {
+          this[_strings$] = this[_nums$] = this[_rest$] = this[_keys$] = null;
+          this[_length$1] = 0;
         }
       }
       forEach(action) {
@@ -18888,16 +19798,16 @@ dart_library.library('dart_sdk', null, /* Imports */[
         for (let i = 0, length = keys[dartx.length]; i < dart.notNull(length); i++) {
           let key = keys[i];
           action(dart.as(key, K), this.get(key));
-          if (keys !== this[_keys]) {
+          if (keys !== this[_keys$]) {
             dart.throw(new core.ConcurrentModificationError(this));
           }
         }
       }
       [_computeKeys]() {
-        if (this[_keys] != null) return this[_keys];
-        let result = core.List.new(this[_length$0]);
+        if (this[_keys$] != null) return this[_keys$];
+        let result = core.List.new(this[_length$1]);
         let index = 0;
-        let strings = this[_strings];
+        let strings = this[_strings$];
         if (strings != null) {
           let names = Object.getOwnPropertyNames(strings);
           let entries = names.length;
@@ -18907,7 +19817,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
             index++;
           }
         }
-        let nums = this[_nums];
+        let nums = this[_nums$];
         if (nums != null) {
           let names = Object.getOwnPropertyNames(nums);
           let entries = names.length;
@@ -18917,7 +19827,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
             index++;
           }
         }
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest != null) {
           let names = Object.getOwnPropertyNames(rest);
           let entries = names.length;
@@ -18932,24 +19842,24 @@ dart_library.library('dart_sdk', null, /* Imports */[
             }
           }
         }
-        dart.assert(index == this[_length$0]);
-        return this[_keys] = result;
+        dart.assert(index == this[_length$1]);
+        return this[_keys$] = result;
       }
-      [_addHashTableEntry](table, key, value) {
+      [_addHashTableEntry$](table, key, value) {
         dart.as(key, K);
         dart.as(value, V);
         if (!dart.notNull(collection._HashMap._hasTableEntry(table, key))) {
-          this[_length$0] = dart.notNull(this[_length$0]) + 1;
-          this[_keys] = null;
+          this[_length$1] = dart.notNull(this[_length$1]) + 1;
+          this[_keys$] = null;
         }
         collection._HashMap._setTableEntry(table, key, value);
       }
-      [_removeHashTableEntry](table, key) {
+      [_removeHashTableEntry$](table, key) {
         if (table != null && dart.notNull(collection._HashMap._hasTableEntry(table, key))) {
           let value = dart.as(collection._HashMap._getTableEntry(table, key), V);
           collection._HashMap._deleteTableEntry(table, key);
-          this[_length$0] = dart.notNull(this[_length$0]) - 1;
-          this[_keys] = null;
+          this[_length$1] = dart.notNull(this[_length$1]) - 1;
+          this[_keys$] = null;
           return value;
         } else {
           return null;
@@ -18982,7 +19892,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
       static _deleteTableEntry(table, key) {
         delete table[key];
       }
-      [_getBucket](table, key) {
+      [_getBucket$](table, key) {
         let hash = this[_computeHashCode](key);
         return table[hash];
       }
@@ -19020,10 +19930,10 @@ dart_library.library('dart_sdk', null, /* Imports */[
         clear: [dart.void, []],
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
         [_computeKeys]: [core.List, []],
-        [_addHashTableEntry]: [dart.void, [dart.dynamic, K, V]],
-        [_removeHashTableEntry]: [V, [dart.dynamic, core.Object]],
+        [_addHashTableEntry$]: [dart.void, [dart.dynamic, K, V]],
+        [_removeHashTableEntry$]: [V, [dart.dynamic, core.Object]],
         [_computeHashCode]: [core.int, [dart.dynamic]],
-        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_getBucket$]: [core.List, [dart.dynamic, dart.dynamic]],
         [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]]
       }),
       statics: () => ({
@@ -19132,32 +20042,31 @@ dart_library.library('dart_sdk', null, /* Imports */[
     return _CustomHashMap;
   });
   collection._CustomHashMap = collection._CustomHashMap$();
-  const _map$ = Symbol('_map');
   collection.HashMapKeyIterable$ = dart.generic(E => {
     class HashMapKeyIterable extends collection.IterableBase$(E) {
       HashMapKeyIterable(map) {
-        this[_map$] = map;
+        this[_map] = map;
         super.IterableBase();
       }
       get length() {
-        return dart.as(dart.dload(this[_map$], _length$0), core.int);
+        return dart.as(dart.dload(this[_map], _length$1), core.int);
       }
       get isEmpty() {
-        return dart.equals(dart.dload(this[_map$], _length$0), 0);
+        return dart.equals(dart.dload(this[_map], _length$1), 0);
       }
       get iterator() {
-        return new (collection.HashMapKeyIterator$(E))(this[_map$], dart.as(dart.dsend(this[_map$], _computeKeys), core.List));
+        return new (collection.HashMapKeyIterator$(E))(this[_map], dart.as(dart.dsend(this[_map], _computeKeys), core.List));
       }
       contains(element) {
-        return dart.as(dart.dsend(this[_map$], 'containsKey', element), core.bool);
+        return dart.as(dart.dsend(this[_map], 'containsKey', element), core.bool);
       }
       forEach(f) {
         dart.as(f, dart.functionType(dart.void, [E]));
-        let keys = dart.as(dart.dsend(this[_map$], _computeKeys), core.List);
+        let keys = dart.as(dart.dsend(this[_map], _computeKeys), core.List);
         for (let i = 0, length = keys.length; i < length; i++) {
           f(keys[i]);
-          if (keys !== dart.dload(this[_map$], _keys)) {
-            dart.throw(new core.ConcurrentModificationError(this[_map$]));
+          if (keys !== dart.dload(this[_map], _keys$)) {
+            dart.throw(new core.ConcurrentModificationError(this[_map]));
           }
         }
       }
@@ -19182,8 +20091,8 @@ dart_library.library('dart_sdk', null, /* Imports */[
   collection.HashMapKeyIterator$ = dart.generic(E => {
     class HashMapKeyIterator extends core.Object {
       HashMapKeyIterator(map, keys) {
-        this[_map$] = map;
-        this[_keys] = keys;
+        this[_map] = map;
+        this[_keys$] = keys;
         this[_offset] = 0;
         this[_current$2] = null;
       }
@@ -19191,10 +20100,10 @@ dart_library.library('dart_sdk', null, /* Imports */[
         return this[_current$2];
       }
       moveNext() {
-        let keys = this[_keys];
+        let keys = this[_keys$];
         let offset = this[_offset];
-        if (keys !== dart.dload(this[_map$], _keys)) {
-          dart.throw(new core.ConcurrentModificationError(this[_map$]));
+        if (keys !== dart.dload(this[_map], _keys$)) {
+          dart.throw(new core.ConcurrentModificationError(this[_map]));
         } else if (dart.notNull(offset) >= keys.length) {
           this[_current$2] = null;
           return false;
@@ -19213,32 +20122,32 @@ dart_library.library('dart_sdk', null, /* Imports */[
     return HashMapKeyIterator;
   });
   collection.HashMapKeyIterator = collection.HashMapKeyIterator$();
-  const _first = Symbol('_first');
-  const _last = Symbol('_last');
-  const _modifications = Symbol('_modifications');
+  const _first$ = Symbol('_first');
+  const _last$ = Symbol('_last');
+  const _modifications$ = Symbol('_modifications');
   const _value = Symbol('_value');
-  const _newLinkedCell = Symbol('_newLinkedCell');
-  const _unlinkCell = Symbol('_unlinkCell');
-  const _modified = Symbol('_modified');
+  const _newLinkedCell$ = Symbol('_newLinkedCell');
+  const _unlinkCell$ = Symbol('_unlinkCell');
+  const _modified$ = Symbol('_modified');
   const _key = Symbol('_key');
-  const _next$ = Symbol('_next');
-  const _previous$ = Symbol('_previous');
+  const _next$0 = Symbol('_next');
+  const _previous$0 = Symbol('_previous');
   collection._LinkedHashMap$ = dart.generic((K, V) => {
     class _LinkedHashMap extends core.Object {
       _LinkedHashMap() {
-        this[_length$0] = 0;
-        this[_strings] = null;
-        this[_nums] = null;
-        this[_rest] = null;
-        this[_first] = null;
-        this[_last] = null;
-        this[_modifications] = 0;
+        this[_length$1] = 0;
+        this[_strings$] = null;
+        this[_nums$] = null;
+        this[_rest$] = null;
+        this[_first$] = null;
+        this[_last$] = null;
+        this[_modifications$] = 0;
       }
       get length() {
-        return this[_length$0];
+        return this[_length$1];
       }
       get isEmpty() {
-        return this[_length$0] == 0;
+        return this[_length$1] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
@@ -19254,12 +20163,12 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       containsKey(key) {
         if (dart.notNull(collection._LinkedHashMap._isStringKey(key))) {
-          let strings = this[_strings];
+          let strings = this[_strings$];
           if (strings == null) return false;
           let cell = dart.as(collection._LinkedHashMap._getTableEntry(strings, key), collection.LinkedHashMapCell);
           return cell != null;
         } else if (dart.notNull(collection._LinkedHashMap._isNumericKey(key))) {
-          let nums = this[_nums];
+          let nums = this[_nums$];
           if (nums == null) return false;
           let cell = dart.as(collection._LinkedHashMap._getTableEntry(nums, key), collection.LinkedHashMapCell);
           return cell != null;
@@ -19268,9 +20177,9 @@ dart_library.library('dart_sdk', null, /* Imports */[
         }
       }
       [_containsKey](key) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return false;
-        let bucket = this[_getBucket](rest, key);
+        let bucket = this[_getBucket$](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
@@ -19289,12 +20198,12 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       get(key) {
         if (dart.notNull(collection._LinkedHashMap._isStringKey(key))) {
-          let strings = this[_strings];
+          let strings = this[_strings$];
           if (strings == null) return null;
           let cell = dart.as(collection._LinkedHashMap._getTableEntry(strings, key), collection.LinkedHashMapCell);
           return dart.as(cell == null ? null : cell[_value], V);
         } else if (dart.notNull(collection._LinkedHashMap._isNumericKey(key))) {
-          let nums = this[_nums];
+          let nums = this[_nums$];
           if (nums == null) return null;
           let cell = dart.as(collection._LinkedHashMap._getTableEntry(nums, key), collection.LinkedHashMapCell);
           return dart.as(cell == null ? null : cell[_value], V);
@@ -19303,9 +20212,9 @@ dart_library.library('dart_sdk', null, /* Imports */[
         }
       }
       [_get](key) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return null;
-        let bucket = this[_getBucket](rest, key);
+        let bucket = this[_getBucket$](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         if (dart.notNull(index) < 0) return null;
         let cell = bucket[index];
@@ -19315,13 +20224,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
         dart.as(key, K);
         dart.as(value, V);
         if (dart.notNull(collection._LinkedHashMap._isStringKey(key))) {
-          let strings = this[_strings];
-          if (strings == null) this[_strings] = strings = collection._LinkedHashMap._newHashTable();
-          this[_addHashTableEntry](strings, key, value);
+          let strings = this[_strings$];
+          if (strings == null) this[_strings$] = strings = collection._LinkedHashMap._newHashTable();
+          this[_addHashTableEntry$](strings, key, value);
         } else if (dart.notNull(collection._LinkedHashMap._isNumericKey(key))) {
-          let nums = this[_nums];
-          if (nums == null) this[_nums] = nums = collection._LinkedHashMap._newHashTable();
-          this[_addHashTableEntry](nums, key, value);
+          let nums = this[_nums$];
+          if (nums == null) this[_nums$] = nums = collection._LinkedHashMap._newHashTable();
+          this[_addHashTableEntry$](nums, key, value);
         } else {
           this[_set](key, value);
         }
@@ -19330,12 +20239,12 @@ dart_library.library('dart_sdk', null, /* Imports */[
       [_set](key, value) {
         dart.as(key, K);
         dart.as(value, V);
-        let rest = this[_rest];
-        if (rest == null) this[_rest] = rest = collection._LinkedHashMap._newHashTable();
+        let rest = this[_rest$];
+        if (rest == null) this[_rest$] = rest = collection._LinkedHashMap._newHashTable();
         let hash = this[_computeHashCode](key);
         let bucket = rest[hash];
         if (bucket == null) {
-          let cell = this[_newLinkedCell](key, value);
+          let cell = this[_newLinkedCell$](key, value);
           collection._LinkedHashMap._setTableEntry(rest, hash, [cell]);
         } else {
           let index = this[_findBucketIndex](bucket, key);
@@ -19343,7 +20252,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
             let cell = bucket[index];
             cell[_value] = value;
           } else {
-            let cell = this[_newLinkedCell](key, value);
+            let cell = this[_newLinkedCell$](key, value);
             bucket.push(cell);
           }
         }
@@ -19358,95 +20267,95 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       remove(key) {
         if (dart.notNull(collection._LinkedHashMap._isStringKey(key))) {
-          return this[_removeHashTableEntry](this[_strings], key);
+          return this[_removeHashTableEntry$](this[_strings$], key);
         } else if (dart.notNull(collection._LinkedHashMap._isNumericKey(key))) {
-          return this[_removeHashTableEntry](this[_nums], key);
+          return this[_removeHashTableEntry$](this[_nums$], key);
         } else {
           return this[_remove](key);
         }
       }
       [_remove](key) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return null;
-        let bucket = this[_getBucket](rest, key);
+        let bucket = this[_getBucket$](rest, key);
         let index = this[_findBucketIndex](bucket, key);
         if (dart.notNull(index) < 0) return null;
         let cell = bucket.splice(index, 1)[0];
-        this[_unlinkCell](cell);
+        this[_unlinkCell$](cell);
         return dart.as(cell[_value], V);
       }
       clear() {
-        if (dart.notNull(this[_length$0]) > 0) {
-          this[_strings] = this[_nums] = this[_rest] = this[_first] = this[_last] = null;
-          this[_length$0] = 0;
-          this[_modified]();
+        if (dart.notNull(this[_length$1]) > 0) {
+          this[_strings$] = this[_nums$] = this[_rest$] = this[_first$] = this[_last$] = null;
+          this[_length$1] = 0;
+          this[_modified$]();
         }
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [K, V]));
-        let cell = this[_first];
-        let modifications = this[_modifications];
+        let cell = this[_first$];
+        let modifications = this[_modifications$];
         while (cell != null) {
           action(dart.as(cell[_key], K), dart.as(cell[_value], V));
-          if (modifications != this[_modifications]) {
+          if (modifications != this[_modifications$]) {
             dart.throw(new core.ConcurrentModificationError(this));
           }
-          cell = cell[_next$];
+          cell = cell[_next$0];
         }
       }
-      [_addHashTableEntry](table, key, value) {
+      [_addHashTableEntry$](table, key, value) {
         dart.as(key, K);
         dart.as(value, V);
         let cell = dart.as(collection._LinkedHashMap._getTableEntry(table, key), collection.LinkedHashMapCell);
         if (cell == null) {
-          collection._LinkedHashMap._setTableEntry(table, key, this[_newLinkedCell](key, value));
+          collection._LinkedHashMap._setTableEntry(table, key, this[_newLinkedCell$](key, value));
         } else {
           cell[_value] = value;
         }
       }
-      [_removeHashTableEntry](table, key) {
+      [_removeHashTableEntry$](table, key) {
         if (table == null) return null;
         let cell = dart.as(collection._LinkedHashMap._getTableEntry(table, key), collection.LinkedHashMapCell);
         if (cell == null) return null;
-        this[_unlinkCell](cell);
+        this[_unlinkCell$](cell);
         collection._LinkedHashMap._deleteTableEntry(table, key);
         return dart.as(cell[_value], V);
       }
-      [_modified]() {
-        this[_modifications] = dart.notNull(this[_modifications]) + 1 & 67108863;
+      [_modified$]() {
+        this[_modifications$] = dart.notNull(this[_modifications$]) + 1 & 67108863;
       }
-      [_newLinkedCell](key, value) {
+      [_newLinkedCell$](key, value) {
         dart.as(key, K);
         dart.as(value, V);
         let cell = new collection.LinkedHashMapCell(key, value);
-        if (this[_first] == null) {
-          this[_first] = this[_last] = cell;
+        if (this[_first$] == null) {
+          this[_first$] = this[_last$] = cell;
         } else {
-          let last = this[_last];
-          cell[_previous$] = last;
-          this[_last] = last[_next$] = cell;
+          let last = this[_last$];
+          cell[_previous$0] = last;
+          this[_last$] = last[_next$0] = cell;
         }
-        this[_length$0] = dart.notNull(this[_length$0]) + 1;
-        this[_modified]();
+        this[_length$1] = dart.notNull(this[_length$1]) + 1;
+        this[_modified$]();
         return cell;
       }
-      [_unlinkCell](cell) {
-        let previous = cell[_previous$];
-        let next = cell[_next$];
+      [_unlinkCell$](cell) {
+        let previous = cell[_previous$0];
+        let next = cell[_next$0];
         if (previous == null) {
-          dart.assert(dart.equals(cell, this[_first]));
-          this[_first] = next;
+          dart.assert(dart.equals(cell, this[_first$]));
+          this[_first$] = next;
         } else {
-          previous[_next$] = next;
+          previous[_next$0] = next;
         }
         if (next == null) {
-          dart.assert(dart.equals(cell, this[_last]));
-          this[_last] = previous;
+          dart.assert(dart.equals(cell, this[_last$]));
+          this[_last$] = previous;
         } else {
-          next[_previous$] = previous;
+          next[_previous$0] = previous;
         }
-        this[_length$0] = dart.notNull(this[_length$0]) - 1;
-        this[_modified]();
+        this[_length$1] = dart.notNull(this[_length$1]) - 1;
+        this[_modified$]();
       }
       static _isStringKey(key) {
         return typeof key == 'string' && key != '__proto__';
@@ -19467,7 +20376,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
       static _deleteTableEntry(table, key) {
         delete table[key];
       }
-      [_getBucket](table, key) {
+      [_getBucket$](table, key) {
         let hash = this[_computeHashCode](key);
         return table[hash];
       }
@@ -19508,13 +20417,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
         [_remove]: [V, [core.Object]],
         clear: [dart.void, []],
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
-        [_addHashTableEntry]: [dart.void, [dart.dynamic, K, V]],
-        [_removeHashTableEntry]: [V, [dart.dynamic, core.Object]],
-        [_modified]: [dart.void, []],
-        [_newLinkedCell]: [collection.LinkedHashMapCell, [K, V]],
-        [_unlinkCell]: [dart.void, [collection.LinkedHashMapCell]],
+        [_addHashTableEntry$]: [dart.void, [dart.dynamic, K, V]],
+        [_removeHashTableEntry$]: [V, [dart.dynamic, core.Object]],
+        [_modified$]: [dart.void, []],
+        [_newLinkedCell$]: [collection.LinkedHashMapCell, [K, V]],
+        [_unlinkCell$]: [dart.void, [collection.LinkedHashMapCell]],
         [_computeHashCode]: [core.int, [dart.dynamic]],
-        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_getBucket$]: [core.List, [dart.dynamic, dart.dynamic]],
         [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]]
       }),
       statics: () => ({
@@ -19622,8 +20531,8 @@ dart_library.library('dart_sdk', null, /* Imports */[
     LinkedHashMapCell(key, value) {
       this[_key] = key;
       this[_value] = value;
-      this[_next$] = null;
-      this[_previous$] = null;
+      this[_next$0] = null;
+      this[_previous$0] = null;
     }
   };
   dart.setSignature(collection.LinkedHashMapCell, {
@@ -19632,31 +20541,31 @@ dart_library.library('dart_sdk', null, /* Imports */[
   collection.LinkedHashMapKeyIterable$ = dart.generic(E => {
     class LinkedHashMapKeyIterable extends collection.IterableBase$(E) {
       LinkedHashMapKeyIterable(map) {
-        this[_map$] = map;
+        this[_map] = map;
         super.IterableBase();
       }
       get length() {
-        return dart.as(dart.dload(this[_map$], _length$0), core.int);
+        return dart.as(dart.dload(this[_map], _length$1), core.int);
       }
       get isEmpty() {
-        return dart.equals(dart.dload(this[_map$], _length$0), 0);
+        return dart.equals(dart.dload(this[_map], _length$1), 0);
       }
       get iterator() {
-        return new (collection.LinkedHashMapKeyIterator$(E))(this[_map$], dart.as(dart.dload(this[_map$], _modifications), core.int));
+        return new (collection.LinkedHashMapKeyIterator$(E))(this[_map], dart.as(dart.dload(this[_map], _modifications$), core.int));
       }
       contains(element) {
-        return dart.as(dart.dsend(this[_map$], 'containsKey', element), core.bool);
+        return dart.as(dart.dsend(this[_map], 'containsKey', element), core.bool);
       }
       forEach(f) {
         dart.as(f, dart.functionType(dart.void, [E]));
-        let cell = dart.as(dart.dload(this[_map$], _first), collection.LinkedHashMapCell);
-        let modifications = dart.as(dart.dload(this[_map$], _modifications), core.int);
+        let cell = dart.as(dart.dload(this[_map], _first$), collection.LinkedHashMapCell);
+        let modifications = dart.as(dart.dload(this[_map], _modifications$), core.int);
         while (cell != null) {
           f(dart.as(cell[_key], E));
-          if (!dart.equals(modifications, dart.dload(this[_map$], _modifications))) {
-            dart.throw(new core.ConcurrentModificationError(this[_map$]));
+          if (!dart.equals(modifications, dart.dload(this[_map], _modifications$))) {
+            dart.throw(new core.ConcurrentModificationError(this[_map]));
           }
-          cell = cell[_next$];
+          cell = cell[_next$0];
         }
       }
     }
@@ -19675,28 +20584,28 @@ dart_library.library('dart_sdk', null, /* Imports */[
     return LinkedHashMapKeyIterable;
   });
   collection.LinkedHashMapKeyIterable = collection.LinkedHashMapKeyIterable$();
-  const _cell = Symbol('_cell');
+  const _cell$ = Symbol('_cell');
   collection.LinkedHashMapKeyIterator$ = dart.generic(E => {
     class LinkedHashMapKeyIterator extends core.Object {
       LinkedHashMapKeyIterator(map, modifications) {
-        this[_map$] = map;
-        this[_modifications] = modifications;
-        this[_cell] = null;
+        this[_map] = map;
+        this[_modifications$] = modifications;
+        this[_cell$] = null;
         this[_current$2] = null;
-        this[_cell] = dart.as(dart.dload(this[_map$], _first), collection.LinkedHashMapCell);
+        this[_cell$] = dart.as(dart.dload(this[_map], _first$), collection.LinkedHashMapCell);
       }
       get current() {
         return this[_current$2];
       }
       moveNext() {
-        if (!dart.equals(this[_modifications], dart.dload(this[_map$], _modifications))) {
-          dart.throw(new core.ConcurrentModificationError(this[_map$]));
-        } else if (this[_cell] == null) {
+        if (!dart.equals(this[_modifications$], dart.dload(this[_map], _modifications$))) {
+          dart.throw(new core.ConcurrentModificationError(this[_map]));
+        } else if (this[_cell$] == null) {
           this[_current$2] = null;
           return false;
         } else {
-          this[_current$2] = dart.as(this[_cell][_key], E);
-          this[_cell] = this[_cell][_next$];
+          this[_current$2] = dart.as(this[_cell$][_key], E);
+          this[_cell$] = this[_cell$][_next$0];
           return true;
         }
       }
@@ -20081,10 +20990,10 @@ dart_library.library('dart_sdk', null, /* Imports */[
   collection._HashSet$ = dart.generic(E => {
     class _HashSet extends collection._HashSetBase$(E) {
       _HashSet() {
-        this[_length$0] = 0;
-        this[_strings] = null;
-        this[_nums] = null;
-        this[_rest] = null;
+        this[_length$1] = 0;
+        this[_strings$] = null;
+        this[_nums$] = null;
+        this[_rest$] = null;
         this[_elements] = null;
       }
       [_newSet]() {
@@ -20094,29 +21003,29 @@ dart_library.library('dart_sdk', null, /* Imports */[
         return new (collection.HashSetIterator$(E))(this, this[_computeElements]());
       }
       get length() {
-        return this[_length$0];
+        return this[_length$1];
       }
       get isEmpty() {
-        return this[_length$0] == 0;
+        return this[_length$1] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       contains(object) {
         if (dart.notNull(collection._HashSet._isStringElement(object))) {
-          let strings = this[_strings];
+          let strings = this[_strings$];
           return strings == null ? false : collection._HashSet._hasTableEntry(strings, object);
         } else if (dart.notNull(collection._HashSet._isNumericElement(object))) {
-          let nums = this[_nums];
+          let nums = this[_nums$];
           return nums == null ? false : collection._HashSet._hasTableEntry(nums, object);
         } else {
           return this[_contains](object);
         }
       }
       [_contains](object) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return false;
-        let bucket = this[_getBucket](rest, object);
+        let bucket = this[_getBucket$](rest, object);
         return dart.notNull(this[_findBucketIndex](bucket, object)) >= 0;
       }
       lookup(object) {
@@ -20126,9 +21035,9 @@ dart_library.library('dart_sdk', null, /* Imports */[
         return this[_lookup](object);
       }
       [_lookup](object) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return null;
-        let bucket = this[_getBucket](rest, object);
+        let bucket = this[_getBucket$](rest, object);
         let index = this[_findBucketIndex](bucket, object);
         if (dart.notNull(index) < 0) return null;
         return dart.as(bucket[dartx.get](index), E);
@@ -20136,21 +21045,21 @@ dart_library.library('dart_sdk', null, /* Imports */[
       add(element) {
         dart.as(element, E);
         if (dart.notNull(collection._HashSet._isStringElement(element))) {
-          let strings = this[_strings];
-          if (strings == null) this[_strings] = strings = collection._HashSet._newHashTable();
-          return this[_addHashTableEntry](strings, element);
+          let strings = this[_strings$];
+          if (strings == null) this[_strings$] = strings = collection._HashSet._newHashTable();
+          return this[_addHashTableEntry$](strings, element);
         } else if (dart.notNull(collection._HashSet._isNumericElement(element))) {
-          let nums = this[_nums];
-          if (nums == null) this[_nums] = nums = collection._HashSet._newHashTable();
-          return this[_addHashTableEntry](nums, element);
+          let nums = this[_nums$];
+          if (nums == null) this[_nums$] = nums = collection._HashSet._newHashTable();
+          return this[_addHashTableEntry$](nums, element);
         } else {
           return this[_add$0](element);
         }
       }
       [_add$0](element) {
         dart.as(element, E);
-        let rest = this[_rest];
-        if (rest == null) this[_rest] = rest = collection._HashSet._newHashTable();
+        let rest = this[_rest$];
+        if (rest == null) this[_rest$] = rest = collection._HashSet._newHashTable();
         let hash = this[_computeHashCode](element);
         let bucket = rest[hash];
         if (bucket == null) {
@@ -20160,7 +21069,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
           if (dart.notNull(index) >= 0) return false;
           bucket.push(element);
         }
-        this[_length$0] = dart.notNull(this[_length$0]) + 1;
+        this[_length$1] = dart.notNull(this[_length$1]) + 1;
         this[_elements] = null;
         return true;
       }
@@ -20172,35 +21081,35 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       remove(object) {
         if (dart.notNull(collection._HashSet._isStringElement(object))) {
-          return this[_removeHashTableEntry](this[_strings], object);
+          return this[_removeHashTableEntry$](this[_strings$], object);
         } else if (dart.notNull(collection._HashSet._isNumericElement(object))) {
-          return this[_removeHashTableEntry](this[_nums], object);
+          return this[_removeHashTableEntry$](this[_nums$], object);
         } else {
           return this[_remove](object);
         }
       }
       [_remove](object) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return false;
-        let bucket = this[_getBucket](rest, object);
+        let bucket = this[_getBucket$](rest, object);
         let index = this[_findBucketIndex](bucket, object);
         if (dart.notNull(index) < 0) return false;
-        this[_length$0] = dart.notNull(this[_length$0]) - 1;
+        this[_length$1] = dart.notNull(this[_length$1]) - 1;
         this[_elements] = null;
         bucket.splice(index, 1);
         return true;
       }
       clear() {
-        if (dart.notNull(this[_length$0]) > 0) {
-          this[_strings] = this[_nums] = this[_rest] = this[_elements] = null;
-          this[_length$0] = 0;
+        if (dart.notNull(this[_length$1]) > 0) {
+          this[_strings$] = this[_nums$] = this[_rest$] = this[_elements] = null;
+          this[_length$1] = 0;
         }
       }
       [_computeElements]() {
         if (this[_elements] != null) return this[_elements];
-        let result = core.List.new(this[_length$0]);
+        let result = core.List.new(this[_length$1]);
         let index = 0;
-        let strings = this[_strings];
+        let strings = this[_strings$];
         if (strings != null) {
           let names = Object.getOwnPropertyNames(strings);
           let entries = names.length;
@@ -20210,7 +21119,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
             index++;
           }
         }
-        let nums = this[_nums];
+        let nums = this[_nums$];
         if (nums != null) {
           let names = Object.getOwnPropertyNames(nums);
           let entries = names.length;
@@ -20220,7 +21129,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
             index++;
           }
         }
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest != null) {
           let names = Object.getOwnPropertyNames(rest);
           let entries = names.length;
@@ -20234,21 +21143,21 @@ dart_library.library('dart_sdk', null, /* Imports */[
             }
           }
         }
-        dart.assert(index == this[_length$0]);
+        dart.assert(index == this[_length$1]);
         return this[_elements] = result;
       }
-      [_addHashTableEntry](table, element) {
+      [_addHashTableEntry$](table, element) {
         dart.as(element, E);
         if (dart.notNull(collection._HashSet._hasTableEntry(table, element))) return false;
         collection._HashSet._setTableEntry(table, element, 0);
-        this[_length$0] = dart.notNull(this[_length$0]) + 1;
+        this[_length$1] = dart.notNull(this[_length$1]) + 1;
         this[_elements] = null;
         return true;
       }
-      [_removeHashTableEntry](table, element) {
+      [_removeHashTableEntry$](table, element) {
         if (table != null && dart.notNull(collection._HashSet._hasTableEntry(table, element))) {
           collection._HashSet._deleteTableEntry(table, element);
-          this[_length$0] = dart.notNull(this[_length$0]) - 1;
+          this[_length$1] = dart.notNull(this[_length$1]) - 1;
           this[_elements] = null;
           return true;
         } else {
@@ -20275,7 +21184,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
       static _deleteTableEntry(table, key) {
         delete table[key];
       }
-      [_getBucket](table, element) {
+      [_getBucket$](table, element) {
         let hash = this[_computeHashCode](element);
         return table[hash];
       }
@@ -20310,10 +21219,10 @@ dart_library.library('dart_sdk', null, /* Imports */[
         remove: [core.bool, [core.Object]],
         [_remove]: [core.bool, [core.Object]],
         [_computeElements]: [core.List, []],
-        [_addHashTableEntry]: [core.bool, [dart.dynamic, E]],
-        [_removeHashTableEntry]: [core.bool, [dart.dynamic, core.Object]],
+        [_addHashTableEntry$]: [core.bool, [dart.dynamic, E]],
+        [_removeHashTableEntry$]: [core.bool, [dart.dynamic, core.Object]],
         [_computeHashCode]: [core.int, [dart.dynamic]],
-        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_getBucket$]: [core.List, [dart.dynamic, dart.dynamic]],
         [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]]
       }),
       statics: () => ({
@@ -20455,13 +21364,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
   collection._LinkedHashSet$ = dart.generic(E => {
     class _LinkedHashSet extends collection._HashSetBase$(E) {
       _LinkedHashSet() {
-        this[_length$0] = 0;
-        this[_strings] = null;
-        this[_nums] = null;
-        this[_rest] = null;
-        this[_first] = null;
-        this[_last] = null;
-        this[_modifications] = 0;
+        this[_length$1] = 0;
+        this[_strings$] = null;
+        this[_nums$] = null;
+        this[_rest$] = null;
+        this[_first$] = null;
+        this[_last$] = null;
+        this[_modifications$] = 0;
       }
       [_newSet]() {
         return new (collection._LinkedHashSet$(E))();
@@ -20470,25 +21379,25 @@ dart_library.library('dart_sdk', null, /* Imports */[
         dart.throw(`LinkedHashSet: unsupported ${operation}`);
       }
       get iterator() {
-        return new (collection.LinkedHashSetIterator$(E))(this, this[_modifications]);
+        return new (collection.LinkedHashSetIterator$(E))(this, this[_modifications$]);
       }
       get length() {
-        return this[_length$0];
+        return this[_length$1];
       }
       get isEmpty() {
-        return this[_length$0] == 0;
+        return this[_length$1] == 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
       contains(object) {
         if (dart.notNull(collection._LinkedHashSet._isStringElement(object))) {
-          let strings = this[_strings];
+          let strings = this[_strings$];
           if (strings == null) return false;
           let cell = dart.as(collection._LinkedHashSet._getTableEntry(strings, object), collection.LinkedHashSetCell);
           return cell != null;
         } else if (dart.notNull(collection._LinkedHashSet._isNumericElement(object))) {
-          let nums = this[_nums];
+          let nums = this[_nums$];
           if (nums == null) return false;
           let cell = dart.as(collection._LinkedHashSet._getTableEntry(nums, object), collection.LinkedHashSetCell);
           return cell != null;
@@ -20497,9 +21406,9 @@ dart_library.library('dart_sdk', null, /* Imports */[
         }
       }
       [_contains](object) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return false;
-        let bucket = this[_getBucket](rest, object);
+        let bucket = this[_getBucket$](rest, object);
         return dart.notNull(this[_findBucketIndex](bucket, object)) >= 0;
       }
       lookup(object) {
@@ -20510,81 +21419,81 @@ dart_library.library('dart_sdk', null, /* Imports */[
         }
       }
       [_lookup](object) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return null;
-        let bucket = this[_getBucket](rest, object);
+        let bucket = this[_getBucket$](rest, object);
         let index = this[_findBucketIndex](bucket, object);
         if (dart.notNull(index) < 0) return null;
         return dart.as(dart.dload(bucket[dartx.get](index), _element), E);
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [E]));
-        let cell = this[_first];
-        let modifications = this[_modifications];
+        let cell = this[_first$];
+        let modifications = this[_modifications$];
         while (cell != null) {
           action(dart.as(cell[_element], E));
-          if (modifications != this[_modifications]) {
+          if (modifications != this[_modifications$]) {
             dart.throw(new core.ConcurrentModificationError(this));
           }
-          cell = cell[_next$];
+          cell = cell[_next$0];
         }
       }
       get first() {
-        if (this[_first] == null) dart.throw(new core.StateError("No elements"));
-        return dart.as(this[_first][_element], E);
+        if (this[_first$] == null) dart.throw(new core.StateError("No elements"));
+        return dart.as(this[_first$][_element], E);
       }
       get last() {
-        if (this[_last] == null) dart.throw(new core.StateError("No elements"));
-        return dart.as(this[_last][_element], E);
+        if (this[_last$] == null) dart.throw(new core.StateError("No elements"));
+        return dart.as(this[_last$][_element], E);
       }
       add(element) {
         dart.as(element, E);
         if (dart.notNull(collection._LinkedHashSet._isStringElement(element))) {
-          let strings = this[_strings];
-          if (strings == null) this[_strings] = strings = collection._LinkedHashSet._newHashTable();
-          return this[_addHashTableEntry](strings, element);
+          let strings = this[_strings$];
+          if (strings == null) this[_strings$] = strings = collection._LinkedHashSet._newHashTable();
+          return this[_addHashTableEntry$](strings, element);
         } else if (dart.notNull(collection._LinkedHashSet._isNumericElement(element))) {
-          let nums = this[_nums];
-          if (nums == null) this[_nums] = nums = collection._LinkedHashSet._newHashTable();
-          return this[_addHashTableEntry](nums, element);
+          let nums = this[_nums$];
+          if (nums == null) this[_nums$] = nums = collection._LinkedHashSet._newHashTable();
+          return this[_addHashTableEntry$](nums, element);
         } else {
           return this[_add$0](element);
         }
       }
       [_add$0](element) {
         dart.as(element, E);
-        let rest = this[_rest];
-        if (rest == null) this[_rest] = rest = collection._LinkedHashSet._newHashTable();
+        let rest = this[_rest$];
+        if (rest == null) this[_rest$] = rest = collection._LinkedHashSet._newHashTable();
         let hash = this[_computeHashCode](element);
         let bucket = rest[hash];
         if (bucket == null) {
-          let cell = this[_newLinkedCell](element);
+          let cell = this[_newLinkedCell$](element);
           collection._LinkedHashSet._setTableEntry(rest, hash, [cell]);
         } else {
           let index = this[_findBucketIndex](bucket, element);
           if (dart.notNull(index) >= 0) return false;
-          let cell = this[_newLinkedCell](element);
+          let cell = this[_newLinkedCell$](element);
           bucket.push(cell);
         }
         return true;
       }
       remove(object) {
         if (dart.notNull(collection._LinkedHashSet._isStringElement(object))) {
-          return this[_removeHashTableEntry](this[_strings], object);
+          return this[_removeHashTableEntry$](this[_strings$], object);
         } else if (dart.notNull(collection._LinkedHashSet._isNumericElement(object))) {
-          return this[_removeHashTableEntry](this[_nums], object);
+          return this[_removeHashTableEntry$](this[_nums$], object);
         } else {
           return this[_remove](object);
         }
       }
       [_remove](object) {
-        let rest = this[_rest];
+        let rest = this[_rest$];
         if (rest == null) return false;
-        let bucket = this[_getBucket](rest, object);
+        let bucket = this[_getBucket$](rest, object);
         let index = this[_findBucketIndex](bucket, object);
         if (dart.notNull(index) < 0) return false;
         let cell = bucket.splice(index, 1)[0];
-        this[_unlinkCell](cell);
+        this[_unlinkCell$](cell);
         return true;
       }
       removeWhere(test) {
@@ -20597,13 +21506,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       [_filterWhere](test, removeMatching) {
         dart.as(test, dart.functionType(core.bool, [E]));
-        let cell = this[_first];
+        let cell = this[_first$];
         while (cell != null) {
           let element = dart.as(cell[_element], E);
-          let next = cell[_next$];
-          let modifications = this[_modifications];
+          let next = cell[_next$0];
+          let modifications = this[_modifications$];
           let shouldRemove = removeMatching == test(element);
-          if (modifications != this[_modifications]) {
+          if (modifications != this[_modifications$]) {
             dart.throw(new core.ConcurrentModificationError(this));
           }
           if (shouldRemove) this.remove(element);
@@ -20611,61 +21520,61 @@ dart_library.library('dart_sdk', null, /* Imports */[
         }
       }
       clear() {
-        if (dart.notNull(this[_length$0]) > 0) {
-          this[_strings] = this[_nums] = this[_rest] = this[_first] = this[_last] = null;
-          this[_length$0] = 0;
-          this[_modified]();
+        if (dart.notNull(this[_length$1]) > 0) {
+          this[_strings$] = this[_nums$] = this[_rest$] = this[_first$] = this[_last$] = null;
+          this[_length$1] = 0;
+          this[_modified$]();
         }
       }
-      [_addHashTableEntry](table, element) {
+      [_addHashTableEntry$](table, element) {
         dart.as(element, E);
         let cell = dart.as(collection._LinkedHashSet._getTableEntry(table, element), collection.LinkedHashSetCell);
         if (cell != null) return false;
-        collection._LinkedHashSet._setTableEntry(table, element, this[_newLinkedCell](element));
+        collection._LinkedHashSet._setTableEntry(table, element, this[_newLinkedCell$](element));
         return true;
       }
-      [_removeHashTableEntry](table, element) {
+      [_removeHashTableEntry$](table, element) {
         if (table == null) return false;
         let cell = dart.as(collection._LinkedHashSet._getTableEntry(table, element), collection.LinkedHashSetCell);
         if (cell == null) return false;
-        this[_unlinkCell](cell);
+        this[_unlinkCell$](cell);
         collection._LinkedHashSet._deleteTableEntry(table, element);
         return true;
       }
-      [_modified]() {
-        this[_modifications] = dart.notNull(this[_modifications]) + 1 & 67108863;
+      [_modified$]() {
+        this[_modifications$] = dart.notNull(this[_modifications$]) + 1 & 67108863;
       }
-      [_newLinkedCell](element) {
+      [_newLinkedCell$](element) {
         dart.as(element, E);
         let cell = new collection.LinkedHashSetCell(element);
-        if (this[_first] == null) {
-          this[_first] = this[_last] = cell;
+        if (this[_first$] == null) {
+          this[_first$] = this[_last$] = cell;
         } else {
-          let last = this[_last];
-          cell[_previous$] = last;
-          this[_last] = last[_next$] = cell;
+          let last = this[_last$];
+          cell[_previous$0] = last;
+          this[_last$] = last[_next$0] = cell;
         }
-        this[_length$0] = dart.notNull(this[_length$0]) + 1;
-        this[_modified]();
+        this[_length$1] = dart.notNull(this[_length$1]) + 1;
+        this[_modified$]();
         return cell;
       }
-      [_unlinkCell](cell) {
-        let previous = cell[_previous$];
-        let next = cell[_next$];
+      [_unlinkCell$](cell) {
+        let previous = cell[_previous$0];
+        let next = cell[_next$0];
         if (previous == null) {
-          dart.assert(dart.equals(cell, this[_first]));
-          this[_first] = next;
+          dart.assert(dart.equals(cell, this[_first$]));
+          this[_first$] = next;
         } else {
-          previous[_next$] = next;
+          previous[_next$0] = next;
         }
         if (next == null) {
-          dart.assert(dart.equals(cell, this[_last]));
-          this[_last] = previous;
+          dart.assert(dart.equals(cell, this[_last$]));
+          this[_last$] = previous;
         } else {
-          next[_previous$] = previous;
+          next[_previous$0] = previous;
         }
-        this[_length$0] = dart.notNull(this[_length$0]) - 1;
-        this[_modified]();
+        this[_length$1] = dart.notNull(this[_length$1]) - 1;
+        this[_modified$]();
       }
       static _isStringElement(element) {
         return typeof element == 'string' && element != '__proto__';
@@ -20686,7 +21595,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
       static _deleteTableEntry(table, key) {
         delete table[key];
       }
-      [_getBucket](table, element) {
+      [_getBucket$](table, element) {
         let hash = this[_computeHashCode](element);
         return table[hash];
       }
@@ -20725,13 +21634,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
         removeWhere: [dart.void, [dart.functionType(core.bool, [E])]],
         retainWhere: [dart.void, [dart.functionType(core.bool, [E])]],
         [_filterWhere]: [dart.void, [dart.functionType(core.bool, [E]), core.bool]],
-        [_addHashTableEntry]: [core.bool, [dart.dynamic, E]],
-        [_removeHashTableEntry]: [core.bool, [dart.dynamic, core.Object]],
-        [_modified]: [dart.void, []],
-        [_newLinkedCell]: [collection.LinkedHashSetCell, [E]],
-        [_unlinkCell]: [dart.void, [collection.LinkedHashSetCell]],
+        [_addHashTableEntry$]: [core.bool, [dart.dynamic, E]],
+        [_removeHashTableEntry$]: [core.bool, [dart.dynamic, core.Object]],
+        [_modified$]: [dart.void, []],
+        [_newLinkedCell$]: [collection.LinkedHashSetCell, [E]],
+        [_unlinkCell$]: [dart.void, [collection.LinkedHashSetCell]],
         [_computeHashCode]: [core.int, [dart.dynamic]],
-        [_getBucket]: [core.List, [dart.dynamic, dart.dynamic]],
+        [_getBucket$]: [core.List, [dart.dynamic, dart.dynamic]],
         [_findBucketIndex]: [core.int, [dart.dynamic, dart.dynamic]]
       }),
       statics: () => ({
@@ -20852,8 +21761,8 @@ dart_library.library('dart_sdk', null, /* Imports */[
   collection.LinkedHashSetCell = class LinkedHashSetCell extends core.Object {
     LinkedHashSetCell(element) {
       this[_element] = element;
-      this[_next$] = null;
-      this[_previous$] = null;
+      this[_next$0] = null;
+      this[_previous$0] = null;
     }
   };
   dart.setSignature(collection.LinkedHashSetCell, {
@@ -20863,23 +21772,23 @@ dart_library.library('dart_sdk', null, /* Imports */[
     class LinkedHashSetIterator extends core.Object {
       LinkedHashSetIterator(set, modifications) {
         this[_set] = set;
-        this[_modifications] = modifications;
-        this[_cell] = null;
+        this[_modifications$] = modifications;
+        this[_cell$] = null;
         this[_current$2] = null;
-        this[_cell] = dart.as(dart.dload(this[_set], _first), collection.LinkedHashSetCell);
+        this[_cell$] = dart.as(dart.dload(this[_set], _first$), collection.LinkedHashSetCell);
       }
       get current() {
         return this[_current$2];
       }
       moveNext() {
-        if (!dart.equals(this[_modifications], dart.dload(this[_set], _modifications))) {
+        if (!dart.equals(this[_modifications$], dart.dload(this[_set], _modifications$))) {
           dart.throw(new core.ConcurrentModificationError(this[_set]));
-        } else if (this[_cell] == null) {
+        } else if (this[_cell$] == null) {
           this[_current$2] = null;
           return false;
         } else {
-          this[_current$2] = dart.as(this[_cell][_element], E);
-          this[_cell] = this[_cell][_next$];
+          this[_current$2] = dart.as(this[_cell$][_element], E);
+          this[_cell$] = this[_cell$][_next$0];
           return true;
         }
       }
@@ -21580,11 +22489,11 @@ dart_library.library('dart_sdk', null, /* Imports */[
     class LinkedList extends collection.IterableBase$(E) {
       LinkedList() {
         this[_modificationCount] = 0;
-        this[_length$0] = 0;
-        this[_next$] = null;
-        this[_previous$] = null;
+        this[_length$1] = 0;
+        this[_next$0] = null;
+        this[_previous$0] = null;
         super.IterableBase();
-        this[_next$] = this[_previous$] = this;
+        this[_next$0] = this[_previous$0] = this;
       }
       addFirst(entry) {
         dart.as(entry, E);
@@ -21592,13 +22501,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       add(entry) {
         dart.as(entry, E);
-        this[_insertAfter](this[_previous$], entry);
+        this[_insertAfter](this[_previous$0], entry);
       }
       addAll(entries) {
         dart.as(entries, core.Iterable$(E));
         entries[dartx.forEach](dart.fn(entry => {
           dart.as(entry, E);
-          return this[_insertAfter](this[_previous$], entry);
+          return this[_insertAfter](this[_previous$0], entry);
         }, dart.void, [E]));
       }
       remove(entry) {
@@ -21611,54 +22520,54 @@ dart_library.library('dart_sdk', null, /* Imports */[
         return new (collection._LinkedListIterator$(E))(this);
       }
       get length() {
-        return this[_length$0];
+        return this[_length$1];
       }
       clear() {
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
-        let next = this[_next$];
+        let next = this[_next$0];
         while (!core.identical(next, this)) {
           let entry = dart.as(next, E);
-          next = entry[_next$];
-          entry[_next$] = entry[_previous$] = entry[_list] = null;
+          next = entry[_next$0];
+          entry[_next$0] = entry[_previous$0] = entry[_list] = null;
         }
-        this[_next$] = this[_previous$] = this;
-        this[_length$0] = 0;
+        this[_next$0] = this[_previous$0] = this;
+        this[_length$1] = 0;
       }
       get first() {
-        if (core.identical(this[_next$], this)) {
+        if (core.identical(this[_next$0], this)) {
           dart.throw(new core.StateError('No such element'));
         }
-        return dart.as(this[_next$], E);
+        return dart.as(this[_next$0], E);
       }
       get last() {
-        if (core.identical(this[_previous$], this)) {
+        if (core.identical(this[_previous$0], this)) {
           dart.throw(new core.StateError('No such element'));
         }
-        return dart.as(this[_previous$], E);
+        return dart.as(this[_previous$0], E);
       }
       get single() {
-        if (core.identical(this[_previous$], this)) {
+        if (core.identical(this[_previous$0], this)) {
           dart.throw(new core.StateError('No such element'));
         }
-        if (!core.identical(this[_previous$], this[_next$])) {
+        if (!core.identical(this[_previous$0], this[_next$0])) {
           dart.throw(new core.StateError('Too many elements'));
         }
-        return dart.as(this[_next$], E);
+        return dart.as(this[_next$0], E);
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [E]));
         let modificationCount = this[_modificationCount];
-        let current = this[_next$];
+        let current = this[_next$0];
         while (!core.identical(current, this)) {
           action(dart.as(current, E));
           if (modificationCount != this[_modificationCount]) {
             dart.throw(new core.ConcurrentModificationError(this));
           }
-          current = current[_next$];
+          current = current[_next$0];
         }
       }
       get isEmpty() {
-        return this[_length$0] == 0;
+        return this[_length$1] == 0;
       }
       [_insertAfter](entry, newEntry) {
         dart.as(newEntry, E);
@@ -21668,20 +22577,20 @@ dart_library.library('dart_sdk', null, /* Imports */[
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
         newEntry[_list] = this;
         let predecessor = entry;
-        let successor = entry[_next$];
-        successor[_previous$] = newEntry;
-        newEntry[_previous$] = predecessor;
-        newEntry[_next$] = successor;
-        predecessor[_next$] = newEntry;
-        this[_length$0] = dart.notNull(this[_length$0]) + 1;
+        let successor = entry[_next$0];
+        successor[_previous$0] = newEntry;
+        newEntry[_previous$0] = predecessor;
+        newEntry[_next$0] = successor;
+        predecessor[_next$0] = newEntry;
+        this[_length$1] = dart.notNull(this[_length$1]) + 1;
       }
       [_unlink$](entry) {
         dart.as(entry, collection.LinkedListEntry$(E));
         this[_modificationCount] = dart.notNull(this[_modificationCount]) + 1;
-        entry[_next$][_previous$] = entry[_previous$];
-        entry[_previous$][_next$] = entry[_next$];
-        this[_length$0] = dart.notNull(this[_length$0]) - 1;
-        entry[_list] = entry[_next$] = entry[_previous$] = null;
+        entry[_next$0][_previous$0] = entry[_previous$0];
+        entry[_previous$0][_next$0] = entry[_next$0];
+        this[_length$1] = dart.notNull(this[_length$1]) - 1;
+        entry[_list] = entry[_next$0] = entry[_previous$0] = null;
       }
     }
     LinkedList[dart.implements] = () => [collection._LinkedListLink];
@@ -21715,22 +22624,22 @@ dart_library.library('dart_sdk', null, /* Imports */[
       _LinkedListIterator(list) {
         this[_list] = list;
         this[_modificationCount] = list[_modificationCount];
-        this[_next$] = list[_next$];
+        this[_next$0] = list[_next$0];
         this[_current$2] = null;
       }
       get current() {
         return this[_current$2];
       }
       moveNext() {
-        if (core.identical(this[_next$], this[_list])) {
+        if (core.identical(this[_next$0], this[_list])) {
           this[_current$2] = null;
           return false;
         }
         if (this[_modificationCount] != this[_list][_modificationCount]) {
           dart.throw(new core.ConcurrentModificationError(this));
         }
-        this[_current$2] = dart.as(this[_next$], E);
-        this[_next$] = this[_next$][_next$];
+        this[_current$2] = dart.as(this[_next$0], E);
+        this[_next$0] = this[_next$0][_next$0];
         return true;
       }
     }
@@ -21744,16 +22653,16 @@ dart_library.library('dart_sdk', null, /* Imports */[
   collection._LinkedListIterator = collection._LinkedListIterator$();
   collection._LinkedListLink = class _LinkedListLink extends core.Object {
     _LinkedListLink() {
-      this[_next$] = null;
-      this[_previous$] = null;
+      this[_next$0] = null;
+      this[_previous$0] = null;
     }
   };
   collection.LinkedListEntry$ = dart.generic(E => {
     class LinkedListEntry extends core.Object {
       LinkedListEntry() {
         this[_list] = null;
-        this[_next$] = null;
-        this[_previous$] = null;
+        this[_next$0] = null;
+        this[_previous$0] = null;
       }
       get list() {
         return this[_list];
@@ -21762,13 +22671,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
         this[_list][_unlink$](this);
       }
       get next() {
-        if (core.identical(this[_next$], this[_list])) return null;
-        let result = dart.as(this[_next$], E);
+        if (core.identical(this[_next$0], this[_list])) return null;
+        let result = dart.as(this[_next$0], E);
         return result;
       }
       get previous() {
-        if (core.identical(this[_previous$], this[_list])) return null;
-        return dart.as(this[_previous$], E);
+        if (core.identical(this[_previous$0], this[_list])) return null;
+        return dart.as(this[_previous$0], E);
       }
       insertAfter(entry) {
         dart.as(entry, E);
@@ -21776,7 +22685,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       insertBefore(entry) {
         dart.as(entry, E);
-        this[_list][_insertAfter](this[_previous$], entry);
+        this[_list][_insertAfter](this[_previous$0], entry);
       }
     }
     LinkedListEntry[dart.implements] = () => [collection._LinkedListLink];
@@ -21866,50 +22775,6 @@ dart_library.library('dart_sdk', null, /* Imports */[
     return MapBase;
   });
   collection.MapBase = collection.MapBase$();
-  collection._UnmodifiableMapMixin$ = dart.generic((K, V) => {
-    class _UnmodifiableMapMixin extends core.Object {
-      set(key, value) {
-        dart.as(key, K);
-        dart.as(value, V);
-        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
-        return value;
-      }
-      addAll(other) {
-        dart.as(other, core.Map$(K, V));
-        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
-      }
-      clear() {
-        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
-      }
-      remove(key) {
-        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
-      }
-      putIfAbsent(key, ifAbsent) {
-        dart.as(key, K);
-        dart.as(ifAbsent, dart.functionType(V, []));
-        dart.throw(new core.UnsupportedError("Cannot modify unmodifiable map"));
-      }
-    }
-    _UnmodifiableMapMixin[dart.implements] = () => [core.Map$(K, V)];
-    dart.setSignature(_UnmodifiableMapMixin, {
-      methods: () => ({
-        set: [dart.void, [K, V]],
-        addAll: [dart.void, [core.Map$(K, V)]],
-        clear: [dart.void, []],
-        remove: [V, [core.Object]],
-        putIfAbsent: [V, [K, dart.functionType(V, [])]]
-      })
-    });
-    dart.defineExtensionMembers(_UnmodifiableMapMixin, [
-      'set',
-      'addAll',
-      'clear',
-      'remove',
-      'putIfAbsent'
-    ]);
-    return _UnmodifiableMapMixin;
-  });
-  collection._UnmodifiableMapMixin = collection._UnmodifiableMapMixin$();
   collection.UnmodifiableMapBase$ = dart.generic((K, V) => {
     class UnmodifiableMapBase extends dart.mixin(collection.MapBase$(K, V), collection._UnmodifiableMapMixin$(K, V)) {
       UnmodifiableMapBase() {
@@ -21922,29 +22787,29 @@ dart_library.library('dart_sdk', null, /* Imports */[
   collection._MapBaseValueIterable$ = dart.generic((K, V) => {
     class _MapBaseValueIterable extends core.Iterable$(V) {
       _MapBaseValueIterable(map) {
-        this[_map$] = map;
+        this[_map] = map;
         super.Iterable();
       }
       get length() {
-        return this[_map$][dartx.length];
+        return this[_map][dartx.length];
       }
       get isEmpty() {
-        return this[_map$][dartx.isEmpty];
+        return this[_map][dartx.isEmpty];
       }
       get isNotEmpty() {
-        return this[_map$][dartx.isNotEmpty];
+        return this[_map][dartx.isNotEmpty];
       }
       get first() {
-        return this[_map$][dartx.get](this[_map$][dartx.keys][dartx.first]);
+        return this[_map][dartx.get](this[_map][dartx.keys][dartx.first]);
       }
       get single() {
-        return this[_map$][dartx.get](this[_map$][dartx.keys][dartx.single]);
+        return this[_map][dartx.get](this[_map][dartx.keys][dartx.single]);
       }
       get last() {
-        return this[_map$][dartx.get](this[_map$][dartx.keys][dartx.last]);
+        return this[_map][dartx.get](this[_map][dartx.keys][dartx.last]);
       }
       get iterator() {
-        return new (collection._MapBaseValueIterator$(K, V))(this[_map$]);
+        return new (collection._MapBaseValueIterator$(K, V))(this[_map]);
       }
     }
     _MapBaseValueIterable[dart.implements] = () => [_internal.EfficientLength];
@@ -21966,13 +22831,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
   collection._MapBaseValueIterator$ = dart.generic((K, V) => {
     class _MapBaseValueIterator extends core.Object {
       _MapBaseValueIterator(map) {
-        this[_map$] = map;
-        this[_keys] = map[dartx.keys][dartx.iterator];
+        this[_map] = map;
+        this[_keys$] = map[dartx.keys][dartx.iterator];
         this[_current$2] = null;
       }
       moveNext() {
-        if (dart.notNull(this[_keys].moveNext())) {
-          this[_current$2] = this[_map$][dartx.get](this[_keys].current);
+        if (dart.notNull(this[_keys$].moveNext())) {
+          this[_current$2] = this[_map][dartx.get](this[_keys$].current);
           return true;
         }
         this[_current$2] = null;
@@ -21990,107 +22855,6 @@ dart_library.library('dart_sdk', null, /* Imports */[
     return _MapBaseValueIterator;
   });
   collection._MapBaseValueIterator = collection._MapBaseValueIterator$();
-  collection.MapView$ = dart.generic((K, V) => {
-    class MapView extends core.Object {
-      MapView(map) {
-        this[_map$] = map;
-      }
-      get(key) {
-        return this[_map$][dartx.get](key);
-      }
-      set(key, value) {
-        dart.as(key, K);
-        dart.as(value, V);
-        this[_map$][dartx.set](key, value);
-        return value;
-      }
-      addAll(other) {
-        dart.as(other, core.Map$(K, V));
-        this[_map$][dartx.addAll](other);
-      }
-      clear() {
-        this[_map$][dartx.clear]();
-      }
-      putIfAbsent(key, ifAbsent) {
-        dart.as(key, K);
-        dart.as(ifAbsent, dart.functionType(V, []));
-        return this[_map$][dartx.putIfAbsent](key, ifAbsent);
-      }
-      containsKey(key) {
-        return this[_map$][dartx.containsKey](key);
-      }
-      containsValue(value) {
-        return this[_map$][dartx.containsValue](value);
-      }
-      forEach(action) {
-        dart.as(action, dart.functionType(dart.void, [K, V]));
-        this[_map$][dartx.forEach](action);
-      }
-      get isEmpty() {
-        return this[_map$][dartx.isEmpty];
-      }
-      get isNotEmpty() {
-        return this[_map$][dartx.isNotEmpty];
-      }
-      get length() {
-        return this[_map$][dartx.length];
-      }
-      get keys() {
-        return this[_map$][dartx.keys];
-      }
-      remove(key) {
-        return this[_map$][dartx.remove](key);
-      }
-      toString() {
-        return dart.toString(this[_map$]);
-      }
-      get values() {
-        return this[_map$][dartx.values];
-      }
-    }
-    MapView[dart.implements] = () => [core.Map$(K, V)];
-    dart.setSignature(MapView, {
-      constructors: () => ({MapView: [collection.MapView$(K, V), [core.Map$(K, V)]]}),
-      methods: () => ({
-        get: [V, [core.Object]],
-        set: [dart.void, [K, V]],
-        addAll: [dart.void, [core.Map$(K, V)]],
-        clear: [dart.void, []],
-        putIfAbsent: [V, [K, dart.functionType(V, [])]],
-        containsKey: [core.bool, [core.Object]],
-        containsValue: [core.bool, [core.Object]],
-        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
-        remove: [V, [core.Object]]
-      })
-    });
-    dart.defineExtensionMembers(MapView, [
-      'get',
-      'set',
-      'addAll',
-      'clear',
-      'putIfAbsent',
-      'containsKey',
-      'containsValue',
-      'forEach',
-      'remove',
-      'isEmpty',
-      'isNotEmpty',
-      'length',
-      'keys',
-      'values'
-    ]);
-    return MapView;
-  });
-  collection.MapView = collection.MapView$();
-  collection.UnmodifiableMapView$ = dart.generic((K, V) => {
-    class UnmodifiableMapView extends dart.mixin(collection.MapView$(K, V), collection._UnmodifiableMapMixin$(K, V)) {
-      UnmodifiableMapView() {
-        super.MapView(...arguments);
-      }
-    }
-    return UnmodifiableMapView;
-  });
-  collection.UnmodifiableMapView = collection.UnmodifiableMapView$();
   collection.Maps = class Maps extends core.Object {
     static containsValue(map, value) {
       for (let v of map[dartx.values]) {
@@ -22234,40 +22998,40 @@ dart_library.library('dart_sdk', null, /* Imports */[
     class DoubleLinkedQueueEntry extends core.Object {
       DoubleLinkedQueueEntry(e) {
         this[_element] = e;
-        this[_previous$] = null;
-        this[_next$] = null;
+        this[_previous$0] = null;
+        this[_next$0] = null;
       }
       [_link](previous, next) {
         dart.as(previous, collection.DoubleLinkedQueueEntry$(E));
         dart.as(next, collection.DoubleLinkedQueueEntry$(E));
-        this[_next$] = next;
-        this[_previous$] = previous;
-        previous[_next$] = this;
-        next[_previous$] = this;
+        this[_next$0] = next;
+        this[_previous$0] = previous;
+        previous[_next$0] = this;
+        next[_previous$0] = this;
       }
       append(e) {
         dart.as(e, E);
-        new (collection.DoubleLinkedQueueEntry$(E))(e)[_link](this, this[_next$]);
+        new (collection.DoubleLinkedQueueEntry$(E))(e)[_link](this, this[_next$0]);
       }
       prepend(e) {
         dart.as(e, E);
-        new (collection.DoubleLinkedQueueEntry$(E))(e)[_link](this[_previous$], this);
+        new (collection.DoubleLinkedQueueEntry$(E))(e)[_link](this[_previous$0], this);
       }
       remove() {
-        this[_previous$][_next$] = this[_next$];
-        this[_next$][_previous$] = this[_previous$];
-        this[_next$] = null;
-        this[_previous$] = null;
+        this[_previous$0][_next$0] = this[_next$0];
+        this[_next$0][_previous$0] = this[_previous$0];
+        this[_next$0] = null;
+        this[_previous$0] = null;
         return this[_element];
       }
       [_asNonSentinelEntry]() {
         return this;
       }
       previousEntry() {
-        return this[_previous$][_asNonSentinelEntry]();
+        return this[_previous$0][_asNonSentinelEntry]();
       }
       nextEntry() {
-        return this[_next$][_asNonSentinelEntry]();
+        return this[_next$0][_asNonSentinelEntry]();
       }
       get element() {
         return this[_element];
@@ -22367,32 +23131,32 @@ dart_library.library('dart_sdk', null, /* Imports */[
         }
       }
       removeLast() {
-        let result = this[_sentinel][_previous$].remove();
+        let result = this[_sentinel][_previous$0].remove();
         this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
         return result;
       }
       removeFirst() {
-        let result = this[_sentinel][_next$].remove();
+        let result = this[_sentinel][_next$0].remove();
         this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
         return result;
       }
       remove(o) {
-        let entry = this[_sentinel][_next$];
+        let entry = this[_sentinel][_next$0];
         while (!core.identical(entry, this[_sentinel])) {
           if (dart.equals(entry.element, o)) {
             entry.remove();
             this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
             return true;
           }
-          entry = entry[_next$];
+          entry = entry[_next$0];
         }
         return false;
       }
       [_filter](test, removeMatching) {
         dart.as(test, dart.functionType(core.bool, [E]));
-        let entry = this[_sentinel][_next$];
+        let entry = this[_sentinel][_next$0];
         while (!core.identical(entry, this[_sentinel])) {
-          let next = entry[_next$];
+          let next = entry[_next$0];
           if (core.identical(removeMatching, test(entry.element))) {
             entry.remove();
             this[_elementCount] = dart.notNull(this[_elementCount]) - 1;
@@ -22409,14 +23173,14 @@ dart_library.library('dart_sdk', null, /* Imports */[
         this[_filter](test, false);
       }
       get first() {
-        return this[_sentinel][_next$].element;
+        return this[_sentinel][_next$0].element;
       }
       get last() {
-        return this[_sentinel][_previous$].element;
+        return this[_sentinel][_previous$0].element;
       }
       get single() {
-        if (core.identical(this[_sentinel][_next$], this[_sentinel][_previous$])) {
-          return this[_sentinel][_next$].element;
+        if (core.identical(this[_sentinel][_next$0], this[_sentinel][_previous$0])) {
+          return this[_sentinel][_next$0].element;
         }
         dart.throw(_internal.IterableElementError.tooMany());
       }
@@ -22427,18 +23191,18 @@ dart_library.library('dart_sdk', null, /* Imports */[
         return this[_sentinel].nextEntry();
       }
       get isEmpty() {
-        return core.identical(this[_sentinel][_next$], this[_sentinel]);
+        return core.identical(this[_sentinel][_next$0], this[_sentinel]);
       }
       clear() {
-        this[_sentinel][_next$] = this[_sentinel];
-        this[_sentinel][_previous$] = this[_sentinel];
+        this[_sentinel][_next$0] = this[_sentinel];
+        this[_sentinel][_previous$0] = this[_sentinel];
         this[_elementCount] = 0;
       }
       forEachEntry(f) {
         dart.as(f, dart.functionType(dart.void, [collection.DoubleLinkedQueueEntry$(E)]));
-        let entry = this[_sentinel][_next$];
+        let entry = this[_sentinel][_next$0];
         while (!core.identical(entry, this[_sentinel])) {
-          let nextEntry = entry[_next$];
+          let nextEntry = entry[_next$0];
           f(entry);
           entry = nextEntry;
         }
@@ -22490,13 +23254,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
     class _DoubleLinkedQueueIterator extends core.Object {
       _DoubleLinkedQueueIterator(sentinel) {
         this[_sentinel] = sentinel;
-        this[_nextEntry] = sentinel[_next$];
+        this[_nextEntry] = sentinel[_next$0];
         this[_current$2] = null;
       }
       moveNext() {
         if (!core.identical(this[_nextEntry], this[_sentinel])) {
           this[_current$2] = this[_nextEntry][_element];
-          this[_nextEntry] = this[_nextEntry][_next$];
+          this[_nextEntry] = this[_nextEntry][_next$0];
           return true;
         }
         this[_current$2] = null;
@@ -23040,12 +23804,12 @@ dart_library.library('dart_sdk', null, /* Imports */[
         }
         this[_root] = node;
       }
-      get [_first]() {
+      get [_first$]() {
         if (this[_root] == null) return null;
         this[_root] = this[_splayMin](this[_root]);
         return this[_root];
       }
-      get [_last]() {
+      get [_last$]() {
         if (this[_root] == null) return null;
         this[_root] = this[_splayMax](this[_root]);
         return this[_root];
@@ -23227,11 +23991,11 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       firstKey() {
         if (this[_root] == null) return null;
-        return dart.as(this[_first].key, K);
+        return dart.as(this[_first$].key, K);
       }
       lastKey() {
         if (this[_root] == null) return null;
-        return dart.as(this[_last].key, K);
+        return dart.as(this[_last$].key, K);
       }
       lastKeyBefore(key) {
         dart.as(key, K);
@@ -23426,17 +24190,17 @@ dart_library.library('dart_sdk', null, /* Imports */[
   collection._SplayTreeValueIterable$ = dart.generic((K, V) => {
     class _SplayTreeValueIterable extends collection.IterableBase$(V) {
       _SplayTreeValueIterable(map) {
-        this[_map$] = map;
+        this[_map] = map;
         super.IterableBase();
       }
       get length() {
-        return this[_map$][_count$];
+        return this[_map][_count$];
       }
       get isEmpty() {
-        return this[_map$][_count$] == 0;
+        return this[_map][_count$] == 0;
       }
       get iterator() {
-        return new (collection._SplayTreeValueIterator$(K, V))(this[_map$]);
+        return new (collection._SplayTreeValueIterator$(K, V))(this[_map]);
       }
     }
     _SplayTreeValueIterable[dart.implements] = () => [_internal.EfficientLength];
@@ -23541,11 +24305,11 @@ dart_library.library('dart_sdk', null, /* Imports */[
       }
       get first() {
         if (this[_count$] == 0) dart.throw(_internal.IterableElementError.noElement());
-        return dart.as(this[_first].key, E);
+        return dart.as(this[_first$].key, E);
       }
       get last() {
         if (this[_count$] == 0) dart.throw(_internal.IterableElementError.noElement());
-        return dart.as(this[_last].key, E);
+        return dart.as(this[_last$].key, E);
       }
       get single() {
         if (this[_count$] == 0) dart.throw(_internal.IterableElementError.noElement());
@@ -24712,17 +25476,17 @@ dart_library.library('dart_sdk', null, /* Imports */[
   });
   convert._ConverterStreamEventSink = convert._ConverterStreamEventSink$();
   const _second = Symbol('_second');
-  const _first$ = Symbol('_first');
+  const _first$0 = Symbol('_first');
   convert._FusedCodec$ = dart.generic((S, M, T) => {
     class _FusedCodec extends convert.Codec$(S, T) {
       get encoder() {
-        return dart.as(this[_first$].encoder.fuse(this[_second].encoder), convert.Converter$(S, T));
+        return dart.as(this[_first$0].encoder.fuse(this[_second].encoder), convert.Converter$(S, T));
       }
       get decoder() {
-        return dart.as(this[_second].decoder.fuse(this[_first$].decoder), convert.Converter$(T, S));
+        return dart.as(this[_second].decoder.fuse(this[_first$0].decoder), convert.Converter$(T, S));
       }
       _FusedCodec(first, second) {
-        this[_first$] = first;
+        this[_first$0] = first;
         this[_second] = second;
         super.Codec();
       }
@@ -24759,17 +25523,17 @@ dart_library.library('dart_sdk', null, /* Imports */[
   convert._FusedConverter$ = dart.generic((S, M, T) => {
     class _FusedConverter extends convert.Converter$(S, T) {
       _FusedConverter(first, second) {
-        this[_first$] = first;
+        this[_first$0] = first;
         this[_second] = second;
         super.Converter();
       }
       convert(input) {
         dart.as(input, S);
-        return dart.as(this[_second].convert(this[_first$].convert(input)), T);
+        return dart.as(this[_second].convert(this[_first$0].convert(input)), T);
       }
       startChunkedConversion(sink) {
         dart.as(sink, core.Sink$(T));
-        return this[_first$].startChunkedConversion(this[_second].startChunkedConversion(sink));
+        return this[_first$0].startChunkedConversion(this[_second].startChunkedConversion(sink));
       }
     }
     dart.setSignature(_FusedConverter, {
@@ -27836,13 +28600,13 @@ dart_library.library('dart_sdk', null, /* Imports */[
   core.Map$ = dart.generic((K, V) => {
     class Map extends core.Object {
       static new() {
-        return collection.LinkedHashMap$(K, V).new();
+        return _js_helper.JsLinkedHashMap$(K, V).es6();
       }
       static from(other) {
         return collection.LinkedHashMap$(K, V).from(other);
       }
       static unmodifiable(other) {
-        return new (collection.UnmodifiableMapView$(K, V))(core.Map$(K, V).from(other));
+        return _js_helper.ConstantMap$(K, V).from(other);
       }
       static identity() {
         return collection.LinkedHashMap$(K, V).identity();
@@ -29798,15 +30562,15 @@ dart_library.library('dart_sdk', null, /* Imports */[
       return js._wrapToDart(js._global);
     }
   });
-  const _jsObject = Symbol('_jsObject');
+  const _jsObject$ = Symbol('_jsObject');
   js.JsObject = class JsObject extends core.Object {
     _fromJs(jsObject) {
-      this[_jsObject] = jsObject;
-      dart.assert(this[_jsObject] != null);
+      this[_jsObject$] = jsObject;
+      dart.assert(this[_jsObject$] != null);
     }
     static new(constructor, arguments$) {
       if (arguments$ === void 0) arguments$ = null;
-      let ctor = constructor[_jsObject];
+      let ctor = constructor[_jsObject$];
       if (arguments$ == null) {
         return js._wrapToDart(new ctor());
       }
@@ -29854,39 +30618,39 @@ dart_library.library('dart_sdk', null, /* Imports */[
       if (!(typeof property == 'string') && !(typeof property == 'number')) {
         dart.throw(new core.ArgumentError("property is not a String or num"));
       }
-      return js._convertToDart(this[_jsObject][property]);
+      return js._convertToDart(this[_jsObject$][property]);
     }
     set(property, value) {
       if (!(typeof property == 'string') && !(typeof property == 'number')) {
         dart.throw(new core.ArgumentError("property is not a String or num"));
       }
-      this[_jsObject][property] = js._convertToJS(value);
+      this[_jsObject$][property] = js._convertToJS(value);
       return value;
     }
     get hashCode() {
       return 0;
     }
     ['=='](other) {
-      return dart.is(other, js.JsObject) && this[_jsObject] === other[_jsObject];
+      return dart.is(other, js.JsObject) && this[_jsObject$] === other[_jsObject$];
     }
     hasProperty(property) {
       if (!(typeof property == 'string') && !(typeof property == 'number')) {
         dart.throw(new core.ArgumentError("property is not a String or num"));
       }
-      return property in this[_jsObject];
+      return property in this[_jsObject$];
     }
     deleteProperty(property) {
       if (!(typeof property == 'string') && !(typeof property == 'number')) {
         dart.throw(new core.ArgumentError("property is not a String or num"));
       }
-      delete this[_jsObject][property];
+      delete this[_jsObject$][property];
     }
     instanceof(type) {
-      return this[_jsObject] instanceof js._convertToJS(type);
+      return this[_jsObject$] instanceof js._convertToJS(type);
     }
     toString() {
       try {
-        return String(this[_jsObject]);
+        return String(this[_jsObject$]);
       } catch (e) {
         return super.toString();
       }
@@ -29898,11 +30662,11 @@ dart_library.library('dart_sdk', null, /* Imports */[
         dart.throw(new core.ArgumentError("method is not a String or num"));
       }
       if (args != null) args = core.List.from(args[dartx.map](dart.dynamic)(js._convertToJS));
-      let fn = this[_jsObject][method];
+      let fn = this[_jsObject$][method];
       if (!(fn instanceof Function)) {
-        dart.throw(new core.NoSuchMethodError(this[_jsObject], core.Symbol.new(dart.as(method, core.String)), args, dart.map()));
+        dart.throw(new core.NoSuchMethodError(this[_jsObject$], core.Symbol.new(dart.as(method, core.String)), args, dart.map()));
       }
-      return js._convertToDart(fn.apply(this[_jsObject], args));
+      return js._convertToDart(fn.apply(this[_jsObject$], args));
     }
   };
   dart.defineNamedConstructor(js.JsObject, '_fromJs');
@@ -29939,7 +30703,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
     }
     apply(args, opts) {
       let thisArg = opts && 'thisArg' in opts ? opts.thisArg : null;
-      return js._convertToDart(this[_jsObject].apply(js._convertToJS(thisArg), args == null ? null : core.List.from(args[dartx.map](dart.dynamic)(js._convertToJS))));
+      return js._convertToDart(this[_jsObject$].apply(js._convertToJS(thisArg), args == null ? null : core.List.from(args[dartx.map](dart.dynamic)(js._convertToJS))));
     }
   };
   dart.defineNamedConstructor(js.JsFunction, '_fromJs');
@@ -30000,7 +30764,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
         return value;
       }
       get length() {
-        let len = this[_jsObject].length;
+        let len = this[_jsObject$].length;
         if (typeof len === "number" && len >>> 0 === len) {
           return len;
         }
@@ -30112,7 +30876,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
     } else if (dart.is(o, core.DateTime)) {
       return _js_helper.Primitives.lazyAsJsDate(o);
     } else if (dart.is(o, js.JsObject)) {
-      return o[_jsObject];
+      return o[_jsObject$];
     } else if (dart.is(o, core.Function)) {
       return js._putIfAbsent(js._jsProxies, o, js._wrapDartFunction);
     } else {
@@ -61153,7 +61917,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
   const _setItem = Symbol('_setItem');
   const _removeItem = Symbol('_removeItem');
   const _key$ = Symbol('_key');
-  const _length$1 = Symbol('_length');
+  const _length$2 = Symbol('_length');
   const __delete__ = Symbol('__delete__');
   dart.defineExtensionNames([
     'addAll',
@@ -61220,7 +61984,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
       return values;
     }
     get [dartx.length]() {
-      return this[_length$1];
+      return this[_length$2];
     }
     get [dartx.isEmpty]() {
       return this[_key$](0) == null;
@@ -61231,7 +61995,7 @@ dart_library.library('dart_sdk', null, /* Imports */[
     static _() {
       dart.throw(new core.UnsupportedError("Not supported"));
     }
-    get [_length$1]() {
+    get [_length$2]() {
       return this.length;
     }
     [__delete__](index_OR_name) {
@@ -70175,18 +70939,18 @@ dart_library.library('dart_sdk', null, /* Imports */[
       FixedSizeListIterator(array) {
         this[_array] = array;
         this[_position$0] = -1;
-        this[_length$1] = array[dartx.length];
+        this[_length$2] = array[dartx.length];
         this[_current$4] = null;
       }
       moveNext() {
         let nextPosition = dart.notNull(this[_position$0]) + 1;
-        if (nextPosition < dart.notNull(this[_length$1])) {
+        if (nextPosition < dart.notNull(this[_length$2])) {
           this[_current$4] = this[_array][dartx.get](nextPosition);
           this[_position$0] = nextPosition;
           return true;
         }
         this[_current$4] = null;
-        this[_position$0] = this[_length$1];
+        this[_position$0] = this[_length$2];
         return false;
       }
       get current() {