Use const for const/final top-levels, types, symbols.

lib/runtime/dart/convert.js

 dart_library.library('dart/convert', null, /* Imports */[
   "dart/_runtime",
   'dart/core',
   'dart/async',
   'dart/typed_data',
   'dart/_internal',
   'dart/collection'
 ], /* Lazy imports */[
 ], function(exports, dart, core, async, typed_data, _internal, collection) {
   'use strict';
   let dartx = dart.dartx;
-  let Codec$ = dart.generic(function(S, T) {
+  const Codec$ = dart.generic(function(S, T) {
     class Codec extends core.Object {
       Codec() {
       }
       encode(input) {
         dart.as(input, S);
         return this.encoder.convert(input);
       }
       decode(encoded) {
         dart.as(encoded, T);
         return this.decoder.convert(encoded);
@@ skipping 33 matching lines @@
       name = name[dartx.toLowerCase]();
       return Encoding._nameToEncoding.get(name);
     }
   }
   dart.setSignature(Encoding, {
     constructors: () => ({Encoding: [Encoding, []]}),
     methods: () => ({decodeStream: [async.Future$(core.String), [async.Stream$(core.List$(core.int))]]}),
     statics: () => ({getByName: [Encoding, [core.String]]}),
     names: ['getByName']
   });
-  let _allowInvalid = Symbol('_allowInvalid');
+  const _allowInvalid = Symbol('_allowInvalid');
   class AsciiCodec extends Encoding {
     AsciiCodec(opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       this[_allowInvalid] = allowInvalid;
       super.Encoding();
     }
     get name() {
       return "us-ascii";
     }
     decode(bytes, opts) {
@@ skipping 10 matching lines @@
       return dart.const(new AsciiEncoder());
     }
     get decoder() {
       return dart.notNull(this[_allowInvalid]) ? dart.const(new AsciiDecoder({allowInvalid: true})) : dart.const(new AsciiDecoder({allowInvalid: false}));
     }
   }
   dart.setSignature(AsciiCodec, {
     constructors: () => ({AsciiCodec: [AsciiCodec, [], {allowInvalid: core.bool}]}),
     methods: () => ({decode: [core.String, [core.List$(core.int)], {allowInvalid: core.bool}]})
   });
-  let ASCII = dart.const(new AsciiCodec());
-  let _ASCII_MASK = 127;
-  let Converter$ = dart.generic(function(S, T) {
+  const ASCII = dart.const(new AsciiCodec());
+  const _ASCII_MASK = 127;
+  const Converter$ = dart.generic(function(S, T) {
     class Converter extends core.Object {
       Converter() {
       }
       fuse(other) {
         dart.as(other, Converter$(T, dart.dynamic));
         return new (_FusedConverter$(S, T, dart.dynamic))(this, other);
       }
       startChunkedConversion(sink) {
         dart.as(sink, core.Sink$(T));
         dart.throw(new core.UnsupportedError(`This converter does not support chunked conversions: ${this}`));
       }
       bind(source) {
         dart.as(source, async.Stream$(S));
         return async.Stream$(T).eventTransformed(source, dart.fn((sink => new _ConverterStreamEventSink(this, sink)).bind(this), _ConverterStreamEventSink, [async.EventSink]));
       }
     }
     Converter[dart.implements] = () => [async.StreamTransformer$(S, T)];
     dart.setSignature(Converter, {
       constructors: () => ({Converter: [Converter$(S, T), []]}),
       methods: () => ({
         fuse: [Converter$(S, dart.dynamic), [Converter$(T, dart.dynamic)]],
         startChunkedConversion: [ChunkedConversionSink, [core.Sink$(T)]],
         bind: [async.Stream$(T), [async.Stream$(S)]]
       })
     });
     return Converter;
   });
   let Converter = Converter$();
-  let _subsetMask = Symbol('_subsetMask');
+  const _subsetMask = Symbol('_subsetMask');
   class _UnicodeSubsetEncoder extends Converter$(core.String, core.List$(core.int)) {
     _UnicodeSubsetEncoder(subsetMask) {
       this[_subsetMask] = subsetMask;
       super.Converter();
     }
     convert(string, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
@@ skipping 51 matching lines @@
   }
   StringConversionSinkMixin[dart.implements] = () => [StringConversionSink];
   dart.setSignature(StringConversionSinkMixin, {
     methods: () => ({
       add: [dart.void, [core.String]],
       asUtf8Sink: [ByteConversionSink, [core.bool]],
       asStringSink: [ClosableStringSink, []]
     })
   });
   class StringConversionSinkBase extends StringConversionSinkMixin {}
-  let _sink = Symbol('_sink');
+  const _sink = Symbol('_sink');
   class _UnicodeSubsetEncoderSink extends StringConversionSinkBase {
     _UnicodeSubsetEncoderSink(subsetMask, sink) {
       this[_subsetMask] = subsetMask;
       this[_sink] = sink;
     }
     close() {
       this[_sink].close();
     }
     addSlice(source, start, end, isLast) {
       core.RangeError.checkValidRange(start, end, source[dartx.length]);
       for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
         let codeUnit = source[dartx.codeUnitAt](i);
         if ((dart.notNull(codeUnit) & ~dart.notNull(this[_subsetMask])) != 0) {
           dart.throw(new core.ArgumentError(`Source contains invalid character with code point: ${codeUnit}.`));
         }
       }
       this[_sink].add(source[dartx.codeUnits][dartx.sublist](start, end));
       if (dart.notNull(isLast)) {
         this.close();
       }
     }
   }
   dart.setSignature(_UnicodeSubsetEncoderSink, {
     constructors: () => ({_UnicodeSubsetEncoderSink: [_UnicodeSubsetEncoderSink, [core.int, ByteConversionSink]]}),
     methods: () => ({
       close: [dart.void, []],
       addSlice: [dart.void, [core.String, core.int, core.int, core.bool]]
     })
   });
-  let _convertInvalid = Symbol('_convertInvalid');
+  const _convertInvalid = Symbol('_convertInvalid');
   class _UnicodeSubsetDecoder extends Converter$(core.List$(core.int), core.String) {
     _UnicodeSubsetDecoder(allowInvalid, subsetMask) {
       this[_allowInvalid] = allowInvalid;
       this[_subsetMask] = subsetMask;
       super.Converter();
     }
     convert(bytes, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
@@ skipping 52 matching lines @@
         return new _ErrorHandlingAsciiDecoderSink(stringSink.asUtf8Sink(false));
       } else {
         return new _SimpleAsciiDecoderSink(stringSink);
       }
     }
   }
   dart.setSignature(AsciiDecoder, {
     constructors: () => ({AsciiDecoder: [AsciiDecoder, [], {allowInvalid: core.bool}]}),
     methods: () => ({startChunkedConversion: [ByteConversionSink, [core.Sink$(core.String)]]})
   });
-  let ChunkedConversionSink$ = dart.generic(function(T) {
+  const ChunkedConversionSink$ = dart.generic(function(T) {
     class ChunkedConversionSink extends core.Object {
       ChunkedConversionSink() {
       }
       static withCallback(callback) {
         return new _SimpleCallbackSink(callback);
       }
     }
     ChunkedConversionSink[dart.implements] = () => [core.Sink$(T)];
     dart.setSignature(ChunkedConversionSink, {
       constructors: () => ({
@@ skipping 28 matching lines @@
     }
     addSlice(chunk, start, end, isLast) {
       this.add(chunk[dartx.sublist](start, end));
       if (dart.notNull(isLast))
         this.close();
     }
   }
   dart.setSignature(ByteConversionSinkBase, {
     methods: () => ({addSlice: [dart.void, [core.List$(core.int), core.int, core.int, core.bool]]})
   });
-  let _utf8Sink = Symbol('_utf8Sink');
+  const _utf8Sink = Symbol('_utf8Sink');
   class _ErrorHandlingAsciiDecoderSink extends ByteConversionSinkBase {
     _ErrorHandlingAsciiDecoderSink(utf8Sink) {
       this[_utf8Sink] = utf8Sink;
     }
     close() {
       this[_utf8Sink].close();
     }
     add(source) {
       this.addSlice(source, 0, source[dartx.length], false);
     }
@@ skipping 67 matching lines @@
       return this[_sink].close();
     }
   }
   dart.setSignature(_ByteAdapterSink, {
     constructors: () => ({_ByteAdapterSink: [_ByteAdapterSink, [core.Sink$(core.List$(core.int))]]}),
     methods: () => ({
       add: [dart.void, [core.List$(core.int)]],
       close: [dart.void, []]
     })
   });
-  let _buffer = Symbol('_buffer');
-  let _callback = Symbol('_callback');
-  let _bufferIndex = Symbol('_bufferIndex');
+  const _buffer = Symbol('_buffer');
+  const _callback = Symbol('_callback');
+  const _bufferIndex = Symbol('_bufferIndex');
   class _ByteCallbackSink extends ByteConversionSinkBase {
     _ByteCallbackSink(callback) {
       this[_buffer] = typed_data.Uint8List.new(_ByteCallbackSink._INITIAL_BUFFER_SIZE);
       this[_callback] = callback;
       this[_bufferIndex] = 0;
     }
     add(chunk) {
       let freeCount = dart.notNull(this[_buffer][dartx.length]) - dart.notNull(this[_bufferIndex]);
       if (dart.notNull(chunk[dartx.length]) > dart.notNull(freeCount)) {
         let oldLength = this[_buffer][dartx.length];
@@ skipping 23 matching lines @@
   dart.setSignature(_ByteCallbackSink, {
     constructors: () => ({_ByteCallbackSink: [_ByteCallbackSink, [dart.functionType(dart.void, [core.List$(core.int)])]]}),
     methods: () => ({
       add: [dart.void, [core.Iterable$(core.int)]],
       close: [dart.void, []]
     }),
     statics: () => ({_roundToPowerOf2: [core.int, [core.int]]}),
     names: ['_roundToPowerOf2']
   });
   _ByteCallbackSink._INITIAL_BUFFER_SIZE = 1024;
-  let _ChunkedConversionCallback$ = dart.generic(function(T) {
-    let _ChunkedConversionCallback = dart.typedef('_ChunkedConversionCallback', () => dart.functionType(dart.void, [T]));
+  const _ChunkedConversionCallback$ = dart.generic(function(T) {
+    const _ChunkedConversionCallback = dart.typedef('_ChunkedConversionCallback', () => dart.functionType(dart.void, [T]));
     return _ChunkedConversionCallback;
   });
   let _ChunkedConversionCallback = _ChunkedConversionCallback$();
-  let _accumulated = Symbol('_accumulated');
-  let _SimpleCallbackSink$ = dart.generic(function(T) {
+  const _accumulated = Symbol('_accumulated');
+  const _SimpleCallbackSink$ = dart.generic(function(T) {
     class _SimpleCallbackSink extends ChunkedConversionSink$(T) {
       _SimpleCallbackSink(callback) {
         this[_accumulated] = dart.list([], T);
         this[_callback] = callback;
         super.ChunkedConversionSink();
       }
       add(chunk) {
         dart.as(chunk, T);
         this[_accumulated][dartx.add](chunk);
       }
       close() {
         this[_callback](this[_accumulated]);
       }
     }
     dart.setSignature(_SimpleCallbackSink, {
       constructors: () => ({_SimpleCallbackSink: [_SimpleCallbackSink$(T), [_ChunkedConversionCallback$(core.List$(T))]]}),
       methods: () => ({
         add: [dart.void, [T]],
         close: [dart.void, []]
       })
     });
     return _SimpleCallbackSink;
   });
   let _SimpleCallbackSink = _SimpleCallbackSink$();
-  let _EventSinkAdapter$ = dart.generic(function(T) {
+  const _EventSinkAdapter$ = dart.generic(function(T) {
     class _EventSinkAdapter extends core.Object {
       _EventSinkAdapter(sink) {
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, T);
         return this[_sink].add(data);
       }
       close() {
         return this[_sink].close();
       }
     }
     _EventSinkAdapter[dart.implements] = () => [ChunkedConversionSink$(T)];
     dart.setSignature(_EventSinkAdapter, {
       constructors: () => ({_EventSinkAdapter: [_EventSinkAdapter$(T), [async.EventSink$(T)]]}),
       methods: () => ({
         add: [dart.void, [T]],
         close: [dart.void, []]
       })
     });
     return _EventSinkAdapter;
   });
   let _EventSinkAdapter = _EventSinkAdapter$();
-  let _eventSink = Symbol('_eventSink');
-  let _chunkedSink = Symbol('_chunkedSink');
-  let _ConverterStreamEventSink$ = dart.generic(function(S, T) {
+  const _eventSink = Symbol('_eventSink');
+  const _chunkedSink = Symbol('_chunkedSink');
+  const _ConverterStreamEventSink$ = dart.generic(function(S, T) {
     class _ConverterStreamEventSink extends core.Object {
       _ConverterStreamEventSink(converter, sink) {
         this[_eventSink] = sink;
         this[_chunkedSink] = converter.startChunkedConversion(sink);
       }
       add(o) {
         dart.as(o, S);
         return this[_chunkedSink].add(o);
       }
       addError(error, stackTrace) {
@@ skipping 10 matching lines @@
       constructors: () => ({_ConverterStreamEventSink: [_ConverterStreamEventSink$(S, T), [Converter, async.EventSink$(T)]]}),
       methods: () => ({
         add: [dart.void, [S]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _ConverterStreamEventSink;
   });
   let _ConverterStreamEventSink = _ConverterStreamEventSink$();
-  let _first = Symbol('_first');
-  let _second = Symbol('_second');
-  let _FusedCodec$ = dart.generic(function(S, M, T) {
+  const _first = Symbol('_first');
+  const _second = Symbol('_second');
+  const _FusedCodec$ = dart.generic(function(S, M, T) {
     class _FusedCodec extends Codec$(S, T) {
       get encoder() {
         return dart.as(this[_first].encoder.fuse(this[_second].encoder), Converter$(S, T));
       }
       get decoder() {
         return dart.as(this[_second].decoder.fuse(this[_first].decoder), Converter$(T, S));
       }
       _FusedCodec(first, second) {
         this[_first] = first;
         this[_second] = second;
         super.Codec();
       }
     }
     dart.setSignature(_FusedCodec, {
       constructors: () => ({_FusedCodec: [_FusedCodec$(S, M, T), [Codec$(S, M), Codec$(M, T)]]})
     });
     return _FusedCodec;
   });
   let _FusedCodec = _FusedCodec$();
-  let _codec = Symbol('_codec');
-  let _InvertedCodec$ = dart.generic(function(T, S) {
+  const _codec = Symbol('_codec');
+  const _InvertedCodec$ = dart.generic(function(T, S) {
     class _InvertedCodec extends Codec$(T, S) {
       _InvertedCodec(codec) {
         this[_codec] = codec;
         super.Codec();
       }
       get encoder() {
         return this[_codec].decoder;
       }
       get decoder() {
         return this[_codec].encoder;
       }
       get inverted() {
         return this[_codec];
       }
     }
     dart.setSignature(_InvertedCodec, {
       constructors: () => ({_InvertedCodec: [_InvertedCodec$(T, S), [Codec$(S, T)]]})
     });
     return _InvertedCodec;
   });
   let _InvertedCodec = _InvertedCodec$();
-  let _FusedConverter$ = dart.generic(function(S, M, T) {
+  const _FusedConverter$ = dart.generic(function(S, M, T) {
     class _FusedConverter extends Converter$(S, T) {
       _FusedConverter(first, second) {
         this[_first] = first;
         this[_second] = second;
         super.Converter();
       }
       convert(input) {
         dart.as(input, S);
         return dart.as(this[_second].convert(this[_first].convert(input)), T);
       }
@@ skipping 11 matching lines @@
     });
     return _FusedConverter;
   });
   let _FusedConverter = _FusedConverter$();
   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(_) {}
   });
-  let _name = Symbol('_name');
+  const _name = Symbol('_name');
   class HtmlEscapeMode extends core.Object {
     _(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.setSignature(HtmlEscapeMode, {
     constructors: () => ({_: [HtmlEscapeMode, [core.String, core.bool, core.bool, core.bool, core.bool]]})
   });
   HtmlEscapeMode.UNKNOWN = dart.const(new HtmlEscapeMode._('unknown', true, true, true, true));
-  let _convert = Symbol('_convert');
+  const _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();
     }
     convert(text) {
       let val = this[_convert](text, 0, text[dartx.length]);
       return val == null ? text : val;
@@ skipping 63 matching lines @@
     }
   }
   dart.setSignature(HtmlEscape, {
     constructors: () => ({HtmlEscape: [HtmlEscape, [], [HtmlEscapeMode]]}),
     methods: () => ({
       convert: [core.String, [core.String]],
       [_convert]: [core.String, [core.String, core.int, core.int]],
       startChunkedConversion: [StringConversionSink, [core.Sink$(core.String)]]
     })
   });
-  let HTML_ESCAPE = dart.const(new HtmlEscape());
+  const HTML_ESCAPE = dart.const(new HtmlEscape());
   HtmlEscapeMode.ATTRIBUTE = dart.const(new HtmlEscapeMode._('attribute', false, true, false, false));
   HtmlEscapeMode.ELEMENT = dart.const(new HtmlEscapeMode._('element', true, false, false, true));
-  let _escape = Symbol('_escape');
+  const _escape = Symbol('_escape');
   class _HtmlEscapeSink extends StringConversionSinkBase {
     _HtmlEscapeSink(escape, sink) {
       this[_escape] = escape;
       this[_sink] = sink;
     }
     addSlice(chunk, start, end, isLast) {
       let val = this[_escape][_convert](chunk, start, end);
       if (val == null) {
         this[_sink].addSlice(chunk, start, end, isLast);
       } else {
@@ skipping 35 matching lines @@
     JsonCyclicError(object) {
       super.JsonUnsupportedObjectError(object);
     }
     toString() {
       return "Cyclic error in JSON stringify";
     }
   }
   dart.setSignature(JsonCyclicError, {
     constructors: () => ({JsonCyclicError: [JsonCyclicError, [core.Object]]})
   });
-  let _reviver = Symbol('_reviver');
-  let _toEncodable$ = Symbol('_toEncodable');
+  const _reviver = Symbol('_reviver');
+  const _toEncodable$ = Symbol('_toEncodable');
   class JsonCodec extends Codec$(core.Object, core.String) {
     JsonCodec(opts) {
       let reviver = opts && 'reviver' in opts ? opts.reviver : null;
       let toEncodable = opts && 'toEncodable' in opts ? opts.toEncodable : null;
       this[_reviver] = reviver;
       this[_toEncodable$] = toEncodable;
       super.Codec();
     }
     withReviver(reviver) {
       this.JsonCodec({reviver: reviver});
@@ skipping 29 matching lines @@
   dart.setSignature(JsonCodec, {
     constructors: () => ({
       JsonCodec: [JsonCodec, [], {reviver: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), toEncodable: dart.functionType(dart.dynamic, [dart.dynamic])}],
       withReviver: [JsonCodec, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]]
     }),
     methods: () => ({
       decode: [dart.dynamic, [core.String], {reviver: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])}],
       encode: [core.String, [core.Object], {toEncodable: dart.functionType(dart.dynamic, [dart.dynamic])}]
     })
   });
-  let JSON = dart.const(new JsonCodec());
-  let _Reviver = dart.typedef('_Reviver', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
-  let _ToEncodable = dart.typedef('_ToEncodable', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  const JSON = dart.const(new JsonCodec());
+  const _Reviver = dart.typedef('_Reviver', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
+  const _ToEncodable = dart.typedef('_ToEncodable', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   class JsonEncoder extends Converter$(core.Object, core.String) {
     JsonEncoder(toEncodable) {
       if (toEncodable === void 0)
         toEncodable = null;
       this.indent = null;
       this[_toEncodable$] = toEncodable;
       super.Converter();
     }
     withIndent(indent, toEncodable) {
       if (toEncodable === void 0)
@@ skipping 29 matching lines @@
       JsonEncoder: [JsonEncoder, [], [dart.functionType(core.Object, [core.Object])]],
       withIndent: [JsonEncoder, [core.String], [dart.functionType(core.Object, [core.Object])]]
     }),
     methods: () => ({
       convert: [core.String, [core.Object]],
       startChunkedConversion: [ChunkedConversionSink$(core.Object), [core.Sink$(core.String)]],
       bind: [async.Stream$(core.String), [async.Stream$(core.Object)]],
       fuse: [Converter$(core.Object, dart.dynamic), [Converter$(core.String, dart.dynamic)]]
     })
   });
-  let _indent = Symbol('_indent');
-  let _bufferSize = Symbol('_bufferSize');
+  const _indent = Symbol('_indent');
+  const _bufferSize = Symbol('_bufferSize');
   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] = JsonUtf8Encoder._utf8Encode(indent);
       this[_toEncodable$] = toEncodable;
@@ skipping 61 matching lines @@
     methods: () => ({
       convert: [core.List$(core.int), [core.Object]],
       startChunkedConversion: [ChunkedConversionSink$(core.Object), [core.Sink$(core.List$(core.int))]],
       bind: [async.Stream$(core.List$(core.int)), [async.Stream$(core.Object)]],
       fuse: [Converter$(core.Object, dart.dynamic), [Converter$(core.List$(core.int), dart.dynamic)]]
     }),
     statics: () => ({_utf8Encode: [core.List$(core.int), [core.String]]}),
     names: ['_utf8Encode']
   });
   JsonUtf8Encoder.DEFAULT_BUFFER_SIZE = 256;
-  let _isDone = Symbol('_isDone');
+  const _isDone = Symbol('_isDone');
   class _JsonEncoderSink extends ChunkedConversionSink$(core.Object) {
     _JsonEncoderSink(sink, toEncodable, indent) {
       this[_sink] = sink;
       this[_toEncodable$] = toEncodable;
       this[_indent] = indent;
       this[_isDone] = false;
       super.ChunkedConversionSink();
     }
     add(o) {
       if (dart.notNull(this[_isDone])) {
         dart.throw(new core.StateError("Only one call to add allowed"));
       }
       this[_isDone] = true;
       let stringSink = this[_sink].asStringSink();
       _JsonStringStringifier.printOn(o, stringSink, dart.as(this[_toEncodable$], dart.functionType(dart.dynamic, [dart.dynamic])), this[_indent]);
       stringSink.close();
     }
     close() {}
   }
   dart.setSignature(_JsonEncoderSink, {
     constructors: () => ({_JsonEncoderSink: [_JsonEncoderSink, [StringConversionSink, core.Function, core.String]]}),
     methods: () => ({
       add: [dart.void, [core.Object]],
       close: [dart.void, []]
     })
   });
-  let _addChunk = Symbol('_addChunk');
+  const _addChunk = Symbol('_addChunk');
   class _JsonUtf8EncoderSink extends ChunkedConversionSink$(core.Object) {
     _JsonUtf8EncoderSink(sink, toEncodable, indent, bufferSize) {
       this[_sink] = sink;
       this[_toEncodable$] = toEncodable;
       this[_indent] = indent;
       this[_bufferSize] = bufferSize;
       this[_isDone] = false;
       super.ChunkedConversionSink();
     }
     [_addChunk](chunk, start, end) {
@@ skipping 61 matching lines @@
       return _convertJsonToDartLazy(parsed);
     } else {
       return _convertJsonToDart(parsed, reviver);
     }
   }
   dart.fn(_parseJson, dart.dynamic, [core.String, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]);
   function _defaultToEncodable(object) {
     return dart.dsend(object, 'toJson');
   }
   dart.fn(_defaultToEncodable, core.Object, [dart.dynamic]);
-  let _seen = Symbol('_seen');
-  let _checkCycle = Symbol('_checkCycle');
-  let _removeSeen = Symbol('_removeSeen');
+  const _seen = Symbol('_seen');
+  const _checkCycle = Symbol('_checkCycle');
+  const _removeSeen = Symbol('_removeSeen');
   class _JsonStringifier extends core.Object {
     _JsonStringifier(_toEncodable) {
       this[_seen] = core.List.new();
       this[_toEncodable$] = _toEncodable != null ? _toEncodable : _defaultToEncodable;
     }
     static hexDigit(x) {
       return dart.notNull(x) < 10 ? 48 + dart.notNull(x) : 87 + dart.notNull(x);
     }
     writeStringContent(s) {
       let offset = 0;
@@ skipping 164 matching lines @@
   _JsonStringifier.FORM_FEED = 12;
   _JsonStringifier.QUOTE = 34;
   _JsonStringifier.CHAR_0 = 48;
   _JsonStringifier.BACKSLASH = 92;
   _JsonStringifier.CHAR_b = 98;
   _JsonStringifier.CHAR_f = 102;
   _JsonStringifier.CHAR_n = 110;
   _JsonStringifier.CHAR_r = 114;
   _JsonStringifier.CHAR_t = 116;
   _JsonStringifier.CHAR_u = 117;
-  let _indentLevel = Symbol('_indentLevel');
+  const _indentLevel = Symbol('_indentLevel');
   class _JsonPrettyPrintMixin extends core.Object {
     _JsonPrettyPrintMixin() {
       this[_indentLevel] = 0;
     }
     writeList(list) {
       if (dart.notNull(list[dartx.isEmpty])) {
         this.writeString('[]');
       } else {
         this.writeString('[\n');
         this[_indentLevel] = dart.notNull(this[_indentLevel]) + 1;
@@ skipping 244 matching lines @@
             this.writeByte(indent[dartx.get](i));
           }
         }
       }
     }
   }
   dart.setSignature(_JsonUtf8StringifierPretty, {
     constructors: () => ({_JsonUtf8StringifierPretty: [_JsonUtf8StringifierPretty, [dart.dynamic, core.List$(core.int), dart.dynamic, dart.dynamic]]}),
     methods: () => ({writeIndentation: [dart.void, [core.int]]})
   });
-  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Object, [core.Object]));
-  let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [core.Object]));
+  const __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Object, [core.Object]));
+  const __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  const __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [core.Object]));
   class Latin1Codec extends Encoding {
     Latin1Codec(opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       this[_allowInvalid] = allowInvalid;
       super.Encoding();
     }
     get name() {
       return "iso-8859-1";
     }
     decode(bytes, opts) {
@@ skipping 10 matching lines @@
       return dart.const(new Latin1Encoder());
     }
     get decoder() {
       return dart.notNull(this[_allowInvalid]) ? dart.const(new Latin1Decoder({allowInvalid: true})) : dart.const(new Latin1Decoder({allowInvalid: false}));
     }
   }
   dart.setSignature(Latin1Codec, {
     constructors: () => ({Latin1Codec: [Latin1Codec, [], {allowInvalid: core.bool}]}),
     methods: () => ({decode: [core.String, [core.List$(core.int)], {allowInvalid: core.bool}]})
   });
-  let LATIN1 = dart.const(new Latin1Codec());
-  let _LATIN1_MASK = 255;
+  const LATIN1 = dart.const(new Latin1Codec());
+  const _LATIN1_MASK = 255;
   class Latin1Encoder extends _UnicodeSubsetEncoder {
     Latin1Encoder() {
       super._UnicodeSubsetEncoder(_LATIN1_MASK);
     }
   }
   dart.setSignature(Latin1Encoder, {
     constructors: () => ({Latin1Encoder: [Latin1Encoder, []]})
   });
   class Latin1Decoder extends _UnicodeSubsetDecoder {
     Latin1Decoder(opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       super._UnicodeSubsetDecoder(allowInvalid, _LATIN1_MASK);
     }
     startChunkedConversion(sink) {
       let stringSink = null;
       if (dart.is(sink, StringConversionSink)) {
         stringSink = sink;
       } else {
         stringSink = StringConversionSink.from(sink);
       }
       if (!dart.notNull(this[_allowInvalid]))
         return new _Latin1DecoderSink(stringSink);
       return new _Latin1AllowInvalidDecoderSink(stringSink);
     }
   }
   dart.setSignature(Latin1Decoder, {
     constructors: () => ({Latin1Decoder: [Latin1Decoder, [], {allowInvalid: core.bool}]}),
     methods: () => ({startChunkedConversion: [ByteConversionSink, [core.Sink$(core.String)]]})
   });
-  let _addSliceToSink = Symbol('_addSliceToSink');
+  const _addSliceToSink = Symbol('_addSliceToSink');
   class _Latin1DecoderSink extends ByteConversionSinkBase {
     _Latin1DecoderSink(sink) {
       this[_sink] = sink;
     }
     close() {
       this[_sink].close();
     }
     add(source) {
       this.addSlice(source, 0, source[dartx.length], false);
     }
@@ skipping 68 matching lines @@
       return new _LineSplitterSink(dart.as(sink, StringConversionSink));
     }
   }
   dart.setSignature(LineSplitter, {
     constructors: () => ({LineSplitter: [LineSplitter, []]}),
     methods: () => ({
       convert: [core.List$(core.String), [core.String]],
       startChunkedConversion: [StringConversionSink, [core.Sink]]
     })
   });
-  let _carry = Symbol('_carry');
+  const _carry = Symbol('_carry');
   class _LineSplitterSink extends StringConversionSinkBase {
     _LineSplitterSink(sink) {
       this[_sink] = sink;
       this[_carry] = null;
     }
     addSlice(chunk, start, end, isLast) {
       if (this[_carry] != null) {
         chunk = dart.notNull(this[_carry]) + dart.notNull(chunk[dartx.substring](start, end));
         start = 0;
         end = chunk[dartx.length];
@@ skipping 75 matching lines @@
     })
   });
   class ClosableStringSink extends core.StringSink {
     static fromStringSink(sink, onClose) {
       return new _ClosableStringSink(sink, onClose);
     }
   }
   dart.setSignature(ClosableStringSink, {
     constructors: () => ({fromStringSink: [ClosableStringSink, [core.StringSink, dart.functionType(dart.void, [])]]})
   });
-  let _StringSinkCloseCallback = dart.typedef('_StringSinkCloseCallback', () => dart.functionType(dart.void, []));
+  const _StringSinkCloseCallback = dart.typedef('_StringSinkCloseCallback', () => dart.functionType(dart.void, []));
   class _ClosableStringSink extends core.Object {
     _ClosableStringSink(sink, callback) {
       this[_sink] = sink;
       this[_callback] = callback;
     }
     close() {
       return this[_callback]();
     }
     writeCharCode(charCode) {
       return this[_sink].writeCharCode(charCode);
@@ skipping 16 matching lines @@
   dart.setSignature(_ClosableStringSink, {
     constructors: () => ({_ClosableStringSink: [_ClosableStringSink, [core.StringSink, _StringSinkCloseCallback]]}),
     methods: () => ({
       close: [dart.void, []],
       writeCharCode: [dart.void, [core.int]],
       write: [dart.void, [core.Object]],
       writeln: [dart.void, [], [core.Object]],
       writeAll: [dart.void, [core.Iterable], [core.String]]
     })
   });
-  let _flush = Symbol('_flush');
+  const _flush = Symbol('_flush');
   class _StringConversionSinkAsStringSinkAdapter extends core.Object {
     _StringConversionSinkAsStringSinkAdapter(chunkedSink) {
       this[_chunkedSink] = chunkedSink;
       this[_buffer] = new core.StringBuffer();
     }
     close() {
       if (dart.notNull(this[_buffer].isNotEmpty))
         this[_flush]();
       this[_chunkedSink].close();
     }
@@ skipping 47 matching lines @@
     methods: () => ({
       close: [dart.void, []],
       writeCharCode: [dart.void, [core.int]],
       write: [dart.void, [core.Object]],
       writeln: [dart.void, [], [core.Object]],
       writeAll: [dart.void, [core.Iterable], [core.String]],
       [_flush]: [dart.void, []]
     })
   });
   _StringConversionSinkAsStringSinkAdapter._MIN_STRING_SIZE = 16;
-  let _stringSink = Symbol('_stringSink');
+  const _stringSink = Symbol('_stringSink');
   class _StringSinkConversionSink extends StringConversionSinkBase {
     _StringSinkConversionSink(stringSink) {
       this[_stringSink] = stringSink;
     }
     close() {}
     addSlice(str, start, end, isLast) {
       if (start != 0 || end != str[dartx.length]) {
         for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
           this[_stringSink].writeCharCode(str[dartx.codeUnitAt](i));
         }
@@ skipping 58 matching lines @@
       return this[_sink].close();
     }
   }
   dart.setSignature(_StringAdapterSink, {
     constructors: () => ({_StringAdapterSink: [_StringAdapterSink, [core.Sink$(core.String)]]}),
     methods: () => ({
       addSlice: [dart.void, [core.String, core.int, core.int, core.bool]],
       close: [dart.void, []]
     })
   });
-  let _decoder = Symbol('_decoder');
+  const _decoder = Symbol('_decoder');
   class _Utf8StringSinkAdapter extends ByteConversionSink {
     _Utf8StringSinkAdapter(sink, stringSink, allowMalformed) {
       this[_sink] = sink;
       this[_decoder] = new _Utf8Decoder(stringSink, allowMalformed);
       super.ByteConversionSink();
     }
     close() {
       this[_decoder].close();
       if (this[_sink] != null)
         this[_sink].close();
@@ skipping 55 matching lines @@
     constructors: () => ({
       _Utf8ConversionSink: [_Utf8ConversionSink, [StringConversionSink, core.bool]],
       _: [_Utf8ConversionSink, [StringConversionSink, core.StringBuffer, core.bool]]
     }),
     methods: () => ({
       close: [dart.void, []],
       add: [dart.void, [core.List$(core.int)]],
       addSlice: [dart.void, [core.List$(core.int), core.int, core.int, core.bool]]
     })
   });
-  let UNICODE_REPLACEMENT_CHARACTER_RUNE = 65533;
-  let UNICODE_BOM_CHARACTER_RUNE = 65279;
-  let _allowMalformed = Symbol('_allowMalformed');
+  const UNICODE_REPLACEMENT_CHARACTER_RUNE = 65533;
+  const UNICODE_BOM_CHARACTER_RUNE = 65279;
+  const _allowMalformed = Symbol('_allowMalformed');
   class Utf8Codec extends Encoding {
     Utf8Codec(opts) {
       let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : false;
       this[_allowMalformed] = allowMalformed;
       super.Encoding();
     }
     get name() {
       return "utf-8";
     }
     decode(codeUnits, opts) {
       let allowMalformed = opts && 'allowMalformed' in opts ? opts.allowMalformed : null;
       if (allowMalformed == null)
         allowMalformed = this[_allowMalformed];
       return new Utf8Decoder({allowMalformed: allowMalformed}).convert(codeUnits);
     }
     get encoder() {
       return new Utf8Encoder();
     }
     get decoder() {
       return new Utf8Decoder({allowMalformed: this[_allowMalformed]});
     }
   }
   dart.setSignature(Utf8Codec, {
     constructors: () => ({Utf8Codec: [Utf8Codec, [], {allowMalformed: core.bool}]}),
     methods: () => ({decode: [core.String, [core.List$(core.int)], {allowMalformed: core.bool}]})
   });
-  let UTF8 = dart.const(new Utf8Codec());
-  let _fillBuffer = Symbol('_fillBuffer');
-  let _writeSurrogate = Symbol('_writeSurrogate');
+  const UTF8 = dart.const(new Utf8Codec());
+  const _fillBuffer = Symbol('_fillBuffer');
+  const _writeSurrogate = Symbol('_writeSurrogate');
   class Utf8Encoder extends Converter$(core.String, core.List$(core.int)) {
     Utf8Encoder() {
       super.Converter();
     }
     convert(string, start, end) {
       if (start === void 0)
         start = 0;
       if (end === void 0)
         end = null;
       let stringLength = string[dartx.length];
@@ skipping 262 matching lines @@
   }
   dart.setSignature(Utf8Decoder, {
     constructors: () => ({Utf8Decoder: [Utf8Decoder, [], {allowMalformed: core.bool}]}),
     methods: () => ({
       convert: [core.String, [core.List$(core.int)], [core.int, core.int]],
       startChunkedConversion: [ByteConversionSink, [core.Sink$(core.String)]],
       bind: [async.Stream$(core.String), [async.Stream$(core.List$(core.int))]],
       fuse: [Converter$(core.List$(core.int), dart.dynamic), [Converter$(core.String, dart.dynamic)]]
     })
   });
-  let _ONE_BYTE_LIMIT = 127;
-  let _TWO_BYTE_LIMIT = 2047;
-  let _THREE_BYTE_LIMIT = 65535;
-  let _FOUR_BYTE_LIMIT = 1114111;
-  let _SURROGATE_MASK = 63488;
-  let _SURROGATE_TAG_MASK = 64512;
-  let _SURROGATE_VALUE_MASK = 1023;
-  let _LEAD_SURROGATE_MIN = 55296;
-  let _TAIL_SURROGATE_MIN = 56320;
+  const _ONE_BYTE_LIMIT = 127;
+  const _TWO_BYTE_LIMIT = 2047;
+  const _THREE_BYTE_LIMIT = 65535;
+  const _FOUR_BYTE_LIMIT = 1114111;
+  const _SURROGATE_MASK = 63488;
+  const _SURROGATE_TAG_MASK = 64512;
+  const _SURROGATE_VALUE_MASK = 1023;
+  const _LEAD_SURROGATE_MIN = 55296;
+  const _TAIL_SURROGATE_MIN = 56320;
   function _isSurrogate(codeUnit) {
     return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_MASK)) == _LEAD_SURROGATE_MIN;
   }
   dart.fn(_isSurrogate, core.bool, [core.int]);
   function _isLeadSurrogate(codeUnit) {
     return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_TAG_MASK)) == _LEAD_SURROGATE_MIN;
   }
   dart.fn(_isLeadSurrogate, core.bool, [core.int]);
   function _isTailSurrogate(codeUnit) {
     return (dart.notNull(codeUnit) & dart.notNull(_SURROGATE_TAG_MASK)) == _TAIL_SURROGATE_MIN;
   }
   dart.fn(_isTailSurrogate, core.bool, [core.int]);
   function _combineSurrogatePair(lead, tail) {
     return 65536 + ((dart.notNull(lead) & dart.notNull(_SURROGATE_VALUE_MASK)) << 10) | dart.notNull(tail) & dart.notNull(_SURROGATE_VALUE_MASK);
   }
   dart.fn(_combineSurrogatePair, core.int, [core.int, core.int]);
-  let _isFirstCharacter = Symbol('_isFirstCharacter');
-  let _value = Symbol('_value');
-  let _expectedUnits = Symbol('_expectedUnits');
-  let _extraUnits = Symbol('_extraUnits');
+  const _isFirstCharacter = Symbol('_isFirstCharacter');
+  const _value = Symbol('_value');
+  const _expectedUnits = Symbol('_expectedUnits');
+  const _extraUnits = Symbol('_extraUnits');
   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 24 matching lines @@
         let to = endIndex;
         let mask = _ONE_BYTE_LIMIT;
         for (let i = from; dart.notNull(i) < dart.notNull(to); i = dart.notNull(i) + 1) {
           let unit = dart.dindex(units, i);
           if (!dart.equals(dart.dsend(unit, '&', mask), unit))
             return dart.notNull(i) - dart.notNull(from);
         }
         return dart.notNull(to) - dart.notNull(from);
       }
       dart.fn(scanOneByteCharacters, core.int, [dart.dynamic, core.int]);
-      let addSingleBytes = (function(from, to) {
+      const addSingleBytes = (function(from, to) {
         dart.assert(dart.notNull(from) >= dart.notNull(startIndex) && dart.notNull(from) <= dart.notNull(endIndex));
         dart.assert(dart.notNull(to) >= dart.notNull(startIndex) && dart.notNull(to) <= dart.notNull(endIndex));
         this[_stringSink].write(core.String.fromCharCodes(codeUnits, from, to));
       }).bind(this);
       dart.fn(addSingleBytes, dart.void, [core.int, core.int]);
       let i = startIndex;
       loop:
         while (true) {
           multibyte:
             if (dart.notNull(expectedUnits) > 0) {
@@ skipping 90 matching lines @@
   }
   dart.setSignature(_Utf8Decoder, {
     constructors: () => ({_Utf8Decoder: [_Utf8Decoder, [core.StringSink, core.bool]]}),
     methods: () => ({
       close: [dart.void, []],
       flush: [dart.void, []],
       convert: [dart.void, [core.List$(core.int), core.int, core.int]]
     })
   });
   _Utf8Decoder._LIMITS = dart.const(dart.list([_ONE_BYTE_LIMIT, _TWO_BYTE_LIMIT, _THREE_BYTE_LIMIT, _FOUR_BYTE_LIMIT], core.int));
-  let _processed = Symbol('_processed');
-  let _computeKeys = Symbol('_computeKeys');
-  let _original = Symbol('_original');
+  const _processed = Symbol('_processed');
+  const _computeKeys = Symbol('_computeKeys');
+  const _original = Symbol('_original');
   function _convertJsonToDart(json, reviver) {
     dart.assert(reviver != null);
     function walk(e) {
       if (e == null || typeof e != "object") {
         return e;
       }
       if (Object.getPrototypeOf(e) === Array.prototype) {
         for (let i = 0; dart.notNull(i) < e.length; i = dart.notNull(i) + 1) {
           let item = e[i];
           e[i] = dart.dcall(reviver, i, walk(item));
@@ skipping 24 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;
   }
   dart.fn(_convertJsonToDartLazy);
-  let _data = Symbol('_data');
-  let _isUpgraded = Symbol('_isUpgraded');
-  let _upgradedMap = Symbol('_upgradedMap');
-  let _process = Symbol('_process');
-  let _upgrade = Symbol('_upgrade');
+  const _data = Symbol('_data');
+  const _isUpgraded = Symbol('_isUpgraded');
+  const _upgradedMap = Symbol('_upgradedMap');
+  const _process = Symbol('_process');
+  const _upgrade = Symbol('_upgrade');
   class _JsonMap extends core.Object {
     _JsonMap(original) {
       this[_processed] = _JsonMap._newJavaScriptObject();
       this[_original] = original;
       this[_data] = null;
     }
     get(key) {
       if (dart.notNull(this[_isUpgraded])) {
         return this[_upgradedMap].get(key);
       } else if (!(typeof key == 'string')) {
@@ skipping 184 matching lines @@
     statics: () => ({
       _hasProperty: [core.bool, [dart.dynamic, core.String]],
       _getProperty: [dart.dynamic, [dart.dynamic, core.String]],
       _setProperty: [dart.dynamic, [dart.dynamic, core.String, dart.dynamic]],
       _getPropertyNames: [core.List, [dart.dynamic]],
       _isUnprocessed: [core.bool, [dart.dynamic]],
       _newJavaScriptObject: [dart.dynamic, []]
     }),
     names: ['_hasProperty', '_getProperty', '_setProperty', '_getPropertyNames', '_isUnprocessed', '_newJavaScriptObject']
   });
-  let _parent = Symbol('_parent');
+  const _parent = Symbol('_parent');
   class _JsonMapKeyIterable extends _internal.ListIterable {
     _JsonMapKeyIterable(parent) {
       this[_parent] = parent;
       super.ListIterable();
     }
     get length() {
       return this[_parent].length;
     }
     elementAt(index) {
       return dart.notNull(this[_parent][_isUpgraded]) ? dart.as(this[_parent].keys[dartx.elementAt](index), core.String) : this[_parent][_computeKeys]()[dartx.get](index);
@@ skipping 62 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.Utf8Codec = Utf8Codec;
   exports.UTF8 = UTF8;
   exports.Utf8Encoder = Utf8Encoder;
   exports.Utf8Decoder = Utf8Decoder;
 });