fix for static methods and names banned in strict mode

lib/runtime/dart/convert.js

 var convert;
 (function(exports) {
   'use strict';
   let ASCII = new AsciiCodec();
   let _ASCII_MASK = 127;
   let _allowInvalid = Symbol('_allowInvalid');
+  let _nameToEncoding = Symbol('_nameToEncoding');
   let Codec$ = dart.generic(function(S, T) {
     class Codec extends core.Object {
       Codec() {
       }
       encode(input) {
         return this.encoder.convert(input);
       }
       decode(encoded) {
         return this.decoder.convert(encoded);
       }
@@ skipping 11 matching lines @@
     Encoding() {
       super.Codec();
     }
     decodeStream(byteStream) {
       return dart.as(byteStream.transform(dart.as(this.decoder, async.StreamTransformer$(core.List$(core.int), dynamic))).fold(new core.StringBuffer(), (buffer, string) => dart.dinvoke(buffer, 'write', string), buffer).then((buffer) => dart.dinvoke(buffer, 'toString')), async.Future$(core.String));
     }
     static getByName(name) {
       if (name === null)
         return null;
       name = name.toLowerCase();
-      return _nameToEncoding.get(name);
+      return Encoding[_nameToEncoding].get(name);
     }
   }
   dart.defineLazyProperties(Encoding, {
     get _nameToEncoding() {
       return dart.map({"iso_8859-1:1987": LATIN1, "iso-ir-100": LATIN1, "iso_8859-1": LATIN1, "iso-8859-1": LATIN1, latin1: LATIN1, l1: LATIN1, ibm819: LATIN1, cp819: LATIN1, csisolatin1: LATIN1, "iso-ir-6": ASCII, "ansi_x3.4-1968": ASCII, "ansi_x3.4-1986": ASCII, "iso_646.irv:1991": ASCII, "iso646-us": ASCII, "us-ascii": ASCII, us: ASCII, ibm367: ASCII, cp367: ASCII, csascii: ASCII, ascii: ASCII, csutf8: UTF8, "utf-8": UTF8});
     },
     set _nameToEncoding(_) {}
   });
   class AsciiCodec extends Encoding {
     AsciiCodec(opts) {
@@ skipping 273 matching lines @@
       super.ByteConversionSinkBase();
     }
     add(chunk) {
       return this[_sink].add(chunk);
     }
     close() {
       return this[_sink].close();
     }
   }
   let _buffer = Symbol('_buffer');
+  let _INITIAL_BUFFER_SIZE = Symbol('_INITIAL_BUFFER_SIZE');
   let _callback = Symbol('_callback');
   let _bufferIndex = Symbol('_bufferIndex');
-  let _roundToPowerOf2$ = Symbol('_roundToPowerOf2');
+  let _roundToPowerOf2 = Symbol('_roundToPowerOf2');
   class _ByteCallbackSink extends ByteConversionSinkBase {
     _ByteCallbackSink(callback) {
-      this[_buffer] = new typed_data.Uint8List(_ByteCallbackSink._INITIAL_BUFFER_SIZE);
+      this[_buffer] = new typed_data.Uint8List(_ByteCallbackSink[_INITIAL_BUFFER_SIZE]);
       this[_callback] = callback;
       this[_bufferIndex] = 0;
       super.ByteConversionSinkBase();
     }
     add(chunk) {
       let freeCount = dart.notNull(this[_buffer].length) - dart.notNull(this[_bufferIndex]);
       if (dart.notNull(chunk.length) > dart.notNull(freeCount)) {
         let oldLength = this[_buffer].length;
-        let newLength = dart.notNull(_roundToPowerOf2(dart.notNull(chunk.length) + dart.notNull(oldLength))) * 2;
+        let newLength = dart.notNull(_ByteCallbackSink[_roundToPowerOf2](dart.notNull(chunk.length) + dart.notNull(oldLength))) * 2;
         let grown = new typed_data.Uint8List(newLength);
         grown.setRange(0, this[_buffer].length, this[_buffer]);
         this[_buffer] = grown;
       }
       this[_buffer].setRange(this[_bufferIndex], dart.notNull(this[_bufferIndex]) + dart.notNull(chunk.length), chunk);
       this[_bufferIndex] = chunk.length;
     }
-    static [_roundToPowerOf2$](v) {
+    static [_roundToPowerOf2](v) {
       dart.assert(dart.notNull(v) > 0);
       v = dart.notNull(v) - 1;
       v = dart.notNull(v) >> 1;
       v = dart.notNull(v) >> 2;
       v = dart.notNull(v) >> 4;
       v = dart.notNull(v) >> 8;
       v = dart.notNull(v) >> 16;
       v = dart.notNull(v) + 1;
       return v;
     }
@@ skipping 109 matching lines @@
       }
       startChunkedConversion(sink) {
         return this[_first].startChunkedConversion(this[_second].startChunkedConversion(sink));
       }
     }
     return _FusedConverter;
   });
   let _FusedConverter = _FusedConverter$(dart.dynamic, dart.dynamic, dart.dynamic);
   let HTML_ESCAPE = new HtmlEscape();
   let _name = Symbol('_name');
+  let _$ = Symbol('_');
   class HtmlEscapeMode extends core.Object {
     HtmlEscapeMode$_(name$, escapeLtGt, escapeQuot, escapeApos, escapeSlash) {
       this[_name] = name$;
       this.escapeLtGt = escapeLtGt;
       this.escapeQuot = escapeQuot;
       this.escapeApos = escapeApos;
       this.escapeSlash = escapeSlash;
     }
     toString() {
       return this[_name];
     }
   }
-  dart.defineNamedConstructor(HtmlEscapeMode, '_');
+  dart.defineNamedConstructor(HtmlEscapeMode, _$);
   HtmlEscapeMode.UNKNOWN = new HtmlEscapeMode._('unknown', true, true, true, true);
   HtmlEscapeMode.ATTRIBUTE = new HtmlEscapeMode._('attribute', false, true, false, false);
   HtmlEscapeMode.ELEMENT = new HtmlEscapeMode._('element', true, false, false, true);
   let _convert = Symbol('_convert');
   class HtmlEscape extends Converter$(core.String, core.String) {
     HtmlEscape(mode) {
       if (mode === void 0)
         mode = HtmlEscapeMode.UNKNOWN;
       this.mode = mode;
       super.Converter();
@@ skipping 169 matching lines @@
     }
     fuse(other) {
       if (dart.is(other, Utf8Encoder)) {
         return new JsonUtf8Encoder(this.indent, dart.as(this[_toEncodable$], dart.throw_("Unimplemented type (Object) → dynamic")));
       }
       return super.fuse(other);
     }
   }
   dart.defineNamedConstructor(JsonEncoder, 'withIndent');
   let _indent = Symbol('_indent');
+  let _utf8Encode = Symbol('_utf8Encode');
   let _bufferSize = Symbol('_bufferSize');
-  let _utf8Encode$ = Symbol('_utf8Encode');
   class JsonUtf8Encoder extends Converter$(core.Object, core.List$(core.int)) {
     JsonUtf8Encoder(indent, toEncodable, bufferSize) {
       if (indent === void 0)
         indent = null;
       if (toEncodable === void 0)
         toEncodable = null;
       if (bufferSize === void 0)
         bufferSize = JsonUtf8Encoder.DEFAULT_BUFFER_SIZE;
-      this[_indent] = _utf8Encode(indent);
+      this[_indent] = JsonUtf8Encoder[_utf8Encode](indent);
       this[_toEncodable$] = toEncodable;
       this[_bufferSize] = bufferSize;
       super.Converter();
     }
-    static [_utf8Encode$](string) {
+    static [_utf8Encode](string) {
       if (string === null)
         return null;
       if (string.isEmpty)
         return new typed_data.Uint8List(0);
       checkAscii: {
         for (let i = 0; dart.notNull(i) < dart.notNull(string.length); i = dart.notNull(i) + 1) {
           if (dart.notNull(string.codeUnitAt(i)) >= 128)
             break checkAscii;
         }
         return string.codeUnits;
@@ skipping 165 matching lines @@
             case _JsonStringifier.FORM_FEED:
               this.writeCharCode(_JsonStringifier.CHAR_f);
               break;
             case _JsonStringifier.CARRIAGE_RETURN:
               this.writeCharCode(_JsonStringifier.CHAR_r);
               break;
             default:
               this.writeCharCode(_JsonStringifier.CHAR_u);
               this.writeCharCode(_JsonStringifier.CHAR_0);
               this.writeCharCode(_JsonStringifier.CHAR_0);
-              this.writeCharCode(hexDigit(dart.notNull(charCode) >> 4 & 15));
-              this.writeCharCode(hexDigit(dart.notNull(charCode) & 15));
+              this.writeCharCode(_JsonStringifier.hexDigit(dart.notNull(charCode) >> 4 & 15));
+              this.writeCharCode(_JsonStringifier.hexDigit(dart.notNull(charCode) & 15));
               break;
           }
         } else if (charCode === _JsonStringifier.QUOTE || charCode === _JsonStringifier.BACKSLASH) {
           if (dart.notNull(i) > dart.notNull(offset))
             this.writeStringSlice(s, offset, i);
           offset = dart.notNull(i) + 1;
           this.writeCharCode(_JsonStringifier.BACKSLASH);
           this.writeCharCode(charCode);
         }
       }
@@ skipping 152 matching lines @@
       }
     }
   }
   class _JsonStringStringifier extends _JsonStringifier {
     _JsonStringStringifier(sink$, _toEncodable) {
       this[_sink] = sink$;
       super._JsonStringifier(dart.as(_toEncodable, dart.throw_("Unimplemented type (Object) → Object")));
     }
     static stringify(object, toEncodable, indent) {
       let output = new core.StringBuffer();
-      printOn(object, output, toEncodable, indent);
+      _JsonStringStringifier.printOn(object, output, toEncodable, indent);
       return output.toString();
     }
     static printOn(object, output, toEncodable, indent) {
       let stringifier = null;
       if (indent === null) {
         stringifier = new _JsonStringStringifier(output, toEncodable);
       } else {
         stringifier = new _JsonStringStringifierPretty(output, toEncodable, indent);
       }
       dart.dinvoke(stringifier, 'writeObject', object);
@@ skipping 262 matching lines @@
       return lines;
     }
     startChunkedConversion(sink) {
       if (!dart.is(sink, StringConversionSink)) {
         sink = new StringConversionSink.from(sink);
       }
       return new _LineSplitterSink(dart.as(sink, StringConversionSink));
     }
   }
   let _carry = Symbol('_carry');
-  let _addSlice$ = Symbol('_addSlice');
+  let _addSlice = Symbol('_addSlice');
+  let _LF = Symbol('_LF');
+  let _CR = Symbol('_CR');
   class _LineSplitterSink extends StringConversionSinkBase {
     _LineSplitterSink(sink$) {
       this[_sink] = sink$;
       this[_carry] = null;
       super.StringConversionSinkBase();
     }
     addSlice(chunk, start, end, isLast) {
       if (this[_carry] !== null) {
         chunk = core.String['+'](this[_carry], chunk.substring(start, end));
         start = 0;
         end = chunk.length;
         this[_carry] = null;
       }
-      this[_carry] = _addSlice(chunk, start, end, isLast, this[_sink].add);
+      this[_carry] = _LineSplitterSink[_addSlice](chunk, start, end, isLast, this[_sink].add);
       if (isLast)
         this[_sink].close();
     }
     close() {
       this.addSlice('', 0, 0, true);
     }
-    static [_addSlice$](chunk, start, end, isLast, adder) {
+    static [_addSlice](chunk, start, end, isLast, adder) {
       let pos = start;
       while (dart.notNull(pos) < dart.notNull(end)) {
         let skip = 0;
         let char = chunk.codeUnitAt(pos);
-        if (char === _LineSplitterSink._LF) {
+        if (char === _LineSplitterSink[_LF]) {
           skip = 1;
-        } else if (char === _LineSplitterSink._CR) {
+        } else if (char === _LineSplitterSink[_CR]) {
           skip = 1;
           if (dart.notNull(pos) + 1 < dart.notNull(end)) {
-            if (chunk.codeUnitAt(dart.notNull(pos) + 1) === _LineSplitterSink._LF) {
+            if (chunk.codeUnitAt(dart.notNull(pos) + 1) === _LineSplitterSink[_LF]) {
               skip = 2;
             }
           } else if (!dart.notNull(isLast)) {
             return chunk.substring(start, end);
           }
         }
         if (dart.notNull(skip) > 0) {
           adder(chunk.substring(start, pos));
           start = pos = dart.notNull(pos) + dart.notNull(skip);
         } else {
@@ skipping 55 matching lines @@
         o = "";
       return this[_sink].writeln(o);
     }
     writeAll(objects, separator) {
       if (separator === void 0)
         separator = "";
       return this[_sink].writeAll(objects, separator);
     }
   }
   let _flush = Symbol('_flush');
+  let _MIN_STRING_SIZE = Symbol('_MIN_STRING_SIZE');
   class _StringConversionSinkAsStringSinkAdapter extends core.Object {
     _StringConversionSinkAsStringSinkAdapter(chunkedSink) {
       this[_chunkedSink] = chunkedSink;
       this[_buffer] = new core.StringBuffer();
     }
     close() {
       if (this[_buffer].isNotEmpty)
         this[_flush]();
       this[_chunkedSink].close();
     }
     writeCharCode(charCode) {
       this[_buffer].writeCharCode(charCode);
-      if (dart.notNull(this[_buffer].length) > dart.notNull(_StringConversionSinkAsStringSinkAdapter._MIN_STRING_SIZE))
+      if (dart.notNull(this[_buffer].length) > dart.notNull(_StringConversionSinkAsStringSinkAdapter[_MIN_STRING_SIZE]))
         this[_flush]();
     }
     write(o) {
       if (this[_buffer].isNotEmpty)
         this[_flush]();
       let str = o.toString();
       this[_chunkedSink].add(o.toString());
     }
     writeln(o) {
       if (o === void 0)
         o = "";
       this[_buffer].writeln(o);
-      if (dart.notNull(this[_buffer].length) > dart.notNull(_StringConversionSinkAsStringSinkAdapter._MIN_STRING_SIZE))
+      if (dart.notNull(this[_buffer].length) > dart.notNull(_StringConversionSinkAsStringSinkAdapter[_MIN_STRING_SIZE]))
         this[_flush]();
     }
     writeAll(objects, separator) {
       if (separator === void 0)
         separator = "";
       if (this[_buffer].isNotEmpty)
         this[_flush]();
       let iterator = objects.iterator;
       if (!dart.notNull(iterator.moveNext()))
         return;
@@ skipping 130 matching lines @@
       if (this[_buffer].isNotEmpty) {
         let accumulated = this[_buffer].toString();
         this[_chunkedSink].addSlice(accumulated, 0, accumulated.length, isLast);
         this[_buffer].clear();
         return;
       }
       if (isLast)
         this.close();
     }
   }
-  dart.defineNamedConstructor(_Utf8ConversionSink, '_');
+  dart.defineNamedConstructor(_Utf8ConversionSink, _$);
   let UNICODE_REPLACEMENT_CHARACTER_RUNE = 65533;
   let UNICODE_BOM_CHARACTER_RUNE = 65279;
   let UTF8 = new Utf8Codec();
   let _allowMalformed = Symbol('_allowMalformed');
   class Utf8Codec extends Encoding {
     Utf8Codec(opts) {
       let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : false;
       this[_allowMalformed] = allowMalformed;
       super.Encoding();
     }
@@ skipping 44 matching lines @@
       if (!dart.is(sink, ByteConversionSink)) {
         sink = new ByteConversionSink.from(sink);
       }
       return new _Utf8EncoderSink(dart.as(sink, ByteConversionSink));
     }
     bind(stream) {
       return dart.as(super.bind(stream), async.Stream$(core.List$(core.int)));
     }
   }
   let _Utf8Encoder$withBufferSize = Symbol('_Utf8Encoder$withBufferSize');
-  let _createBuffer$ = Symbol('_createBuffer');
+  let _DEFAULT_BYTE_BUFFER_SIZE = Symbol('_DEFAULT_BYTE_BUFFER_SIZE');
+  let _createBuffer = Symbol('_createBuffer');
   let _writeSurrogate = Symbol('_writeSurrogate');
   let _fillBuffer = Symbol('_fillBuffer');
   class _Utf8Encoder extends core.Object {
     _Utf8Encoder() {
-      this[_Utf8Encoder$withBufferSize](_Utf8Encoder._DEFAULT_BYTE_BUFFER_SIZE);
+      this[_Utf8Encoder$withBufferSize](_Utf8Encoder[_DEFAULT_BYTE_BUFFER_SIZE]);
     }
     _Utf8Encoder$withBufferSize(bufferSize) {
-      this[_buffer] = _createBuffer(bufferSize);
+      this[_buffer] = _Utf8Encoder[_createBuffer](bufferSize);
       this[_carry] = 0;
       this[_bufferIndex] = 0;
     }
-    static [_createBuffer$](size) {
+    static [_createBuffer](size) {
       return new typed_data.Uint8List(size);
     }
     [_writeSurrogate](leadingSurrogate, nextCodeUnit) {
       if (_isTailSurrogate(nextCodeUnit)) {
         let rune = _combineSurrogatePair(leadingSurrogate, nextCodeUnit);
         dart.assert(dart.notNull(rune) > dart.notNull(_THREE_BYTE_LIMIT));
         dart.assert(dart.notNull(rune) <= dart.notNull(_FOUR_BYTE_LIMIT));
         this[_buffer].set(((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 240 | dart.notNull(rune) >> 18);
         this[_buffer].set(((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(rune) >> 12 & 63);
         this[_buffer].set(((x$) => this[_bufferIndex] = dart.notNull(x$) + 1, x$).bind(this)(this[_bufferIndex]), 128 | dart.notNull(rune) >> 6 & 63);
@@ skipping 154 matching lines @@
     return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_TAG_MASK)) === _TAIL_SURROGATE_MIN;
   }
   // Function _combineSurrogatePair: (int, int) → int
   function _combineSurrogatePair(lead, tail) {
     return 65536 + ((dart.notNull(lead) & dart.notNull(_SURROGATE_VALUE_MASK)) << 10) | dart.notNull(tail) & dart.notNull(_SURROGATE_VALUE_MASK);
   }
   let _isFirstCharacter = Symbol('_isFirstCharacter');
   let _value = Symbol('_value');
   let _expectedUnits = Symbol('_expectedUnits');
   let _extraUnits = Symbol('_extraUnits');
+  let _LIMITS = Symbol('_LIMITS');
   class _Utf8Decoder extends core.Object {
     _Utf8Decoder(stringSink$, allowMalformed$) {
       this[_stringSink] = stringSink$;
       this[_allowMalformed] = allowMalformed$;
       this[_isFirstCharacter] = true;
       this[_value] = 0;
       this[_expectedUnits] = 0;
       this[_extraUnits] = 0;
     }
     get hasPartialInput() {
@@ skipping 54 matching lines @@
                   }
                   this[_isFirstCharacter] = false;
                   this[_stringSink].writeCharCode(UNICODE_REPLACEMENT_CHARACTER_RUNE);
                   break multibyte;
                 } else {
                   value = dart.notNull(value) << 6 | dart.notNull(unit) & 63;
                   expectedUnits = dart.notNull(expectedUnits) - 1;
                   i = dart.notNull(i) + 1;
                 }
               } while (dart.notNull(expectedUnits) > 0);
-              if (dart.notNull(value) <= dart.notNull(_Utf8Decoder._LIMITS.get(dart.notNull(extraUnits) - 1))) {
+              if (dart.notNull(value) <= dart.notNull(_Utf8Decoder[_LIMITS].get(dart.notNull(extraUnits) - 1))) {
                 if (!dart.notNull(this[_allowMalformed])) {
                   throw new core.FormatException(`Overlong encoding of 0x${value.toRadixString(16)}`);
                 }
                 expectedUnits = extraUnits = 0;
                 value = UNICODE_REPLACEMENT_CHARACTER_RUNE;
               }
               if (dart.notNull(value) > dart.notNull(_FOUR_BYTE_LIMIT)) {
                 if (!dart.notNull(this[_allowMalformed])) {
                   throw new core.FormatException("Character outside valid Unicode range: " + `0x${value.toRadixString(16)}`);
                 }
@@ skipping 94 matching lines @@
     }
     if (Object.getPrototypeOf(object) !== Array.prototype) {
       return new _JsonMap(object);
     }
     for (let i = 0; dart.notNull(i) < object.length; i = dart.notNull(i) + 1) {
       let item = object[i];
       object[i] = _convertJsonToDartLazy(item);
     }
     return object;
   }
+  let _newJavaScriptObject = Symbol('_newJavaScriptObject');
   let _data = Symbol('_data');
   let _isUpgraded = Symbol('_isUpgraded');
   let _upgradedMap = Symbol('_upgradedMap');
+  let _getProperty = Symbol('_getProperty');
+  let _isUnprocessed = Symbol('_isUnprocessed');
   let _process = Symbol('_process');
   let _computeKeys = Symbol('_computeKeys');
+  let _setProperty = Symbol('_setProperty');
   let _upgrade = Symbol('_upgrade');
-  let _hasProperty$ = Symbol('_hasProperty');
-  let _getProperty$ = Symbol('_getProperty');
-  let _setProperty$ = Symbol('_setProperty');
-  let _getPropertyNames$ = Symbol('_getPropertyNames');
-  let _isUnprocessed$ = Symbol('_isUnprocessed');
-  let _newJavaScriptObject$ = Symbol('_newJavaScriptObject');
+  let _hasProperty = Symbol('_hasProperty');
+  let _getPropertyNames = Symbol('_getPropertyNames');
   class _JsonMap extends core.Object {
     _JsonMap(original$) {
-      this[_processed] = _newJavaScriptObject();
+      this[_processed] = _JsonMap[_newJavaScriptObject]();
       this[_original] = original$;
       this[_data] = null;
     }
     get(key) {
       if (this[_isUpgraded]) {
         return this[_upgradedMap].get(key);
       } else if (!(typeof key == string)) {
         return null;
       } else {
-        let result = _getProperty(this[_processed], dart.as(key, core.String));
-        if (_isUnprocessed(result))
+        let result = _JsonMap[_getProperty](this[_processed], dart.as(key, core.String));
+        if (_JsonMap[_isUnprocessed](result))
           result = this[_process](dart.as(key, core.String));
         return result;
       }
     }
     get length() {
       return this[_isUpgraded] ? this[_upgradedMap].length : this[_computeKeys]().length;
     }
     get isEmpty() {
       return this.length === 0;
     }
     get isNotEmpty() {
       return dart.notNull(this.length) > 0;
     }
     get keys() {
       if (this[_isUpgraded])
         return this[_upgradedMap].keys;
       return new _JsonMapKeyIterable(this);
     }
     get values() {
       if (this[_isUpgraded])
         return this[_upgradedMap].values;
       return new _internal.MappedIterable(this[_computeKeys](), ((each) => this.get(each)).bind(this));
     }
     set(key, value) {
       if (this[_isUpgraded]) {
         this[_upgradedMap].set(key, value);
       } else if (this.containsKey(key)) {
         let processed = this[_processed];
-        _setProperty(processed, dart.as(key, core.String), value);
+        _JsonMap[_setProperty](processed, dart.as(key, core.String), value);
         let original = this[_original];
         if (!dart.notNull(core.identical(original, processed))) {
-          _setProperty(original, dart.as(key, core.String), null);
+          _JsonMap[_setProperty](original, dart.as(key, core.String), null);
         }
       } else {
         this[_upgrade]().set(key, value);
       }
     }
     addAll(other) {
       other.forEach(((key, value) => {
         this.set(key, value);
       }).bind(this));
     }
     containsValue(value) {
       if (this[_isUpgraded])
         return this[_upgradedMap].containsValue(value);
       let keys = this[_computeKeys]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
         let key = keys.get(i);
         if (dart.equals(this.get(key), value))
           return true;
       }
       return false;
     }
     containsKey(key) {
       if (this[_isUpgraded])
         return this[_upgradedMap].containsKey(key);
       if (!(typeof key == string))
         return false;
-      return _hasProperty(this[_original], dart.as(key, core.String));
+      return _JsonMap[_hasProperty](this[_original], dart.as(key, core.String));
     }
     putIfAbsent(key, ifAbsent) {
       if (this.containsKey(key))
         return this.get(key);
       let value = ifAbsent();
       this.set(key, value);
       return value;
     }
     remove(key) {
       if (!dart.notNull(this[_isUpgraded]) && !dart.notNull(this.containsKey(key)))
@@ skipping 10 matching lines @@
         this[_original] = this[_processed] = null;
         this[_data] = dart.map();
       }
     }
     forEach(f) {
       if (this[_isUpgraded])
         return this[_upgradedMap].forEach(f);
       let keys = this[_computeKeys]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
         let key = keys.get(i);
-        let value = _getProperty(this[_processed], key);
-        if (_isUnprocessed(value)) {
-          value = _convertJsonToDartLazy(_getProperty(this[_original], key));
-          _setProperty(this[_processed], key, value);
+        let value = _JsonMap[_getProperty](this[_processed], key);
+        if (_JsonMap[_isUnprocessed](value)) {
+          value = _convertJsonToDartLazy(_JsonMap[_getProperty](this[_original], key));
+          _JsonMap[_setProperty](this[_processed], key, value);
         }
         dart.dinvokef(f, key, value);
         if (!dart.notNull(core.identical(keys, this[_data]))) {
           throw new core.ConcurrentModificationError(this);
         }
       }
     }
     toString() {
       return collection.Maps.mapToString(this);
     }
     get [_isUpgraded]() {
       return this[_processed] === null;
     }
     get [_upgradedMap]() {
       dart.assert(this[_isUpgraded]);
       return dart.as(this[_data], core.Map);
     }
     [_computeKeys]() {
       dart.assert(!dart.notNull(this[_isUpgraded]));
       let keys = dart.as(this[_data], core.List);
       if (keys === null) {
-        keys = this[_data] = _getPropertyNames(this[_original]);
+        keys = this[_data] = _JsonMap[_getPropertyNames](this[_original]);
       }
       return dart.as(keys, core.List$(core.String));
     }
     [_upgrade]() {
       if (this[_isUpgraded])
         return this[_upgradedMap];
       let result = dart.map();
       let keys = this[_computeKeys]();
       for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
         let key = keys.get(i);
         result.set(key, this.get(key));
       }
       if (keys.isEmpty) {
         keys.add(null);
       } else {
         keys.clear();
       }
       this[_original] = this[_processed] = null;
       this[_data] = result;
       dart.assert(this[_isUpgraded]);
       return result;
     }
     [_process](key) {
-      if (!dart.notNull(_hasProperty(this[_original], key)))
+      if (!dart.notNull(_JsonMap[_hasProperty](this[_original], key)))
         return null;
-      let result = _convertJsonToDartLazy(_getProperty(this[_original], key));
-      return _setProperty(this[_processed], key, result);
+      let result = _convertJsonToDartLazy(_JsonMap[_getProperty](this[_original], key));
+      return _JsonMap[_setProperty](this[_processed], key, result);
     }
-    static [_hasProperty$](object, key) {
+    static [_hasProperty](object, key) {
       return Object.prototype.hasOwnProperty.call(object, key);
     }
-    static [_getProperty$](object, key) {
+    static [_getProperty](object, key) {
       return object[key];
     }
-    static [_setProperty$](object, key, value) {
+    static [_setProperty](object, key, value) {
       return object[key] = value;
     }
-    static [_getPropertyNames$](object) {
+    static [_getPropertyNames](object) {
       return dart.as(Object.keys(object), core.List);
     }
-    static [_isUnprocessed$](object) {
+    static [_isUnprocessed](object) {
       return typeof object == "undefined";
     }
-    static [_newJavaScriptObject$]() {
+    static [_newJavaScriptObject]() {
       return Object.create(null);
     }
   }
   let _parent = Symbol('_parent');
   class _JsonMapKeyIterable extends _internal.ListIterable {
     _JsonMapKeyIterable(parent) {
       this[_parent] = parent;
       super.ListIterable();
     }
     get length() {
@@ skipping 58 matching lines @@
   exports.LineSplitter = LineSplitter;
   exports.StringConversionSink = StringConversionSink;
   exports.ClosableStringSink = ClosableStringSink;
   exports.UNICODE_REPLACEMENT_CHARACTER_RUNE = UNICODE_REPLACEMENT_CHARACTER_RUNE;
   exports.UNICODE_BOM_CHARACTER_RUNE = UNICODE_BOM_CHARACTER_RUNE;
   exports.UTF8 = UTF8;
   exports.Utf8Codec = Utf8Codec;
   exports.Utf8Encoder = Utf8Encoder;
   exports.Utf8Decoder = Utf8Decoder;
 })(convert || (convert = {}));