Add --modules=node support

lib/runtime/dart/core.js

 dart_library.library('dart/core', null, /* Imports */[
   'dart/_runtime'
 ], /* Lazy imports */[
   'dart/_js_helper',
   'dart/_internal',
   'dart/collection',
   'dart/_interceptors',
   'dart/convert'
 ], function(exports, dart, _js_helper, _internal, collection, _interceptors, convert) {
   'use strict';
@@ skipping 69 matching lines @@
       return this ? "true" : "false";
     }
   }
   dart.setSignature(bool, {
     constructors: () => ({fromEnvironment: [bool, [String], {defaultValue: bool}]})
   });
   const Comparator$ = dart.generic(function(T) {
     const Comparator = dart.typedef('Comparator', () => dart.functionType(int, [T, T]));
     return Comparator;
   });
-  let Comparator = Comparator$();
+  const Comparator = Comparator$();
   const Comparable$ = dart.generic(function(T) {
     class Comparable extends Object {
       static compare(a, b) {
         return a[dartx.compareTo](b);
       }
     }
     dart.setSignature(Comparable, {
       statics: () => ({compare: [int, [Comparable$(), Comparable$()]]}),
       names: ['compare']
     });
     return Comparable;
   });
-  let Comparable = Comparable$();
+  const Comparable = Comparable$();
   class DateTime extends Object {
     DateTime(year, month, day, hour, minute, second, millisecond) {
       if (month === void 0) month = 1;
       if (day === void 0) day = 1;
       if (hour === void 0) hour = 0;
       if (minute === void 0) minute = 0;
       if (second === void 0) second = 0;
       if (millisecond === void 0) millisecond = 0;
       this._internal(year, month, day, hour, minute, second, millisecond, false);
     }
@@ skipping 1005 matching lines @@
     dart.setSignature(Expando, {
       constructors: () => ({Expando: [Expando$(T), [], [String]]}),
       methods: () => ({
         get: [T, [Object]],
         set: [dart.void, [Object, T]],
         [_getKey]: [String, []]
       })
     });
     return Expando;
   });
-  let Expando = Expando$();
+  const Expando = Expando$();
   Expando._KEY_PROPERTY_NAME = 'expando$key';
   Expando._EXPANDO_PROPERTY_NAME = 'expando$values';
   Expando._keyCount = 0;
   class Function extends Object {
     static apply(f, positionalArguments, namedArguments) {
       if (namedArguments === void 0) namedArguments = null;
       return dart.dcall.apply(null, [f].concat(positionalArguments));
     }
     static _toMangledNames(namedArguments) {
       let result = dart.map();
@@ skipping 63 matching lines @@
     }
     dart.setSignature(Iterable, {
       constructors: () => ({
         Iterable: [Iterable$(E), []],
         generate: [Iterable$(E), [int], [dart.functionType(E, [int])]]
       }),
       methods: () => ({[dartx.join]: [String, [], [String]]})
     });
     return Iterable;
   });
-  let Iterable = Iterable$();
+  const Iterable = Iterable$();
   const _Generator$ = dart.generic(function(E) {
     const _Generator = dart.typedef('_Generator', () => dart.functionType(E, [int]));
     return _Generator;
   });
-  let _Generator = _Generator$();
+  const _Generator = _Generator$();
   const _end = dart.JsSymbol('_end');
   const _start = dart.JsSymbol('_start');
   const _generator = dart.JsSymbol('_generator');
   const _GeneratorIterable$ = dart.generic(function(E) {
     class _GeneratorIterable extends collection.IterableBase$(E) {
       _GeneratorIterable(end, generator) {
         this[_end] = end;
         this[_start] = 0;
         this[_generator] = dart.as(generator != null ? generator : exports._GeneratorIterable$()._id, _Generator$(E));
         super.IterableBase();
@@ skipping 70 matching lines @@
         return this[_current];
       }
     }
     _GeneratorIterator[dart.implements] = () => [Iterator$(E)];
     dart.setSignature(_GeneratorIterator, {
       constructors: () => ({_GeneratorIterator: [_GeneratorIterator$(E), [int, int, _Generator$(E)]]}),
       methods: () => ({moveNext: [bool, []]})
     });
     return _GeneratorIterator;
   });
-  let _GeneratorIterator = _GeneratorIterator$();
+  const _GeneratorIterator = _GeneratorIterator$();
   const BidirectionalIterator$ = dart.generic(function(E) {
     class BidirectionalIterator extends Object {}
     BidirectionalIterator[dart.implements] = () => [Iterator$(E)];
     return BidirectionalIterator;
   });
-  let BidirectionalIterator = BidirectionalIterator$();
+  const BidirectionalIterator = BidirectionalIterator$();
   const Iterator$ = dart.generic(function(E) {
     class Iterator extends Object {}
     return Iterator;
   });
-  let Iterator = Iterator$();
+  const Iterator = Iterator$();
   const List$ = dart.generic(function(E) {
     class List extends Object {
       static new(length) {
         if (length === void 0) length = null;
         let list = null;
         if (length == null) {
           list = [];
         } else {
           if (!(typeof length == 'number') || dart.notNull(length) < 0) {
             dart.throw(new ArgumentError(`Length must be a non-negative integer: ${length}`));
@@ skipping 42 matching lines @@
     dart.setSignature(List, {
       constructors: () => ({
         new: [List$(E), [], [int]],
         filled: [List$(E), [int, E]],
         from: [List$(E), [Iterable], {growable: bool}],
         generate: [List$(E), [int, dart.functionType(E, [int])], {growable: bool}]
       })
     });
     return List;
   });
-  let List = List$();
+  const List = List$();
   const Map$ = dart.generic(function(K, V) {
     class Map extends Object {
       static new() {
         return collection.LinkedHashMap$(K, V).new();
       }
       static from(other) {
         return collection.LinkedHashMap$(K, V).from(other);
       }
       static identity() {
         return collection.LinkedHashMap$(K, V).identity();
       }
       static fromIterable(iterable, opts) {
         return collection.LinkedHashMap$(K, V).fromIterable(iterable, opts);
       }
       static fromIterables(keys, values) {
         return collection.LinkedHashMap$(K, V).fromIterables(keys, values);
       }
     }
     dart.setSignature(Map, {
       constructors: () => ({
         new: [Map$(K, V), []],
         from: [Map$(K, V), [Map$()]],
         identity: [Map$(K, V), []],
         fromIterable: [Map$(K, V), [Iterable], {key: dart.functionType(K, [dart.dynamic]), value: dart.functionType(V, [dart.dynamic])}],
         fromIterables: [Map$(K, V), [Iterable$(K), Iterable$(V)]]
       })
     });
     return Map;
   });
-  let Map = Map$();
+  const Map = Map$();
   class Null extends Object {
     static _uninstantiable() {
       dart.throw(new UnsupportedError('class Null cannot be instantiated'));
     }
     toString() {
       return "null";
     }
   }
   dart.setSignature(Null, {
     constructors: () => ({_uninstantiable: [Null, []]})
@@ skipping 41 matching lines @@
         from: [exports.Set$(E), [Iterable$(E)]]
       })
     });
     return Set;
   });
   dart.defineLazyClassGeneric(exports, 'Set', {get: Set$});
   const Sink$ = dart.generic(function(T) {
     class Sink extends Object {}
     return Sink;
   });
-  let Sink = Sink$();
+  const Sink = Sink$();
   class StackTrace extends Object {}
   const _stop = dart.JsSymbol('_stop');
   class Stopwatch extends Object {
     get frequency() {
       return Stopwatch._frequency;
     }
     Stopwatch() {
       this[_start] = null;
       this[_stop] = null;
       Stopwatch._initTicker();
@@ skipping 1724 matching lines @@
   exports.StackTrace = StackTrace;
   exports.Stopwatch = Stopwatch;
   exports.String = String;
   exports.RuneIterator = RuneIterator;
   exports.StringBuffer = StringBuffer;
   exports.StringSink = StringSink;
   exports.Symbol = Symbol;
   exports.Type = Type;
   exports.Uri = Uri;
 });