Add --modules=node support

lib/runtime/dart/async.js

 dart_library.library('dart/async', null, /* Imports */[
   'dart/_runtime',
   'dart/core',
   'dart/_internal',
   'dart/collection'
 ], /* Lazy imports */[
   'dart/_isolate_helper'
 ], function(exports, dart, core, _internal, collection, _isolate_helper) {
   'use strict';
   let dartx = dart.dartx;
@@ skipping 739 matching lines @@
         distinct: [Stream$(T), [], [dart.functionType(core.bool, [T, T])]],
         firstWhere: [Future, [dart.functionType(core.bool, [T])], {defaultValue: dart.functionType(core.Object, [])}],
         lastWhere: [Future, [dart.functionType(core.bool, [T])], {defaultValue: dart.functionType(core.Object, [])}],
         singleWhere: [Future$(T), [dart.functionType(core.bool, [T])]],
         elementAt: [Future$(T), [core.int]],
         timeout: [Stream$(), [core.Duration], {onTimeout: dart.functionType(dart.void, [EventSink])}]
       })
     });
     return Stream;
   });
-  let Stream = Stream$();
+  const Stream = Stream$();
   const _createSubscription = Symbol('_createSubscription');
   const _onListen = Symbol('_onListen');
   const _StreamImpl$ = dart.generic(function(T) {
     class _StreamImpl extends Stream$(T) {
       _StreamImpl() {
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
@@ skipping 14 matching lines @@
     }
     dart.setSignature(_StreamImpl, {
       methods: () => ({
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         [_onListen]: [dart.void, [StreamSubscription]]
       })
     });
     return _StreamImpl;
   });
-  let _StreamImpl = _StreamImpl$();
+  const _StreamImpl = _StreamImpl$();
   const _controller = Symbol('_controller');
   const _subscribe = Symbol('_subscribe');
   const _ControllerStream$ = dart.generic(function(T) {
     class _ControllerStream extends _StreamImpl$(T) {
       _ControllerStream(controller) {
         this[_controller] = controller;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
@@ skipping 11 matching lines @@
     }
     dart.setSignature(_ControllerStream, {
       constructors: () => ({_ControllerStream: [_ControllerStream$(T), [_StreamControllerLifecycle$(T)]]}),
       methods: () => ({
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         '==': [core.bool, [core.Object]]
       })
     });
     return _ControllerStream;
   });
-  let _ControllerStream = _ControllerStream$();
+  const _ControllerStream = _ControllerStream$();
   const _BroadcastStream$ = dart.generic(function(T) {
     class _BroadcastStream extends _ControllerStream$(T) {
       _BroadcastStream(controller) {
         super._ControllerStream(dart.as(controller, _StreamControllerLifecycle$(T)));
       }
       get isBroadcast() {
         return true;
       }
     }
     dart.setSignature(_BroadcastStream, {
       constructors: () => ({_BroadcastStream: [_BroadcastStream$(T), [_StreamControllerLifecycle]]})
     });
     return _BroadcastStream;
   });
-  let _BroadcastStream = _BroadcastStream$();
+  const _BroadcastStream = _BroadcastStream$();
   const _next = Symbol('_next');
   const _previous = Symbol('_previous');
   class _BroadcastSubscriptionLink extends core.Object {
     _BroadcastSubscriptionLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
   const _zone = Symbol('_zone');
   const _state = Symbol('_state');
@@ skipping 331 matching lines @@
         [_addPending]: [dart.void, [_DelayedEvent]],
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []],
         [_guardCallback]: [dart.void, [dart.dynamic]],
         [_checkState]: [dart.void, [core.bool]]
       })
     });
     return _BufferingStreamSubscription;
   });
-  let _BufferingStreamSubscription = _BufferingStreamSubscription$();
+  const _BufferingStreamSubscription = _BufferingStreamSubscription$();
   const _recordCancel = Symbol('_recordCancel');
   const _recordPause = Symbol('_recordPause');
   const _recordResume = Symbol('_recordResume');
   const _ControllerSubscription$ = dart.generic(function(T) {
     class _ControllerSubscription extends _BufferingStreamSubscription$(T) {
       _ControllerSubscription(controller, onData, onError, onDone, cancelOnError) {
         this[_controller] = controller;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
         return this[_controller][_recordCancel](this);
       }
       [_onPause]() {
         this[_controller][_recordPause](this);
       }
       [_onResume]() {
         this[_controller][_recordResume](this);
       }
     }
     dart.setSignature(_ControllerSubscription, {
       constructors: () => ({_ControllerSubscription: [_ControllerSubscription$(T), [_StreamControllerLifecycle$(T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]})
     });
     return _ControllerSubscription;
   });
-  let _ControllerSubscription = _ControllerSubscription$();
+  const _ControllerSubscription = _ControllerSubscription$();
   const _eventState = Symbol('_eventState');
   const _expectsEvent = Symbol('_expectsEvent');
   const _toggleEventId = Symbol('_toggleEventId');
   const _isFiring = Symbol('_isFiring');
   const _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
   const _removeAfterFiring = Symbol('_removeAfterFiring');
   const _BroadcastSubscription$ = dart.generic(function(T) {
     class _BroadcastSubscription extends _ControllerSubscription$(T) {
       _BroadcastSubscription(controller, onData, onError, onDone, cancelOnError) {
         this[_eventState] = null;
@@ skipping 25 matching lines @@
     dart.setSignature(_BroadcastSubscription, {
       constructors: () => ({_BroadcastSubscription: [_BroadcastSubscription$(T), [_StreamControllerLifecycle, dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_expectsEvent]: [core.bool, [core.int]],
         [_toggleEventId]: [dart.void, []],
         [_setRemoveAfterFiring]: [dart.void, []]
       })
     });
     return _BroadcastSubscription;
   });
-  let _BroadcastSubscription = _BroadcastSubscription$();
+  const _BroadcastSubscription = _BroadcastSubscription$();
   _BroadcastSubscription._STATE_EVENT_ID = 1;
   _BroadcastSubscription._STATE_FIRING = 2;
   _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
   const _addStreamState = Symbol('_addStreamState');
   const _doneFuture = Symbol('_doneFuture');
   const _isEmpty = Symbol('_isEmpty');
   const _hasOneListener = Symbol('_hasOneListener');
   const _isAddingStream = Symbol('_isAddingStream');
   const _mayAddEvent = Symbol('_mayAddEvent');
   const _ensureDoneFuture = Symbol('_ensureDoneFuture');
@@ skipping 220 matching lines @@
         addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}],
         [_add]: [dart.void, [T]],
         [_addError]: [dart.void, [core.Object, core.StackTrace]],
         [_close]: [dart.void, []],
         [_forEachListener]: [dart.void, [dart.functionType(dart.void, [_BufferingStreamSubscription$(T)])]],
         [_callOnCancel]: [dart.void, []]
       })
     });
     return _BroadcastStreamController;
   });
-  let _BroadcastStreamController = _BroadcastStreamController$();
+  const _BroadcastStreamController = _BroadcastStreamController$();
   _BroadcastStreamController._STATE_INITIAL = 0;
   _BroadcastStreamController._STATE_EVENT_ID = 1;
   _BroadcastStreamController._STATE_FIRING = 2;
   _BroadcastStreamController._STATE_CLOSED = 4;
   _BroadcastStreamController._STATE_ADDSTREAM = 8;
   const _SyncBroadcastStreamController$ = dart.generic(function(T) {
     class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
@@ skipping 38 matching lines @@
     dart.setSignature(_SyncBroadcastStreamController, {
       constructors: () => ({_SyncBroadcastStreamController: [_SyncBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _SyncBroadcastStreamController;
   });
-  let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
+  const _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
   const _AsyncBroadcastStreamController$ = dart.generic(function(T) {
     class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _AsyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
         for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           subscription[_addPending](new _DelayedData(data));
@@ skipping 21 matching lines @@
     dart.setSignature(_AsyncBroadcastStreamController, {
       constructors: () => ({_AsyncBroadcastStreamController: [_AsyncBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _AsyncBroadcastStreamController;
   });
-  let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$();
+  const _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$();
   const _addPendingEvent = Symbol('_addPendingEvent');
   const _AsBroadcastStreamController$ = dart.generic(function(T) {
     class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T) {
       _AsBroadcastStreamController(onListen, onCancel) {
         this[_pending] = null;
         super._SyncBroadcastStreamController(onListen, onCancel);
       }
       get [_hasPending]() {
         return this[_pending] != null && !dart.notNull(this[_pending].isEmpty);
       }
@@ skipping 47 matching lines @@
     _AsBroadcastStreamController[dart.implements] = () => [_EventDispatch$(T)];
     dart.setSignature(_AsBroadcastStreamController, {
       constructors: () => ({_AsBroadcastStreamController: [_AsBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
         [_addPendingEvent]: [dart.void, [_DelayedEvent]],
         add: [dart.void, [T]]
       })
     });
     return _AsBroadcastStreamController;
   });
-  let _AsBroadcastStreamController = _AsBroadcastStreamController$();
+  const _AsBroadcastStreamController = _AsBroadcastStreamController$();
   const _pauseCount = Symbol('_pauseCount');
   const _resume = Symbol('_resume');
   const _DoneSubscription$ = dart.generic(function(T) {
     class _DoneSubscription extends core.Object {
       _DoneSubscription() {
         this[_pauseCount] = 0;
       }
       onData(handleData) {
         dart.as(handleData, dart.functionType(dart.void, [T]));
       }
@@ skipping 33 matching lines @@
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         [_resume]: [dart.void, [dart.dynamic]],
         cancel: [Future, []],
         asFuture: [Future, [], [core.Object]]
       })
     });
     return _DoneSubscription;
   });
-  let _DoneSubscription = _DoneSubscription$();
+  const _DoneSubscription = _DoneSubscription$();
   const __CastType2$ = dart.generic(function(T) {
     const __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
     return __CastType2;
   });
-  let __CastType2 = __CastType2$();
+  const __CastType2 = __CastType2$();
   class DeferredLibrary extends core.Object {
     DeferredLibrary(libraryName, opts) {
       let uri = opts && 'uri' in opts ? opts.uri : null;
       this.libraryName = libraryName;
       this.uri = uri;
     }
     load() {
       dart.throw('DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.');
     }
   }
@@ skipping 179 matching lines @@
       }),
       statics: () => ({
         wait: [Future$(core.List), [core.Iterable$(Future$())], {eagerError: core.bool, cleanUp: dart.functionType(dart.void, [dart.dynamic])}],
         forEach: [Future$(), [core.Iterable, dart.functionType(dart.dynamic, [dart.dynamic])]],
         doWhile: [Future$(), [dart.functionType(dart.dynamic, [])]]
       }),
       names: ['wait', 'forEach', 'doWhile']
     });
     return Future;
   });
-  let Future = Future$();
+  const Future = Future$();
   dart.defineLazyProperties(Future, {
     get _nullFuture() {
       return new _Future.immediate(null);
     }
   });
   class TimeoutException extends core.Object {
     TimeoutException(message, duration) {
       if (duration === void 0) duration = null;
       this.message = message;
       this.duration = duration;
@@ skipping 19 matching lines @@
       }
     }
     dart.setSignature(Completer, {
       constructors: () => ({
         new: [Completer$(T), []],
         sync: [Completer$(T), []]
       })
     });
     return Completer;
   });
-  let Completer = Completer$();
+  const Completer = Completer$();
   function _completeWithErrorCallback(result, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     result[_completeError](error, dart.as(stackTrace, core.StackTrace));
   }
   dart.fn(_completeWithErrorCallback, () => dart.definiteFunctionType(dart.void, [_Future, dart.dynamic, dart.dynamic]));
   function _nonNullError(error) {
     return error != null ? error : new core.NullThrownError();
   }
   dart.fn(_nonNullError, core.Object, [core.Object]);
   const __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   const _FutureOnValue$ = dart.generic(function(T) {
     const _FutureOnValue = dart.typedef('_FutureOnValue', () => dart.functionType(dart.dynamic, [T]));
     return _FutureOnValue;
   });
-  let _FutureOnValue = _FutureOnValue$();
+  const _FutureOnValue = _FutureOnValue$();
   const _FutureErrorTest = dart.typedef('_FutureErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
   const _FutureAction = dart.typedef('_FutureAction', () => dart.functionType(dart.dynamic, []));
   const _Completer$ = dart.generic(function(T) {
     class _Completer extends core.Object {
       _Completer() {
         this.future = new (_Future$(T))();
       }
       completeError(error, stackTrace) {
         if (stackTrace === void 0) stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this.future[_mayComplete])) dart.throw(new core.StateError("Future already completed"));
         let replacement = Zone.current.errorCallback(error, stackTrace);
         if (replacement != null) {
           error = _nonNullError(replacement.error);
           stackTrace = replacement.stackTrace;
         }
         this[_completeError](error, stackTrace);
       }
       get isCompleted() {
         return !dart.notNull(this.future[_mayComplete]);
       }
     }
     _Completer[dart.implements] = () => [Completer$(T)];
     dart.setSignature(_Completer, {
       methods: () => ({completeError: [dart.void, [core.Object], [core.StackTrace]]})
     });
     return _Completer;
   });
-  let _Completer = _Completer$();
+  const _Completer = _Completer$();
   const _asyncCompleteError = Symbol('_asyncCompleteError');
   const _AsyncCompleter$ = dart.generic(function(T) {
     class _AsyncCompleter extends _Completer$(T) {
       _AsyncCompleter() {
         super._Completer();
       }
       complete(value) {
         if (value === void 0) value = null;
         if (!dart.notNull(this.future[_mayComplete])) dart.throw(new core.StateError("Future already completed"));
         this.future[_asyncComplete](value);
       }
       [_completeError](error, stackTrace) {
         this.future[_asyncCompleteError](error, stackTrace);
       }
     }
     dart.setSignature(_AsyncCompleter, {
       methods: () => ({
         complete: [dart.void, [], [dart.dynamic]],
         [_completeError]: [dart.void, [core.Object, core.StackTrace]]
       })
     });
     return _AsyncCompleter;
   });
-  let _AsyncCompleter = _AsyncCompleter$();
+  const _AsyncCompleter = _AsyncCompleter$();
   const _SyncCompleter$ = dart.generic(function(T) {
     class _SyncCompleter extends _Completer$(T) {
       _SyncCompleter() {
         super._Completer();
       }
       complete(value) {
         if (value === void 0) value = null;
         if (!dart.notNull(this.future[_mayComplete])) dart.throw(new core.StateError("Future already completed"));
         this.future[_complete](value);
       }
       [_completeError](error, stackTrace) {
         this.future[_completeError](error, stackTrace);
       }
     }
     dart.setSignature(_SyncCompleter, {
       methods: () => ({
         complete: [dart.void, [], [dart.dynamic]],
         [_completeError]: [dart.void, [core.Object, core.StackTrace]]
       })
     });
     return _SyncCompleter;
   });
-  let _SyncCompleter = _SyncCompleter$();
+  const _SyncCompleter = _SyncCompleter$();
   const _nextListener = Symbol('_nextListener');
   const _onValue = Symbol('_onValue');
   const _errorTest = Symbol('_errorTest');
   const _whenCompleteAction = Symbol('_whenCompleteAction');
   class _FutureListener extends core.Object {
     then(result, onValue, errorCallback) {
       this.result = result;
       this.callback = onValue;
       this.errorCallback = errorCallback;
       this.state = errorCallback == null ? _FutureListener.STATE_THEN : _FutureListener.STATE_THEN_ONERROR;
@@ skipping 523 matching lines @@
       }),
       statics: () => ({
         _chainForeignFuture: [dart.void, [Future, _Future$()]],
         _chainCoreFuture: [dart.void, [_Future$(), _Future$()]],
         _propagateToListeners: [dart.void, [_Future$(), _FutureListener]]
       }),
       names: ['_chainForeignFuture', '_chainCoreFuture', '_propagateToListeners']
     });
     return _Future;
   });
-  let _Future = _Future$();
+  const _Future = _Future$();
   _Future._INCOMPLETE = 0;
   _Future._PENDING_COMPLETE = 1;
   _Future._CHAINED = 2;
   _Future._VALUE = 4;
   _Future._ERROR = 8;
   const __CastType6$ = dart.generic(function(T, S) {
     const __CastType6 = dart.typedef('__CastType6', () => dart.functionType(S, [T]));
     return __CastType6;
   });
-  let __CastType6 = __CastType6$();
+  const __CastType6 = __CastType6$();
   const __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.dynamic]));
   const __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   const _AsyncCallback = dart.typedef('_AsyncCallback', () => dart.functionType(dart.void, []));
   class _AsyncCallbackEntry extends core.Object {
     _AsyncCallbackEntry(callback) {
       this.callback = callback;
       this.next = null;
     }
   }
   dart.setSignature(_AsyncCallbackEntry, {
@@ skipping 132 matching lines @@
   });
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
       return _AsyncRun._initializeScheduleImmediate();
     }
   });
   const StreamSubscription$ = dart.generic(function(T) {
     class StreamSubscription extends core.Object {}
     return StreamSubscription;
   });
-  let StreamSubscription = StreamSubscription$();
+  const StreamSubscription = StreamSubscription$();
   const EventSink$ = dart.generic(function(T) {
     class EventSink extends core.Object {}
     EventSink[dart.implements] = () => [core.Sink$(T)];
     return EventSink;
   });
-  let EventSink = EventSink$();
+  const EventSink = EventSink$();
   const _stream = Symbol('_stream');
   const StreamView$ = dart.generic(function(T) {
     class StreamView extends Stream$(T) {
       StreamView(stream) {
         this[_stream] = stream;
         super.Stream();
       }
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
@@ skipping 15 matching lines @@
     }
     dart.setSignature(StreamView, {
       constructors: () => ({StreamView: [StreamView$(T), [Stream$(T)]]}),
       methods: () => ({
         asBroadcastStream: [Stream$(T), [], {onListen: dart.functionType(dart.void, [StreamSubscription$(T)]), onCancel: dart.functionType(dart.void, [StreamSubscription$(T)])}],
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]
       })
     });
     return StreamView;
   });
-  let StreamView = StreamView$();
+  const StreamView = StreamView$();
   const StreamConsumer$ = dart.generic(function(S) {
     class StreamConsumer extends core.Object {}
     return StreamConsumer;
   });
-  let StreamConsumer = StreamConsumer$();
+  const StreamConsumer = StreamConsumer$();
   const StreamSink$ = dart.generic(function(S) {
     class StreamSink extends core.Object {}
     StreamSink[dart.implements] = () => [StreamConsumer$(S), EventSink$(S)];
     return StreamSink;
   });
-  let StreamSink = StreamSink$();
+  const StreamSink = StreamSink$();
   const StreamTransformer$ = dart.generic(function(S, T) {
     class StreamTransformer extends core.Object {
       static new(transformer) {
         return new (_StreamSubscriptionTransformer$(S, T))(transformer);
       }
       static fromHandlers(opts) {
         return new (_StreamHandlerTransformer$(S, T))(opts);
       }
     }
     dart.setSignature(StreamTransformer, {
       constructors: () => ({
         new: [StreamTransformer$(S, T), [dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool])]],
         fromHandlers: [StreamTransformer$(S, T), [], {handleData: dart.functionType(dart.void, [S, EventSink$(T)]), handleError: dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]), handleDone: dart.functionType(dart.void, [EventSink$(T)])}]
       })
     });
     return StreamTransformer;
   });
-  let StreamTransformer = StreamTransformer$();
+  const StreamTransformer = StreamTransformer$();
   const StreamIterator$ = dart.generic(function(T) {
     class StreamIterator extends core.Object {
       static new(stream) {
         return new (_StreamIteratorImpl$(T))(stream);
       }
     }
     dart.setSignature(StreamIterator, {
       constructors: () => ({new: [StreamIterator$(T), [Stream$(T)]]})
     });
     return StreamIterator;
   });
-  let StreamIterator = StreamIterator$();
+  const StreamIterator = StreamIterator$();
   const _ControllerEventSinkWrapper$ = dart.generic(function(T) {
     class _ControllerEventSinkWrapper extends core.Object {
       _ControllerEventSinkWrapper(sink) {
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, T);
         this[_sink].add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0) stackTrace = null;
         this[_sink].addError(error, stackTrace);
       }
       close() {
         this[_sink].close();
       }
     }
     _ControllerEventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_ControllerEventSinkWrapper, {
       constructors: () => ({_ControllerEventSinkWrapper: [_ControllerEventSinkWrapper$(T), [EventSink]]}),
       methods: () => ({
         add: [dart.void, [T]],
         addError: [dart.void, [dart.dynamic], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _ControllerEventSinkWrapper;
   });
-  let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$();
+  const _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$();
   const __CastType12 = dart.typedef('__CastType12', () => dart.functionType(dart.void, [StreamSubscription]));
   const __CastType14 = dart.typedef('__CastType14', () => dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace]));
   const __CastType17 = dart.typedef('__CastType17', () => dart.functionType(dart.void, []));
   const __CastType18 = dart.typedef('__CastType18', () => dart.functionType(dart.void, [EventSink]));
   const StreamController$ = dart.generic(function(T) {
     class StreamController extends core.Object {
       static new(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onPause = opts && 'onPause' in opts ? opts.onPause : null;
         let onResume = opts && 'onResume' in opts ? opts.onResume : null;
@@ skipping 13 matching lines @@
     }
     StreamController[dart.implements] = () => [StreamSink$(T)];
     dart.setSignature(StreamController, {
       constructors: () => ({
         new: [StreamController$(T), [], {onListen: dart.functionType(dart.void, []), onPause: dart.functionType(dart.void, []), onResume: dart.functionType(dart.void, []), onCancel: dart.functionType(dart.dynamic, []), sync: core.bool}],
         broadcast: [StreamController$(T), [], {onListen: dart.functionType(dart.void, []), onCancel: dart.functionType(dart.void, []), sync: core.bool}]
       })
     });
     return StreamController;
   });
-  let StreamController = StreamController$();
+  const StreamController = StreamController$();
   const _StreamControllerLifecycle$ = dart.generic(function(T) {
     class _StreamControllerLifecycle extends core.Object {
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_recordResume](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         return null;
       }
     }
     dart.setSignature(_StreamControllerLifecycle, {
       methods: () => ({
         [_recordPause]: [dart.void, [StreamSubscription$(T)]],
         [_recordResume]: [dart.void, [StreamSubscription$(T)]],
         [_recordCancel]: [Future, [StreamSubscription$(T)]]
       })
     });
     return _StreamControllerLifecycle;
   });
-  let _StreamControllerLifecycle = _StreamControllerLifecycle$();
+  const _StreamControllerLifecycle = _StreamControllerLifecycle$();
   const _varData = Symbol('_varData');
   const _isInitialState = Symbol('_isInitialState');
   const _subscription = Symbol('_subscription');
   const _pendingEvents = Symbol('_pendingEvents');
   const _ensurePendingEvents = Symbol('_ensurePendingEvents');
   const _badEventState = Symbol('_badEventState');
   const _StreamController$ = dart.generic(function(T) {
     class _StreamController extends core.Object {
       _StreamController() {
         this[_varData] = null;
@@ skipping 224 matching lines @@
         [_addError]: [dart.void, [core.Object, core.StackTrace]],
         [_close]: [dart.void, []],
         [_subscribe]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         [_recordCancel]: [Future, [StreamSubscription$(T)]],
         [_recordPause]: [dart.void, [StreamSubscription$(T)]],
         [_recordResume]: [dart.void, [StreamSubscription$(T)]]
       })
     });
     return _StreamController;
   });
-  let _StreamController = _StreamController$();
+  const _StreamController = _StreamController$();
   _StreamController._STATE_INITIAL = 0;
   _StreamController._STATE_SUBSCRIBED = 1;
   _StreamController._STATE_CANCELED = 2;
   _StreamController._STATE_SUBSCRIPTION_MASK = 3;
   _StreamController._STATE_CLOSED = 4;
   _StreamController._STATE_ADDSTREAM = 8;
   const _SyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _SyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         dart.as(data, T);
         this[_subscription][_add](data);
       }
       [_sendError](error, stackTrace) {
         this[_subscription][_addError](error, stackTrace);
       }
       [_sendDone]() {
         this[_subscription][_close]();
       }
     }
     _SyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     dart.setSignature(_SyncStreamControllerDispatch, {
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _SyncStreamControllerDispatch;
   });
-  let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$();
+  const _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$();
   const _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _AsyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         dart.as(data, T);
         this[_subscription][_addPending](new _DelayedData(data));
       }
       [_sendError](error, stackTrace) {
         this[_subscription][_addPending](new _DelayedError(error, stackTrace));
       }
       [_sendDone]() {
         this[_subscription][_addPending](dart.const(new _DelayedDone()));
       }
     }
     _AsyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     dart.setSignature(_AsyncStreamControllerDispatch, {
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _AsyncStreamControllerDispatch;
   });
-  let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$();
+  const _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$();
   const _AsyncStreamController$ = dart.generic(function(T) {
     class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
       _AsyncStreamController(onListen, onPause, onResume, onCancel) {
         this[_onListen] = onListen;
         this[_onPause] = onPause;
         this[_onResume] = onResume;
         this[_onCancel] = onCancel;
         super._StreamController();
       }
     }
     dart.setSignature(_AsyncStreamController, {
       constructors: () => ({_AsyncStreamController: [_AsyncStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.dynamic, [])]]})
     });
     return _AsyncStreamController;
   });
-  let _AsyncStreamController = _AsyncStreamController$();
+  const _AsyncStreamController = _AsyncStreamController$();
   const _SyncStreamController$ = dart.generic(function(T) {
     class _SyncStreamController extends dart.mixin(_StreamController$(T), _SyncStreamControllerDispatch$(T)) {
       _SyncStreamController(onListen, onPause, onResume, onCancel) {
         this[_onListen] = onListen;
         this[_onPause] = onPause;
         this[_onResume] = onResume;
         this[_onCancel] = onCancel;
         super._StreamController();
       }
     }
     dart.setSignature(_SyncStreamController, {
       constructors: () => ({_SyncStreamController: [_SyncStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.dynamic, [])]]})
     });
     return _SyncStreamController;
   });
-  let _SyncStreamController = _SyncStreamController$();
+  const _SyncStreamController = _SyncStreamController$();
   class _NoCallbacks extends core.Object {
     get [_onListen]() {
       return null;
     }
     get [_onPause]() {
       return null;
     }
     get [_onResume]() {
       return null;
     }
     get [_onCancel]() {
       return null;
     }
   }
   const _NoCallbackAsyncStreamController$ = dart.generic(function(T) {
     class _NoCallbackAsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T), _NoCallbacks) {
       _NoCallbackAsyncStreamController() {
         super._StreamController(...arguments);
       }
     }
     return _NoCallbackAsyncStreamController;
   });
-  let _NoCallbackAsyncStreamController = _NoCallbackAsyncStreamController$();
+  const _NoCallbackAsyncStreamController = _NoCallbackAsyncStreamController$();
   const _NoCallbackSyncStreamController$ = dart.generic(function(T) {
     class _NoCallbackSyncStreamController extends dart.mixin(_StreamController$(T), _SyncStreamControllerDispatch$(T), _NoCallbacks) {
       _NoCallbackSyncStreamController() {
         super._StreamController(...arguments);
       }
     }
     return _NoCallbackSyncStreamController;
   });
-  let _NoCallbackSyncStreamController = _NoCallbackSyncStreamController$();
+  const _NoCallbackSyncStreamController = _NoCallbackSyncStreamController$();
   const _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.functionType(dart.dynamic, []));
   function _runGuarded(notificationHandler) {
     if (notificationHandler == null) return null;
     try {
       let result = notificationHandler();
       if (dart.is(result, Future)) return dart.as(result, Future);
       return null;
     } catch (e) {
       let s = dart.stackTrace(e);
       Zone.current.handleUncaughtError(e, s);
@@ skipping 32 matching lines @@
       constructors: () => ({_StreamSinkWrapper: [_StreamSinkWrapper$(T), [StreamController]]}),
       methods: () => ({
         add: [dart.void, [T]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [Future, []],
         addStream: [Future, [Stream$(T)], {cancelOnError: core.bool}]
       })
     });
     return _StreamSinkWrapper;
   });
-  let _StreamSinkWrapper = _StreamSinkWrapper$();
+  const _StreamSinkWrapper = _StreamSinkWrapper$();
   const _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
         this.addSubscription = source.listen(dart.bind(controller, _add), {onError: dart.as(dart.notNull(cancelOnError) ? _AddStreamState$().makeErrorHandler(controller) : dart.bind(controller, _addError), core.Function), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return dart.fn((e, s) => {
           controller[_addError](e, s);
           controller[_close]();
@@ skipping 25 matching lines @@
         pause: [dart.void, []],
         resume: [dart.void, []],
         cancel: [Future, []],
         complete: [dart.void, []]
       }),
       statics: () => ({makeErrorHandler: [dart.dynamic, [_EventSink]]}),
       names: ['makeErrorHandler']
     });
     return _AddStreamState;
   });
-  let _AddStreamState = _AddStreamState$();
+  const _AddStreamState = _AddStreamState$();
   const _StreamControllerAddStreamState$ = dart.generic(function(T) {
     class _StreamControllerAddStreamState extends _AddStreamState$(T) {
       _StreamControllerAddStreamState(controller, varData, source, cancelOnError) {
         this.varData = varData;
         super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cancelOnError);
         if (dart.notNull(controller.isPaused)) {
           this.addSubscription.pause();
         }
       }
     }
     dart.setSignature(_StreamControllerAddStreamState, {
       constructors: () => ({_StreamControllerAddStreamState: [_StreamControllerAddStreamState$(T), [_StreamController, dart.dynamic, Stream, core.bool]]})
     });
     return _StreamControllerAddStreamState;
   });
-  let _StreamControllerAddStreamState = _StreamControllerAddStreamState$();
+  const _StreamControllerAddStreamState = _StreamControllerAddStreamState$();
   const _EventSink$ = dart.generic(function(T) {
     class _EventSink extends core.Object {}
     return _EventSink;
   });
-  let _EventSink = _EventSink$();
+  const _EventSink = _EventSink$();
   const _EventDispatch$ = dart.generic(function(T) {
     class _EventDispatch extends core.Object {}
     return _EventDispatch;
   });
-  let _EventDispatch = _EventDispatch$();
+  const _EventDispatch = _EventDispatch$();
   _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
   _BufferingStreamSubscription._STATE_CLOSED = 2;
   _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
   _BufferingStreamSubscription._STATE_CANCELED = 8;
   _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
   _BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
   _BufferingStreamSubscription._STATE_HAS_PENDING = 64;
   _BufferingStreamSubscription._STATE_PAUSE_COUNT = 128;
   _BufferingStreamSubscription._STATE_PAUSE_COUNT_SHIFT = 7;
   const _EventGenerator = dart.typedef('_EventGenerator', () => dart.functionType(_PendingEvents, []));
@@ skipping 13 matching lines @@
         _[_setPendingEvents](this[_pending]());
         return _;
       }
     }
     dart.setSignature(_GeneratedStreamImpl, {
       constructors: () => ({_GeneratedStreamImpl: [_GeneratedStreamImpl$(T), [_EventGenerator]]}),
       methods: () => ({[_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]})
     });
     return _GeneratedStreamImpl;
   });
-  let _GeneratedStreamImpl = _GeneratedStreamImpl$();
+  const _GeneratedStreamImpl = _GeneratedStreamImpl$();
   const _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
     _PendingEvents() {
       this[_state] = _PendingEvents._STATE_UNSCHEDULED;
     }
     get isScheduled() {
       return this[_state] == _PendingEvents._STATE_SCHEDULED;
     }
     get [_eventScheduled]() {
       return dart.notNull(this[_state]) >= dart.notNull(_PendingEvents._STATE_SCHEDULED);
@@ skipping 62 matching lines @@
     }
     dart.setSignature(_IterablePendingEvents, {
       constructors: () => ({_IterablePendingEvents: [_IterablePendingEvents$(T), [core.Iterable$(T)]]}),
       methods: () => ({
         handleNext: [dart.void, [_EventDispatch]],
         clear: [dart.void, []]
       })
     });
     return _IterablePendingEvents;
   });
-  let _IterablePendingEvents = _IterablePendingEvents$();
+  const _IterablePendingEvents = _IterablePendingEvents$();
   const _DataHandler$ = dart.generic(function(T) {
     const _DataHandler = dart.typedef('_DataHandler', () => dart.functionType(dart.void, [T]));
     return _DataHandler;
   });
-  let _DataHandler = _DataHandler$();
+  const _DataHandler = _DataHandler$();
   const _DoneHandler = dart.typedef('_DoneHandler', () => dart.functionType(dart.void, []));
   function _nullDataHandler(value) {
   }
   dart.fn(_nullDataHandler, dart.void, [dart.dynamic]);
   function _nullErrorHandler(error, stackTrace) {
     if (stackTrace === void 0) stackTrace = null;
     Zone.current.handleUncaughtError(error, stackTrace);
   }
   dart.fn(_nullErrorHandler, dart.void, [dart.dynamic], [core.StackTrace]);
   function _nullDoneHandler() {
   }
   dart.fn(_nullDoneHandler, dart.void, []);
   const _DelayedEvent$ = dart.generic(function(T) {
     class _DelayedEvent extends core.Object {
       _DelayedEvent() {
         this.next = null;
       }
     }
     return _DelayedEvent;
   });
-  let _DelayedEvent = _DelayedEvent$();
+  const _DelayedEvent = _DelayedEvent$();
   const _DelayedData$ = dart.generic(function(T) {
     class _DelayedData extends _DelayedEvent$(T) {
       _DelayedData(value) {
         this.value = value;
         super._DelayedEvent();
       }
       perform(dispatch) {
         dart.as(dispatch, _EventDispatch$(T));
         dispatch[_sendData](this.value);
       }
     }
     dart.setSignature(_DelayedData, {
       constructors: () => ({_DelayedData: [_DelayedData$(T), [T]]}),
       methods: () => ({perform: [dart.void, [_EventDispatch$(T)]]})
     });
     return _DelayedData;
   });
-  let _DelayedData = _DelayedData$();
+  const _DelayedData = _DelayedData$();
   class _DelayedError extends _DelayedEvent {
     _DelayedError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
       super._DelayedEvent();
     }
     perform(dispatch) {
       dispatch[_sendError](this.error, this.stackTrace);
     }
   }
@@ skipping 160 matching lines @@
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         cancel: [Future, []],
         asFuture: [Future, [], [dart.dynamic]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _DoneStreamSubscription;
   });
-  let _DoneStreamSubscription = _DoneStreamSubscription$();
+  const _DoneStreamSubscription = _DoneStreamSubscription$();
   _DoneStreamSubscription._DONE_SENT = 1;
   _DoneStreamSubscription._SCHEDULED = 2;
   _DoneStreamSubscription._PAUSED = 4;
   const _source = Symbol('_source');
   const _onListenHandler = Symbol('_onListenHandler');
   const _onCancelHandler = Symbol('_onCancelHandler');
   const _cancelSubscription = Symbol('_cancelSubscription');
   const _pauseSubscription = Symbol('_pauseSubscription');
   const _resumeSubscription = Symbol('_resumeSubscription');
   const _isSubscriptionPaused = Symbol('_isSubscriptionPaused');
@@ skipping 70 matching lines @@
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
         [_onCancel]: [dart.void, []],
         [_onListen]: [dart.void, []],
         [_cancelSubscription]: [dart.void, []],
         [_pauseSubscription]: [dart.void, [Future]],
         [_resumeSubscription]: [dart.void, []]
       })
     });
     return _AsBroadcastStream;
   });
-  let _AsBroadcastStream = _AsBroadcastStream$();
+  const _AsBroadcastStream = _AsBroadcastStream$();
   const _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
     class _BroadcastSubscriptionWrapper extends core.Object {
       _BroadcastSubscriptionWrapper(stream) {
         this[_stream] = stream;
       }
       onData(handleData) {
         dart.as(handleData, dart.functionType(dart.void, [T]));
         dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription."));
       }
       onError(handleError) {
@@ skipping 30 matching lines @@
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         cancel: [Future, []],
         asFuture: [Future, [], [dart.dynamic]]
       })
     });
     return _BroadcastSubscriptionWrapper;
   });
-  let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$();
+  const _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$();
   const _current = Symbol('_current');
   const _futureOrPrefetch = Symbol('_futureOrPrefetch');
   const _clear = Symbol('_clear');
   const _StreamIteratorImpl$ = dart.generic(function(T) {
     class _StreamIteratorImpl extends core.Object {
       _StreamIteratorImpl(stream) {
         this[_subscription] = null;
         this[_current] = null;
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl$()._STATE_FOUND;
@@ skipping 104 matching lines @@
         moveNext: [Future$(core.bool), []],
         [_clear]: [dart.void, []],
         cancel: [Future, []],
         [_onData]: [dart.void, [T]],
         [_onError]: [dart.void, [core.Object], [core.StackTrace]],
         [_onDone]: [dart.void, []]
       })
     });
     return _StreamIteratorImpl;
   });
-  let _StreamIteratorImpl = _StreamIteratorImpl$();
+  const _StreamIteratorImpl = _StreamIteratorImpl$();
   _StreamIteratorImpl._STATE_FOUND = 0;
   _StreamIteratorImpl._STATE_DONE = 1;
   _StreamIteratorImpl._STATE_MOVING = 2;
   _StreamIteratorImpl._STATE_EXTRA_DATA = 3;
   _StreamIteratorImpl._STATE_EXTRA_ERROR = 4;
   _StreamIteratorImpl._STATE_EXTRA_DONE = 5;
   const __CastType20$ = dart.generic(function(T) {
     const __CastType20 = dart.typedef('__CastType20', () => dart.functionType(dart.void, [T]));
     return __CastType20;
   });
-  let __CastType20 = __CastType20$();
+  const __CastType20 = __CastType20$();
   const __CastType22 = dart.typedef('__CastType22', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
   const __CastType25 = dart.typedef('__CastType25', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   function _runUserCode(userCode, onSuccess, onError) {
     try {
       dart.dcall(onSuccess, userCode());
     } catch (e) {
       let s = dart.stackTrace(e);
       let replacement = Zone.current.errorCallback(e, s);
       if (replacement == null) {
         dart.dcall(onError, e, s);
@@ skipping 83 matching lines @@
       methods: () => ({
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}],
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         [_handleData]: [dart.void, [S, _EventSink$(T)]],
         [_handleError]: [dart.void, [dart.dynamic, core.StackTrace, _EventSink$(T)]],
         [_handleDone]: [dart.void, [_EventSink$(T)]]
       })
     });
     return _ForwardingStream;
   });
-  let _ForwardingStream = _ForwardingStream$();
+  const _ForwardingStream = _ForwardingStream$();
   const _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
     class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
       _ForwardingStreamSubscription(stream, onData, onError, onDone, cancelOnError) {
         this[_stream] = stream;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         this[_subscription] = this[_stream][_source].listen(dart.bind(this, _handleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
       }
       [_add](data) {
         dart.as(data, T);
@@ skipping 35 matching lines @@
       constructors: () => ({_ForwardingStreamSubscription: [_ForwardingStreamSubscription$(S, T), [_ForwardingStream$(S, T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
         [_handleError]: [dart.void, [dart.dynamic, core.StackTrace]],
         [_handleDone]: [dart.void, []]
       })
     });
     return _ForwardingStreamSubscription;
   });
-  let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
+  const _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
   const _Predicate$ = dart.generic(function(T) {
     const _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
     return _Predicate;
   });
-  let _Predicate = _Predicate$();
+  const _Predicate = _Predicate$();
   function _addErrorWithReplacement(sink, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     sink[_addError](error, dart.as(stackTrace, core.StackTrace));
   }
   dart.fn(_addErrorWithReplacement, dart.void, [_EventSink, dart.dynamic, dart.dynamic]);
   const _test = Symbol('_test');
@@ skipping 19 matching lines @@
           sink[_add](inputEvent);
         }
       }
     }
     dart.setSignature(_WhereStream, {
       constructors: () => ({_WhereStream: [_WhereStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _WhereStream;
   });
-  let _WhereStream = _WhereStream$();
+  const _WhereStream = _WhereStream$();
   const _Transformation$ = dart.generic(function(S, T) {
     const _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
     return _Transformation;
   });
-  let _Transformation = _Transformation$();
+  const _Transformation = _Transformation$();
   const _transform = Symbol('_transform');
   const _MapStream$ = dart.generic(function(S, T) {
     class _MapStream extends _ForwardingStream$(S, T) {
       _MapStream(source, transform) {
         this[_transform] = transform;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, S);
         dart.as(sink, _EventSink$(T));
         let outputEvent = null;
         try {
           outputEvent = dart.as(dart.dcall(this[_transform], inputEvent), T);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         sink[_add](outputEvent);
       }
     }
     dart.setSignature(_MapStream, {
       constructors: () => ({_MapStream: [_MapStream$(S, T), [Stream$(S), dart.functionType(T, [S])]]}),
       methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
     });
     return _MapStream;
   });
-  let _MapStream = _MapStream$();
+  const _MapStream = _MapStream$();
   const _expand = Symbol('_expand');
   const _ExpandStream$ = dart.generic(function(S, T) {
     class _ExpandStream extends _ForwardingStream$(S, T) {
       _ExpandStream(source, expand) {
         this[_expand] = expand;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, S);
         dart.as(sink, _EventSink$(T));
         try {
           for (let value of this[_expand](inputEvent)) {
             sink[_add](value);
           }
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
         }
 
       }
     }
     dart.setSignature(_ExpandStream, {
       constructors: () => ({_ExpandStream: [_ExpandStream$(S, T), [Stream$(S), dart.functionType(core.Iterable$(T), [S])]]}),
       methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
     });
     return _ExpandStream;
   });
-  let _ExpandStream = _ExpandStream$();
+  const _ExpandStream = _ExpandStream$();
   const _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
   const _HandleErrorStream$ = dart.generic(function(T) {
     class _HandleErrorStream extends _ForwardingStream$(T, T) {
       _HandleErrorStream(source, onError, test) {
         this[_transform] = onError;
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleError](error, stackTrace, sink) {
         dart.as(sink, _EventSink$(T));
@@ skipping 25 matching lines @@
           sink[_addError](error, stackTrace);
         }
       }
     }
     dart.setSignature(_HandleErrorStream, {
       constructors: () => ({_HandleErrorStream: [_HandleErrorStream$(T), [Stream$(T), core.Function, dart.functionType(core.bool, [dart.dynamic])]]}),
       methods: () => ({[_handleError]: [dart.void, [core.Object, core.StackTrace, _EventSink$(T)]]})
     });
     return _HandleErrorStream;
   });
-  let _HandleErrorStream = _HandleErrorStream$();
+  const _HandleErrorStream = _HandleErrorStream$();
   const _remaining = Symbol('_remaining');
   const _TakeStream$ = dart.generic(function(T) {
     class _TakeStream extends _ForwardingStream$(T, T) {
       _TakeStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number')) dart.throw(new core.ArgumentError(count));
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
           sink[_add](inputEvent);
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           if (this[_remaining] == 0) {
             sink[_close]();
           }
         }
       }
     }
     dart.setSignature(_TakeStream, {
       constructors: () => ({_TakeStream: [_TakeStream$(T), [Stream$(T), core.int]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _TakeStream;
   });
-  let _TakeStream = _TakeStream$();
+  const _TakeStream = _TakeStream$();
   const _TakeWhileStream$ = dart.generic(function(T) {
     class _TakeWhileStream extends _ForwardingStream$(T, T) {
       _TakeWhileStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         let satisfies = null;
@@ skipping 12 matching lines @@
           sink[_close]();
         }
       }
     }
     dart.setSignature(_TakeWhileStream, {
       constructors: () => ({_TakeWhileStream: [_TakeWhileStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _TakeWhileStream;
   });
-  let _TakeWhileStream = _TakeWhileStream$();
+  const _TakeWhileStream = _TakeWhileStream$();
   const _SkipStream$ = dart.generic(function(T) {
     class _SkipStream extends _ForwardingStream$(T, T) {
       _SkipStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number') || dart.notNull(count) < 0) dart.throw(new core.ArgumentError(count));
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           return;
         }
         sink[_add](inputEvent);
       }
     }
     dart.setSignature(_SkipStream, {
       constructors: () => ({_SkipStream: [_SkipStream$(T), [Stream$(T), core.int]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _SkipStream;
   });
-  let _SkipStream = _SkipStream$();
+  const _SkipStream = _SkipStream$();
   const _hasFailed = Symbol('_hasFailed');
   const _SkipWhileStream$ = dart.generic(function(T) {
     class _SkipWhileStream extends _ForwardingStream$(T, T) {
       _SkipWhileStream(source, test) {
         this[_test] = test;
         this[_hasFailed] = false;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
@@ skipping 17 matching lines @@
           sink[_add](inputEvent);
         }
       }
     }
     dart.setSignature(_SkipWhileStream, {
       constructors: () => ({_SkipWhileStream: [_SkipWhileStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _SkipWhileStream;
   });
-  let _SkipWhileStream = _SkipWhileStream$();
+  const _SkipWhileStream = _SkipWhileStream$();
   const _Equality$ = dart.generic(function(T) {
     const _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [T, T]));
     return _Equality;
   });
-  let _Equality = _Equality$();
+  const _Equality = _Equality$();
   const _equals = Symbol('_equals');
   const _DistinctStream$ = dart.generic(function(T) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
         this[_previous] = _DistinctStream$()._SENTINEL;
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
@@ skipping 21 matching lines @@
           }
         }
       }
     }
     dart.setSignature(_DistinctStream, {
       constructors: () => ({_DistinctStream: [_DistinctStream$(T), [Stream$(T), dart.functionType(core.bool, [T, T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _DistinctStream;
   });
-  let _DistinctStream = _DistinctStream$();
+  const _DistinctStream = _DistinctStream$();
   dart.defineLazyProperties(_DistinctStream, {
     get _SENTINEL() {
       return new core.Object();
     },
     set _SENTINEL(_) {}
   });
   const _EventSinkWrapper$ = dart.generic(function(T) {
     class _EventSinkWrapper extends core.Object {
       _EventSinkWrapper(sink) {
         this[_sink] = sink;
@@ skipping 14 matching lines @@
     dart.setSignature(_EventSinkWrapper, {
       constructors: () => ({_EventSinkWrapper: [_EventSinkWrapper$(T), [_EventSink]]}),
       methods: () => ({
         add: [dart.void, [T]],
         addError: [dart.void, [dart.dynamic], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _EventSinkWrapper;
   });
-  let _EventSinkWrapper = _EventSinkWrapper$();
+  const _EventSinkWrapper = _EventSinkWrapper$();
   const _transformerSink = Symbol('_transformerSink');
   const _isSubscribed = Symbol('_isSubscribed');
   const _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
     class _SinkTransformerStreamSubscription extends _BufferingStreamSubscription$(T) {
       _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone, cancelOnError) {
         this[_transformerSink] = null;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         let eventSink = new (_EventSinkWrapper$(T))(this);
         this[_transformerSink] = mapper(eventSink);
@@ skipping 74 matching lines @@
       constructors: () => ({_SinkTransformerStreamSubscription: [_SinkTransformerStreamSubscription$(S, T), [Stream$(S), _SinkMapper$(S, T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
         [_handleError]: [dart.void, [dart.dynamic], [dart.dynamic]],
         [_handleDone]: [dart.void, []]
       })
     });
     return _SinkTransformerStreamSubscription;
   });
-  let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
+  const _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
   const _SinkMapper$ = dart.generic(function(S, T) {
     const _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventSink$(S), [EventSink$(T)]));
     return _SinkMapper;
   });
-  let _SinkMapper = _SinkMapper$();
+  const _SinkMapper = _SinkMapper$();
   const _sinkMapper = Symbol('_sinkMapper');
   const _StreamSinkTransformer$ = dart.generic(function(S, T) {
     class _StreamSinkTransformer extends core.Object {
       _StreamSinkTransformer(sinkMapper) {
         this[_sinkMapper] = sinkMapper;
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return new (_BoundSinkStream$(S, T))(stream, this[_sinkMapper]);
       }
     }
     _StreamSinkTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     dart.setSignature(_StreamSinkTransformer, {
       constructors: () => ({_StreamSinkTransformer: [_StreamSinkTransformer$(S, T), [_SinkMapper$(S, T)]]}),
       methods: () => ({bind: [Stream$(T), [Stream$(S)]]})
     });
     return _StreamSinkTransformer;
   });
-  let _StreamSinkTransformer = _StreamSinkTransformer$();
+  const _StreamSinkTransformer = _StreamSinkTransformer$();
   const _BoundSinkStream$ = dart.generic(function(S, T) {
     class _BoundSinkStream extends Stream$(T) {
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
       _BoundSinkStream(stream, sinkMapper) {
         this[_stream] = stream;
         this[_sinkMapper] = sinkMapper;
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let subscription = new (_SinkTransformerStreamSubscription$(dart.dynamic, T))(this[_stream], this[_sinkMapper], onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     dart.setSignature(_BoundSinkStream, {
       constructors: () => ({_BoundSinkStream: [_BoundSinkStream$(S, T), [Stream$(S), _SinkMapper$(S, T)]]}),
       methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]})
     });
     return _BoundSinkStream;
   });
-  let _BoundSinkStream = _BoundSinkStream$();
+  const _BoundSinkStream = _BoundSinkStream$();
   const _TransformDataHandler$ = dart.generic(function(S, T) {
     const _TransformDataHandler = dart.typedef('_TransformDataHandler', () => dart.functionType(dart.void, [S, EventSink$(T)]));
     return _TransformDataHandler;
   });
-  let _TransformDataHandler = _TransformDataHandler$();
+  const _TransformDataHandler = _TransformDataHandler$();
   const _TransformErrorHandler$ = dart.generic(function(T) {
     const _TransformErrorHandler = dart.typedef('_TransformErrorHandler', () => dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
     return _TransformErrorHandler;
   });
-  let _TransformErrorHandler = _TransformErrorHandler$();
+  const _TransformErrorHandler = _TransformErrorHandler$();
   const _TransformDoneHandler$ = dart.generic(function(T) {
     const _TransformDoneHandler = dart.typedef('_TransformDoneHandler', () => dart.functionType(dart.void, [EventSink$(T)]));
     return _TransformDoneHandler;
   });
-  let _TransformDoneHandler = _TransformDoneHandler$();
+  const _TransformDoneHandler = _TransformDoneHandler$();
   const _HandlerEventSink$ = dart.generic(function(S, T) {
     class _HandlerEventSink extends core.Object {
       _HandlerEventSink(handleData, handleError, handleDone, sink) {
         this[_handleData] = handleData;
         this[_handleError] = handleError;
         this[_handleDone] = handleDone;
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, S);
@@ skipping 11 matching lines @@
     dart.setSignature(_HandlerEventSink, {
       constructors: () => ({_HandlerEventSink: [_HandlerEventSink$(S, T), [_TransformDataHandler$(S, T), _TransformErrorHandler$(T), _TransformDoneHandler$(T), EventSink$(T)]]}),
       methods: () => ({
         add: [dart.void, [S]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _HandlerEventSink;
   });
-  let _HandlerEventSink = _HandlerEventSink$();
+  const _HandlerEventSink = _HandlerEventSink$();
   const _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
       _StreamHandlerTransformer(opts) {
         let handleData = opts && 'handleData' in opts ? opts.handleData : null;
         let handleError = opts && 'handleError' in opts ? opts.handleError : null;
         let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
         super._StreamSinkTransformer(dart.fn(outputSink => {
           dart.as(outputSink, EventSink$(T));
           if (handleData == null) handleData = dart.as(_StreamHandlerTransformer$()._defaultHandleData, __CastType27);
           if (handleError == null) handleError = dart.as(_StreamHandlerTransformer$()._defaultHandleError, __CastType30);
@@ skipping 20 matching lines @@
       methods: () => ({bind: [Stream$(T), [Stream$(S)]]}),
       statics: () => ({
         _defaultHandleData: [dart.void, [dart.dynamic, EventSink]],
         _defaultHandleError: [dart.void, [dart.dynamic, core.StackTrace, EventSink]],
         _defaultHandleDone: [dart.void, [EventSink]]
       }),
       names: ['_defaultHandleData', '_defaultHandleError', '_defaultHandleDone']
     });
     return _StreamHandlerTransformer;
   });
-  let _StreamHandlerTransformer = _StreamHandlerTransformer$();
+  const _StreamHandlerTransformer = _StreamHandlerTransformer$();
   const _SubscriptionTransformer$ = dart.generic(function(S, T) {
     const _SubscriptionTransformer = dart.typedef('_SubscriptionTransformer', () => dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool]));
     return _SubscriptionTransformer;
   });
-  let _SubscriptionTransformer = _SubscriptionTransformer$();
+  const _SubscriptionTransformer = _SubscriptionTransformer$();
   const _transformer = Symbol('_transformer');
   const _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
     class _StreamSubscriptionTransformer extends core.Object {
       _StreamSubscriptionTransformer(transformer) {
         this[_transformer] = transformer;
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return new (_BoundSubscriptionStream$(S, T))(stream, this[_transformer]);
       }
     }
     _StreamSubscriptionTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     dart.setSignature(_StreamSubscriptionTransformer, {
       constructors: () => ({_StreamSubscriptionTransformer: [_StreamSubscriptionTransformer$(S, T), [_SubscriptionTransformer$(S, T)]]}),
       methods: () => ({bind: [Stream$(T), [Stream$(S)]]})
     });
     return _StreamSubscriptionTransformer;
   });
-  let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$();
+  const _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$();
   const _BoundSubscriptionStream$ = dart.generic(function(S, T) {
     class _BoundSubscriptionStream extends Stream$(T) {
       _BoundSubscriptionStream(stream, transformer) {
         this[_stream] = stream;
         this[_transformer] = transformer;
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let result = this[_transformer](this[_stream], cancelOnError);
         result.onData(onData);
         result.onError(onError);
         result.onDone(onDone);
         return result;
       }
     }
     dart.setSignature(_BoundSubscriptionStream, {
       constructors: () => ({_BoundSubscriptionStream: [_BoundSubscriptionStream$(S, T), [Stream$(S), _SubscriptionTransformer$(S, T)]]}),
       methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {onError: core.Function, onDone: dart.functionType(dart.void, []), cancelOnError: core.bool}]})
     });
     return _BoundSubscriptionStream;
   });
-  let _BoundSubscriptionStream = _BoundSubscriptionStream$();
+  const _BoundSubscriptionStream = _BoundSubscriptionStream$();
   const __CastType27$ = dart.generic(function(S, T) {
     const __CastType27 = dart.typedef('__CastType27', () => dart.functionType(dart.void, [S, EventSink$(T)]));
     return __CastType27;
   });
-  let __CastType27 = __CastType27$();
+  const __CastType27 = __CastType27$();
   const __CastType30$ = dart.generic(function(T) {
     const __CastType30 = dart.typedef('__CastType30', () => dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
     return __CastType30;
   });
-  let __CastType30 = __CastType30$();
+  const __CastType30 = __CastType30$();
   class Timer extends core.Object {
     static new(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createTimer(duration, callback);
       }
       return Zone.current.createTimer(duration, Zone.current.bindCallback(callback, {runGuarded: true}));
     }
     static periodic(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createPeriodicTimer(duration, callback);
@@ skipping 923 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 });