Add --modules=node support

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) {
+], function(exports, dart, core, $async, typed_data, _internal, collection) {
   'use strict';
   let dartx = dart.dartx;
   const Codec$ = dart.generic(function(S, T) {
     class Codec extends core.Object {
       Codec() {
       }
       encode(input) {
         dart.as(input, S);
         return this.encoder.convert(input);
       }
@@ skipping 12 matching lines @@
     dart.setSignature(Codec, {
       constructors: () => ({Codec: [Codec$(S, T), []]}),
       methods: () => ({
         encode: [T, [S]],
         decode: [S, [T]],
         fuse: [Codec$(S, dart.dynamic), [Codec$(T, dart.dynamic)]]
       })
     });
     return Codec;
   });
-  let Codec = Codec$();
+  const Codec = Codec$();
   class Encoding extends Codec$(core.String, core.List$(core.int)) {
     Encoding() {
       super.Codec();
     }
     decodeStream(byteStream) {
       return byteStream.transform(this.decoder).fold(new core.StringBuffer(), dart.fn((buffer, string) => ((() => {
         dart.dsend(buffer, 'write', string);
         return buffer;
       })()))).then(dart.fn(buffer => dart.toString(buffer), core.String, [dart.dynamic]));
     }
     static getByName(name) {
       if (name == null) return null;
       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))]]}),
+    methods: () => ({decodeStream: [$async.Future$(core.String), [$async.Stream$(core.List$(core.int))]]}),
     statics: () => ({getByName: [Encoding, [core.String]]}),
     names: ['getByName']
   });
   const _allowInvalid = Symbol('_allowInvalid');
   class AsciiCodec extends Encoding {
     AsciiCodec(opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       this[_allowInvalid] = allowInvalid;
       super.Encoding();
     }
@@ skipping 28 matching lines @@
       }
       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]));
+        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)];
+    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)]]
+        bind: [$async.Stream$(T), [$async.Stream$(S)]]
       })
     });
     return Converter;
   });
-  let Converter = Converter$();
+  const Converter = Converter$();
   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;
       let stringLength = string[dartx.length];
@@ skipping 18 matching lines @@
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
   dart.setSignature(_UnicodeSubsetEncoder, {
     constructors: () => ({_UnicodeSubsetEncoder: [_UnicodeSubsetEncoder, [core.int]]}),
     methods: () => ({
       convert: [core.List$(core.int), [core.String], [core.int, core.int]],
       startChunkedConversion: [StringConversionSink, [core.Sink$(core.List$(core.int))]],
-      bind: [async.Stream$(core.List$(core.int)), [async.Stream$(core.String)]]
+      bind: [$async.Stream$(core.List$(core.int)), [$async.Stream$(core.String)]]
     })
   });
   class AsciiEncoder extends _UnicodeSubsetEncoder {
     AsciiEncoder() {
       super._UnicodeSubsetEncoder(_ASCII_MASK);
     }
   }
   dart.setSignature(AsciiEncoder, {
     constructors: () => ({AsciiEncoder: [AsciiEncoder, []]})
   });
@@ skipping 83 matching lines @@
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
   dart.setSignature(_UnicodeSubsetDecoder, {
     constructors: () => ({_UnicodeSubsetDecoder: [_UnicodeSubsetDecoder, [core.bool, core.int]]}),
     methods: () => ({
       convert: [core.String, [core.List$(core.int)], [core.int, core.int]],
       [_convertInvalid]: [core.String, [core.List$(core.int), core.int, core.int]],
-      bind: [async.Stream$(core.String), [async.Stream$(core.List$(core.int))]]
+      bind: [$async.Stream$(core.String), [$async.Stream$(core.List$(core.int))]]
     })
   });
   class AsciiDecoder extends _UnicodeSubsetDecoder {
     AsciiDecoder(opts) {
       let allowInvalid = opts && 'allowInvalid' in opts ? opts.allowInvalid : false;
       super._UnicodeSubsetDecoder(allowInvalid, _ASCII_MASK);
     }
     startChunkedConversion(sink) {
       let stringSink = null;
       if (dart.is(sink, StringConversionSink)) {
@@ skipping 22 matching lines @@
     }
     ChunkedConversionSink[dart.implements] = () => [core.Sink$(T)];
     dart.setSignature(ChunkedConversionSink, {
       constructors: () => ({
         ChunkedConversionSink: [ChunkedConversionSink$(T), []],
         withCallback: [ChunkedConversionSink$(T), [dart.functionType(dart.void, [core.List$(T)])]]
       })
     });
     return ChunkedConversionSink;
   });
-  let ChunkedConversionSink = ChunkedConversionSink$();
+  const ChunkedConversionSink = ChunkedConversionSink$();
   class ByteConversionSink extends ChunkedConversionSink$(core.List$(core.int)) {
     ByteConversionSink() {
       super.ChunkedConversionSink();
     }
     static withCallback(callback) {
       return new _ByteCallbackSink(callback);
     }
     static from(sink) {
       return new _ByteAdapterSink(sink);
     }
@@ skipping 146 matching lines @@
       close: [dart.void, []]
     }),
     statics: () => ({_roundToPowerOf2: [core.int, [core.int]]}),
     names: ['_roundToPowerOf2']
   });
   _ByteCallbackSink._INITIAL_BUFFER_SIZE = 1024;
   const _ChunkedConversionCallback$ = dart.generic(function(T) {
     const _ChunkedConversionCallback = dart.typedef('_ChunkedConversionCallback', () => dart.functionType(dart.void, [T]));
     return _ChunkedConversionCallback;
   });
-  let _ChunkedConversionCallback = _ChunkedConversionCallback$();
+  const _ChunkedConversionCallback = _ChunkedConversionCallback$();
   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$();
+  const _SimpleCallbackSink = _SimpleCallbackSink$();
   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)]]}),
+      constructors: () => ({_EventSinkAdapter: [_EventSinkAdapter$(T), [$async.EventSink$(T)]]}),
       methods: () => ({
         add: [dart.void, [T]],
         close: [dart.void, []]
       })
     });
     return _EventSinkAdapter;
   });
-  let _EventSinkAdapter = _EventSinkAdapter$();
+  const _EventSinkAdapter = _EventSinkAdapter$();
   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) {
         if (stackTrace === void 0) stackTrace = null;
         this[_eventSink].addError(error, stackTrace);
       }
       close() {
         return this[_chunkedSink].close();
       }
     }
-    _ConverterStreamEventSink[dart.implements] = () => [async.EventSink$(S)];
+    _ConverterStreamEventSink[dart.implements] = () => [$async.EventSink$(S)];
     dart.setSignature(_ConverterStreamEventSink, {
-      constructors: () => ({_ConverterStreamEventSink: [_ConverterStreamEventSink$(S, T), [Converter, async.EventSink$(T)]]}),
+      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$();
+  const _ConverterStreamEventSink = _ConverterStreamEventSink$();
   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$();
+  const _FusedCodec = _FusedCodec$();
   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$();
+  const _InvertedCodec = _InvertedCodec$();
   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);
       }
       startChunkedConversion(sink) {
         dart.as(sink, core.Sink$(T));
         return this[_first].startChunkedConversion(this[_second].startChunkedConversion(sink));
       }
     }
     dart.setSignature(_FusedConverter, {
       constructors: () => ({_FusedConverter: [_FusedConverter$(S, M, T), [Converter, Converter]]}),
       methods: () => ({
         convert: [T, [S]],
         startChunkedConversion: [ChunkedConversionSink, [core.Sink$(T)]]
       })
     });
     return _FusedConverter;
   });
-  let _FusedConverter = _FusedConverter$();
+  const _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(_) {}
   });
   const _name = Symbol('_name');
   class HtmlEscapeMode extends core.Object {
     _(name, escapeLtGt, escapeQuot, escapeApos, escapeSlash) {
       this[_name] = name;
@@ skipping 230 matching lines @@
   }
   dart.defineNamedConstructor(JsonEncoder, 'withIndent');
   dart.setSignature(JsonEncoder, {
     constructors: () => ({
       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)]],
+      bind: [$async.Stream$(core.String), [$async.Stream$(core.Object)]],
       fuse: [Converter$(core.Object, dart.dynamic), [Converter$(core.String, dart.dynamic)]]
     })
   });
   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;
@@ skipping 52 matching lines @@
     }
     fuse(other) {
       return super.fuse(other);
     }
   }
   dart.setSignature(JsonUtf8Encoder, {
     constructors: () => ({JsonUtf8Encoder: [JsonUtf8Encoder, [], [core.String, dart.functionType(dart.dynamic, [core.Object]), core.int]]}),
     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)]],
+      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;
   const _isDone = Symbol('_isDone');
   class _JsonEncoderSink extends ChunkedConversionSink$(core.Object) {
     _JsonEncoderSink(sink, toEncodable, indent) {
       this[_sink] = sink;
@@ skipping 70 matching lines @@
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
   dart.setSignature(JsonDecoder, {
     constructors: () => ({JsonDecoder: [JsonDecoder, [], [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]]}),
     methods: () => ({
       convert: [dart.dynamic, [core.String]],
       startChunkedConversion: [StringConversionSink, [core.Sink$(core.Object)]],
-      bind: [async.Stream$(core.Object), [async.Stream$(core.String)]]
+      bind: [$async.Stream$(core.Object), [$async.Stream$(core.String)]]
     })
   });
   function _parseJson(source, reviver) {
     if (!(typeof source == 'string')) dart.throw(new core.ArgumentError(source));
     let parsed = null;
     try {
       parsed = dart.global.JSON.parse(source);
     } catch (e) {
       dart.throw(new core.FormatException(String(e)));
     }
@@ skipping 1007 matching lines @@
     }
     bind(stream) {
       return super.bind(stream);
     }
   }
   dart.setSignature(Utf8Encoder, {
     constructors: () => ({Utf8Encoder: [Utf8Encoder, []]}),
     methods: () => ({
       convert: [core.List$(core.int), [core.String], [core.int, core.int]],
       startChunkedConversion: [StringConversionSink, [core.Sink$(core.List$(core.int))]],
-      bind: [async.Stream$(core.List$(core.int)), [async.Stream$(core.String)]]
+      bind: [$async.Stream$(core.List$(core.int)), [$async.Stream$(core.String)]]
     })
   });
   class _Utf8Encoder extends core.Object {
     _Utf8Encoder() {
       this.withBufferSize(_Utf8Encoder._DEFAULT_BYTE_BUFFER_SIZE);
     }
     withBufferSize(bufferSize) {
       this[_buffer] = _Utf8Encoder._createBuffer(bufferSize);
       this[_carry] = 0;
       this[_bufferIndex] = 0;
@@ skipping 207 matching lines @@
     }
     fuse(next) {
       return super.fuse(next);
     }
   }
   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))]],
+      bind: [$async.Stream$(core.String), [$async.Stream$(core.List$(core.int))]],
       fuse: [Converter$(core.List$(core.int), dart.dynamic), [Converter$(core.String, dart.dynamic)]]
     })
   });
   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;
@@ skipping 491 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;
 });