fix for static methods and names banned in strict mode

lib/runtime/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
   }
   // Function _registerErrorHandler: (Function, Zone) → Function
   function _registerErrorHandler(errorHandler, zone) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return zone.registerBinaryCallback(errorHandler);
     } else {
       return zone.registerUnaryCallback(dart.as(errorHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")));
     }
   }
-  let _getBestStackTrace$ = Symbol('_getBestStackTrace');
+  let _getBestStackTrace = Symbol('_getBestStackTrace');
   class AsyncError extends core.Object {
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
     toString() {
       return dart.as(dart.dinvoke(this.error, 'toString'), core.String);
     }
   }
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
-      super.AsyncError(error, _getBestStackTrace(error, stackTrace));
+      super.AsyncError(error, _UncaughtAsyncError[_getBestStackTrace](error, stackTrace));
     }
-    static [_getBestStackTrace$](error, stackTrace) {
+    static [_getBestStackTrace](error, stackTrace) {
       if (stackTrace !== null)
         return stackTrace;
       if (dart.is(error, core.Error)) {
         return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
       }
       return null;
     }
     toString() {
       let result = `Uncaught Error: ${this.error}`;
       if (this.stackTrace !== null) {
@@ skipping 681 matching lines @@
   let _next = Symbol('_next');
   let _previous = Symbol('_previous');
   class _BroadcastSubscriptionLink extends core.Object {
     _BroadcastSubscriptionLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
   let _eventState = Symbol('_eventState');
   let _expectsEvent = Symbol('_expectsEvent');
+  let _STATE_EVENT_ID = Symbol('_STATE_EVENT_ID');
   let _toggleEventId = Symbol('_toggleEventId');
   let _isFiring = Symbol('_isFiring');
+  let _STATE_FIRING = Symbol('_STATE_FIRING');
   let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
+  let _STATE_REMOVE_AFTER_FIRING = Symbol('_STATE_REMOVE_AFTER_FIRING');
   let _removeAfterFiring = Symbol('_removeAfterFiring');
   let _onPause = Symbol('_onPause');
   let _onResume = Symbol('_onResume');
   let _onCancel = Symbol('_onCancel');
   let _zone = Symbol('_zone');
   let _state = Symbol('_state');
+  let _STATE_CANCEL_ON_ERROR = Symbol('_STATE_CANCEL_ON_ERROR');
   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 _STATE_HAS_PENDING = Symbol('_STATE_HAS_PENDING');
   let _extractPending = Symbol('_extractPending');
   let _isCanceled = Symbol('_isCanceled');
   let _isPaused = Symbol('_isPaused');
   let _isInputPaused = Symbol('_isInputPaused');
+  let _STATE_PAUSE_COUNT = Symbol('_STATE_PAUSE_COUNT');
+  let _STATE_INPUT_PAUSED = Symbol('_STATE_INPUT_PAUSED');
   let _inCallback = Symbol('_inCallback');
   let _guardCallback = Symbol('_guardCallback');
   let _decrementPauseCount = Symbol('_decrementPauseCount');
   let _hasPending = Symbol('_hasPending');
   let _mayResumeInput = Symbol('_mayResumeInput');
+  let _STATE_WAIT_FOR_CANCEL = Symbol('_STATE_WAIT_FOR_CANCEL');
   let _cancel = Symbol('_cancel');
   let _isClosed = Symbol('_isClosed');
+  let _STATE_CLOSED = Symbol('_STATE_CLOSED');
+  let _STATE_CANCELED = Symbol('_STATE_CANCELED');
   let _waitsForCancel = Symbol('_waitsForCancel');
+  let _STATE_IN_CALLBACK = Symbol('_STATE_IN_CALLBACK');
   let _canFire = Symbol('_canFire');
   let _cancelOnError = Symbol('_cancelOnError');
   let _incrementPauseCount = Symbol('_incrementPauseCount');
   let _add = Symbol('_add');
   let _sendData = Symbol('_sendData');
   let _addPending = Symbol('_addPending');
   let _sendError = Symbol('_sendError');
   let _close = Symbol('_close');
   let _sendDone = Symbol('_sendDone');
   let _checkState = Symbol('_checkState');
   let _BufferingStreamSubscription$ = dart.generic(function(T) {
     class _BufferingStreamSubscription extends core.Object {
       _BufferingStreamSubscription(onData, onError, onDone, cancelOnError) {
         this[_zone] = Zone.current;
-        this[_state] = cancelOnError ? _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR : 0;
+        this[_state] = 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);
         this.onError(onError);
         this.onDone(onDone);
       }
       [_setPendingEvents](pendingEvents) {
         dart.assert(this[_pending] === null);
         if (pendingEvents === null)
           return;
         this[_pending] = pendingEvents;
         if (!dart.notNull(pendingEvents.isEmpty)) {
-          this[_state] = _BufferingStreamSubscription._STATE_HAS_PENDING;
+          this[_state] = _BufferingStreamSubscription[_STATE_HAS_PENDING];
           this[_pending].schedule(this);
         }
       }
       [_extractPending]() {
         dart.assert(this[_isCanceled]);
         let events = this[_pending];
         this[_pending] = null;
         return events;
       }
       onData(handleData) {
@@ skipping 11 matching lines @@
           handleDone = _nullDoneHandler;
         this[_onDone] = this[_zone].registerCallback(handleDone);
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
         if (this[_isCanceled])
           return;
         let wasPaused = this[_isPaused];
         let wasInputPaused = this[_isInputPaused];
-        this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
+        this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription[_STATE_PAUSE_COUNT]) | dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
         if (resumeSignal !== null)
           resumeSignal.whenComplete(this.resume);
         if (!dart.notNull(wasPaused) && dart.notNull(this[_pending] !== null))
           this[_pending].cancelSchedule();
         if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
           this[_guardCallback](this[_onPause]);
       }
       resume() {
         if (this[_isCanceled])
           return;
         if (this[_isPaused]) {
           this[_decrementPauseCount]();
           if (!dart.notNull(this[_isPaused])) {
             if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_pending].isEmpty)) {
               this[_pending].schedule(this);
             } else {
               dart.assert(this[_mayResumeInput]);
-              this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
+              this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
               if (!dart.notNull(this[_inCallback]))
                 this[_guardCallback](this[_onResume]);
             }
           }
         }
       }
       cancel() {
-        this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL);
+        this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL]);
         if (this[_isCanceled])
           return this[_cancelFuture];
         this[_cancel]();
         return this[_cancelFuture];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new _Future();
         this[_onDone] = (() => {
           result._complete(futureValue);
         }).bind(this);
         this[_onError] = ((error, stackTrace) => {
           this.cancel();
           result._completeError(error, dart.as(stackTrace, core.StackTrace));
         }).bind(this);
         return result;
       }
       get [_isInputPaused]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED])) !== 0;
       }
       get [_isClosed]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_CLOSED)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription[_STATE_CLOSED])) !== 0;
       }
       get [_isCanceled]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_CANCELED)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription[_STATE_CANCELED])) !== 0;
       }
       get [_waitsForCancel]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL])) !== 0;
       }
       get [_inCallback]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK])) !== 0;
       }
       get [_hasPending]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_HAS_PENDING)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription[_STATE_HAS_PENDING])) !== 0;
       }
       get [_isPaused]() {
-        return dart.notNull(this[_state]) >= dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT);
+        return dart.notNull(this[_state]) >= dart.notNull(_BufferingStreamSubscription[_STATE_PAUSE_COUNT]);
       }
       get [_canFire]() {
-        return dart.notNull(this[_state]) < dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        return dart.notNull(this[_state]) < dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
       }
       get [_mayResumeInput]() {
         return !dart.notNull(this[_isPaused]) && (dart.notNull(this[_pending] === null) || dart.notNull(this[_pending].isEmpty));
       }
       get [_cancelOnError]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_CANCEL_ON_ERROR)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription[_STATE_CANCEL_ON_ERROR])) !== 0;
       }
       get isPaused() {
         return this[_isPaused];
       }
       [_cancel]() {
-        this[_state] = _BufferingStreamSubscription._STATE_CANCELED;
+        this[_state] = _BufferingStreamSubscription[_STATE_CANCELED];
         if (this[_hasPending]) {
           this[_pending].cancelSchedule();
         }
         if (!dart.notNull(this[_inCallback]))
           this[_pending] = null;
         this[_cancelFuture] = this[_onCancel]();
       }
       [_incrementPauseCount]() {
-        this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
+        this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription[_STATE_PAUSE_COUNT]) | dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
       }
       [_decrementPauseCount]() {
         dart.assert(this[_isPaused]);
-        this[_state] = _BufferingStreamSubscription._STATE_PAUSE_COUNT;
+        this[_state] = _BufferingStreamSubscription[_STATE_PAUSE_COUNT];
       }
       [_add](data) {
         dart.assert(!dart.notNull(this[_isClosed]));
         if (this[_isCanceled])
           return;
         if (this[_canFire]) {
           this[_sendData](data);
         } else {
           this[_addPending](new _DelayedData(data));
         }
       }
       [_addError](error, stackTrace) {
         if (this[_isCanceled])
           return;
         if (this[_canFire]) {
           this[_sendError](error, stackTrace);
         } else {
           this[_addPending](new _DelayedError(error, stackTrace));
         }
       }
       [_close]() {
         dart.assert(!dart.notNull(this[_isClosed]));
         if (this[_isCanceled])
           return;
-        this[_state] = _BufferingStreamSubscription._STATE_CLOSED;
+        this[_state] = _BufferingStreamSubscription[_STATE_CLOSED];
         if (this[_canFire]) {
           this[_sendDone]();
         } else {
           this[_addPending](new _DelayedDone());
         }
       }
       [_onPause]() {
         dart.assert(this[_isInputPaused]);
       }
       [_onResume]() {
         dart.assert(!dart.notNull(this[_isInputPaused]));
       }
       [_onCancel]() {
         dart.assert(this[_isCanceled]);
         return null;
       }
       [_addPending](event) {
         let pending = dart.as(this[_pending], _StreamImplEvents);
         if (this[_pending] === null)
           pending = this[_pending] = new _StreamImplEvents();
         pending.add(event);
         if (!dart.notNull(this[_hasPending])) {
-          this[_state] = _BufferingStreamSubscription._STATE_HAS_PENDING;
+          this[_state] = _BufferingStreamSubscription[_STATE_HAS_PENDING];
           if (!dart.notNull(this[_isPaused])) {
             this[_pending].schedule(this);
           }
         }
       }
       [_sendData](data) {
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
-        this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
+        this[_state] = _BufferingStreamSubscription[_STATE_IN_CALLBACK];
         this[_zone].runUnaryGuarded(this[_onData], data);
-        this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        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];
         // Function sendError: () → void
         function sendError() {
           if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
             return;
-          this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
+          this[_state] = _BufferingStreamSubscription[_STATE_IN_CALLBACK];
           if (dart.is(this[_onError], ZoneBinaryCallback)) {
             this[_zone].runBinaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic, dynamic) → dynamic")), error, stackTrace);
           } else {
             this[_zone].runUnaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic) → dynamic")), error);
           }
-          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+          this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
         }
         if (this[_cancelOnError]) {
-          this[_state] = _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL;
+          this[_state] = _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]));
         // Function sendDone: () → void
         function sendDone() {
           if (!dart.notNull(this[_waitsForCancel]))
             return;
-          this[_state] = dart.notNull(_BufferingStreamSubscription._STATE_CANCELED) | dart.notNull(_BufferingStreamSubscription._STATE_CLOSED) | dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+          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(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+          this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
         }
         this[_cancel]();
-        this[_state] = _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL;
+        this[_state] = _BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL];
         if (dart.is(this[_cancelFuture], Future)) {
           this[_cancelFuture].whenComplete(sendDone);
         } else {
           sendDone();
         }
       }
       [_guardCallback](callback) {
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
-        this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
+        this[_state] = _BufferingStreamSubscription[_STATE_IN_CALLBACK];
         dart.dinvokef(callback);
-        this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
         this[_checkState](wasInputPaused);
       }
       [_checkState](wasInputPaused) {
         dart.assert(!dart.notNull(this[_inCallback]));
         if (dart.notNull(this[_hasPending]) && dart.notNull(this[_pending].isEmpty)) {
-          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_HAS_PENDING);
+          this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_HAS_PENDING]);
           if (dart.notNull(this[_isInputPaused]) && dart.notNull(this[_mayResumeInput])) {
-            this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
+            this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_INPUT_PAUSED]);
           }
         }
         while (true) {
           if (this[_isCanceled]) {
             this[_pending] = null;
             return;
           }
           let isInputPaused = this[_isInputPaused];
           if (wasInputPaused === isInputPaused)
             break;
-          this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
+          this[_state] = _BufferingStreamSubscription[_STATE_IN_CALLBACK];
           if (isInputPaused) {
             this[_onPause]();
           } else {
             this[_onResume]();
           }
-          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+          this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_IN_CALLBACK]);
           wasInputPaused = isInputPaused;
         }
         if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
           this[_pending].schedule(this);
         }
       }
     }
     _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
     _BufferingStreamSubscription._STATE_CLOSED = 2;
     _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
@@ skipping 31 matching lines @@
         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;
       }
       get [_controller]() {
         return dart.as(super[_controller], _BroadcastStreamController);
       }
       [_expectsEvent](eventId) {
-        return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription._STATE_EVENT_ID)) === eventId;
+        return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription[_STATE_EVENT_ID])) === eventId;
       }
       [_toggleEventId]() {
-        this[_eventState] = _BroadcastSubscription._STATE_EVENT_ID;
+        this[_eventState] = _BroadcastSubscription[_STATE_EVENT_ID];
       }
       get [_isFiring]() {
-        return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription._STATE_FIRING)) !== 0;
+        return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription[_STATE_FIRING])) !== 0;
       }
       [_setRemoveAfterFiring]() {
         dart.assert(this[_isFiring]);
-        this[_eventState] = _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING;
+        this[_eventState] = _BroadcastSubscription[_STATE_REMOVE_AFTER_FIRING];
       }
       get [_removeAfterFiring]() {
-        return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription._STATE_REMOVE_AFTER_FIRING)) !== 0;
+        return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription[_STATE_REMOVE_AFTER_FIRING])) !== 0;
       }
       [_onPause]() {}
       [_onResume]() {}
     }
     _BroadcastSubscription._STATE_EVENT_ID = 1;
     _BroadcastSubscription._STATE_FIRING = 2;
     _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
     return _BroadcastSubscription;
   });
   let _BroadcastSubscription = _BroadcastSubscription$(dart.dynamic);
+  let _STATE_INITIAL = Symbol('_STATE_INITIAL');
   let _addStreamState = Symbol('_addStreamState');
   let _doneFuture = Symbol('_doneFuture');
   let _isEmpty = Symbol('_isEmpty');
   let _hasOneListener = Symbol('_hasOneListener');
   let _isAddingStream = Symbol('_isAddingStream');
+  let _STATE_ADDSTREAM = Symbol('_STATE_ADDSTREAM');
   let _mayAddEvent = Symbol('_mayAddEvent');
   let _ensureDoneFuture = Symbol('_ensureDoneFuture');
   let _addListener = Symbol('_addListener');
   let _removeListener = Symbol('_removeListener');
   let _subscribe = Symbol('_subscribe');
   let _recordCancel = Symbol('_recordCancel');
   let _callOnCancel = Symbol('_callOnCancel');
   let _recordPause = Symbol('_recordPause');
   let _recordResume = Symbol('_recordResume');
   let _addEventError = Symbol('_addEventError');
   let _forEachListener = Symbol('_forEachListener');
-  let _STATE_FIRING = Symbol('_STATE_FIRING');
   let _mayComplete = Symbol('_mayComplete');
   let _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[_state] = _BroadcastStreamController[_STATE_INITIAL];
         this[_next] = null;
         this[_previous] = null;
         this[_addStreamState] = null;
         this[_doneFuture] = null;
         this[_next] = this[_previous] = this;
       }
       get stream() {
         return new _BroadcastStream(this);
       }
       get sink() {
         return new _StreamSinkWrapper(this);
       }
       get isClosed() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController._STATE_CLOSED)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController[_STATE_CLOSED])) !== 0;
       }
       get isPaused() {
         return false;
       }
       get hasListener() {
         return !dart.notNull(this[_isEmpty]);
       }
       get [_hasOneListener]() {
         dart.assert(!dart.notNull(this[_isEmpty]));
         return core.identical(this[_next][_next], this);
       }
       get [_isFiring]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController._STATE_FIRING)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController[_STATE_FIRING])) !== 0;
       }
       get [_isAddingStream]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController._STATE_ADDSTREAM)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController[_STATE_ADDSTREAM])) !== 0;
       }
       get [_mayAddEvent]() {
-        return dart.notNull(this[_state]) < dart.notNull(_BroadcastStreamController._STATE_CLOSED);
+        return dart.notNull(this[_state]) < dart.notNull(_BroadcastStreamController[_STATE_CLOSED]);
       }
       [_ensureDoneFuture]() {
         if (this[_doneFuture] !== null)
           return this[_doneFuture];
         return this[_doneFuture] = new _Future();
       }
       get [_isEmpty]() {
         return core.identical(this[_next], this);
       }
       [_addListener](subscription) {
         dart.assert(core.identical(subscription[_next], subscription));
         subscription[_previous] = this[_previous];
         subscription[_next] = this;
         this[_previous][_next] = subscription;
         this[_previous] = subscription;
-        subscription[_eventState] = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController._STATE_EVENT_ID);
+        subscription[_eventState] = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController[_STATE_EVENT_ID]);
       }
       [_removeListener](subscription) {
         dart.assert(core.identical(subscription[_controller], this));
         dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
         let previous = subscription[_previous];
         let next = subscription[_next];
         previous[_next] = next;
         next[_previous] = previous;
         subscription[_next] = subscription[_previous] = subscription;
       }
@@ skipping 52 matching lines @@
         }
         this[_sendError](error, stackTrace);
       }
       close() {
         if (this.isClosed) {
           dart.assert(this[_doneFuture] !== null);
           return this[_doneFuture];
         }
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
-        this[_state] = _BroadcastStreamController._STATE_CLOSED;
+        this[_state] = _BroadcastStreamController[_STATE_CLOSED];
         let doneFuture = this[_ensureDoneFuture]();
         this[_sendDone]();
         return doneFuture;
       }
       get done() {
         return this[_ensureDoneFuture]();
       }
       addStream(stream, opts) {
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
-        this[_state] = _BroadcastStreamController._STATE_ADDSTREAM;
+        this[_state] = _BroadcastStreamController[_STATE_ADDSTREAM];
         this[_addStreamState] = dart.as(new _AddStreamState(this, stream, cancelOnError), _AddStreamState$(T));
         return this[_addStreamState].addStreamFuture;
       }
       [_add](data) {
         this[_sendData](data);
       }
       [_addError](error, stackTrace) {
         this[_sendError](error, stackTrace);
       }
       [_close]() {
         dart.assert(this[_isAddingStream]);
         let addState = this[_addStreamState];
         this[_addStreamState] = null;
-        this[_state] = ~dart.notNull(_BroadcastStreamController._STATE_ADDSTREAM);
+        this[_state] = ~dart.notNull(_BroadcastStreamController[_STATE_ADDSTREAM]);
         addState.complete();
       }
       [_forEachListener](action) {
         if (this[_isFiring]) {
           throw new core.StateError("Cannot fire new event. Controller is already firing an event");
         }
         if (this[_isEmpty])
           return;
-        let id = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController._STATE_EVENT_ID);
-        this[_state] = dart.notNull(_BroadcastStreamController._STATE_EVENT_ID) | dart.notNull(_BroadcastStreamController._STATE_FIRING);
+        let id = dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController[_STATE_EVENT_ID]);
+        this[_state] = dart.notNull(_BroadcastStreamController[_STATE_EVENT_ID]) | dart.notNull(_BroadcastStreamController[_STATE_FIRING]);
         let link = this[_next];
         while (!dart.notNull(core.identical(link, this))) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           if (subscription._expectsEvent(id)) {
             subscription[_eventState] = _BroadcastSubscription[_STATE_FIRING];
             action(subscription);
             subscription._toggleEventId();
             link = subscription[_next];
             if (subscription[_removeAfterFiring]) {
               this[_removeListener](subscription);
             }
             subscription[_eventState] = ~dart.notNull(_BroadcastSubscription[_STATE_FIRING]);
           } else {
             link = subscription[_next];
           }
         }
-        this[_state] = ~dart.notNull(_BroadcastStreamController._STATE_FIRING);
+        this[_state] = ~dart.notNull(_BroadcastStreamController[_STATE_FIRING]);
         if (this[_isEmpty]) {
           this[_callOnCancel]();
         }
       }
       [_callOnCancel]() {
         dart.assert(this[_isEmpty]);
         if (dart.notNull(this.isClosed) && dart.notNull(this[_doneFuture][_mayComplete])) {
           this[_doneFuture]._asyncComplete(null);
         }
         _runGuarded(this[_onCancel]);
@@ skipping 78 matching lines @@
           dart.assert(this[_doneFuture] !== null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture]._asyncComplete(null);
         }
       }
     }
     return _AsyncBroadcastStreamController;
   });
   let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$(dart.dynamic);
   let _addPendingEvent = Symbol('_addPendingEvent');
-  let _STATE_CLOSED = Symbol('_STATE_CLOSED');
   let _AsBroadcastStreamController$ = dart.generic(function(T) {
     class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T) {
       _AsBroadcastStreamController(onListen, onCancel) {
         this[_pending] = null;
         super._SyncBroadcastStreamController(onListen, onCancel);
       }
       get [_hasPending]() {
         return dart.notNull(this[_pending] !== null) && !dart.notNull(this[_pending].isEmpty);
       }
       [_addPendingEvent](event) {
@@ skipping 230 matching lines @@
           }).bind(this), {onError: handleError});
         }
         if (remaining === 0) {
           return dart.as(new Future.value(/* Unimplemented const */new List.from([])), Future$(core.List));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
         let iterator = input.iterator;
-        return doWhile((() => {
+        return Future.doWhile((() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
           return new Future.sync((() => dart.dinvokef(f, iterator.current)).bind(this)).then((_) => true);
         }).bind(this));
       }
       static doWhile(f) {
         let doneSignal = new _Future();
         let nextIteration = null;
         nextIteration = Zone.current.bindUnaryCallback(((keepGoing) => {
           if (keepGoing) {
@@ skipping 189 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 _INCOMPLETE = Symbol('_INCOMPLETE');
   let _resultOrListeners = Symbol('_resultOrListeners');
   let _asyncComplete = Symbol('_asyncComplete');
   let _asyncCompleteError = Symbol('_asyncCompleteError');
   let _isChained = Symbol('_isChained');
+  let _CHAINED = Symbol('_CHAINED');
   let _isComplete = Symbol('_isComplete');
+  let _VALUE = Symbol('_VALUE');
   let _hasValue = Symbol('_hasValue');
   let _hasError = Symbol('_hasError');
+  let _ERROR = Symbol('_ERROR');
   let _markPendingCompletion = Symbol('_markPendingCompletion');
+  let _PENDING_COMPLETE = Symbol('_PENDING_COMPLETE');
   let _value = Symbol('_value');
   let _error = Symbol('_error');
   let _setValue = Symbol('_setValue');
   let _setErrorObject = Symbol('_setErrorObject');
   let _setError = Symbol('_setError');
+  let _propagateToListeners = Symbol('_propagateToListeners');
   let _removeListeners = Symbol('_removeListeners');
-  let _chainForeignFuture$ = Symbol('_chainForeignFuture');
-  let _chainCoreFuture$ = Symbol('_chainCoreFuture');
+  let _chainForeignFuture = Symbol('_chainForeignFuture');
+  let _chainCoreFuture = Symbol('_chainCoreFuture');
   let _completeWithValue = Symbol('_completeWithValue');
-  let _propagateToListeners$ = Symbol('_propagateToListeners');
   let _Future$ = dart.generic(function(T) {
     class _Future extends core.Object {
       _Future() {
         this[_zone] = Zone.current;
-        this[_state] = _Future._INCOMPLETE;
+        this[_state] = _Future[_INCOMPLETE];
         this[_resultOrListeners] = null;
       }
       _Future$immediate(value) {
         this[_zone] = Zone.current;
-        this[_state] = _Future._INCOMPLETE;
+        this[_state] = _Future[_INCOMPLETE];
         this[_resultOrListeners] = null;
         this[_asyncComplete](value);
       }
       _Future$immediateError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_zone] = Zone.current;
-        this[_state] = _Future._INCOMPLETE;
+        this[_state] = _Future[_INCOMPLETE];
         this[_resultOrListeners] = null;
         this[_asyncCompleteError](error, stackTrace);
       }
       get [_mayComplete]() {
-        return this[_state] === _Future._INCOMPLETE;
+        return this[_state] === _Future[_INCOMPLETE];
       }
       get [_isChained]() {
-        return this[_state] === _Future._CHAINED;
+        return this[_state] === _Future[_CHAINED];
       }
       get [_isComplete]() {
-        return dart.notNull(this[_state]) >= dart.notNull(_Future._VALUE);
+        return dart.notNull(this[_state]) >= dart.notNull(_Future[_VALUE]);
       }
       get [_hasValue]() {
-        return this[_state] === _Future._VALUE;
+        return this[_state] === _Future[_VALUE];
       }
       get [_hasError]() {
-        return this[_state] === _Future._ERROR;
+        return this[_state] === _Future[_ERROR];
       }
       set [_isChained](value) {
         if (value) {
           dart.assert(!dart.notNull(this[_isComplete]));
-          this[_state] = _Future._CHAINED;
+          this[_state] = _Future[_CHAINED];
         } else {
           dart.assert(this[_isChained]);
-          this[_state] = _Future._INCOMPLETE;
+          this[_state] = _Future[_INCOMPLETE];
         }
       }
       then(f, opts) {
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let result = new _Future();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           f = dart.closureWrap(result[_zone].registerUnaryCallback(f), "(T) → dynamic");
           if (onError !== null) {
             onError = _registerErrorHandler(onError, result[_zone]);
           }
@@ skipping 19 matching lines @@
         }
         this[_addListener](new _FutureListener.whenComplete(result, action));
         return dart.as(result, Future$(T));
       }
       asStream() {
         return dart.as(new Stream.fromFuture(this), Stream$(T));
       }
       [_markPendingCompletion]() {
         if (!dart.notNull(this[_mayComplete]))
           throw new core.StateError("Future already completed");
-        this[_state] = _Future._PENDING_COMPLETE;
+        this[_state] = _Future[_PENDING_COMPLETE];
       }
       get [_value]() {
         dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasValue]));
         return dart.as(this[_resultOrListeners], T);
       }
       get [_error]() {
         dart.assert(dart.notNull(this[_isComplete]) && dart.notNull(this[_hasError]));
         return dart.as(this[_resultOrListeners], AsyncError);
       }
       [_setValue](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
-        this[_state] = _Future._VALUE;
+        this[_state] = _Future[_VALUE];
         this[_resultOrListeners] = value;
       }
       [_setErrorObject](error) {
         dart.assert(!dart.notNull(this[_isComplete]));
-        this[_state] = _Future._ERROR;
+        this[_state] = _Future[_ERROR];
         this[_resultOrListeners] = error;
       }
       [_setError](error, stackTrace) {
         this[_setErrorObject](new AsyncError(error, stackTrace));
       }
       [_addListener](listener) {
         dart.assert(listener[_nextListener] === null);
         if (this[_isComplete]) {
           this[_zone].scheduleMicrotask((() => {
-            _propagateToListeners(this, listener);
+            _Future[_propagateToListeners](this, listener);
           }).bind(this));
         } else {
           listener[_nextListener] = dart.as(this[_resultOrListeners], _FutureListener);
           this[_resultOrListeners] = listener;
         }
       }
       [_removeListeners]() {
         dart.assert(!dart.notNull(this[_isComplete]));
         let current = dart.as(this[_resultOrListeners], _FutureListener);
         this[_resultOrListeners] = null;
         let prev = null;
         while (current !== null) {
           let next = current[_nextListener];
           current[_nextListener] = prev;
           prev = current;
           current = next;
         }
         return prev;
       }
-      static [_chainForeignFuture$](source, target) {
+      static [_chainForeignFuture](source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(!dart.is(source, _Future));
         target[_isChained] = true;
         source.then(((value) => {
           dart.assert(target[_isChained]);
           target._completeWithValue(value);
         }).bind(this), {onError: ((error, stackTrace) => {
             if (stackTrace === void 0)
               stackTrace = null;
             dart.assert(target[_isChained]);
             target._completeError(error, dart.as(stackTrace, core.StackTrace));
           }).bind(this)});
       }
-      static [_chainCoreFuture$](source, target) {
+      static [_chainCoreFuture](source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(dart.is(source, _Future));
         target[_isChained] = true;
         let listener = new _FutureListener.chain(target);
         if (source[_isComplete]) {
-          _propagateToListeners(source, listener);
+          _Future[_propagateToListeners](source, listener);
         } else {
           source._addListener(listener);
         }
       }
       [_complete](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
         if (dart.is(value, Future)) {
           if (dart.is(value, _Future)) {
-            _chainCoreFuture(dart.as(value, _Future), this);
+            _Future[_chainCoreFuture](dart.as(value, _Future), this);
           } else {
-            _chainForeignFuture(dart.as(value, Future), this);
+            _Future[_chainForeignFuture](dart.as(value, Future), this);
           }
         } else {
           let listeners = this[_removeListeners]();
           this[_setValue](dart.as(value, T));
-          _propagateToListeners(this, listeners);
+          _Future[_propagateToListeners](this, listeners);
         }
       }
       [_completeWithValue](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
         dart.assert(!dart.is(value, Future));
         let listeners = this[_removeListeners]();
         this[_setValue](dart.as(value, T));
-        _propagateToListeners(this, listeners);
+        _Future[_propagateToListeners](this, listeners);
       }
       [_completeError](error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         dart.assert(!dart.notNull(this[_isComplete]));
         let listeners = this[_removeListeners]();
         this[_setError](error, stackTrace);
-        _propagateToListeners(this, listeners);
+        _Future[_propagateToListeners](this, listeners);
       }
       [_asyncComplete](value) {
         dart.assert(!dart.notNull(this[_isComplete]));
         if (value === null) {
         } else if (dart.is(value, Future)) {
           let typedFuture = dart.as(value, Future$(T));
           if (dart.is(typedFuture, _Future)) {
             let coreFuture = dart.as(typedFuture, _Future$(T));
             if (dart.notNull(coreFuture[_isComplete]) && dart.notNull(coreFuture[_hasError])) {
               this[_markPendingCompletion]();
               this[_zone].scheduleMicrotask((() => {
-                _chainCoreFuture(coreFuture, this);
+                _Future[_chainCoreFuture](coreFuture, this);
               }).bind(this));
             } else {
-              _chainCoreFuture(coreFuture, this);
+              _Future[_chainCoreFuture](coreFuture, this);
             }
           } else {
-            _chainForeignFuture(typedFuture, this);
+            _Future[_chainForeignFuture](typedFuture, this);
           }
           return;
         } else {
           let typedValue = dart.as(value, T);
         }
         this[_markPendingCompletion]();
         this[_zone].scheduleMicrotask((() => {
           this[_completeWithValue](value);
         }).bind(this));
       }
       [_asyncCompleteError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_markPendingCompletion]();
         this[_zone].scheduleMicrotask((() => {
           this[_completeError](error, stackTrace);
         }).bind(this));
       }
-      static [_propagateToListeners$](source, listeners) {
+      static [_propagateToListeners](source, listeners) {
         while (true) {
           dart.assert(source[_isComplete]);
           let hasError = source[_hasError];
           if (listeners === null) {
             if (hasError) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
             }
             return;
           }
           while (listeners[_nextListener] !== null) {
             let listener = listeners;
             listeners = listener[_nextListener];
             listener[_nextListener] = null;
-            _propagateToListeners(source, listener);
+            _Future[_propagateToListeners](source, listener);
           }
           let listener = listeners;
           let listenerHasValue = true;
           let sourceValue = hasError ? null : source[_value];
           let listenerValueOrError = sourceValue;
           let isPropagationAborted = false;
           if (dart.notNull(hasError) || dart.notNull(listener.handlesValue) || dart.notNull(listener.handlesComplete)) {
             let zone = listener[_zone];
             if (dart.notNull(hasError) && !dart.notNull(source[_zone].inSameErrorZone(zone))) {
               let asyncError = source[_error];
@@ skipping 67 matching lines @@
                 }
                 listenerHasValue = false;
                 return;
               }
 
               if (dart.is(completeResult, Future)) {
                 let result = listener.result;
                 result[_isChained] = true;
                 isPropagationAborted = true;
                 dart.dinvoke(completeResult, 'then', (ignored) => {
-                  _propagateToListeners(source, new _FutureListener.chain(result));
+                  _Future[_propagateToListeners](source, new _FutureListener.chain(result));
                 }, {
                   onError: (error, stackTrace) => {
                     if (stackTrace === void 0)
                       stackTrace = null;
                     if (!dart.is(completeResult, _Future)) {
                       completeResult = new _Future();
                       dart.dinvoke(completeResult, '_setError', error, stackTrace);
                     }
-                    _propagateToListeners(dart.as(completeResult, _Future), new _FutureListener.chain(result));
+                    _Future[_propagateToListeners](dart.as(completeResult, _Future), new _FutureListener.chain(result));
                   }
                 });
               }
             }
             if (!dart.notNull(hasError)) {
               if (listener.handlesValue) {
                 listenerHasValue = handleValueCallback();
               }
             } else {
               handleError();
             }
             if (listener.handlesComplete) {
               handleWhenCompleteCallback();
             }
             if (oldZone !== null)
               Zone._leave(oldZone);
             if (isPropagationAborted)
               return;
             if (dart.notNull(listenerHasValue) && !dart.notNull(core.identical(sourceValue, listenerValueOrError)) && dart.notNull(dart.is(listenerValueOrError, Future))) {
               let chainSource = dart.as(listenerValueOrError, Future);
               let result = listener.result;
               if (dart.is(chainSource, _Future)) {
                 if (chainSource[_isComplete]) {
                   result[_isChained] = true;
                   source = chainSource;
                   listeners = new _FutureListener.chain(result);
                   continue;
                 } else {
-                  _chainCoreFuture(chainSource, result);
+                  _Future[_chainCoreFuture](chainSource, result);
                 }
               } else {
-                _chainForeignFuture(chainSource, result);
+                _Future[_chainForeignFuture](chainSource, result);
               }
               return;
             }
           }
           let result = listener.result;
           listeners = result._removeListeners();
           if (listenerHasValue) {
             result._setValue(listenerValueOrError);
           } else {
             let asyncError = dart.as(listenerValueOrError, AsyncError);
@@ skipping 115 matching lines @@
   }
   // Function scheduleMicrotask: (() → void) → void
   function scheduleMicrotask(callback) {
     if (core.identical(_ROOT_ZONE, Zone.current)) {
       _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
       return;
     }
     Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
   }
   let _scheduleImmediate = Symbol('_scheduleImmediate');
-  let _initializeScheduleImmediate$ = Symbol('_initializeScheduleImmediate');
-  let _scheduleImmediateJsOverride$ = Symbol('_scheduleImmediateJsOverride');
-  let _scheduleImmediateWithSetImmediate$ = Symbol('_scheduleImmediateWithSetImmediate');
-  let _scheduleImmediateWithTimer$ = Symbol('_scheduleImmediateWithTimer');
+  let _initializeScheduleImmediate = Symbol('_initializeScheduleImmediate');
+  let _scheduleImmediateJsOverride = Symbol('_scheduleImmediateJsOverride');
+  let _scheduleImmediateWithSetImmediate = Symbol('_scheduleImmediateWithSetImmediate');
+  let _scheduleImmediateWithTimer = Symbol('_scheduleImmediateWithTimer');
   class _AsyncRun extends core.Object {
     static [_scheduleImmediate](callback) {
-      dart.dinvokef(scheduleImmediateClosure, callback);
+      dart.dinvokef(_AsyncRun.scheduleImmediateClosure, callback);
     }
-    static [_initializeScheduleImmediate$]() {
+    static [_initializeScheduleImmediate]() {
       _js_helper.requiresPreamble();
       if (self.scheduleImmediate !== null) {
-        return _scheduleImmediateJsOverride;
+        return _AsyncRun[_scheduleImmediateJsOverride];
       }
       if (dart.notNull(self.MutationObserver !== null) && dart.notNull(self.document !== null)) {
         let div = self.document.createElement("div");
         let span = self.document.createElement("span");
         let storedCallback = null;
         // Function internalCallback: (dynamic) → dynamic
         function internalCallback(_) {
           _isolate_helper.leaveJsAsync();
           let f = storedCallback;
           storedCallback = null;
           dart.dinvokef(f);
         }
         ;
         let observer = new self.MutationObserver(_js_helper.convertDartClosureToJS(internalCallback, 1));
         observer.observe(div, {childList: true});
         return (callback) => {
           dart.assert(storedCallback === null);
           _isolate_helper.enterJsAsync();
           storedCallback = callback;
           div.firstChild ? div.removeChild(span) : div.appendChild(span);
         };
       } else if (self.setImmediate !== null) {
-        return _scheduleImmediateWithSetImmediate;
+        return _AsyncRun[_scheduleImmediateWithSetImmediate];
       }
-      return _scheduleImmediateWithTimer;
+      return _AsyncRun[_scheduleImmediateWithTimer];
     }
-    static [_scheduleImmediateJsOverride$](callback) {
+    static [_scheduleImmediateJsOverride](callback) {
       // Function internalCallback: () → dynamic
       function internalCallback() {
         _isolate_helper.leaveJsAsync();
         callback();
       }
       ;
       _isolate_helper.enterJsAsync();
       self.scheduleImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
     }
-    static [_scheduleImmediateWithSetImmediate$](callback) {
+    static [_scheduleImmediateWithSetImmediate](callback) {
       // Function internalCallback: () → dynamic
       function internalCallback() {
         _isolate_helper.leaveJsAsync();
         callback();
       }
       ;
       _isolate_helper.enterJsAsync();
       self.setImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
     }
-    static [_scheduleImmediateWithTimer$](callback) {
+    static [_scheduleImmediateWithTimer](callback) {
       Timer._createTimer(core.Duration.ZERO, callback);
     }
   }
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
-      return _initializeScheduleImmediate();
+      return _AsyncRun[_initializeScheduleImmediate]();
     }
   });
   let StreamSubscription$ = dart.generic(function(T) {
     class StreamSubscription extends core.Object {
     }
     return StreamSubscription;
   });
   let StreamSubscription = StreamSubscription$(dart.dynamic);
   let EventSink$ = dart.generic(function(T) {
     class EventSink extends core.Object {
@@ skipping 109 matching lines @@
       [_recordPause](subscription) {}
       [_recordResume](subscription) {}
       [_recordCancel](subscription) {
         return null;
       }
     }
     return _StreamControllerLifecycle;
   });
   let _StreamControllerLifecycle = _StreamControllerLifecycle$(dart.dynamic);
   let _varData = Symbol('_varData');
+  let _STATE_SUBSCRIBED = Symbol('_STATE_SUBSCRIBED');
   let _isInitialState = Symbol('_isInitialState');
+  let _STATE_SUBSCRIPTION_MASK = Symbol('_STATE_SUBSCRIPTION_MASK');
   let _subscription = Symbol('_subscription');
   let _pendingEvents = Symbol('_pendingEvents');
   let _ensurePendingEvents = Symbol('_ensurePendingEvents');
   let _badEventState = Symbol('_badEventState');
   let _nullFuture = Symbol('_nullFuture');
   let _closeUnchecked = Symbol('_closeUnchecked');
   let _StreamController$ = dart.generic(function(T) {
     class _StreamController extends core.Object {
       _StreamController() {
         this[_varData] = null;
-        this[_state] = _StreamController._STATE_INITIAL;
+        this[_state] = _StreamController[_STATE_INITIAL];
         this[_doneFuture] = null;
       }
       get stream() {
         return dart.as(new _ControllerStream(this), Stream$(T));
       }
       get sink() {
         return new _StreamSinkWrapper(this);
       }
       get [_isCanceled]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STATE_CANCELED)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_StreamController[_STATE_CANCELED])) !== 0;
       }
       get hasListener() {
-        return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STATE_SUBSCRIBED)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_StreamController[_STATE_SUBSCRIBED])) !== 0;
       }
       get [_isInitialState]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STATE_SUBSCRIPTION_MASK)) === _StreamController._STATE_INITIAL;
+        return (dart.notNull(this[_state]) & dart.notNull(_StreamController[_STATE_SUBSCRIPTION_MASK])) === _StreamController[_STATE_INITIAL];
       }
       get isClosed() {
-        return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STATE_CLOSED)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_StreamController[_STATE_CLOSED])) !== 0;
       }
       get isPaused() {
         return this.hasListener ? this[_subscription][_isInputPaused] : !dart.notNull(this[_isCanceled]);
       }
       get [_isAddingStream]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_StreamController._STATE_ADDSTREAM)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_StreamController[_STATE_ADDSTREAM])) !== 0;
       }
       get [_mayAddEvent]() {
-        return dart.notNull(this[_state]) < dart.notNull(_StreamController._STATE_CLOSED);
+        return dart.notNull(this[_state]) < dart.notNull(_StreamController[_STATE_CLOSED]);
       }
       get [_pendingEvents]() {
         dart.assert(this[_isInitialState]);
         if (!dart.notNull(this[_isAddingStream])) {
           return dart.as(this[_varData], _PendingEvents);
         }
         let state = dart.as(this[_varData], _StreamControllerAddStreamState);
         return dart.as(state.varData, _PendingEvents);
       }
       [_ensurePendingEvents]() {
@@ skipping 24 matching lines @@
         return new core.StateError("Cannot add event while adding a stream");
       }
       addStream(source, opts) {
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         if (this[_isCanceled])
           return new _Future.immediate(null);
         let addState = new _StreamControllerAddStreamState(this, this[_varData], source, cancelOnError);
         this[_varData] = addState;
-        this[_state] = _StreamController._STATE_ADDSTREAM;
+        this[_state] = _StreamController[_STATE_ADDSTREAM];
         return addState.addStreamFuture;
       }
       get done() {
         return this[_ensureDoneFuture]();
       }
       [_ensureDoneFuture]() {
         if (this[_doneFuture] === null) {
           this[_doneFuture] = this[_isCanceled] ? Future[_nullFuture] : new _Future();
         }
         return this[_doneFuture];
@@ skipping 19 matching lines @@
       close() {
         if (this.isClosed) {
           return this[_ensureDoneFuture]();
         }
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         this[_closeUnchecked]();
         return this[_ensureDoneFuture]();
       }
       [_closeUnchecked]() {
-        this[_state] = _StreamController._STATE_CLOSED;
+        this[_state] = _StreamController[_STATE_CLOSED];
         if (this.hasListener) {
           this[_sendDone]();
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new _DelayedDone());
         }
       }
       [_add](value) {
         if (this.hasListener) {
           this[_sendData](value);
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new _DelayedData(value));
         }
       }
       [_addError](error, stackTrace) {
         if (this.hasListener) {
           this[_sendError](error, stackTrace);
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new _DelayedError(error, stackTrace));
         }
       }
       [_close]() {
         dart.assert(this[_isAddingStream]);
         let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
         this[_varData] = addState.varData;
-        this[_state] = ~dart.notNull(_StreamController._STATE_ADDSTREAM);
+        this[_state] = ~dart.notNull(_StreamController[_STATE_ADDSTREAM]);
         addState.complete();
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         if (!dart.notNull(this[_isInitialState])) {
           throw new core.StateError("Stream has already been listened to.");
         }
         let subscription = new _ControllerSubscription(this, onData, onError, onDone, cancelOnError);
         let pendingEvents = this[_pendingEvents];
-        this[_state] = _StreamController._STATE_SUBSCRIBED;
+        this[_state] = _StreamController[_STATE_SUBSCRIBED];
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.varData = subscription;
           addState.resume();
         } else {
           this[_varData] = subscription;
         }
         subscription._setPendingEvents(pendingEvents);
         subscription._guardCallback((() => {
           _runGuarded(this[_onListen]);
         }).bind(this));
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         let result = null;
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           result = addState.cancel();
         }
         this[_varData] = null;
-        this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamController._STATE_SUBSCRIBED) | dart.notNull(_StreamController._STATE_ADDSTREAM)) | dart.notNull(_StreamController._STATE_CANCELED);
+        this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamController[_STATE_SUBSCRIBED]) | dart.notNull(_StreamController[_STATE_ADDSTREAM])) | dart.notNull(_StreamController[_STATE_CANCELED]);
         if (this[_onCancel] !== null) {
           if (result === null) {
             try {
               result = dart.as(this[_onCancel](), Future);
             } catch (e) {
               let s = dart.stackTrace(e);
               result = ((_$) => {
                 _$._asyncCompleteError(e, s);
                 return _$;
               }).bind(this)(new _Future());
@@ skipping 154 matching lines @@
         return this[_target].done;
       }
     }
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$(dart.dynamic);
   let _AddStreamState$ = dart.generic(function(T) {
     class _AddStreamState extends core.Object {
       _AddStreamState(controller, source, cancelOnError) {
         this.addStreamFuture = new _Future();
-        this.addSubscription = source.listen(controller[_add], {onError: dart.as(cancelOnError ? makeErrorHandler(controller) : controller[_addError], core.Function), onDone: controller[_close], cancelOnError: cancelOnError});
+        this.addSubscription = source.listen(controller[_add], {onError: dart.as(cancelOnError ? _AddStreamState.makeErrorHandler(controller) : controller[_addError], core.Function), onDone: controller[_close], cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return ((e, s) => {
           controller._addError(e, s);
           controller._close();
         }).bind(this);
       }
       pause() {
         this.addSubscription.pause();
       }
@@ skipping 57 matching lines @@
         return ((_$) => {
           _$._setPendingEvents(this[_pending]());
           return _$;
         }).bind(this)(new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError));
       }
     }
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$(dart.dynamic);
   let _iterator = Symbol('_iterator');
+  let _STATE_UNSCHEDULED = Symbol('_STATE_UNSCHEDULED');
+  let _STATE_SCHEDULED = Symbol('_STATE_SCHEDULED');
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
     _PendingEvents() {
-      this[_state] = _PendingEvents._STATE_UNSCHEDULED;
+      this[_state] = _PendingEvents[_STATE_UNSCHEDULED];
     }
     get isScheduled() {
-      return this[_state] === _PendingEvents._STATE_SCHEDULED;
+      return this[_state] === _PendingEvents[_STATE_SCHEDULED];
     }
     get [_eventScheduled]() {
-      return dart.notNull(this[_state]) >= dart.notNull(_PendingEvents._STATE_SCHEDULED);
+      return dart.notNull(this[_state]) >= dart.notNull(_PendingEvents[_STATE_SCHEDULED]);
     }
     schedule(dispatch) {
       if (this.isScheduled)
         return;
       dart.assert(!dart.notNull(this.isEmpty));
       if (this[_eventScheduled]) {
-        dart.assert(this[_state] === _PendingEvents._STATE_CANCELED);
-        this[_state] = _PendingEvents._STATE_SCHEDULED;
+        dart.assert(this[_state] === _PendingEvents[_STATE_CANCELED]);
+        this[_state] = _PendingEvents[_STATE_SCHEDULED];
         return;
       }
       scheduleMicrotask((() => {
         let oldState = this[_state];
-        this[_state] = _PendingEvents._STATE_UNSCHEDULED;
-        if (oldState === _PendingEvents._STATE_CANCELED)
+        this[_state] = _PendingEvents[_STATE_UNSCHEDULED];
+        if (oldState === _PendingEvents[_STATE_CANCELED])
           return;
         this.handleNext(dispatch);
       }).bind(this));
-      this[_state] = _PendingEvents._STATE_SCHEDULED;
+      this[_state] = _PendingEvents[_STATE_SCHEDULED];
     }
     cancelSchedule() {
       if (this.isScheduled)
-        this[_state] = _PendingEvents._STATE_CANCELED;
+        this[_state] = _PendingEvents[_STATE_CANCELED];
     }
   }
   _PendingEvents._STATE_UNSCHEDULED = 0;
   _PendingEvents._STATE_SCHEDULED = 1;
   _PendingEvents._STATE_CANCELED = 3;
   let _IterablePendingEvents$ = dart.generic(function(T) {
     class _IterablePendingEvents extends _PendingEvents {
       _IterablePendingEvents(data) {
         this[_iterator] = data.iterator;
         super._PendingEvents();
@@ skipping 130 matching lines @@
     [_insertBefore](newNext) {
       let newPrevious = newNext[_previous];
       newPrevious[_next] = this;
       newNext[_previous] = this[_previous];
       this[_previous][_next] = newNext;
       this[_previous] = newPrevious;
     }
   }
   let _schedule = Symbol('_schedule');
   let _isSent = Symbol('_isSent');
+  let _DONE_SENT = Symbol('_DONE_SENT');
   let _isScheduled = Symbol('_isScheduled');
+  let _SCHEDULED = Symbol('_SCHEDULED');
+  let _PAUSED = Symbol('_PAUSED');
   let _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;
+        return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription[_DONE_SENT])) !== 0;
       }
       get [_isScheduled]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription._SCHEDULED)) !== 0;
+        return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription[_SCHEDULED])) !== 0;
       }
       get isPaused() {
-        return dart.notNull(this[_state]) >= dart.notNull(_DoneStreamSubscription._PAUSED);
+        return dart.notNull(this[_state]) >= dart.notNull(_DoneStreamSubscription[_PAUSED]);
       }
       [_schedule]() {
         if (this[_isScheduled])
           return;
         this[_zone].scheduleMicrotask(this[_sendDone]);
-        this[_state] = _DoneStreamSubscription._SCHEDULED;
+        this[_state] = _DoneStreamSubscription[_SCHEDULED];
       }
       onData(handleData) {}
       onError(handleError) {}
       onDone(handleDone) {
         this[_onDone] = handleDone;
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
-        this[_state] = _DoneStreamSubscription._PAUSED;
+        this[_state] = _DoneStreamSubscription[_PAUSED];
         if (resumeSignal !== null)
           resumeSignal.whenComplete(this.resume);
       }
       resume() {
         if (this.isPaused) {
-          this[_state] = _DoneStreamSubscription._PAUSED;
+          this[_state] = _DoneStreamSubscription[_PAUSED];
           if (!dart.notNull(this.isPaused) && !dart.notNull(this[_isSent])) {
             this[_schedule]();
           }
         }
       }
       cancel() {
         return null;
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         let result = new _Future();
         this[_onDone] = (() => {
           result._completeWithValue(null);
         }).bind(this);
         return result;
       }
       [_sendDone]() {
-        this[_state] = ~dart.notNull(_DoneStreamSubscription._SCHEDULED);
+        this[_state] = ~dart.notNull(_DoneStreamSubscription[_SCHEDULED]);
         if (this.isPaused)
           return;
-        this[_state] = _DoneStreamSubscription._DONE_SENT;
+        this[_state] = _DoneStreamSubscription[_DONE_SENT];
         if (this[_onDone] !== null)
           this[_zone].runGuarded(this[_onDone]);
       }
     }
     _DoneStreamSubscription._DONE_SENT = 1;
     _DoneStreamSubscription._SCHEDULED = 2;
     _DoneStreamSubscription._PAUSED = 4;
     return _DoneStreamSubscription;
   });
   let _DoneStreamSubscription = _DoneStreamSubscription$(dart.dynamic);
@@ skipping 107 matching lines @@
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
     }
     return _BroadcastSubscriptionWrapper;
   });
   let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$(dart.dynamic);
-  let _current$ = Symbol('_current');
+  let _current = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
+  let _STATE_FOUND = Symbol('_STATE_FOUND');
+  let _STATE_DONE = Symbol('_STATE_DONE');
+  let _STATE_MOVING = Symbol('_STATE_MOVING');
+  let _STATE_EXTRA_DATA = Symbol('_STATE_EXTRA_DATA');
+  let _STATE_EXTRA_ERROR = Symbol('_STATE_EXTRA_ERROR');
   let _clear = Symbol('_clear');
+  let _STATE_EXTRA_DONE = Symbol('_STATE_EXTRA_DONE');
   let _StreamIteratorImpl$ = dart.generic(function(T) {
     class _StreamIteratorImpl extends core.Object {
       _StreamIteratorImpl(stream) {
         this[_subscription] = null;
-        this[_current$] = null;
+        this[_current] = null;
         this[_futureOrPrefetch] = null;
-        this[_state] = _StreamIteratorImpl._STATE_FOUND;
+        this[_state] = _StreamIteratorImpl[_STATE_FOUND];
         this[_subscription] = stream.listen(this[_onData], {onError: this[_onError], onDone: this[_onDone], cancelOnError: true});
       }
       get current() {
-        return this[_current$];
+        return this[_current];
       }
       moveNext() {
-        if (this[_state] === _StreamIteratorImpl._STATE_DONE) {
+        if (this[_state] === _StreamIteratorImpl[_STATE_DONE]) {
           return new _Future.immediate(false);
         }
-        if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
+        if (this[_state] === _StreamIteratorImpl[_STATE_MOVING]) {
           throw new core.StateError("Already waiting for next.");
         }
-        if (this[_state] === _StreamIteratorImpl._STATE_FOUND) {
-          this[_state] = _StreamIteratorImpl._STATE_MOVING;
-          this[_current$] = null;
+        if (this[_state] === _StreamIteratorImpl[_STATE_FOUND]) {
+          this[_state] = _StreamIteratorImpl[_STATE_MOVING];
+          this[_current] = null;
           this[_futureOrPrefetch] = new _Future();
           return dart.as(this[_futureOrPrefetch], Future$(core.bool));
         } else {
-          dart.assert(dart.notNull(this[_state]) >= dart.notNull(_StreamIteratorImpl._STATE_EXTRA_DATA));
+          dart.assert(dart.notNull(this[_state]) >= dart.notNull(_StreamIteratorImpl[_STATE_EXTRA_DATA]));
           switch (this[_state]) {
-            case _StreamIteratorImpl._STATE_EXTRA_DATA:
-              this[_state] = _StreamIteratorImpl._STATE_FOUND;
-              this[_current$] = dart.as(this[_futureOrPrefetch], T);
+            case _StreamIteratorImpl[_STATE_EXTRA_DATA]:
+              this[_state] = _StreamIteratorImpl[_STATE_FOUND];
+              this[_current] = dart.as(this[_futureOrPrefetch], T);
               this[_futureOrPrefetch] = null;
               this[_subscription].resume();
               return new _Future.immediate(true);
-            case _StreamIteratorImpl._STATE_EXTRA_ERROR:
+            case _StreamIteratorImpl[_STATE_EXTRA_ERROR]:
               let prefetch = dart.as(this[_futureOrPrefetch], AsyncError);
               this[_clear]();
               return new _Future.immediateError(prefetch.error, prefetch.stackTrace);
-            case _StreamIteratorImpl._STATE_EXTRA_DONE:
+            case _StreamIteratorImpl[_STATE_EXTRA_DONE]:
               this[_clear]();
               return new _Future.immediate(false);
           }
         }
       }
       [_clear]() {
         this[_subscription] = null;
         this[_futureOrPrefetch] = null;
-        this[_current$] = null;
-        this[_state] = _StreamIteratorImpl._STATE_DONE;
+        this[_current] = null;
+        this[_state] = _StreamIteratorImpl[_STATE_DONE];
       }
       cancel() {
         let subscription = this[_subscription];
-        if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
+        if (this[_state] === _StreamIteratorImpl[_STATE_MOVING]) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
           hasNext._complete(false);
         } else {
           this[_clear]();
         }
         return subscription.cancel();
       }
       [_onData](data) {
-        if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
-          this[_current$] = data;
+        if (this[_state] === _StreamIteratorImpl[_STATE_MOVING]) {
+          this[_current] = data;
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_futureOrPrefetch] = null;
-          this[_state] = _StreamIteratorImpl._STATE_FOUND;
+          this[_state] = _StreamIteratorImpl[_STATE_FOUND];
           hasNext._complete(true);
           return;
         }
         this[_subscription].pause();
         dart.assert(this[_futureOrPrefetch] === null);
         this[_futureOrPrefetch] = data;
-        this[_state] = _StreamIteratorImpl._STATE_EXTRA_DATA;
+        this[_state] = _StreamIteratorImpl[_STATE_EXTRA_DATA];
       }
       [_onError](error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
-        if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
+        if (this[_state] === _StreamIteratorImpl[_STATE_MOVING]) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
           hasNext._completeError(error, stackTrace);
           return;
         }
         this[_subscription].pause();
         dart.assert(this[_futureOrPrefetch] === null);
         this[_futureOrPrefetch] = new AsyncError(error, stackTrace);
-        this[_state] = _StreamIteratorImpl._STATE_EXTRA_ERROR;
+        this[_state] = _StreamIteratorImpl[_STATE_EXTRA_ERROR];
       }
       [_onDone]() {
-        if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
+        if (this[_state] === _StreamIteratorImpl[_STATE_MOVING]) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
           hasNext._complete(false);
           return;
         }
         this[_subscription].pause();
         this[_futureOrPrefetch] = null;
-        this[_state] = _StreamIteratorImpl._STATE_EXTRA_DONE;
+        this[_state] = _StreamIteratorImpl[_STATE_EXTRA_DONE];
       }
     }
     _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;
     return _StreamIteratorImpl;
   });
@@ skipping 343 matching lines @@
 
         if (!dart.notNull(satisfies)) {
           this[_hasFailed] = true;
           sink._add(inputEvent);
         }
       }
     }
     return _SkipWhileStream;
   });
   let _SkipWhileStream = _SkipWhileStream$(dart.dynamic);
+  let _SENTINEL = Symbol('_SENTINEL');
   let _equals = Symbol('_equals');
   let _DistinctStream$ = dart.generic(function(T) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
-        this[_previous] = _SENTINEL;
+        this[_previous] = _DistinctStream[_SENTINEL];
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
-        if (core.identical(this[_previous], _SENTINEL)) {
+        if (core.identical(this[_previous], _DistinctStream[_SENTINEL])) {
           this[_previous] = inputEvent;
           return sink._add(inputEvent);
         } else {
           let isEqual = null;
           try {
             if (this[_equals] === null) {
               isEqual = dart.equals(this[_previous], inputEvent);
             } else {
               isEqual = this[_equals](dart.as(this[_previous], T), inputEvent);
             }
@@ skipping 177 matching lines @@
           stackTrace = null;
         return this[_handleError](error, stackTrace, this[_sink]);
       }
       close() {
         return this[_handleDone](this[_sink]);
       }
     }
     return _HandlerEventSink;
   });
   let _HandlerEventSink = _HandlerEventSink$(dart.dynamic, dart.dynamic);
-  let _defaultHandleData$ = Symbol('_defaultHandleData');
-  let _defaultHandleError$ = Symbol('_defaultHandleError');
-  let _defaultHandleDone$ = Symbol('_defaultHandleDone');
+  let _defaultHandleData = Symbol('_defaultHandleData');
+  let _defaultHandleError = Symbol('_defaultHandleError');
+  let _defaultHandleDone = Symbol('_defaultHandleDone');
   let _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.closureWrap((outputSink) => {
           if (handleData === null)
-            handleData = dart.closureWrap(_defaultHandleData, "(S, EventSink<T>) → void");
+            handleData = dart.closureWrap(_StreamHandlerTransformer[_defaultHandleData], "(S, EventSink<T>) → void");
           if (handleError === null)
-            handleError = dart.closureWrap(_defaultHandleError, "(Object, StackTrace, EventSink<T>) → void");
+            handleError = dart.closureWrap(_StreamHandlerTransformer[_defaultHandleError], "(Object, StackTrace, EventSink<T>) → void");
           if (handleDone === null)
-            handleDone = _defaultHandleDone;
+            handleDone = _StreamHandlerTransformer[_defaultHandleDone];
           return new _HandlerEventSink(handleData, handleError, handleDone, outputSink);
         }, "(EventSink<T>) → EventSink<S>"));
       }
       bind(stream) {
         return super.bind(stream);
       }
-      static [_defaultHandleData$](data, sink) {
+      static [_defaultHandleData](data, sink) {
         sink.add(data);
       }
-      static [_defaultHandleError$](error, stackTrace, sink) {
+      static [_defaultHandleError](error, stackTrace, sink) {
         sink.addError(error);
       }
-      static [_defaultHandleDone$](sink) {
+      static [_defaultHandleDone](sink) {
         sink.close();
       }
     }
     return _StreamHandlerTransformer;
   });
   let _StreamHandlerTransformer = _StreamHandlerTransformer$(dart.dynamic, dart.dynamic);
   let _transformer = Symbol('_transformer');
   let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
     class _StreamSubscriptionTransformer extends core.Object {
       _StreamSubscriptionTransformer(transformer$) {
@@ skipping 115 matching lines @@
       this.createTimer = createTimer;
       this.createPeriodicTimer = createPeriodicTimer;
       this.print = print;
       this.fork = fork;
     }
   }
   class ZoneDelegate extends core.Object {
   }
   let _enter = Symbol('_enter');
   let _leave = Symbol('_leave');
+  let _$ = Symbol('_');
   class Zone extends core.Object {
     Zone$_() {
     }
     static get current() {
-      return _current;
+      return Zone[_current];
     }
     static [_enter](zone) {
       dart.assert(zone !== null);
-      dart.assert(!dart.notNull(core.identical(zone, _current)));
-      let previous = _current;
-      _current = zone;
+      dart.assert(!dart.notNull(core.identical(zone, Zone[_current])));
+      let previous = Zone[_current];
+      Zone[_current] = zone;
       return previous;
     }
     static [_leave](previous) {
       dart.assert(previous !== null);
-      Zone[_current$] = previous;
+      Zone[_current] = previous;
     }
   }
-  dart.defineNamedConstructor(Zone, '_');
+  dart.defineNamedConstructor(Zone, _$);
   Zone.ROOT = _ROOT_ZONE;
   Zone._current = _ROOT_ZONE;
   let _delegate = Symbol('_delegate');
   // Function _parentDelegate: (_Zone) → ZoneDelegate
   function _parentDelegate(zone) {
     if (zone.parent === null)
       return null;
     return zone.parent[_delegate];
   }
   let _delegationTarget = Symbol('_delegationTarget');
@@ skipping 284 matching lines @@
     }
   }
   // Function _rootHandleUncaughtError: (Zone, ZoneDelegate, Zone, dynamic, StackTrace) → void
   function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
     _schedulePriorityAsyncCallback(() => {
       throw new _UncaughtAsyncError(error, stackTrace);
     });
   }
   // Function _rootRun: (Zone, ZoneDelegate, Zone, () → dynamic) → dynamic
   function _rootRun(self, parent, zone, f) {
-    if (dart.equals(Zone[_current$], zone))
+    if (dart.equals(Zone[_current], zone))
       return f();
     let old = Zone._enter(zone);
     try {
       return f();
     } finally {
       Zone._leave(old);
     }
   }
   // Function _rootRunUnary: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dynamic) → dynamic
   function _rootRunUnary(self, parent, zone, f, arg) {
-    if (dart.equals(Zone[_current$], zone))
+    if (dart.equals(Zone[_current], zone))
       return dart.dinvokef(f, arg);
     let old = Zone._enter(zone);
     try {
       return dart.dinvokef(f, arg);
     } finally {
       Zone._leave(old);
     }
   }
   // Function _rootRunBinary: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dynamic
   function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
-    if (dart.equals(Zone[_current$], zone))
+    if (dart.equals(Zone[_current], zone))
       return dart.dinvokef(f, arg1, arg2);
     let old = Zone._enter(zone);
     try {
       return dart.dinvokef(f, arg1, arg2);
     } finally {
       Zone._leave(old);
     }
   }
   // Function _rootRegisterCallback: (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback
   function _rootRegisterCallback(self, parent, zone, f) {
@@ skipping 95 matching lines @@
     get createPeriodicTimer() {
       return _rootCreatePeriodicTimer;
     }
     get print() {
       return _rootPrint;
     }
     get fork() {
       return _rootFork;
     }
   }
+  let _rootMap = Symbol('_rootMap');
+  let _rootDelegate = Symbol('_rootDelegate');
   class _RootZone extends _Zone {
     _RootZone() {
       super._Zone();
     }
     get [_run]() {
       return new _ZoneFunction(_ROOT_ZONE, _rootRun);
     }
     get [_runUnary]() {
       return new _ZoneFunction(_ROOT_ZONE, _rootRunUnary);
     }
@@ skipping 27 matching lines @@
     get [_fork]() {
       return new _ZoneFunction(_ROOT_ZONE, _rootFork);
     }
     get [_handleUncaughtError]() {
       return new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError);
     }
     get parent() {
       return null;
     }
     get [_map]() {
-      return _rootMap;
+      return _RootZone[_rootMap];
     }
     get [_delegate]() {
-      if (_rootDelegate !== null)
-        return _rootDelegate;
-      return _rootDelegate = new _ZoneDelegate(this);
+      if (_RootZone[_rootDelegate] !== null)
+        return _RootZone[_rootDelegate];
+      return _RootZone[_rootDelegate] = new _ZoneDelegate(this);
     }
     get errorZone() {
       return this;
     }
     runGuarded(f) {
       try {
-        if (core.identical(_ROOT_ZONE, Zone[_current$])) {
+        if (core.identical(_ROOT_ZONE, Zone[_current])) {
           return f();
         }
         return _rootRun(null, null, this, f);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runUnaryGuarded(f, arg) {
       try {
-        if (core.identical(_ROOT_ZONE, Zone[_current$])) {
+        if (core.identical(_ROOT_ZONE, Zone[_current])) {
           return dart.dinvokef(f, arg);
         }
         return _rootRunUnary(null, null, this, f, arg);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runBinaryGuarded(f, arg1, arg2) {
       try {
-        if (core.identical(_ROOT_ZONE, Zone[_current$])) {
+        if (core.identical(_ROOT_ZONE, Zone[_current])) {
           return dart.dinvokef(f, arg1, arg2);
         }
         return _rootRunBinary(null, null, this, f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     bindCallback(f, opts) {
@@ skipping 25 matching lines @@
     }
     handleUncaughtError(error, stackTrace) {
       return _rootHandleUncaughtError(null, null, this, error, stackTrace);
     }
     fork(opts) {
       let specification = opts && 'specification' in opts ? opts.specification : null;
       let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
       return _rootFork(null, null, this, specification, zoneValues);
     }
     run(f) {
-      if (core.identical(Zone[_current$], _ROOT_ZONE))
+      if (core.identical(Zone[_current], _ROOT_ZONE))
         return f();
       return _rootRun(null, null, this, f);
     }
     runUnary(f, arg) {
-      if (core.identical(Zone[_current$], _ROOT_ZONE))
+      if (core.identical(Zone[_current], _ROOT_ZONE))
         return dart.dinvokef(f, arg);
       return _rootRunUnary(null, null, this, f, arg);
     }
     runBinary(f, arg1, arg2) {
-      if (core.identical(Zone[_current$], _ROOT_ZONE))
+      if (core.identical(Zone[_current], _ROOT_ZONE))
         return dart.dinvokef(f, arg1, arg2);
       return _rootRunBinary(null, null, this, f, arg1, arg2);
     }
     registerCallback(f) {
       return f;
     }
     registerUnaryCallback(f) {
       return f;
     }
     registerBinaryCallback(f) {
@@ skipping 91 matching lines @@
   exports.StreamIterator = StreamIterator;
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamController = StreamController;
   exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));