Wrapperless dart:html and friends

lib/runtime/dart/collection.js

 dart_library.library('dart/collection', null, /* Imports */[
   'dart/_runtime',
   'dart/core'
 ], /* Lazy imports */[
   'dart/_internal',
   'dart/_js_helper',
   'dart/math'
 ], function(exports, dart, core, _internal, _js_helper, math) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 64 matching lines @@
             equals = _defaultEquals;
           }
         }
         return new (_CustomHashMap$(K, V))(equals, hashCode, isValidKey);
       }
       static identity() {
         return new (_IdentityHashMap$(K, V))();
       }
       static from(other) {
         let result = HashMap$(K, V).new();
-        other.forEach(dart.fn((k, v) => {
+        other[dartx.forEach](dart.fn((k, v) => {
           result.set(dart.as(k, K), dart.as(v, V));
         }, dart.void, [dart.dynamic, dart.dynamic]));
         return result;
       }
       static fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
         let map = HashMap$(K, V).new();
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
@@ skipping 1139 matching lines @@
             equals = _defaultEquals;
           }
         }
         return new (_LinkedCustomHashMap$(K, V))(equals, hashCode, isValidKey);
       }
       static identity() {
         return new (_LinkedIdentityHashMap$(K, V))();
       }
       static from(other) {
         let result = LinkedHashMap$(K, V).new();
-        other.forEach(dart.fn((k, v) => {
+        other[dartx.forEach](dart.fn((k, v) => {
           result.set(dart.as(k, K), dart.as(v, V));
         }, dart.void, [dart.dynamic, dart.dynamic]));
         return result;
       }
       static fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
         let map = LinkedHashMap$(K, V).new();
         Maps._fillMapWithMappedIterable(map, iterable, key, value);
         return map;
@@ skipping 877 matching lines @@
   const MapMixin$ = dart.generic(function(K, V) {
     class MapMixin extends core.Object {
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [K, V]));
         for (let key of this.keys) {
           action(key, this.get(key));
         }
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
-        for (let key of other.keys) {
-          this.set(key, other.get(key));
+        for (let key of other[dartx.keys]) {
+          this.set(key, other[dartx.get](key));
         }
       }
       containsValue(value) {
         for (let key of this.keys) {
           if (dart.equals(this.get(key), value)) return true;
         }
         return false;
       }
       putIfAbsent(key, ifAbsent) {
         dart.as(key, K);
@@ skipping 25 matching lines @@
     MapMixin[dart.implements] = () => [core.Map$(K, V)];
     dart.setSignature(MapMixin, {
       methods: () => ({
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
         addAll: [dart.void, [core.Map$(K, V)]],
         containsValue: [core.bool, [core.Object]],
         putIfAbsent: [V, [K, dart.functionType(V, [])]],
         containsKey: [core.bool, [core.Object]]
       })
     });
+    dart.defineExtensionMembers(MapMixin, [
+      'forEach',
+      'addAll',
+      'containsValue',
+      'putIfAbsent',
+      'containsKey',
+      'length',
+      'isEmpty',
+      'isNotEmpty',
+      'values'
+    ]);
     return MapMixin;
   });
   let MapMixin = MapMixin$();
   const MapBase$ = dart.generic(function(K, V) {
     class MapBase extends dart.mixin(core.Object, MapMixin$(K, V)) {}
     return MapBase;
   });
   let MapBase = MapBase$();
   const _UnmodifiableMapMixin$ = dart.generic(function(K, V) {
     class _UnmodifiableMapMixin extends core.Object {
@@ skipping 22 matching lines @@
     _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;
   });
   let _UnmodifiableMapMixin = _UnmodifiableMapMixin$();
   const UnmodifiableMapBase$ = dart.generic(function(K, V) {
     class UnmodifiableMapBase extends dart.mixin(MapBase$(K, V), _UnmodifiableMapMixin$(K, V)) {
       UnmodifiableMapBase() {
         super.MapBase(...arguments);
       }
     }
     return UnmodifiableMapBase;
   });
   let UnmodifiableMapBase = UnmodifiableMapBase$();
   const _map = Symbol('_map');
   const _MapBaseValueIterable$ = dart.generic(function(V) {
     class _MapBaseValueIterable extends IterableBase$(V) {
       _MapBaseValueIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get length() {
-        return this[_map].length;
+        return this[_map][dartx.length];
       }
       get isEmpty() {
-        return this[_map].isEmpty;
+        return this[_map][dartx.isEmpty];
       }
       get isNotEmpty() {
-        return this[_map].isNotEmpty;
+        return this[_map][dartx.isNotEmpty];
       }
       get first() {
-        return dart.as(this[_map].get(this[_map].keys[dartx.first]), V);
+        return dart.as(this[_map][dartx.get](this[_map][dartx.keys][dartx.first]), V);
       }
       get single() {
-        return dart.as(this[_map].get(this[_map].keys[dartx.single]), V);
+        return dart.as(this[_map][dartx.get](this[_map][dartx.keys][dartx.single]), V);
       }
       get last() {
-        return dart.as(this[_map].get(this[_map].keys[dartx.last]), V);
+        return dart.as(this[_map][dartx.get](this[_map][dartx.keys][dartx.last]), V);
       }
       get iterator() {
         return new (_MapBaseValueIterator$(V))(this[_map]);
       }
     }
     _MapBaseValueIterable[dart.implements] = () => [_internal.EfficientLength];
     dart.setSignature(_MapBaseValueIterable, {
       constructors: () => ({_MapBaseValueIterable: [_MapBaseValueIterable$(V), [core.Map]]})
     });
     dart.defineExtensionMembers(_MapBaseValueIterable, [
       'length',
       'isEmpty',
       'isNotEmpty',
       'first',
       'single',
       'last',
       'iterator'
     ]);
     return _MapBaseValueIterable;
   });
   let _MapBaseValueIterable = _MapBaseValueIterable$();
   const _keys = Symbol('_keys');
   const _MapBaseValueIterator$ = dart.generic(function(V) {
     class _MapBaseValueIterator extends core.Object {
       _MapBaseValueIterator(map) {
         this[_map] = map;
-        this[_keys] = map.keys[dartx.iterator];
+        this[_keys] = map[dartx.keys][dartx.iterator];
         this[_current] = null;
       }
       moveNext() {
         if (dart.notNull(this[_keys].moveNext())) {
-          this[_current] = dart.as(this[_map].get(this[_keys].current), V);
+          this[_current] = dart.as(this[_map][dartx.get](this[_keys].current), V);
           return true;
         }
         this[_current] = null;
         return false;
       }
       get current() {
         return this[_current];
       }
     }
     _MapBaseValueIterator[dart.implements] = () => [core.Iterator$(V)];
     dart.setSignature(_MapBaseValueIterator, {
       constructors: () => ({_MapBaseValueIterator: [_MapBaseValueIterator$(V), [core.Map]]}),
       methods: () => ({moveNext: [core.bool, []]})
     });
     return _MapBaseValueIterator;
   });
   let _MapBaseValueIterator = _MapBaseValueIterator$();
   const MapView$ = dart.generic(function(K, V) {
     class MapView extends core.Object {
       MapView(map) {
         this[_map] = map;
       }
       get(key) {
-        return this[_map].get(key);
+        return this[_map][dartx.get](key);
       }
       set(key, value) {
         dart.as(key, K);
         dart.as(value, V);
-        this[_map].set(key, value);
+        this[_map][dartx.set](key, value);
         return value;
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
-        this[_map].addAll(other);
+        this[_map][dartx.addAll](other);
       }
       clear() {
-        this[_map].clear();
+        this[_map][dartx.clear]();
       }
       putIfAbsent(key, ifAbsent) {
         dart.as(key, K);
         dart.as(ifAbsent, dart.functionType(V, []));
-        return this[_map].putIfAbsent(key, ifAbsent);
+        return this[_map][dartx.putIfAbsent](key, ifAbsent);
       }
       containsKey(key) {
-        return this[_map].containsKey(key);
+        return this[_map][dartx.containsKey](key);
       }
       containsValue(value) {
-        return this[_map].containsValue(value);
+        return this[_map][dartx.containsValue](value);
       }
       forEach(action) {
         dart.as(action, dart.functionType(dart.void, [K, V]));
-        this[_map].forEach(action);
+        this[_map][dartx.forEach](action);
       }
       get isEmpty() {
-        return this[_map].isEmpty;
+        return this[_map][dartx.isEmpty];
       }
       get isNotEmpty() {
-        return this[_map].isNotEmpty;
+        return this[_map][dartx.isNotEmpty];
       }
       get length() {
-        return this[_map].length;
+        return this[_map][dartx.length];
       }
       get keys() {
-        return this[_map].keys;
+        return this[_map][dartx.keys];
       }
       remove(key) {
-        return this[_map].remove(key);
+        return this[_map][dartx.remove](key);
       }
       toString() {
         return dart.toString(this[_map]);
       }
       get values() {
-        return this[_map].values;
+        return this[_map][dartx.values];
       }
     }
     MapView[dart.implements] = () => [core.Map$(K, V)];
     dart.setSignature(MapView, {
       constructors: () => ({MapView: [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;
   });
   let MapView = MapView$();
   const UnmodifiableMapView$ = dart.generic(function(K, V) {
     class UnmodifiableMapView extends dart.mixin(MapView$(K, V), _UnmodifiableMapMixin$(K, V)) {
       UnmodifiableMapView() {
         super.MapView(...arguments);
       }
     }
     return UnmodifiableMapView;
   });
   let UnmodifiableMapView = UnmodifiableMapView$();
   class Maps extends core.Object {
     static containsValue(map, value) {
-      for (let v of map.values) {
+      for (let v of map[dartx.values]) {
         if (dart.equals(value, v)) {
           return true;
         }
       }
       return false;
     }
     static containsKey(map, key) {
-      for (let k of map.keys) {
+      for (let k of map[dartx.keys]) {
         if (dart.equals(key, k)) {
           return true;
         }
       }
       return false;
     }
     static putIfAbsent(map, key, ifAbsent) {
-      if (dart.notNull(map.containsKey(key))) {
-        return map.get(key);
+      if (dart.notNull(map[dartx.containsKey](key))) {
+        return map[dartx.get](key);
       }
       let v = ifAbsent();
-      map.set(key, v);
+      map[dartx.set](key, v);
       return v;
     }
     static clear(map) {
-      for (let k of map.keys[dartx.toList]()) {
-        map.remove(k);
+      for (let k of map[dartx.keys][dartx.toList]()) {
+        map[dartx.remove](k);
       }
     }
     static forEach(map, f) {
-      for (let k of map.keys) {
-        dart.dcall(f, k, map.get(k));
+      for (let k of map[dartx.keys]) {
+        dart.dcall(f, k, map[dartx.get](k));
       }
     }
     static getValues(map) {
-      return map.keys[dartx.map](dart.fn(key => map.get(key)));
+      return map[dartx.keys][dartx.map](dart.fn(key => map[dartx.get](key)));
     }
     static length(map) {
-      return map.keys[dartx.length];
+      return map[dartx.keys][dartx.length];
     }
     static isEmpty(map) {
-      return map.keys[dartx.isEmpty];
+      return map[dartx.keys][dartx.isEmpty];
     }
     static isNotEmpty(map) {
-      return map.keys[dartx.isNotEmpty];
+      return map[dartx.keys][dartx.isNotEmpty];
     }
     static mapToString(m) {
       if (dart.notNull(IterableBase._isToStringVisiting(m))) {
         return '{...}';
       }
       let result = new core.StringBuffer();
       try {
         IterableBase._toStringVisiting[dartx.add](m);
         result.write('{');
         let first = true;
-        m.forEach(dart.fn((k, v) => {
+        m[dartx.forEach](dart.fn((k, v) => {
           if (!first) {
             result.write(', ');
           }
           first = false;
           result.write(k);
           result.write(': ');
           result.write(v);
         }, dart.void, [dart.dynamic, dart.dynamic]));
         result.write('}');
       } finally {
         dart.assert(core.identical(IterableBase._toStringVisiting[dartx.last], m));
         IterableBase._toStringVisiting[dartx.removeLast]();
       }
       return dart.toString(result);
     }
     static _id(x) {
       return x;
     }
     static _fillMapWithMappedIterable(map, iterable, key, value) {
       if (key == null) key = Maps._id;
       if (value == null) value = Maps._id;
       for (let element of iterable) {
-        map.set(dart.dcall(key, element), dart.dcall(value, element));
+        map[dartx.set](dart.dcall(key, element), dart.dcall(value, element));
       }
     }
     static _fillMapWithIterables(map, keys, values) {
       let keyIterator = keys[dartx.iterator];
       let valueIterator = values[dartx.iterator];
       let hasNextKey = keyIterator.moveNext();
       let hasNextValue = valueIterator.moveNext();
       while (dart.notNull(hasNextKey) && dart.notNull(hasNextValue)) {
-        map.set(keyIterator.current, valueIterator.current);
+        map[dartx.set](keyIterator.current, valueIterator.current);
         hasNextKey = keyIterator.moveNext();
         hasNextValue = valueIterator.moveNext();
       }
       if (dart.notNull(hasNextKey) || dart.notNull(hasNextValue)) {
         dart.throw(new core.ArgumentError("Iterables do not have same length."));
       }
     }
   }
   dart.setSignature(Maps, {
     statics: () => ({
@@ skipping 885 matching lines @@
         if (compare === void 0) compare = null;
         if (isValidKey === void 0) isValidKey = null;
         this[_comparator] = dart.as(compare == null ? core.Comparable.compare : compare, core.Comparator$(K));
         this[_validKey] = dart.as(isValidKey != null ? isValidKey : dart.fn(v => dart.is(v, K), core.bool, [core.Object]), _Predicate$(core.Object));
         super._SplayTree();
       }
       static from(other, compare, isValidKey) {
         if (compare === void 0) compare = null;
         if (isValidKey === void 0) isValidKey = null;
         let result = new (SplayTreeMap$(K, V))();
-        other.forEach(dart.fn((k, v) => {
+        other[dartx.forEach](dart.fn((k, v) => {
           result.set(dart.as(k, K), dart.as(v, V));
         }, dart.void, [dart.dynamic, dart.dynamic]));
         return result;
       }
       static fromIterable(iterable, opts) {
         let key = opts && 'key' in opts ? opts.key : null;
         let value = opts && 'value' in opts ? opts.value : null;
         let compare = opts && 'compare' in opts ? opts.compare : null;
         let isValidKey = opts && 'isValidKey' in opts ? opts.isValidKey : null;
         let map = new (SplayTreeMap$(K, V))(compare, isValidKey);
@@ skipping 67 matching lines @@
         }
         if (splayCount != this[_splayCount]) {
           comp = this[_splay](key);
           dart.assert(comp != 0);
         }
         this[_addNewRoot](new (_SplayTreeMapNode$(K, dart.dynamic))(key, value), comp);
         return value;
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
-        other.forEach(dart.fn((key, value) => {
+        other[dartx.forEach](dart.fn((key, value) => {
           dart.as(key, K);
           dart.as(value, V);
           this.set(key, value);
         }, dart.void, [K, V]));
       }
       get isEmpty() {
         return this[_root] == null;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
@@ skipping 96 matching lines @@
         forEach: [dart.void, [dart.functionType(dart.void, [K, V])]],
         clear: [dart.void, []],
         containsKey: [core.bool, [core.Object]],
         containsValue: [core.bool, [core.Object]],
         firstKey: [K, []],
         lastKey: [K, []],
         lastKeyBefore: [K, [K]],
         firstKeyAfter: [K, [K]]
       })
     });
+    dart.defineExtensionMembers(SplayTreeMap, [
+      'get',
+      'remove',
+      'set',
+      'putIfAbsent',
+      'addAll',
+      'forEach',
+      'clear',
+      'containsKey',
+      'containsValue',
+      'isEmpty',
+      'isNotEmpty',
+      'length',
+      'keys',
+      'values'
+    ]);
     return SplayTreeMap;
   });
   let SplayTreeMap = SplayTreeMap$();
   const _workList = Symbol('_workList');
   const _tree = Symbol('_tree');
   const _currentNode = Symbol('_currentNode');
   const _findLeftMostDescendent = Symbol('_findLeftMostDescendent');
   const _getValue = Symbol('_getValue');
   const _rebuildWorkList = Symbol('_rebuildWorkList');
   const _SplayTreeIterator$ = dart.generic(function(T) {
@@ skipping 413 matching lines @@
         let rest = this[_rest];
         if (rest == null) return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
         return this[_computeKeys]()[dartx.any](dart.fn(each => dart.equals(this.get(each), value), core.bool, [dart.dynamic]));
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
-        other.forEach(dart.fn((key, value) => {
+        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(_HashMap$()._isStringKey(key))) {
           let strings = this[_strings];
           return dart.as(strings == null ? null : _HashMap$()._getTableEntry(strings, key), V);
         } else if (dart.notNull(_HashMap$()._isNumericKey(key))) {
@@ skipping 229 matching lines @@
         _isStringKey: [core.bool, [dart.dynamic]],
         _isNumericKey: [core.bool, [dart.dynamic]],
         _hasTableEntry: [core.bool, [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]],
         _newHashTable: [dart.dynamic, []]
       }),
       names: ['_isStringKey', '_isNumericKey', '_hasTableEntry', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
+    dart.defineExtensionMembers(_HashMap, [
+      'containsKey',
+      'containsValue',
+      'addAll',
+      'get',
+      'set',
+      'putIfAbsent',
+      'remove',
+      'clear',
+      'forEach',
+      'length',
+      'isEmpty',
+      'isNotEmpty',
+      'keys',
+      'values'
+    ]);
     return _HashMap;
   });
   let _HashMap = _HashMap$();
   const _IdentityHashMap$ = dart.generic(function(K, V) {
     class _IdentityHashMap extends _HashMap$(K, V) {
       _IdentityHashMap() {
         super._HashMap();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
@@ skipping 54 matching lines @@
       }
     }
     dart.setSignature(_CustomHashMap, {
       constructors: () => ({_CustomHashMap: [_CustomHashMap$(K, V), [_Equality$(K), _Hasher$(K), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         get: [V, [core.Object]],
         set: [dart.void, [K, V]],
         remove: [V, [core.Object]]
       })
     });
+    dart.defineExtensionMembers(_CustomHashMap, ['get', 'set', 'containsKey', 'remove']);
     return _CustomHashMap;
   });
   let _CustomHashMap = _CustomHashMap$();
   const HashMapKeyIterable$ = dart.generic(function(E) {
     class HashMapKeyIterable extends IterableBase$(E) {
       HashMapKeyIterable(map) {
         this[_map] = map;
         super.IterableBase();
       }
       get length() {
@@ skipping 120 matching lines @@
         let rest = this[_rest];
         if (rest == null) return false;
         let bucket = this[_getBucket](rest, key);
         return dart.notNull(this[_findBucketIndex](bucket, key)) >= 0;
       }
       containsValue(value) {
         return this.keys[dartx.any](dart.fn(each => dart.equals(this.get(each), value), core.bool, [K]));
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
-        other.forEach(dart.fn((key, value) => {
+        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(_LinkedHashMap$()._isStringKey(key))) {
           let strings = this[_strings];
           if (strings == null) return null;
           let cell = dart.as(_LinkedHashMap$()._getTableEntry(strings, key), LinkedHashMapCell);
@@ skipping 225 matching lines @@
       statics: () => ({
         _isStringKey: [core.bool, [dart.dynamic]],
         _isNumericKey: [core.bool, [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]],
         _newHashTable: [dart.dynamic, []]
       }),
       names: ['_isStringKey', '_isNumericKey', '_getTableEntry', '_setTableEntry', '_deleteTableEntry', '_newHashTable']
     });
+    dart.defineExtensionMembers(_LinkedHashMap, [
+      'containsKey',
+      'containsValue',
+      'addAll',
+      'get',
+      'set',
+      'putIfAbsent',
+      'remove',
+      'clear',
+      'forEach',
+      'length',
+      'isEmpty',
+      'isNotEmpty',
+      'keys',
+      'values'
+    ]);
     return _LinkedHashMap;
   });
   let _LinkedHashMap = _LinkedHashMap$();
   const _LinkedIdentityHashMap$ = dart.generic(function(K, V) {
     class _LinkedIdentityHashMap extends _LinkedHashMap$(K, V) {
       _LinkedIdentityHashMap() {
         super._LinkedHashMap();
       }
       [_computeHashCode](key) {
         return core.identityHashCode(key) & 0x3ffffff;
@@ skipping 51 matching lines @@
       }
     }
     dart.setSignature(_LinkedCustomHashMap, {
       constructors: () => ({_LinkedCustomHashMap: [_LinkedCustomHashMap$(K, V), [_Equality$(K), _Hasher$(K), dart.functionType(core.bool, [core.Object])]]}),
       methods: () => ({
         get: [V, [core.Object]],
         set: [dart.void, [K, V]],
         remove: [V, [core.Object]]
       })
     });
+    dart.defineExtensionMembers(_LinkedCustomHashMap, ['get', 'set', 'containsKey', 'remove']);
     return _LinkedCustomHashMap;
   });
   let _LinkedCustomHashMap = _LinkedCustomHashMap$();
   class LinkedHashMapCell extends core.Object {
     LinkedHashMapCell(key, value) {
       this[_key] = key;
       this[_value] = value;
       this[_next] = null;
       this[_previous] = null;
     }
@@ skipping 956 matching lines @@
   exports.LinkedHashMapKeyIterable$ = LinkedHashMapKeyIterable$;
   exports.LinkedHashMapKeyIterable = LinkedHashMapKeyIterable;
   exports.LinkedHashMapKeyIterator$ = LinkedHashMapKeyIterator$;
   exports.LinkedHashMapKeyIterator = LinkedHashMapKeyIterator;
   exports.HashSetIterator$ = HashSetIterator$;
   exports.HashSetIterator = HashSetIterator;
   exports.LinkedHashSetCell = LinkedHashSetCell;
   exports.LinkedHashSetIterator$ = LinkedHashSetIterator$;
   exports.LinkedHashSetIterator = LinkedHashSetIterator;
 });