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

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 44 matching lines @@
         result = dart.notNull(result) + `\nStack Trace:\n${this.stackTrace}`;
       }
       return result;
     }
   }
   dart.setSignature(_UncaughtAsyncError, {
     constructors: () => ({_UncaughtAsyncError: [_UncaughtAsyncError, [dart.dynamic, core.StackTrace]]}),
     statics: () => ({_getBestStackTrace: [core.StackTrace, [dart.dynamic, core.StackTrace]]}),
     names: ['_getBestStackTrace']
   });
-  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  let _add = Symbol('_add');
-  let _closeUnchecked = Symbol('_closeUnchecked');
-  let _addError = Symbol('_addError');
-  let _completeError = Symbol('_completeError');
-  let _complete = Symbol('_complete');
-  let _sink = Symbol('_sink');
-  let Stream$ = dart.generic(function(T) {
+  const __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  const _add = Symbol('_add');
+  const _closeUnchecked = Symbol('_closeUnchecked');
+  const _addError = Symbol('_addError');
+  const _completeError = Symbol('_completeError');
+  const _complete = Symbol('_complete');
+  const _sink = Symbol('_sink');
+  const Stream$ = dart.generic(function(T) {
     class Stream extends core.Object {
       Stream() {
       }
       static fromFuture(future) {
         let controller = dart.as(StreamController$(T).new({sync: true}), _StreamController$(T));
         future.then(dart.fn(value => {
           controller[_add](dart.as(value, T));
           controller[_closeUnchecked]();
         }), {onError: dart.fn((error, stackTrace) => {
             controller[_addError](error, dart.as(stackTrace, core.StackTrace));
@@ skipping 71 matching lines @@
         return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         return new (_MapStream$(T, dart.dynamic))(this, convert);
       }
       asyncMap(convert) {
         dart.as(convert, dart.functionType(dart.dynamic, [T]));
         let controller = null;
         let subscription = null;
-        let onListen = (function() {
+        const onListen = (function() {
           let add = dart.bind(controller, 'add');
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = dart.as(controller, _EventSink$(T));
           let addError = dart.bind(eventSink, _addError);
           subscription = this.listen(dart.fn(event => {
             dart.as(event, T);
             let newValue = null;
             try {
               newValue = convert(event);
             } catch (e) {
@@ skipping 23 matching lines @@
             }), onCancel: dart.fn(() => {
               subscription.cancel();
             }), sync: true});
         }
         return controller.stream;
       }
       asyncExpand(convert) {
         dart.as(convert, dart.functionType(Stream$(), [T]));
         let controller = null;
         let subscription = null;
-        let onListen = (function() {
+        const onListen = (function() {
           dart.assert(dart.is(controller, _StreamController) || dart.is(controller, _BroadcastStreamController));
           let eventSink = dart.as(controller, _EventSink$(T));
           subscription = this.listen(dart.fn(event => {
             dart.as(event, T);
             let newStream = null;
             try {
               newStream = convert(event);
             } catch (e) {
               let s = dart.stackTrace(e);
               controller.addError(e, s);
@@ skipping 458 matching lines @@
           let eventSink = dart.as(controller, _EventSink$(T));
           eventSink[_addError](error, stackTrace);
           timer = zone.createTimer(timeLimit, dart.as(timeout2, dart.functionType(dart.void, [])));
         }
         dart.fn(onError, dart.void, [dart.dynamic, core.StackTrace]);
         function onDone() {
           timer.cancel();
           controller.close();
         }
         dart.fn(onDone, dart.void, []);
-        let onListen = (function() {
+        const onListen = (function() {
           zone = Zone.current;
           if (onTimeout == null) {
             timeout2 = dart.fn(() => {
               controller.addError(new TimeoutException("No stream event", timeLimit), null);
             });
           } else {
             onTimeout = dart.as(zone.registerUnaryCallback(onTimeout), __CastType18);
             let wrapper = new _ControllerEventSinkWrapper(null);
             timeout2 = dart.fn(() => {
               wrapper[_sink] = controller;
@@ skipping 58 matching lines @@
         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$();
-  let _createSubscription = Symbol('_createSubscription');
-  let _onListen = Symbol('_onListen');
-  let _StreamImpl$ = dart.generic(function(T) {
+  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;
         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;
@@ skipping 12 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$();
-  let _controller = Symbol('_controller');
-  let _subscribe = Symbol('_subscribe');
-  let _ControllerStream$ = dart.generic(function(T) {
+  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, []));
         return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
@@ 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$();
-  let _BroadcastStream$ = dart.generic(function(T) {
+  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$();
-  let _next = Symbol('_next');
-  let _previous = Symbol('_previous');
+  const _next = Symbol('_next');
+  const _previous = Symbol('_previous');
   class _BroadcastSubscriptionLink extends core.Object {
     _BroadcastSubscriptionLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
-  let _zone = Symbol('_zone');
-  let _state = Symbol('_state');
-  let _onData = Symbol('_onData');
-  let _onError = Symbol('_onError');
-  let _onDone = Symbol('_onDone');
-  let _cancelFuture = Symbol('_cancelFuture');
-  let _pending = Symbol('_pending');
-  let _setPendingEvents = Symbol('_setPendingEvents');
-  let _isCanceled = Symbol('_isCanceled');
-  let _extractPending = Symbol('_extractPending');
-  let _isPaused = Symbol('_isPaused');
-  let _isInputPaused = Symbol('_isInputPaused');
-  let _inCallback = Symbol('_inCallback');
-  let _guardCallback = Symbol('_guardCallback');
-  let _onPause = Symbol('_onPause');
-  let _decrementPauseCount = Symbol('_decrementPauseCount');
-  let _hasPending = Symbol('_hasPending');
-  let _mayResumeInput = Symbol('_mayResumeInput');
-  let _onResume = Symbol('_onResume');
-  let _cancel = Symbol('_cancel');
-  let _isClosed = Symbol('_isClosed');
-  let _waitsForCancel = Symbol('_waitsForCancel');
-  let _canFire = Symbol('_canFire');
-  let _cancelOnError = Symbol('_cancelOnError');
-  let _onCancel = Symbol('_onCancel');
-  let _incrementPauseCount = Symbol('_incrementPauseCount');
-  let _sendData = Symbol('_sendData');
-  let _addPending = Symbol('_addPending');
-  let _sendError = Symbol('_sendError');
-  let _sendDone = Symbol('_sendDone');
-  let _close = Symbol('_close');
-  let _checkState = Symbol('_checkState');
-  let _BufferingStreamSubscription$ = dart.generic(function(T) {
+  const _zone = Symbol('_zone');
+  const _state = Symbol('_state');
+  const _onData = Symbol('_onData');
+  const _onError = Symbol('_onError');
+  const _onDone = Symbol('_onDone');
+  const _cancelFuture = Symbol('_cancelFuture');
+  const _pending = Symbol('_pending');
+  const _setPendingEvents = Symbol('_setPendingEvents');
+  const _isCanceled = Symbol('_isCanceled');
+  const _extractPending = Symbol('_extractPending');
+  const _isPaused = Symbol('_isPaused');
+  const _isInputPaused = Symbol('_isInputPaused');
+  const _inCallback = Symbol('_inCallback');
+  const _guardCallback = Symbol('_guardCallback');
+  const _onPause = Symbol('_onPause');
+  const _decrementPauseCount = Symbol('_decrementPauseCount');
+  const _hasPending = Symbol('_hasPending');
+  const _mayResumeInput = Symbol('_mayResumeInput');
+  const _onResume = Symbol('_onResume');
+  const _cancel = Symbol('_cancel');
+  const _isClosed = Symbol('_isClosed');
+  const _waitsForCancel = Symbol('_waitsForCancel');
+  const _canFire = Symbol('_canFire');
+  const _cancelOnError = Symbol('_cancelOnError');
+  const _onCancel = Symbol('_onCancel');
+  const _incrementPauseCount = Symbol('_incrementPauseCount');
+  const _sendData = Symbol('_sendData');
+  const _addPending = Symbol('_addPending');
+  const _sendError = Symbol('_sendError');
+  const _sendDone = Symbol('_sendDone');
+  const _close = Symbol('_close');
+  const _checkState = Symbol('_checkState');
+  const _BufferingStreamSubscription$ = dart.generic(function(T) {
     class _BufferingStreamSubscription extends core.Object {
       _BufferingStreamSubscription(onData, onError, onDone, cancelOnError) {
         this[_zone] = Zone.current;
         this[_state] = dart.notNull(cancelOnError) ? _BufferingStreamSubscription$()._STATE_CANCEL_ON_ERROR : 0;
         this[_onData] = null;
         this[_onError] = null;
         this[_onDone] = null;
         this[_cancelFuture] = null;
         this[_pending] = null;
         this.onData(onData);
@@ skipping 196 matching lines @@
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         this[_zone].runUnaryGuarded(this[_onData], data);
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         this[_checkState](wasInputPaused);
       }
       [_sendError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
-        let sendError = (function() {
+        const sendError = (function() {
           if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           if (dart.is(this[_onError], ZoneBinaryCallback)) {
             this[_zone].runBinaryGuarded(dart.as(this[_onError], __CastType22), error, stackTrace);
           } else {
             this[_zone].runUnaryGuarded(dart.as(this[_onError], __CastType25), error);
           }
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         }).bind(this);
         dart.fn(sendError, dart.void, []);
         if (dart.notNull(this[_cancelOnError])) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
           this[_cancel]();
           if (dart.is(this[_cancelFuture], Future)) {
             this[_cancelFuture].whenComplete(sendError);
           } else {
             sendError();
           }
         } else {
           sendError();
           this[_checkState](wasInputPaused);
         }
       }
       [_sendDone]() {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
-        let sendDone = (function() {
+        const sendDone = (function() {
           if (!dart.notNull(this[_waitsForCancel]))
             return;
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_CANCELED) | dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           this[_zone].runGuarded(this[_onDone]);
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         }).bind(this);
         dart.fn(sendDone, dart.void, []);
         this[_cancel]();
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_WAIT_FOR_CANCEL);
         if (dart.is(this[_cancelFuture], Future)) {
@@ skipping 66 matching lines @@
         [_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$();
-  let _recordCancel = Symbol('_recordCancel');
-  let _recordPause = Symbol('_recordPause');
-  let _recordResume = Symbol('_recordResume');
-  let _ControllerSubscription$ = dart.generic(function(T) {
+  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$();
-  let _eventState = Symbol('_eventState');
-  let _expectsEvent = Symbol('_expectsEvent');
-  let _toggleEventId = Symbol('_toggleEventId');
-  let _isFiring = Symbol('_isFiring');
-  let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
-  let _removeAfterFiring = Symbol('_removeAfterFiring');
-  let _BroadcastSubscription$ = dart.generic(function(T) {
+  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;
         this[_next] = null;
         this[_previous] = null;
         super._ControllerSubscription(dart.as(controller, _StreamControllerLifecycle$(T)), onData, onError, onDone, cancelOnError);
         this[_next] = this[_previous] = this;
       }
       [_expectsEvent](eventId) {
         return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription$()._STATE_EVENT_ID)) == eventId;
@@ skipping 22 matching lines @@
         [_toggleEventId]: [dart.void, []],
         [_setRemoveAfterFiring]: [dart.void, []]
       })
     });
     return _BroadcastSubscription;
   });
   let _BroadcastSubscription = _BroadcastSubscription$();
   _BroadcastSubscription._STATE_EVENT_ID = 1;
   _BroadcastSubscription._STATE_FIRING = 2;
   _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
-  let _addStreamState = Symbol('_addStreamState');
-  let _doneFuture = Symbol('_doneFuture');
-  let _isEmpty = Symbol('_isEmpty');
-  let _hasOneListener = Symbol('_hasOneListener');
-  let _isAddingStream = Symbol('_isAddingStream');
-  let _mayAddEvent = Symbol('_mayAddEvent');
-  let _ensureDoneFuture = Symbol('_ensureDoneFuture');
-  let _addListener = Symbol('_addListener');
-  let _removeListener = Symbol('_removeListener');
-  let _callOnCancel = Symbol('_callOnCancel');
-  let _addEventError = Symbol('_addEventError');
-  let _forEachListener = Symbol('_forEachListener');
-  let _mayComplete = Symbol('_mayComplete');
-  let _asyncComplete = Symbol('_asyncComplete');
-  let _BroadcastStreamController$ = dart.generic(function(T) {
+  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');
+  const _addListener = Symbol('_addListener');
+  const _removeListener = Symbol('_removeListener');
+  const _callOnCancel = Symbol('_callOnCancel');
+  const _addEventError = Symbol('_addEventError');
+  const _forEachListener = Symbol('_forEachListener');
+  const _mayComplete = Symbol('_mayComplete');
+  const _asyncComplete = Symbol('_asyncComplete');
+  const _BroadcastStreamController$ = dart.generic(function(T) {
     class _BroadcastStreamController extends core.Object {
       _BroadcastStreamController(onListen, onCancel) {
         this[_onListen] = onListen;
         this[_onCancel] = onCancel;
         this[_state] = _BroadcastStreamController$()._STATE_INITIAL;
         this[_next] = null;
         this[_previous] = null;
         this[_addStreamState] = null;
         this[_doneFuture] = null;
         this[_next] = this[_previous] = this;
@@ skipping 217 matching lines @@
       })
     });
     return _BroadcastStreamController;
   });
   let _BroadcastStreamController = _BroadcastStreamController$();
   _BroadcastStreamController._STATE_INITIAL = 0;
   _BroadcastStreamController._STATE_EVENT_ID = 1;
   _BroadcastStreamController._STATE_FIRING = 2;
   _BroadcastStreamController._STATE_CLOSED = 4;
   _BroadcastStreamController._STATE_ADDSTREAM = 8;
-  let _SyncBroadcastStreamController$ = dart.generic(function(T) {
+  const _SyncBroadcastStreamController$ = dart.generic(function(T) {
     class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
         if (dart.notNull(this[_isEmpty]))
           return;
         if (dart.notNull(this[_hasOneListener])) {
           this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_FIRING);
@@ skipping 35 matching lines @@
       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$();
-  let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
+  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 @@
       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$();
-  let _addPendingEvent = Symbol('_addPendingEvent');
-  let _AsBroadcastStreamController$ = dart.generic(function(T) {
+  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);
       }
       [_addPendingEvent](event) {
         if (this[_pending] == null) {
@@ skipping 48 matching lines @@
     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$();
-  let _pauseCount = Symbol('_pauseCount');
-  let _resume = Symbol('_resume');
-  let _DoneSubscription$ = dart.generic(function(T) {
+  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]));
       }
       onError(handleError) {}
       onDone(handleDone) {
         dart.as(handleDone, dart.functionType(dart.void, []));
@@ skipping 34 matching lines @@
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         [_resume]: [dart.void, [dart.dynamic]],
         cancel: [Future, []],
         asFuture: [Future, [], [core.Object]]
       })
     });
     return _DoneSubscription;
   });
   let _DoneSubscription = _DoneSubscription$();
-  let __CastType2$ = dart.generic(function(T) {
-    let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
+  const __CastType2$ = dart.generic(function(T) {
+    const __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
     return __CastType2;
   });
   let __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.');
     }
   }
   dart.setSignature(DeferredLibrary, {
     constructors: () => ({DeferredLibrary: [DeferredLibrary, [core.String], {uri: core.String}]}),
     methods: () => ({load: [Future$(core.Null), []]})
   });
   DeferredLibrary[dart.metadata] = () => [dart.const(new core.Deprecated("Dart sdk v. 1.8"))];
-  let _s = Symbol('_s');
+  const _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
     DeferredLoadException(s) {
       this[_s] = s;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
   DeferredLoadException[dart.implements] = () => [core.Exception];
   dart.setSignature(DeferredLoadException, {
     constructors: () => ({DeferredLoadException: [DeferredLoadException, [core.String]]})
   });
-  let _completeWithValue = Symbol('_completeWithValue');
-  let Future$ = dart.generic(function(T) {
+  const _completeWithValue = Symbol('_completeWithValue');
+  const Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       static new(computation) {
         let result = new (_Future$(T))();
         Timer.run(dart.fn(() => {
           try {
             result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
@@ skipping 179 matching lines @@
         result = `TimeoutException after ${this.duration}`;
       if (this.message != null)
         result = `${result}: ${this.message}`;
       return result;
     }
   }
   TimeoutException[dart.implements] = () => [core.Exception];
   dart.setSignature(TimeoutException, {
     constructors: () => ({TimeoutException: [TimeoutException, [core.String], [core.Duration]]})
   });
-  let Completer$ = dart.generic(function(T) {
+  const Completer$ = dart.generic(function(T) {
     class Completer extends core.Object {
       static new() {
         return new (_AsyncCompleter$(T))();
       }
       static sync() {
         return new (_SyncCompleter$(T))();
       }
     }
     dart.setSignature(Completer, {
       constructors: () => ({
@@ skipping 10 matching lines @@
       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]);
-  let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  let _FutureOnValue$ = dart.generic(function(T) {
-    let _FutureOnValue = dart.typedef('_FutureOnValue', () => dart.functionType(dart.dynamic, [T]));
+  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$();
-  let _FutureErrorTest = dart.typedef('_FutureErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
-  let _FutureAction = dart.typedef('_FutureAction', () => dart.functionType(dart.dynamic, []));
-  let _Completer$ = dart.generic(function(T) {
+  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$();
-  let _asyncCompleteError = Symbol('_asyncCompleteError');
-  let _AsyncCompleter$ = dart.generic(function(T) {
+  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$();
-  let _SyncCompleter$ = dart.generic(function(T) {
+  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$();
-  let _nextListener = Symbol('_nextListener');
-  let _onValue = Symbol('_onValue');
-  let _errorTest = Symbol('_errorTest');
-  let _whenCompleteAction = Symbol('_whenCompleteAction');
+  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;
       this[_nextListener] = null;
     }
     catchError(result, errorCallback, test) {
       this.result = result;
@@ skipping 62 matching lines @@
   _FutureListener.MASK_VALUE = 1;
   _FutureListener.MASK_ERROR = 2;
   _FutureListener.MASK_TEST_ERROR = 4;
   _FutureListener.MASK_WHENCOMPLETE = 8;
   _FutureListener.STATE_CHAIN = 0;
   _FutureListener.STATE_THEN = _FutureListener.MASK_VALUE;
   _FutureListener.STATE_THEN_ONERROR = dart.notNull(_FutureListener.MASK_VALUE) | dart.notNull(_FutureListener.MASK_ERROR);
   _FutureListener.STATE_CATCHERROR = _FutureListener.MASK_ERROR;
   _FutureListener.STATE_CATCHERROR_TEST = dart.notNull(_FutureListener.MASK_ERROR) | dart.notNull(_FutureListener.MASK_TEST_ERROR);
   _FutureListener.STATE_WHENCOMPLETE = _FutureListener.MASK_WHENCOMPLETE;
-  let _resultOrListeners = Symbol('_resultOrListeners');
-  let _isChained = Symbol('_isChained');
-  let _isComplete = Symbol('_isComplete');
-  let _hasValue = Symbol('_hasValue');
-  let _hasError = Symbol('_hasError');
-  let _markPendingCompletion = Symbol('_markPendingCompletion');
-  let _value = Symbol('_value');
-  let _error = Symbol('_error');
-  let _setValue = Symbol('_setValue');
-  let _setErrorObject = Symbol('_setErrorObject');
-  let _setError = Symbol('_setError');
-  let _removeListeners = Symbol('_removeListeners');
-  let _Future$ = dart.generic(function(T) {
+  const _resultOrListeners = Symbol('_resultOrListeners');
+  const _isChained = Symbol('_isChained');
+  const _isComplete = Symbol('_isComplete');
+  const _hasValue = Symbol('_hasValue');
+  const _hasError = Symbol('_hasError');
+  const _markPendingCompletion = Symbol('_markPendingCompletion');
+  const _value = Symbol('_value');
+  const _error = Symbol('_error');
+  const _setValue = Symbol('_setValue');
+  const _setErrorObject = Symbol('_setErrorObject');
+  const _setError = Symbol('_setError');
+  const _removeListeners = Symbol('_removeListeners');
+  const _Future$ = dart.generic(function(T) {
     class _Future extends core.Object {
       _Future() {
         this[_zone] = Zone.current;
         this[_state] = _Future$()._INCOMPLETE;
         this[_resultOrListeners] = null;
       }
       immediate(value) {
         this[_zone] = Zone.current;
         this[_state] = _Future$()._INCOMPLETE;
         this[_resultOrListeners] = null;
@@ skipping 439 matching lines @@
       names: ['_chainForeignFuture', '_chainCoreFuture', '_propagateToListeners']
     });
     return _Future;
   });
   let _Future = _Future$();
   _Future._INCOMPLETE = 0;
   _Future._PENDING_COMPLETE = 1;
   _Future._CHAINED = 2;
   _Future._VALUE = 4;
   _Future._ERROR = 8;
-  let __CastType6$ = dart.generic(function(T) {
-    let __CastType6 = dart.typedef('__CastType6', () => dart.functionType(dart.dynamic, [T]));
+  const __CastType6$ = dart.generic(function(T) {
+    const __CastType6 = dart.typedef('__CastType6', () => dart.functionType(dart.dynamic, [T]));
     return __CastType6;
   });
   let __CastType6 = __CastType6$();
-  let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.dynamic]));
-  let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  let _AsyncCallback = dart.typedef('_AsyncCallback', () => dart.functionType(dart.void, []));
+  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, {
     constructors: () => ({_AsyncCallbackEntry: [_AsyncCallbackEntry, [_AsyncCallback]]})
   });
   exports._nextCallback = null;
@@ skipping 127 matching lines @@
       _scheduleImmediateWithSetImmediate: [dart.void, [dart.functionType(dart.void, [])]],
       _scheduleImmediateWithTimer: [dart.void, [dart.functionType(dart.void, [])]]
     }),
     names: ['_scheduleImmediate', '_initializeScheduleImmediate', '_scheduleImmediateJsOverride', '_scheduleImmediateWithSetImmediate', '_scheduleImmediateWithTimer']
   });
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
       return _AsyncRun._initializeScheduleImmediate();
     }
   });
-  let StreamSubscription$ = dart.generic(function(T) {
+  const StreamSubscription$ = dart.generic(function(T) {
     class StreamSubscription extends core.Object {}
     return StreamSubscription;
   });
   let StreamSubscription = StreamSubscription$();
-  let EventSink$ = dart.generic(function(T) {
+  const EventSink$ = dart.generic(function(T) {
     class EventSink extends core.Object {}
     EventSink[dart.implements] = () => [core.Sink$(T)];
     return EventSink;
   });
   let EventSink = EventSink$();
-  let _stream = Symbol('_stream');
-  let StreamView$ = dart.generic(function(T) {
+  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;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
@@ skipping 14 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$();
-  let StreamConsumer$ = dart.generic(function(S) {
+  const StreamConsumer$ = dart.generic(function(S) {
     class StreamConsumer extends core.Object {}
     return StreamConsumer;
   });
   let StreamConsumer = StreamConsumer$();
-  let StreamSink$ = dart.generic(function(S) {
+  const StreamSink$ = dart.generic(function(S) {
     class StreamSink extends core.Object {}
     StreamSink[dart.implements] = () => [StreamConsumer$(S), EventSink$(S)];
     return StreamSink;
   });
   let StreamSink = StreamSink$();
-  let StreamTransformer$ = dart.generic(function(S, T) {
+  const StreamTransformer$ = dart.generic(function(S, T) {
     class StreamTransformer extends core.Object {
       static new(transformer) {
         return new _StreamSubscriptionTransformer(transformer);
       }
       static fromHandlers(opts) {
         return new _StreamHandlerTransformer(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$();
-  let StreamIterator$ = dart.generic(function(T) {
+  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$();
-  let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
+  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$();
-  let __CastType12 = dart.typedef('__CastType12', () => dart.functionType(dart.void, [StreamSubscription]));
-  let __CastType14 = dart.typedef('__CastType14', () => dart.functionType(dart.dynamic, [dart.dynamic, core.StackTrace]));
-  let __CastType17 = dart.typedef('__CastType17', () => dart.functionType(dart.void, []));
-  let __CastType18 = dart.typedef('__CastType18', () => dart.functionType(dart.void, [EventSink]));
-  let StreamController$ = dart.generic(function(T) {
+  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;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         if (onListen == null && onPause == null && onResume == null && onCancel == null) {
           return dart.as(dart.notNull(sync) ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
         }
         return dart.notNull(sync) ? new (_SyncStreamController$(T))(onListen, onPause, onResume, onCancel) : new (_AsyncStreamController$(T))(onListen, onPause, onResume, onCancel);
       }
       static broadcast(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         return dart.notNull(sync) ? new (_SyncBroadcastStreamController$(T))(onListen, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel);
       }
     }
     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$();
-  let _StreamControllerLifecycle$ = dart.generic(function(T) {
+  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$();
-  let _varData = Symbol('_varData');
-  let _isInitialState = Symbol('_isInitialState');
-  let _subscription = Symbol('_subscription');
-  let _pendingEvents = Symbol('_pendingEvents');
-  let _ensurePendingEvents = Symbol('_ensurePendingEvents');
-  let _badEventState = Symbol('_badEventState');
-  let _StreamController$ = dart.generic(function(T) {
+  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;
         this[_state] = _StreamController$()._STATE_INITIAL;
         this[_doneFuture] = null;
       }
       get stream() {
         return new (_ControllerStream$(T))(this);
       }
       get sink() {
@@ skipping 172 matching lines @@
             } catch (e) {
               let s = dart.stackTrace(e);
               result = new _Future();
               result[_asyncCompleteError](e, s);
             }
 
           } else {
             result = result.whenComplete(this[_onCancel]);
           }
         }
-        let complete = (function() {
+        const complete = (function() {
           if (this[_doneFuture] != null && dart.notNull(this[_doneFuture][_mayComplete])) {
             this[_doneFuture][_asyncComplete](null);
           }
         }).bind(this);
         dart.fn(complete, dart.void, []);
         if (result != null) {
           result = result.whenComplete(complete);
         } else {
           complete();
         }
@@ skipping 39 matching lines @@
     });
     return _StreamController;
   });
   let _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;
-  let _SyncStreamControllerDispatch$ = dart.generic(function(T) {
+  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$();
-  let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
+  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$();
-  let _AsyncStreamController$ = dart.generic(function(T) {
+  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$();
-  let _SyncStreamController$ = dart.generic(function(T) {
+  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, {
@@ skipping 19 matching lines @@
   class _NoCallbackAsyncStreamController extends dart.mixin(_StreamController$(dart.dynamic), _AsyncStreamControllerDispatch$(dart.dynamic), _NoCallbacks) {
     _NoCallbackAsyncStreamController() {
       super._StreamController(...arguments);
     }
   }
   class _NoCallbackSyncStreamController extends dart.mixin(_StreamController$(dart.dynamic), _SyncStreamControllerDispatch$(dart.dynamic), _NoCallbacks) {
     _NoCallbackSyncStreamController() {
       super._StreamController(...arguments);
     }
   }
-  let _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.functionType(dart.dynamic, []));
+  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);
     }
 
   }
   dart.fn(_runGuarded, Future, [_NotificationHandler]);
-  let _target = Symbol('_target');
-  let _StreamSinkWrapper$ = dart.generic(function(T) {
+  const _target = Symbol('_target');
+  const _StreamSinkWrapper$ = dart.generic(function(T) {
     class _StreamSinkWrapper extends core.Object {
       _StreamSinkWrapper(target) {
         this[_target] = target;
       }
       add(data) {
         dart.as(data, T);
         this[_target].add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
@@ skipping 18 matching lines @@
       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$();
-  let _AddStreamState$ = dart.generic(function(T) {
+  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.notNull(cancelOnError) ? dart.as(_AddStreamState$().makeErrorHandler(controller), core.Function) : dart.bind(controller, _addError), onDone: dart.bind(controller, _close), cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return dart.fn((e, s) => {
           controller[_addError](e, s);
           controller[_close]();
         }, dart.dynamic, [dart.dynamic, core.StackTrace]);
@@ skipping 25 matching lines @@
         resume: [dart.void, []],
         cancel: [Future, []],
         complete: [dart.void, []]
       }),
       statics: () => ({makeErrorHandler: [dart.dynamic, [_EventSink]]}),
       names: ['makeErrorHandler']
     });
     return _AddStreamState;
   });
   let _AddStreamState = _AddStreamState$();
-  let _StreamControllerAddStreamState$ = dart.generic(function(T) {
+  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$();
-  let _EventSink$ = dart.generic(function(T) {
+  const _EventSink$ = dart.generic(function(T) {
     class _EventSink extends core.Object {}
     return _EventSink;
   });
   let _EventSink = _EventSink$();
-  let _EventDispatch$ = dart.generic(function(T) {
+  const _EventDispatch$ = dart.generic(function(T) {
     class _EventDispatch extends core.Object {}
     return _EventDispatch;
   });
   let _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;
-  let _EventGenerator = dart.typedef('_EventGenerator', () => dart.functionType(_PendingEvents, []));
-  let _isUsed = Symbol('_isUsed');
-  let _GeneratedStreamImpl$ = dart.generic(function(T) {
+  const _EventGenerator = dart.typedef('_EventGenerator', () => dart.functionType(_PendingEvents, []));
+  const _isUsed = Symbol('_isUsed');
+  const _GeneratedStreamImpl$ = dart.generic(function(T) {
     class _GeneratedStreamImpl extends _StreamImpl$(T) {
       _GeneratedStreamImpl(pending) {
         this[_pending] = pending;
         this[_isUsed] = false;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         if (dart.notNull(this[_isUsed]))
           dart.throw(new core.StateError("Stream has already been listened to."));
         this[_isUsed] = true;
         return dart.as((() => {
           let _ = new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
           _[_setPendingEvents](this[_pending]());
           return _;
         }).bind(this)(), StreamSubscription$(T));
       }
     }
     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$();
-  let _eventScheduled = Symbol('_eventScheduled');
+  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 19 matching lines @@
       if (dart.notNull(this.isScheduled))
         this[_state] = _PendingEvents._STATE_CANCELED;
     }
   }
   dart.setSignature(_PendingEvents, {
     methods: () => ({
       schedule: [dart.void, [_EventDispatch]],
       cancelSchedule: [dart.void, []]
     })
   });
-  let _iterator = Symbol('_iterator');
-  let _IterablePendingEvents$ = dart.generic(function(T) {
+  const _iterator = Symbol('_iterator');
+  const _IterablePendingEvents$ = dart.generic(function(T) {
     class _IterablePendingEvents extends _PendingEvents {
       _IterablePendingEvents(data) {
         this[_iterator] = data[dartx.iterator];
         super._PendingEvents();
       }
       get isEmpty() {
         return this[_iterator] == null;
       }
       handleNext(dispatch) {
         if (this[_iterator] == null) {
@@ skipping 25 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$();
-  let _DataHandler$ = dart.generic(function(T) {
-    let _DataHandler = dart.typedef('_DataHandler', () => dart.functionType(dart.void, [T]));
+  const _DataHandler$ = dart.generic(function(T) {
+    const _DataHandler = dart.typedef('_DataHandler', () => dart.functionType(dart.void, [T]));
     return _DataHandler;
   });
   let _DataHandler = _DataHandler$();
-  let _DoneHandler = dart.typedef('_DoneHandler', () => dart.functionType(dart.void, []));
+  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, []);
-  let _DelayedEvent$ = dart.generic(function(T) {
+  const _DelayedEvent$ = dart.generic(function(T) {
     class _DelayedEvent extends core.Object {
       _DelayedEvent() {
         this.next = null;
       }
     }
     return _DelayedEvent;
   });
   let _DelayedEvent = _DelayedEvent$();
-  let _DelayedData$ = dart.generic(function(T) {
+  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);
       }
     }
@@ skipping 70 matching lines @@
       this.firstPendingEvent = this.lastPendingEvent = null;
     }
   }
   dart.setSignature(_StreamImplEvents, {
     methods: () => ({
       add: [dart.void, [_DelayedEvent]],
       handleNext: [dart.void, [_EventDispatch]],
       clear: [dart.void, []]
     })
   });
-  let _unlink = Symbol('_unlink');
-  let _insertBefore = Symbol('_insertBefore');
+  const _unlink = Symbol('_unlink');
+  const _insertBefore = Symbol('_insertBefore');
   class _BroadcastLinkedList extends core.Object {
     _BroadcastLinkedList() {
       this[_next] = null;
       this[_previous] = null;
     }
     [_unlink]() {
       this[_previous][_next] = this[_next];
       this[_next][_previous] = this[_previous];
       this[_next] = this[_previous] = this;
     }
     [_insertBefore](newNext) {
       let newPrevious = newNext[_previous];
       newPrevious[_next] = this;
       newNext[_previous] = this[_previous];
       this[_previous][_next] = newNext;
       this[_previous] = newPrevious;
     }
   }
   dart.setSignature(_BroadcastLinkedList, {
     methods: () => ({
       [_unlink]: [dart.void, []],
       [_insertBefore]: [dart.void, [_BroadcastLinkedList]]
     })
   });
-  let _broadcastCallback = dart.typedef('_broadcastCallback', () => dart.functionType(dart.void, [StreamSubscription]));
-  let _schedule = Symbol('_schedule');
-  let _isSent = Symbol('_isSent');
-  let _isScheduled = Symbol('_isScheduled');
-  let _DoneStreamSubscription$ = dart.generic(function(T) {
+  const _broadcastCallback = dart.typedef('_broadcastCallback', () => dart.functionType(dart.void, [StreamSubscription]));
+  const _schedule = Symbol('_schedule');
+  const _isSent = Symbol('_isSent');
+  const _isScheduled = Symbol('_isScheduled');
+  const _DoneStreamSubscription$ = dart.generic(function(T) {
     class _DoneStreamSubscription extends core.Object {
       _DoneStreamSubscription(onDone) {
         this[_onDone] = onDone;
         this[_zone] = Zone.current;
         this[_state] = 0;
         this[_schedule]();
       }
       get [_isSent]() {
         return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription$()._DONE_SENT)) != 0;
       }
@@ skipping 67 matching lines @@
         asFuture: [Future, [], [dart.dynamic]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _DoneStreamSubscription;
   });
   let _DoneStreamSubscription = _DoneStreamSubscription$();
   _DoneStreamSubscription._DONE_SENT = 1;
   _DoneStreamSubscription._SCHEDULED = 2;
   _DoneStreamSubscription._PAUSED = 4;
-  let _source = Symbol('_source');
-  let _onListenHandler = Symbol('_onListenHandler');
-  let _onCancelHandler = Symbol('_onCancelHandler');
-  let _cancelSubscription = Symbol('_cancelSubscription');
-  let _pauseSubscription = Symbol('_pauseSubscription');
-  let _resumeSubscription = Symbol('_resumeSubscription');
-  let _isSubscriptionPaused = Symbol('_isSubscriptionPaused');
-  let _AsBroadcastStream$ = dart.generic(function(T) {
+  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');
+  const _AsBroadcastStream$ = dart.generic(function(T) {
     class _AsBroadcastStream extends Stream$(T) {
       _AsBroadcastStream(source, onListenHandler, onCancelHandler) {
         this[_source] = source;
         this[_onListenHandler] = dart.as(Zone.current.registerUnaryCallback(onListenHandler), _broadcastCallback);
         this[_onCancelHandler] = dart.as(Zone.current.registerUnaryCallback(onCancelHandler), _broadcastCallback);
         this[_zone] = Zone.current;
         this[_controller] = null;
         this[_subscription] = null;
         super.Stream();
         this[_controller] = new (_AsBroadcastStreamController$(T))(dart.bind(this, _onListen), dart.bind(this, _onCancel));
@@ skipping 64 matching lines @@
         [_onCancel]: [dart.void, []],
         [_onListen]: [dart.void, []],
         [_cancelSubscription]: [dart.void, []],
         [_pauseSubscription]: [dart.void, [Future]],
         [_resumeSubscription]: [dart.void, []]
       })
     });
     return _AsBroadcastStream;
   });
   let _AsBroadcastStream = _AsBroadcastStream$();
-  let _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
+  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) {
         dart.throw(new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription."));
@@ skipping 32 matching lines @@
         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$();
-  let _current = Symbol('_current');
-  let _futureOrPrefetch = Symbol('_futureOrPrefetch');
-  let _clear = Symbol('_clear');
-  let _StreamIteratorImpl$ = dart.generic(function(T) {
+  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;
         this[_subscription] = stream.listen(dart.bind(this, _onData), {onError: dart.bind(this, _onError), onDone: dart.bind(this, _onDone), cancelOnError: true});
       }
       get current() {
         return this[_current];
@@ skipping 109 matching lines @@
     });
     return _StreamIteratorImpl;
   });
   let _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;
-  let __CastType20$ = dart.generic(function(T) {
-    let __CastType20 = dart.typedef('__CastType20', () => dart.functionType(dart.void, [T]));
+  const __CastType20$ = dart.generic(function(T) {
+    const __CastType20 = dart.typedef('__CastType20', () => dart.functionType(dart.void, [T]));
     return __CastType20;
   });
   let __CastType20 = __CastType20$();
-  let __CastType22 = dart.typedef('__CastType22', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
-  let __CastType25 = dart.typedef('__CastType25', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  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);
       } else {
         let error = _nonNullError(replacement.error);
@@ skipping 28 matching lines @@
   dart.fn(_cancelAndErrorClosure, dart.dynamic, [StreamSubscription, _Future]);
   function _cancelAndValue(subscription, future, value) {
     let cancelFuture = subscription.cancel();
     if (dart.is(cancelFuture, Future)) {
       cancelFuture.whenComplete(dart.fn(() => future[_complete](value), dart.void, []));
     } else {
       future[_complete](value);
     }
   }
   dart.fn(_cancelAndValue, dart.void, [StreamSubscription, _Future, dart.dynamic]);
-  let _handleData = Symbol('_handleData');
-  let _handleError = Symbol('_handleError');
-  let _handleDone = Symbol('_handleDone');
-  let _ForwardingStream$ = dart.generic(function(S, T) {
+  const _handleData = Symbol('_handleData');
+  const _handleError = Symbol('_handleError');
+  const _handleDone = Symbol('_handleDone');
+  const _ForwardingStream$ = dart.generic(function(S, T) {
     class _ForwardingStream extends Stream$(T) {
       _ForwardingStream(source) {
         this[_source] = source;
         super.Stream();
       }
       get isBroadcast() {
         return this[_source].isBroadcast;
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
@@ skipping 30 matching lines @@
         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$();
-  let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
+  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);
         if (dart.notNull(this[_isClosed]))
@@ skipping 39 matching lines @@
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
         [_handleError]: [dart.void, [dart.dynamic, core.StackTrace]],
         [_handleDone]: [dart.void, []]
       })
     });
     return _ForwardingStreamSubscription;
   });
   let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
-  let _Predicate$ = dart.generic(function(T) {
-    let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
+  const _Predicate$ = dart.generic(function(T) {
+    const _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
     return _Predicate;
   });
   let _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]);
-  let _test = Symbol('_test');
-  let _WhereStream$ = dart.generic(function(T) {
+  const _test = Symbol('_test');
+  const _WhereStream$ = dart.generic(function(T) {
     class _WhereStream extends _ForwardingStream$(T, T) {
       _WhereStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         if (dart.notNull(satisfies)) {
           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$();
-  let _Transformation$ = dart.generic(function(S, T) {
-    let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
+  const _Transformation$ = dart.generic(function(S, T) {
+    const _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
     return _Transformation;
   });
   let _Transformation = _Transformation$();
-  let _transform = Symbol('_transform');
-  let _MapStream$ = dart.generic(function(S, T) {
+  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$();
-  let _expand = Symbol('_expand');
-  let _ExpandStream$ = dart.generic(function(S, T) {
+  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$();
-  let _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
-  let _HandleErrorStream$ = dart.generic(function(T) {
+  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));
         let matches = true;
         if (this[_test] != null) {
@@ skipping 24 matching lines @@
         }
       }
     }
     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$();
-  let _remaining = Symbol('_remaining');
-  let _TakeStream$ = dart.generic(function(T) {
+  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$();
-  let _TakeWhileStream$ = dart.generic(function(T) {
+  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;
         try {
@@ skipping 12 matching lines @@
         }
       }
     }
     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$();
-  let _SkipStream$ = dart.generic(function(T) {
+  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$();
-  let _hasFailed = Symbol('_hasFailed');
-  let _SkipWhileStream$ = dart.generic(function(T) {
+  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);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_hasFailed])) {
@@ skipping 16 matching lines @@
         }
       }
     }
     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$();
-  let _Equality$ = dart.generic(function(T) {
-    let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [T, T]));
+  const _Equality$ = dart.generic(function(T) {
+    const _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [T, T]));
     return _Equality;
   });
   let _Equality = _Equality$();
-  let _equals = Symbol('_equals');
-  let _DistinctStream$ = dart.generic(function(T) {
+  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);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(core.identical(this[_previous], _DistinctStream$()._SENTINEL))) {
@@ skipping 26 matching lines @@
     });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$();
   dart.defineLazyProperties(_DistinctStream, {
     get _SENTINEL() {
       return new core.Object();
     },
     set _SENTINEL(_) {}
   });
-  let _EventSinkWrapper$ = dart.generic(function(T) {
+  const _EventSinkWrapper$ = dart.generic(function(T) {
     class _EventSinkWrapper extends core.Object {
       _EventSinkWrapper(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]();
       }
     }
     _EventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     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$();
-  let _transformerSink = Symbol('_transformerSink');
-  let _isSubscribed = Symbol('_isSubscribed');
-  let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
+  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);
         this[_subscription] = source.listen(dart.bind(this, _handleData), {onError: dart.bind(this, _handleError), onDone: dart.bind(this, _handleDone)});
       }
       get [_isSubscribed]() {
@@ skipping 75 matching lines @@
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
         [_handleError]: [dart.void, [dart.dynamic], [dart.dynamic]],
         [_handleDone]: [dart.void, []]
       })
     });
     return _SinkTransformerStreamSubscription;
   });
   let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
-  let _SinkMapper$ = dart.generic(function(S, T) {
-    let _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventSink$(S), [EventSink$(T)]));
+  const _SinkMapper$ = dart.generic(function(S, T) {
+    const _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventSink$(S), [EventSink$(T)]));
     return _SinkMapper;
   });
   let _SinkMapper = _SinkMapper$();
-  let _sinkMapper = Symbol('_sinkMapper');
-  let _StreamSinkTransformer$ = dart.generic(function(S, T) {
+  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$();
-  let _BoundSinkStream$ = dart.generic(function(S, T) {
+  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], dart.as(this[_sinkMapper], _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$();
-  let _TransformDataHandler$ = dart.generic(function(S, T) {
-    let _TransformDataHandler = dart.typedef('_TransformDataHandler', () => dart.functionType(dart.void, [S, EventSink$(T)]));
+  const _TransformDataHandler$ = dart.generic(function(S, T) {
+    const _TransformDataHandler = dart.typedef('_TransformDataHandler', () => dart.functionType(dart.void, [S, EventSink$(T)]));
     return _TransformDataHandler;
   });
   let _TransformDataHandler = _TransformDataHandler$();
-  let _TransformErrorHandler$ = dart.generic(function(T) {
-    let _TransformErrorHandler = dart.typedef('_TransformErrorHandler', () => dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
+  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$();
-  let _TransformDoneHandler$ = dart.generic(function(T) {
-    let _TransformDoneHandler = dart.typedef('_TransformDoneHandler', () => dart.functionType(dart.void, [EventSink$(T)]));
+  const _TransformDoneHandler$ = dart.generic(function(T) {
+    const _TransformDoneHandler = dart.typedef('_TransformDoneHandler', () => dart.functionType(dart.void, [EventSink$(T)]));
     return _TransformDoneHandler;
   });
   let _TransformDoneHandler = _TransformDoneHandler$();
-  let _HandlerEventSink$ = dart.generic(function(S, T) {
+  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);
         return this[_handleData](data, this[_sink]);
@@ skipping 12 matching lines @@
       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$();
-  let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
+  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.as(dart.fn(outputSink => {
           dart.as(outputSink, EventSink$(T));
           if (handleData == null)
             handleData = dart.as(_StreamHandlerTransformer$()._defaultHandleData, __CastType27$(S, T));
           if (handleError == null)
@@ skipping 23 matching lines @@
       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$();
-  let _SubscriptionTransformer$ = dart.generic(function(S, T) {
-    let _SubscriptionTransformer = dart.typedef('_SubscriptionTransformer', () => dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool]));
+  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$();
-  let _transformer = Symbol('_transformer');
-  let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
+  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$();
-  let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
+  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$();
-  let __CastType27$ = dart.generic(function(S, T) {
-    let __CastType27 = dart.typedef('__CastType27', () => dart.functionType(dart.void, [S, EventSink$(T)]));
+  const __CastType27$ = dart.generic(function(S, T) {
+    const __CastType27 = dart.typedef('__CastType27', () => dart.functionType(dart.void, [S, EventSink$(T)]));
     return __CastType27;
   });
   let __CastType27 = __CastType27$();
-  let __CastType30$ = dart.generic(function(T) {
-    let __CastType30 = dart.typedef('__CastType30', () => dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
+  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$();
   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}));
     }
@@ skipping 24 matching lines @@
       new: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       periodic: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
     }),
     statics: () => ({
       run: [dart.void, [dart.functionType(dart.void, [])]],
       _createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       _createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
     }),
     names: ['run', '_createTimer', '_createPeriodicTimer']
   });
-  let __CastType34 = dart.typedef('__CastType34', () => dart.functionType(dart.void, [Timer]));
-  let ZoneCallback = dart.typedef('ZoneCallback', () => dart.functionType(dart.dynamic, []));
-  let ZoneUnaryCallback = dart.typedef('ZoneUnaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  let ZoneBinaryCallback = dart.typedef('ZoneBinaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
-  let HandleUncaughtErrorHandler = dart.typedef('HandleUncaughtErrorHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]));
-  let RunHandler = dart.typedef('RunHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
-  let RunUnaryHandler = dart.typedef('RunUnaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]));
-  let RunBinaryHandler = dart.typedef('RunBinaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]));
-  let RegisterCallbackHandler = dart.typedef('RegisterCallbackHandler', () => dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
-  let RegisterUnaryCallbackHandler = dart.typedef('RegisterUnaryCallbackHandler', () => dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]));
-  let RegisterBinaryCallbackHandler = dart.typedef('RegisterBinaryCallbackHandler', () => dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]));
-  let ErrorCallbackHandler = dart.typedef('ErrorCallbackHandler', () => dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]));
-  let ScheduleMicrotaskHandler = dart.typedef('ScheduleMicrotaskHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
-  let CreateTimerHandler = dart.typedef('CreateTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]));
-  let CreatePeriodicTimerHandler = dart.typedef('CreatePeriodicTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]));
-  let PrintHandler = dart.typedef('PrintHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]));
-  let ForkHandler = dart.typedef('ForkHandler', () => dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map]));
+  const __CastType34 = dart.typedef('__CastType34', () => dart.functionType(dart.void, [Timer]));
+  const ZoneCallback = dart.typedef('ZoneCallback', () => dart.functionType(dart.dynamic, []));
+  const ZoneUnaryCallback = dart.typedef('ZoneUnaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  const ZoneBinaryCallback = dart.typedef('ZoneBinaryCallback', () => dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
+  const HandleUncaughtErrorHandler = dart.typedef('HandleUncaughtErrorHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.dynamic, core.StackTrace]));
+  const RunHandler = dart.typedef('RunHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
+  const RunUnaryHandler = dart.typedef('RunUnaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic]), dart.dynamic]));
+  const RunBinaryHandler = dart.typedef('RunBinaryHandler', () => dart.functionType(dart.dynamic, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]), dart.dynamic, dart.dynamic]));
+  const RegisterCallbackHandler = dart.typedef('RegisterCallbackHandler', () => dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
+  const RegisterUnaryCallbackHandler = dart.typedef('RegisterUnaryCallbackHandler', () => dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic])]));
+  const RegisterBinaryCallbackHandler = dart.typedef('RegisterBinaryCallbackHandler', () => dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]));
+  const ErrorCallbackHandler = dart.typedef('ErrorCallbackHandler', () => dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]));
+  const ScheduleMicrotaskHandler = dart.typedef('ScheduleMicrotaskHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(dart.dynamic, [])]));
+  const CreateTimerHandler = dart.typedef('CreateTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]));
+  const CreatePeriodicTimerHandler = dart.typedef('CreatePeriodicTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]));
+  const PrintHandler = dart.typedef('PrintHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]));
+  const ForkHandler = dart.typedef('ForkHandler', () => dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map]));
   class _ZoneFunction extends core.Object {
     _ZoneFunction(zone, func) {
       this.zone = zone;
       this.function = func;
     }
   }
   dart.setSignature(_ZoneFunction, {
     constructors: () => ({_ZoneFunction: [_ZoneFunction, [_Zone, core.Function]]})
   });
   class ZoneSpecification extends core.Object {
@@ skipping 90 matching lines @@
     }
     inSameErrorZone(otherZone) {
       return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
     }
   }
   _Zone[dart.implements] = () => [Zone];
   dart.setSignature(_Zone, {
     constructors: () => ({_Zone: [_Zone, []]}),
     methods: () => ({inSameErrorZone: [core.bool, [Zone]]})
   });
-  let _run = Symbol('_run');
-  let _runUnary = Symbol('_runUnary');
-  let _runBinary = Symbol('_runBinary');
-  let _registerCallback = Symbol('_registerCallback');
-  let _registerUnaryCallback = Symbol('_registerUnaryCallback');
-  let _registerBinaryCallback = Symbol('_registerBinaryCallback');
-  let _errorCallback = Symbol('_errorCallback');
-  let _scheduleMicrotask = Symbol('_scheduleMicrotask');
-  let _createTimer = Symbol('_createTimer');
-  let _createPeriodicTimer = Symbol('_createPeriodicTimer');
-  let _print = Symbol('_print');
-  let _fork = Symbol('_fork');
-  let _handleUncaughtError = Symbol('_handleUncaughtError');
-  let _map = Symbol('_map');
-  let _delegate = Symbol('_delegate');
+  const _run = Symbol('_run');
+  const _runUnary = Symbol('_runUnary');
+  const _runBinary = Symbol('_runBinary');
+  const _registerCallback = Symbol('_registerCallback');
+  const _registerUnaryCallback = Symbol('_registerUnaryCallback');
+  const _registerBinaryCallback = Symbol('_registerBinaryCallback');
+  const _errorCallback = Symbol('_errorCallback');
+  const _scheduleMicrotask = Symbol('_scheduleMicrotask');
+  const _createTimer = Symbol('_createTimer');
+  const _createPeriodicTimer = Symbol('_createPeriodicTimer');
+  const _print = Symbol('_print');
+  const _fork = Symbol('_fork');
+  const _handleUncaughtError = Symbol('_handleUncaughtError');
+  const _map = Symbol('_map');
+  const _delegate = Symbol('_delegate');
   class _RootZone extends _Zone {
     _RootZone() {
       super._Zone();
     }
     get [_run]() {
       return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRun));
     }
     get [_runUnary]() {
       return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunUnary));
     }
@@ skipping 173 matching lines @@
       registerCallback: [ZoneCallback, [dart.functionType(dart.dynamic, [])]],
       registerUnaryCallback: [ZoneUnaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic])]],
       registerBinaryCallback: [ZoneBinaryCallback, [dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
       errorCallback: [AsyncError, [core.Object, core.StackTrace]],
       scheduleMicrotask: [dart.void, [dart.functionType(dart.void, [])]],
       createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]],
       print: [dart.void, [core.String]]
     })
   });
-  let _ROOT_ZONE = dart.const(new _RootZone());
+  const _ROOT_ZONE = dart.const(new _RootZone());
   Zone.ROOT = _ROOT_ZONE;
   Zone._current = _ROOT_ZONE;
   function _parentDelegate(zone) {
     if (zone.parent == null)
       return null;
     return zone.parent[_delegate];
   }
   dart.fn(_parentDelegate, ZoneDelegate, [_Zone]);
-  let _delegationTarget = Symbol('_delegationTarget');
+  const _delegationTarget = Symbol('_delegationTarget');
   class _ZoneDelegate extends core.Object {
     _ZoneDelegate(delegationTarget) {
       this[_delegationTarget] = delegationTarget;
     }
     handleUncaughtError(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_handleUncaughtError];
       let implZone = implementation.zone;
       return dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace);
     }
     run(zone, f) {
@@ skipping 71 matching lines @@
       registerUnaryCallback: [ZoneUnaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic])]],
       registerBinaryCallback: [ZoneBinaryCallback, [Zone, dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])]],
       errorCallback: [AsyncError, [Zone, core.Object, core.StackTrace]],
       scheduleMicrotask: [dart.void, [Zone, dart.functionType(dart.dynamic, [])]],
       createTimer: [Timer, [Zone, core.Duration, dart.functionType(dart.void, [])]],
       createPeriodicTimer: [Timer, [Zone, core.Duration, dart.functionType(dart.void, [Timer])]],
       print: [dart.void, [Zone, core.String]],
       fork: [Zone, [Zone, ZoneSpecification, core.Map]]
     })
   });
-  let _delegateCache = Symbol('_delegateCache');
+  const _delegateCache = Symbol('_delegateCache');
   class _CustomZone extends _Zone {
     get [_delegate]() {
       if (this[_delegateCache] != null)
         return this[_delegateCache];
       this[_delegateCache] = new _ZoneDelegate(this);
       return this[_delegateCache];
     }
     _CustomZone(parent, specification, map) {
       this.parent = parent;
       this[_map] = map;
@@ skipping 389 matching lines @@
       zoneSpecification = ZoneSpecification.from(zoneSpecification, {handleUncaughtError: errorHandler});
     }
     let zone = Zone.current.fork({specification: zoneSpecification, zoneValues: zoneValues});
     if (onError != null) {
       return zone.runGuarded(body);
     } else {
       return zone.run(body);
     }
   }
   dart.fn(runZoned, dart.dynamic, [dart.functionType(dart.dynamic, [])], {zoneValues: core.Map, zoneSpecification: ZoneSpecification, onError: core.Function});
-  let __CastType36 = dart.typedef('__CastType36', () => dart.functionType(dart.void, [Timer]));
-  let __CastType38 = dart.typedef('__CastType38', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  const __CastType36 = dart.typedef('__CastType36', () => dart.functionType(dart.void, [Timer]));
+  const __CastType38 = dart.typedef('__CastType38', () => dart.functionType(dart.dynamic, [dart.dynamic]));
   dart.copyProperties(exports, {
     get _hasDocument() {
       return typeof document == 'object';
     }
   });
   // Exports:
   exports.AsyncError = AsyncError;
   exports.Stream$ = Stream$;
   exports.Stream = Stream;
   exports.DeferredLibrary = DeferredLibrary;
@@ skipping 35 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;
 });