fixes #131, use before define from variables to classes

lib/runtime/dart/async.js

 var async = dart.defineLibrary(async, {});
 var core = dart.import(core);
 var _internal = dart.import(_internal);
 var _js_helper = dart.lazyImport(_js_helper);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
 var collection = dart.import(collection);
 (function(exports, core, _internal, _js_helper, _isolate_helper, collection) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
@@ skipping 34 matching lines @@
       return null;
     }
     toString() {
       let result = `Uncaught Error: ${this.error}`;
       if (this.stackTrace != null) {
         result = dart.notNull(result) + `\nStack Trace:\n${this.stackTrace}`;
       }
       return result;
     }
   }
-  let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(dart.dynamic, [dart.dynamic]));
-  let _controller = Symbol('_controller');
-  let _createSubscription = Symbol('_createSubscription');
-  let _subscribe = Symbol('_subscribe');
-  let _onListen = Symbol('_onListen');
+  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) {
     class Stream extends core.Object {
       Stream() {
       }
@@ skipping 744 matching lines @@
         return controller.stream;
       }
     }
     dart.defineNamedConstructor(Stream, 'fromFuture');
     dart.defineNamedConstructor(Stream, 'fromIterable');
     dart.defineNamedConstructor(Stream, 'periodic');
     dart.defineNamedConstructor(Stream, 'eventTransformed');
     return Stream;
   });
   let Stream = Stream$();
+  let _createSubscription = Symbol('_createSubscription');
+  let _onListen = Symbol('_onListen');
   let _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;
         cancelOnError = core.identical(true, cancelOnError);
         let subscription = this[_createSubscription](onData, onError, onDone, cancelOnError);
         this[_onListen](subscription);
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         return new (_BufferingStreamSubscription$(T))(onData, onError, onDone, cancelOnError);
       }
       [_onListen](subscription) {}
     }
     return _StreamImpl;
   });
   let _StreamImpl = _StreamImpl$();
+  let _controller = Symbol('_controller');
+  let _subscribe = Symbol('_subscribe');
   let _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);
       }
@@ skipping 25 matching lines @@
   });
   let _BroadcastStream = _BroadcastStream$();
   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 _toggleEventId = Symbol('_toggleEventId');
-  let _isFiring = Symbol('_isFiring');
-  let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
-  let _removeAfterFiring = Symbol('_removeAfterFiring');
-  let _onPause = Symbol('_onPause');
-  let _onResume = Symbol('_onResume');
-  let _onCancel = Symbol('_onCancel');
-  let _recordCancel = Symbol('_recordCancel');
-  let _recordPause = Symbol('_recordPause');
-  let _recordResume = Symbol('_recordResume');
   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 _extractPending = Symbol('_extractPending');
   let _isCanceled = Symbol('_isCanceled');
   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 _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] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_HAS_PENDING);
+          this[_state] = dart.notNull(this[_state]) | dart.notNull(_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 13 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.bind(this));
         if (!dart.notNull(wasPaused) && dart.notNull(this[_pending] != null))
           this[_pending].cancelSchedule();
         if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
           this[_guardCallback](this[_onPause].bind(this));
       }
       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(this[_state]) & ~dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
+              this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_INPUT_PAUSED);
               if (!dart.notNull(this[_inCallback]))
                 this[_guardCallback](this[_onResume].bind(this));
             }
           }
         }
       }
       cancel() {
-        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL);
+        this[_state] = dart.notNull(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$(T))();
         this[_onDone] = () => {
           result[_complete](futureValue);
         };
         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] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_CANCELED);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_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] = dart.notNull(this[_state]) - dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT);
+        this[_state] = dart.notNull(this[_state]) - dart.notNull(_BufferingStreamSubscription$()._STATE_PAUSE_COUNT);
       }
       [_add](data) {
         dart.as(data, T);
         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] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_CLOSED);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_CLOSED);
         if (this[_canFire]) {
           this[_sendDone]();
         } else {
           this[_addPending](dart.const(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] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_HAS_PENDING);
+          this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_HAS_PENDING);
           if (!dart.notNull(this[_isPaused])) {
             this[_pending].schedule(this);
           }
         }
       }
       [_sendData](data) {
         dart.as(data, T);
         dart.assert(!dart.notNull(this[_isCanceled]));
         dart.assert(!dart.notNull(this[_isPaused]));
         dart.assert(!dart.notNull(this[_inCallback]));
         let wasInputPaused = this[_isInputPaused];
-        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        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[_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];
         // Function sendError: () → void
         let sendError = (() => {
           if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
             return;
-          this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+          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);
+          this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         }).bind(this);
         if (this[_cancelOnError]) {
-          this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL);
+          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]));
         // Function sendDone: () → void
         let sendDone = (() => {
           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[_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);
+          this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         }).bind(this);
         this[_cancel]();
-        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_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] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
         dart.dcall(callback);
-        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        this[_state] = dart.notNull(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(this[_state]) & ~dart.notNull(_BufferingStreamSubscription._STATE_HAS_PENDING);
+          this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_HAS_PENDING);
           if (dart.notNull(this[_isInputPaused]) && dart.notNull(this[_mayResumeInput])) {
-            this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
+            this[_state] = dart.notNull(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] = dart.notNull(this[_state]) ^ dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+          this[_state] = dart.notNull(this[_state]) ^ dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           if (isInputPaused) {
             this[_onPause]();
           } else {
             this[_onResume]();
           }
-          this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+          this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           wasInputPaused = isInputPaused;
         }
         if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
           this[_pending].schedule(this);
         }
       }
     }
     _BufferingStreamSubscription[dart.implements] = () => [StreamSubscription$(T), _EventSink$(T), _EventDispatch$(T)];
-    _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;
     return _BufferingStreamSubscription;
   });
   let _BufferingStreamSubscription = _BufferingStreamSubscription$();
+  let _recordCancel = Symbol('_recordCancel');
+  let _recordPause = Symbol('_recordPause');
+  let _recordResume = Symbol('_recordResume');
   let _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);
       }
     }
     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) {
     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;
       }
       get [_controller]() {
         return dart.as(super[_controller], _BroadcastStreamController$(T));
       }
       [_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] = dart.notNull(this[_eventState]) ^ dart.notNull(_BroadcastSubscription._STATE_EVENT_ID);
+        this[_eventState] = dart.notNull(this[_eventState]) ^ dart.notNull(_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] = dart.notNull(this[_eventState]) | dart.notNull(_BroadcastSubscription._STATE_REMOVE_AFTER_FIRING);
+        this[_eventState] = dart.notNull(this[_eventState]) | dart.notNull(_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[dart.implements] = () => [_BroadcastSubscriptionLink];
-    _BroadcastSubscription._STATE_EVENT_ID = 1;
-    _BroadcastSubscription._STATE_FIRING = 2;
-    _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
     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) {
     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$(T))(this);
       }
       get sink() {
         return new (_StreamSinkWrapper$(T))(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.as(subscription, _BroadcastSubscription$(T));
         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.as(subscription, _BroadcastSubscription$(T));
         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 61 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] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_CLOSED);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController$()._STATE_CLOSED);
         let doneFuture = this[_ensureDoneFuture]();
         this[_sendDone]();
         return doneFuture;
       }
       get done() {
         return this[_ensureDoneFuture]();
       }
       addStream(stream, opts) {
         dart.as(stream, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
-        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController._STATE_ADDSTREAM);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_BroadcastStreamController$()._STATE_ADDSTREAM);
         this[_addStreamState] = new (_AddStreamState$(T))(this, stream, cancelOnError);
         return this[_addStreamState].addStreamFuture;
       }
       [_add](data) {
         dart.as(data, T);
         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(this[_state]) & ~dart.notNull(_BroadcastStreamController._STATE_ADDSTREAM);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController$()._STATE_ADDSTREAM);
         addState.complete();
       }
       [_forEachListener](action) {
         dart.as(action, dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
         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(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(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] = dart.notNull(subscription[_eventState]) | dart.notNull(_BroadcastSubscription._STATE_FIRING);
             action(subscription);
             subscription[_toggleEventId]();
             link = subscription[_next];
             if (subscription[_removeAfterFiring]) {
               this[_removeListener](subscription);
             }
             subscription[_eventState] = dart.notNull(subscription[_eventState]) & ~dart.notNull(_BroadcastSubscription._STATE_FIRING);
           } else {
             link = subscription[_next];
           }
         }
-        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BroadcastStreamController._STATE_FIRING);
+        this[_state] = dart.notNull(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]);
       }
     }
     _BroadcastStreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _BroadcastSubscriptionLink, _EventSink$(T), _EventDispatch$(T)];
-    _BroadcastStreamController._STATE_INITIAL = 0;
-    _BroadcastStreamController._STATE_EVENT_ID = 1;
-    _BroadcastStreamController._STATE_FIRING = 2;
-    _BroadcastStreamController._STATE_CLOSED = 4;
-    _BroadcastStreamController._STATE_ADDSTREAM = 8;
     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) {
     class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         dart.as(data, T);
         if (this[_isEmpty])
           return;
         if (this[_hasOneListener]) {
@@ skipping 171 matching lines @@
         if (value === void 0)
           value = null;
         return new _Future();
       }
     }
     _DoneSubscription[dart.implements] = () => [StreamSubscription$(T)];
     return _DoneSubscription;
   });
   let _DoneSubscription = _DoneSubscription$();
   let __CastType2$ = dart.generic(function(T) {
-    let __CastType2 = dart.typedef('__CastType2', () => dart.functionType(dart.void, [_BufferingStreamSubscription$(T)]));
+    let __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() {
@@ skipping 139 matching lines @@
         }
         if (remaining == 0) {
           return new (Future$(core.List)).value(dart.const([]));
         }
         values = new core.List(remaining);
         return result;
       }
       static forEach(input, f) {
         dart.as(f, dart.functionType(dart.dynamic, [dart.dynamic]));
         let iterator = input[core.$iterator];
-        return Future.doWhile(() => {
+        return Future$().doWhile(() => {
           if (!dart.notNull(iterator.moveNext()))
             return false;
           return new (Future$()).sync(() => dart.dcall(f, iterator.current)).then(_ => true);
         });
       }
       static doWhile(f) {
         dart.as(f, dart.functionType(dart.dynamic, []));
         let doneSignal = new _Future();
         let nextIteration = null;
         nextIteration = Zone.current.bindUnaryCallback(keepGoing => {
           if (keepGoing) {
             new (Future$()).sync(f).then(dart.as(nextIteration, __CastType4), {onError: doneSignal[_completeError].bind(doneSignal)});
           } else {
             doneSignal[_complete](null);
           }
         }, {runGuarded: true});
         dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
     dart.defineNamedConstructor(Future, 'value');
     dart.defineNamedConstructor(Future, 'error');
     dart.defineNamedConstructor(Future, 'delayed');
-    dart.defineLazyProperties(Future, {
-      get _nullFuture() {
-        return new _Future.immediate(null);
-      }
-    });
     return Future;
   });
   let Future = Future$();
+  dart.defineLazyProperties(Future, {
+    get _nullFuture() {
+      return new _Future.immediate(null);
+    }
+  });
   class TimeoutException extends core.Object {
     TimeoutException(message, duration) {
       if (duration === void 0)
         duration = null;
       this.message = message;
       this.duration = duration;
     }
     toString() {
       let result = "TimeoutException";
       if (this.duration != null)
@@ skipping 23 matching lines @@
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     result[_completeError](error, dart.as(stackTrace, core.StackTrace));
   }
   // Function _nonNullError: (Object) → Object
   function _nonNullError(error) {
     return error != null ? error : new core.NullThrownError();
   }
-  let __CastType4 = dart.typedef('__CastType4', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  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]));
+    let _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 _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) {
     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]))
@@ skipping 139 matching lines @@
   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) {
     class _Future extends core.Object {
       _Future() {
         this[_zone] = Zone.current;
-        this[_state] = _Future._INCOMPLETE;
+        this[_state] = _Future$()._INCOMPLETE;
         this[_resultOrListeners] = null;
       }
       immediate(value) {
         this[_zone] = Zone.current;
-        this[_state] = _Future._INCOMPLETE;
+        this[_state] = _Future$()._INCOMPLETE;
         this[_resultOrListeners] = null;
         this[_asyncComplete](value);
       }
       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) {
         dart.as(f, dart.functionType(dart.dynamic, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let result = new (_Future$())();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           f = dart.as(result[_zone].registerUnaryCallback(f), __CastType6);
           if (onError != null) {
             onError = _registerErrorHandler(onError, result[_zone]);
@@ skipping 22 matching lines @@
         }
         this[_addListener](new _FutureListener.whenComplete(result, action));
         return dart.as(result, Future$(T));
       }
       asStream() {
         return new (Stream$(T)).fromFuture(this);
       }
       [_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.as(value, T);
         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((() => {
-            _Future._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;
@@ skipping 21 matching lines @@
             target[_completeError](error, dart.as(stackTrace, core.StackTrace));
           }
         });
       }
       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]) {
-          _Future._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$())) {
-            _Future._chainCoreFuture(dart.as(value, _Future$()), this);
+            _Future$()._chainCoreFuture(dart.as(value, _Future$()), this);
           } else {
-            _Future._chainForeignFuture(dart.as(value, Future), this);
+            _Future$()._chainForeignFuture(dart.as(value, Future), this);
           }
         } else {
           let listeners = this[_removeListeners]();
           this[_setValue](dart.as(value, T));
-          _Future._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));
-        _Future._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);
-        _Future._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((() => {
-                _Future._chainCoreFuture(coreFuture, this);
+                _Future$()._chainCoreFuture(coreFuture, this);
               }).bind(this));
             } else {
-              _Future._chainCoreFuture(coreFuture, this);
+              _Future$()._chainCoreFuture(coreFuture, this);
             }
           } else {
-            _Future._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));
       }
@@ skipping 12 matching lines @@
             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;
-            _Future._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.dsend(completeResult, 'then', ignored => {
-                  _Future._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.dsend(completeResult, _setError, error, stackTrace);
                     }
-                    _Future._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.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 {
-                  _Future._chainCoreFuture(chainSource, result);
+                  _Future$()._chainCoreFuture(chainSource, result);
                 }
               } else {
-                _Future._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 39 matching lines @@
               result[_completeError](e, dart.as(s, core.StackTrace));
             }
           }
         });
         return result;
       }
     }
     _Future[dart.implements] = () => [Future$(T)];
     dart.defineNamedConstructor(_Future, 'immediate');
     dart.defineNamedConstructor(_Future, 'immediateError');
-    _Future._INCOMPLETE = 0;
-    _Future._PENDING_COMPLETE = 1;
-    _Future._CHAINED = 2;
-    _Future._VALUE = 4;
-    _Future._ERROR = 8;
     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]));
+    let __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, []));
+  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, []));
   class _AsyncCallbackEntry extends core.Object {
     _AsyncCallbackEntry(callback) {
       this.callback = callback;
       this.next = null;
     }
   }
   exports._nextCallback = null;
   exports._lastCallback = null;
   exports._lastPriorityCallback = null;
   exports._isInCallbackLoop = false;
@@ skipping 210 matching lines @@
         this[_sink].addError(error, stackTrace);
       }
       close() {
         this[_sink].close();
       }
     }
     _ControllerEventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     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 __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) {
     class StreamController extends core.Object {
       StreamController(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 (dart.notNull(onListen == null) && dart.notNull(onPause == null) && dart.notNull(onResume == null) && dart.notNull(onCancel == null)) {
           return dart.as(sync ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
@@ skipping 31 matching lines @@
   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) {
     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 new (_ControllerStream$(T))(this);
       }
       get sink() {
         return new (_StreamSinkWrapper$(T))(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 25 matching lines @@
       }
       addStream(source, opts) {
         dart.as(source, Stream$(T));
         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] = dart.notNull(this[_state]) | dart.notNull(_StreamController._STATE_ADDSTREAM);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_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 20 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] = dart.notNull(this[_state]) | dart.notNull(_StreamController._STATE_CLOSED);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_StreamController$()._STATE_CLOSED);
         if (this.hasListener) {
           this[_sendDone]();
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(dart.const(new _DelayedDone()));
         }
       }
       [_add](value) {
         dart.as(value, T);
         if (this.hasListener) {
           this[_sendData](value);
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new (_DelayedData$(T))(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(this[_state]) & ~dart.notNull(_StreamController._STATE_ADDSTREAM);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_StreamController$()._STATE_ADDSTREAM);
         addState.complete();
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         dart.as(onDone, dart.functionType(dart.void, []));
         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] = dart.notNull(this[_state]) | dart.notNull(_StreamController._STATE_SUBSCRIBED);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_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) {
         dart.as(subscription, StreamSubscription$(T));
         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 = new _Future();
               result[_asyncCompleteError](e, s);
             }
 
@@ skipping 25 matching lines @@
       [_recordResume](subscription) {
         dart.as(subscription, StreamSubscription$(T));
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.resume();
         }
         _runGuarded(this[_onResume]);
       }
     }
     _StreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _EventSink$(T), _EventDispatch$(T)];
-    _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;
     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) {
     class _SyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         dart.as(data, T);
         this[_subscription][_add](data);
       }
       [_sendError](error, stackTrace) {
         this[_subscription][_addError](error, stackTrace);
       }
       [_sendDone]() {
@@ skipping 56 matching lines @@
     }
     get [_onResume]() {
       return null;
     }
     get [_onCancel]() {
       return null;
     }
   }
   class _NoCallbackAsyncStreamController extends dart.mixin(_StreamController, _AsyncStreamControllerDispatch, _NoCallbacks) {}
   class _NoCallbackSyncStreamController extends dart.mixin(_StreamController, _SyncStreamControllerDispatch, _NoCallbacks) {}
-  let _NotificationHandler = dart.typedef('_NotificationHandler', () => dart.functionType(dart.dynamic, []));
+  let _NotificationHandler = dart.typedef('_NotificationHandler', dart.functionType(dart.dynamic, []));
   // Function _runGuarded: (() → dynamic) → Future<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) {
@@ skipping 30 matching lines @@
       }
     }
     _StreamSinkWrapper[dart.implements] = () => [StreamSink$(T)];
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$();
   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].bind(controller), {onError: cancelOnError ? dart.as(_AddStreamState.makeErrorHandler(controller), core.Function) : controller[_addError].bind(controller), onDone: controller[_close].bind(controller), cancelOnError: cancelOnError});
+        this.addSubscription = source.listen(controller[_add].bind(controller), {onError: cancelOnError ? dart.as(_AddStreamState$().makeErrorHandler(controller), core.Function) : controller[_addError].bind(controller), onDone: controller[_close].bind(controller), cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return (e, s) => {
           controller[_addError](e, s);
           controller[_close]();
         };
       }
       pause() {
         this.addSubscription.pause();
       }
@@ skipping 33 matching lines @@
   let _EventSink$ = dart.generic(function(T) {
     class _EventSink extends core.Object {}
     return _EventSink;
   });
   let _EventSink = _EventSink$();
   let _EventDispatch$ = dart.generic(function(T) {
     class _EventDispatch extends core.Object {}
     return _EventDispatch;
   });
   let _EventDispatch = _EventDispatch$();
-  let _EventGenerator = dart.typedef('_EventGenerator', () => dart.functionType(_PendingEvents, []));
-  let _isUsed = Symbol('_isUsed');
-  let _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 (this[_isUsed])
-          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));
-      }
-    }
-    return _GeneratedStreamImpl;
-  });
-  let _GeneratedStreamImpl = _GeneratedStreamImpl$();
-  let _iterator = Symbol('_iterator');
+  _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 _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 14 matching lines @@
           return;
         this.handleNext(dispatch);
       }).bind(this));
       this[_state] = _PendingEvents._STATE_SCHEDULED;
     }
     cancelSchedule() {
       if (this.isScheduled)
         this[_state] = _PendingEvents._STATE_CANCELED;
     }
   }
-  _PendingEvents._STATE_UNSCHEDULED = 0;
-  _PendingEvents._STATE_SCHEDULED = 1;
-  _PendingEvents._STATE_CANCELED = 3;
+  let _EventGenerator = dart.typedef('_EventGenerator', dart.functionType(_PendingEvents, []));
+  let _isUsed = Symbol('_isUsed');
+  let _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 (this[_isUsed])
+          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));
+      }
+    }
+    return _GeneratedStreamImpl;
+  });
+  let _GeneratedStreamImpl = _GeneratedStreamImpl$();
+  let _iterator = Symbol('_iterator');
   let _IterablePendingEvents$ = dart.generic(function(T) {
     class _IterablePendingEvents extends _PendingEvents {
       _IterablePendingEvents(data) {
         this[_iterator] = data[core.$iterator];
         super._PendingEvents();
       }
       get isEmpty() {
         return this[_iterator] == null;
       }
       handleNext(dispatch) {
@@ skipping 20 matching lines @@
       clear() {
         if (this.isScheduled)
           this.cancelSchedule();
         this[_iterator] = null;
       }
     }
     return _IterablePendingEvents;
   });
   let _IterablePendingEvents = _IterablePendingEvents$();
   let _DataHandler$ = dart.generic(function(T) {
-    let _DataHandler = dart.typedef('_DataHandler', () => dart.functionType(dart.void, [T]));
+    let _DataHandler = dart.typedef('_DataHandler', dart.functionType(dart.void, [T]));
     return _DataHandler;
   });
   let _DataHandler = _DataHandler$();
-  let _DoneHandler = dart.typedef('_DoneHandler', () => dart.functionType(dart.void, []));
+  let _DoneHandler = dart.typedef('_DoneHandler', dart.functionType(dart.void, []));
   // Function _nullDataHandler: (dynamic) → void
   function _nullDataHandler(value) {
   }
   // Function _nullErrorHandler: (dynamic, [StackTrace]) → void
   function _nullErrorHandler(error, stackTrace) {
     if (stackTrace === void 0)
       stackTrace = null;
     Zone.current.handleUncaughtError(error, stackTrace);
   }
   // Function _nullDoneHandler: () → void
@@ skipping 39 matching lines @@
       dispatch[_sendDone]();
     }
     get next() {
       return null;
     }
     set next(_) {
       throw new core.StateError("No events after a done.");
     }
   }
   _DelayedDone[dart.implements] = () => [_DelayedEvent];
+  _PendingEvents._STATE_UNSCHEDULED = 0;
+  _PendingEvents._STATE_SCHEDULED = 1;
+  _PendingEvents._STATE_CANCELED = 3;
   class _StreamImplEvents extends _PendingEvents {
     _StreamImplEvents() {
       this.firstPendingEvent = null;
       this.lastPendingEvent = null;
       super._PendingEvents();
     }
     get isEmpty() {
       return this.lastPendingEvent == null;
     }
     add(event) {
@@ skipping 31 matching lines @@
       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;
     }
   }
-  let _broadcastCallback = dart.typedef('_broadcastCallback', () => dart.functionType(dart.void, [StreamSubscription]));
+  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) {
     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].bind(this));
-        this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription._SCHEDULED);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription$()._SCHEDULED);
       }
       onData(handleData) {
         dart.as(handleData, dart.functionType(dart.void, [T]));
       }
       onError(handleError) {}
       onDone(handleDone) {
         dart.as(handleDone, dart.functionType(dart.void, []));
         this[_onDone] = handleDone;
       }
       pause(resumeSignal) {
         if (resumeSignal === void 0)
           resumeSignal = null;
-        this[_state] = dart.notNull(this[_state]) + dart.notNull(_DoneStreamSubscription._PAUSED);
+        this[_state] = dart.notNull(this[_state]) + dart.notNull(_DoneStreamSubscription$()._PAUSED);
         if (resumeSignal != null)
           resumeSignal.whenComplete(this.resume.bind(this));
       }
       resume() {
         if (this.isPaused) {
-          this[_state] = dart.notNull(this[_state]) - dart.notNull(_DoneStreamSubscription._PAUSED);
+          this[_state] = dart.notNull(this[_state]) - dart.notNull(_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);
         };
         return result;
       }
       [_sendDone]() {
-        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_DoneStreamSubscription._SCHEDULED);
+        this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_DoneStreamSubscription$()._SCHEDULED);
         if (this.isPaused)
           return;
-        this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription._DONE_SENT);
+        this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription$()._DONE_SENT);
         if (this[_onDone] != null)
           this[_zone].runGuarded(this[_onDone]);
       }
     }
     _DoneStreamSubscription[dart.implements] = () => [StreamSubscription$(T)];
-    _DoneStreamSubscription._DONE_SENT = 1;
-    _DoneStreamSubscription._SCHEDULED = 2;
-    _DoneStreamSubscription._PAUSED = 4;
     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) {
     class _AsBroadcastStream extends Stream$(T) {
       _AsBroadcastStream(source, onListenHandler, onCancelHandler) {
@@ skipping 111 matching lines @@
   let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$();
   let _current = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
   let _clear = Symbol('_clear');
   let _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[_state] = _StreamIteratorImpl$()._STATE_FOUND;
         this[_subscription] = stream.listen(this[_onData].bind(this), {onError: this[_onError].bind(this), onDone: this[_onDone].bind(this), cancelOnError: true});
       }
       get current() {
         return this[_current];
       }
       moveNext() {
-        if (this[_state] == _StreamIteratorImpl._STATE_DONE) {
+        if (this[_state] == _StreamIteratorImpl$()._STATE_DONE) {
           return new (_Future$(core.bool)).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;
+        if (this[_state] == _StreamIteratorImpl$()._STATE_FOUND) {
+          this[_state] = _StreamIteratorImpl$()._STATE_MOVING;
           this[_current] = null;
           this[_futureOrPrefetch] = new (_Future$(core.bool))();
           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:
+            case _StreamIteratorImpl$()._STATE_EXTRA_DATA:
             {
-              this[_state] = _StreamIteratorImpl._STATE_FOUND;
+              this[_state] = _StreamIteratorImpl$()._STATE_FOUND;
               this[_current] = dart.as(this[_futureOrPrefetch], T);
               this[_futureOrPrefetch] = null;
               this[_subscription].resume();
               return new (_Future$(core.bool)).immediate(true);
             }
-            case _StreamIteratorImpl._STATE_EXTRA_ERROR:
+            case _StreamIteratorImpl$()._STATE_EXTRA_ERROR:
             {
               let prefetch = dart.as(this[_futureOrPrefetch], AsyncError);
               this[_clear]();
               return new (_Future$(core.bool)).immediateError(prefetch.error, prefetch.stackTrace);
             }
-            case _StreamIteratorImpl._STATE_EXTRA_DONE:
+            case _StreamIteratorImpl$()._STATE_EXTRA_DONE:
             {
               this[_clear]();
               return new (_Future$(core.bool)).immediate(false);
             }
           }
         }
       }
       [_clear]() {
         this[_subscription] = null;
         this[_futureOrPrefetch] = null;
         this[_current] = null;
-        this[_state] = _StreamIteratorImpl._STATE_DONE;
+        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) {
         dart.as(data, T);
-        if (this[_state] == _StreamIteratorImpl._STATE_MOVING) {
+        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[dart.implements] = () => [StreamIterator$(T)];
-    _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;
   });
   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]));
+    let __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]));
+  let __CastType22 = dart.typedef('__CastType22', dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]));
+  let __CastType25 = dart.typedef('__CastType25', dart.functionType(dart.dynamic, [dart.dynamic]));
   // Function _runUserCode: (() → dynamic, (dynamic) → dynamic, (dynamic, StackTrace) → dynamic) → 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 {
@@ skipping 124 matching lines @@
         this[_stream][_handleError](error, stackTrace, this);
       }
       [_handleDone]() {
         this[_stream][_handleDone](this);
       }
     }
     return _ForwardingStreamSubscription;
   });
   let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
   let _Predicate$ = dart.generic(function(T) {
-    let _Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [T]));
+    let _Predicate = dart.typedef('_Predicate', dart.functionType(core.bool, [T]));
     return _Predicate;
   });
   let _Predicate = _Predicate$();
   // Function _addErrorWithReplacement: (_EventSink<dynamic>, dynamic, dynamic) → void
   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;
     }
@@ skipping 20 matching lines @@
 
         if (satisfies) {
           sink[_add](inputEvent);
         }
       }
     }
     return _WhereStream;
   });
   let _WhereStream = _WhereStream$();
   let _Transformation$ = dart.generic(function(S, T) {
-    let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
+    let _Transformation = dart.typedef('_Transformation', dart.functionType(T, [S]));
     return _Transformation;
   });
   let _Transformation = _Transformation$();
   let _transform = Symbol('_transform');
   let _MapStream$ = dart.generic(function(S, T) {
     class _MapStream extends _ForwardingStream$(S, T) {
       _MapStream(source, transform) {
         this[_transform] = transform;
         super._ForwardingStream(source);
       }
@@ skipping 32 matching lines @@
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
         }
 
       }
     }
     return _ExpandStream;
   });
   let _ExpandStream = _ExpandStream$();
-  let _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dart.dynamic]));
+  let _ErrorTest = dart.typedef('_ErrorTest', dart.functionType(core.bool, [dart.dynamic]));
   let _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;
@@ skipping 130 matching lines @@
         if (!dart.notNull(satisfies)) {
           this[_hasFailed] = true;
           sink[_add](inputEvent);
         }
       }
     }
     return _SkipWhileStream;
   });
   let _SkipWhileStream = _SkipWhileStream$();
   let _Equality$ = dart.generic(function(T) {
-    let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [T, T]));
+    let _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) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
-        this[_previous] = _DistinctStream._SENTINEL;
+        this[_previous] = _DistinctStream$()._SENTINEL;
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
-        if (core.identical(this[_previous], _DistinctStream._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);
             }
           } catch (e) {
             let s = dart.stackTrace(e);
             _addErrorWithReplacement(sink, e, s);
             return null;
           }
 
           if (!dart.notNull(isEqual)) {
             sink[_add](inputEvent);
             this[_previous] = inputEvent;
           }
         }
       }
     }
-    dart.defineLazyProperties(_DistinctStream, {
-      get _SENTINEL() {
-        return new core.Object();
-      },
-      set _SENTINEL(_) {}
-    });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$();
+  dart.defineLazyProperties(_DistinctStream, {
+    get _SENTINEL() {
+      return new core.Object();
+    },
+    set _SENTINEL(_) {}
+  });
   let _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) {
@@ skipping 92 matching lines @@
           let s = dart.stackTrace(e);
           this[_addError](e, s);
         }
 
       }
     }
     return _SinkTransformerStreamSubscription;
   });
   let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
   let _SinkMapper$ = dart.generic(function(S, T) {
-    let _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventSink$(S), [EventSink$(T)]));
+    let _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) {
     class _StreamSinkTransformer extends core.Object {
       _StreamSinkTransformer(sinkMapper) {
         this[_sinkMapper] = sinkMapper;
       }
       bind(stream) {
@@ skipping 23 matching lines @@
         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;
       }
     }
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$();
   let _TransformDataHandler$ = dart.generic(function(S, T) {
-    let _TransformDataHandler = dart.typedef('_TransformDataHandler', () => dart.functionType(dart.void, [S, EventSink$(T)]));
+    let _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)]));
+    let _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)]));
+    let _TransformDoneHandler = dart.typedef('_TransformDoneHandler', dart.functionType(dart.void, [EventSink$(T)]));
     return _TransformDoneHandler;
   });
   let _TransformDoneHandler = _TransformDoneHandler$();
   let _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;
@@ skipping 17 matching lines @@
   let _HandlerEventSink = _HandlerEventSink$();
   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.as(outputSink => {
           dart.as(outputSink, EventSink$(T));
           if (handleData == null)
-            handleData = dart.as(_StreamHandlerTransformer._defaultHandleData, __CastType27);
+            handleData = dart.as(_StreamHandlerTransformer$()._defaultHandleData, __CastType27);
           if (handleError == null)
-            handleError = dart.as(_StreamHandlerTransformer._defaultHandleError, __CastType30);
+            handleError = dart.as(_StreamHandlerTransformer$()._defaultHandleError, __CastType30);
           if (handleDone == null)
-            handleDone = _StreamHandlerTransformer._defaultHandleDone;
+            handleDone = _StreamHandlerTransformer$()._defaultHandleDone;
           return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
         }, _SinkMapper$(S, T)));
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return super.bind(stream);
       }
       static _defaultHandleData(data, sink) {
         sink.add(data);
       }
       static _defaultHandleError(error, stackTrace, sink) {
         sink.addError(error);
       }
       static _defaultHandleDone(sink) {
         sink.close();
       }
     }
     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]));
+    let _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) {
     class _StreamSubscriptionTransformer extends core.Object {
       _StreamSubscriptionTransformer(transformer) {
         this[_transformer] = transformer;
       }
       bind(stream) {
@@ skipping 23 matching lines @@
         result.onData(onData);
         result.onError(onError);
         result.onDone(onDone);
         return result;
       }
     }
     return _BoundSubscriptionStream;
   });
   let _BoundSubscriptionStream = _BoundSubscriptionStream$();
   let __CastType27$ = dart.generic(function(S, T) {
-    let __CastType27 = dart.typedef('__CastType27', () => dart.functionType(dart.void, [S, EventSink$(T)]));
+    let __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)]));
+    let __CastType30 = dart.typedef('__CastType30', dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]));
     return __CastType30;
   });
   let __CastType30 = __CastType30$();
   class Timer extends core.Object {
     Timer(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 13 matching lines @@
       return new _isolate_helper.TimerImpl(milliseconds, callback);
     }
     static _createPeriodicTimer(duration, callback) {
       let milliseconds = duration.inMilliseconds;
       if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl.periodic(milliseconds, callback);
     }
   }
   dart.defineNamedConstructor(Timer, 'periodic');
-  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]));
-  class _ZoneFunction extends core.Object {
-    _ZoneFunction(zone, func) {
-      this.zone = zone;
-      this.function = func;
+  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]));
+  class Zone extends core.Object {
+    _() {
+    }
+    static get current() {
+      return Zone._current;
+    }
+    static _enter(zone) {
+      dart.assert(zone != null);
+      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;
     }
   }
+  dart.defineNamedConstructor(Zone, '_');
+  class ZoneDelegate extends core.Object {}
+  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]));
   class ZoneSpecification extends core.Object {
     ZoneSpecification(opts) {
       return new _ZoneSpecification(opts);
     }
     from(other, opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
       let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
       let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
       let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.scheduleMicrotask : null;
       let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
       let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.createPeriodicTimer : null;
       let print = opts && 'print' in opts ? opts.print : null;
       let fork = opts && 'fork' in opts ? opts.fork : null;
       return new ZoneSpecification({handleUncaughtError: handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, run: run != null ? run : other.run, runUnary: runUnary != null ? runUnary : other.runUnary, runBinary: runBinary != null ? runBinary : other.runBinary, registerCallback: registerCallback != null ? registerCallback : other.registerCallback, registerUnaryCallback: registerUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, registerBinaryCallback: registerBinaryCallback != null ? registerBinaryCallback : other.registerBinaryCallback, errorCallback: errorCallback != null ? errorCallback : other.errorCallback, scheduleMicrotask: scheduleMicrotask != null ? scheduleMicrotask : other.scheduleMicrotask, createTimer: createTimer != null ? createTimer : other.createTimer, createPeriodicTimer: createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, print: print != null ? print : other.print, fork: fork != null ? fork : other.fork});
     }
   }
   dart.defineNamedConstructor(ZoneSpecification, 'from');
+  let 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;
+    }
+  }
   class _ZoneSpecification extends core.Object {
     _ZoneSpecification(opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
       let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
       let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
@@ skipping 11 matching lines @@
       this.registerBinaryCallback = registerBinaryCallback;
       this.errorCallback = errorCallback;
       this.scheduleMicrotask = scheduleMicrotask;
       this.createTimer = createTimer;
       this.createPeriodicTimer = createPeriodicTimer;
       this.print = print;
       this.fork = fork;
     }
   }
   _ZoneSpecification[dart.implements] = () => [ZoneSpecification];
-  class ZoneDelegate extends core.Object {}
-  class Zone extends core.Object {
-    _() {
+  class _Zone extends core.Object {
+    _Zone() {
     }
-    static get current() {
-      return Zone._current;
-    }
-    static _enter(zone) {
-      dart.assert(zone != null);
-      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;
+    inSameErrorZone(otherZone) {
+      return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
     }
   }
-  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');
-  let _handleUncaughtError = Symbol('_handleUncaughtError');
+  _Zone[dart.implements] = () => [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');
+  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));
+    }
+    get [_runBinary]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunBinary));
+    }
+    get [_registerCallback]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback));
+    }
+    get [_registerUnaryCallback]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback));
+    }
+    get [_registerBinaryCallback]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback));
+    }
+    get [_errorCallback]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback));
+    }
+    get [_scheduleMicrotask]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask));
+    }
+    get [_createTimer]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer));
+    }
+    get [_createPeriodicTimer]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer));
+    }
+    get [_print]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootPrint));
+    }
+    get [_fork]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootFork));
+    }
+    get [_handleUncaughtError]() {
+      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError));
+    }
+    get parent() {
+      return null;
+    }
+    get [_map]() {
+      return _RootZone._rootMap;
+    }
+    get [_delegate]() {
+      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)) {
+          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)) {
+          return dart.dcall(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)) {
+          return dart.dcall(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) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
+      if (runGuarded) {
+        return (() => this.runGuarded(f)).bind(this);
+      } else {
+        return (() => this.run(f)).bind(this);
+      }
+    }
+    bindUnaryCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
+      if (runGuarded) {
+        return (arg => this.runUnaryGuarded(f, arg)).bind(this);
+      } else {
+        return (arg => this.runUnary(f, arg)).bind(this);
+      }
+    }
+    bindBinaryCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
+      if (runGuarded) {
+        return ((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this);
+      } else {
+        return ((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this);
+      }
+    }
+    get(key) {
+      return null;
+    }
+    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))
+        return f();
+      return _rootRun(null, null, this, f);
+    }
+    runUnary(f, arg) {
+      if (core.identical(Zone._current, _ROOT_ZONE))
+        return dart.dcall(f, arg);
+      return _rootRunUnary(null, null, this, f, arg);
+    }
+    runBinary(f, arg1, arg2) {
+      if (core.identical(Zone._current, _ROOT_ZONE))
+        return dart.dcall(f, arg1, arg2);
+      return _rootRunBinary(null, null, this, f, arg1, arg2);
+    }
+    registerCallback(f) {
+      return f;
+    }
+    registerUnaryCallback(f) {
+      return f;
+    }
+    registerBinaryCallback(f) {
+      return f;
+    }
+    errorCallback(error, stackTrace) {
+      return null;
+    }
+    scheduleMicrotask(f) {
+      _rootScheduleMicrotask(null, null, this, f);
+    }
+    createTimer(duration, f) {
+      return Timer._createTimer(duration, f);
+    }
+    createPeriodicTimer(duration, f) {
+      return Timer._createPeriodicTimer(duration, f);
+    }
+    print(line) {
+      _internal.printToConsole(line);
+    }
+  }
+  let _ROOT_ZONE = dart.const(new _RootZone());
+  Zone.ROOT = _ROOT_ZONE;
+  Zone._current = _ROOT_ZONE;
+  // Function _parentDelegate: (_Zone) → ZoneDelegate
+  function _parentDelegate(zone) {
+    if (zone.parent == null)
+      return null;
+    return zone.parent[_delegate];
+  }
+  let _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 53 matching lines @@
       let implZone = implementation.zone;
       dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, line);
     }
     fork(zone, specification, zoneValues) {
       let implementation = this[_delegationTarget][_fork];
       let implZone = implementation.zone;
       return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
     }
   }
   _ZoneDelegate[dart.implements] = () => [ZoneDelegate];
-  class _Zone extends core.Object {
-    _Zone() {
-    }
-    inSameErrorZone(otherZone) {
-      return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
-    }
-  }
-  _Zone[dart.implements] = () => [Zone];
   let _delegateCache = Symbol('_delegateCache');
-  let _map = Symbol('_map');
   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 321 matching lines @@
       return _rootCreatePeriodicTimer;
     }
     get print() {
       return _rootPrint;
     }
     get fork() {
       return _rootFork;
     }
   }
   _RootZoneSpecification[dart.implements] = () => [ZoneSpecification];
-  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));
-    }
-    get [_runBinary]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRunBinary));
-    }
-    get [_registerCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterCallback));
-    }
-    get [_registerUnaryCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterUnaryCallback));
-    }
-    get [_registerBinaryCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootRegisterBinaryCallback));
-    }
-    get [_errorCallback]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootErrorCallback));
-    }
-    get [_scheduleMicrotask]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootScheduleMicrotask));
-    }
-    get [_createTimer]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreateTimer));
-    }
-    get [_createPeriodicTimer]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootCreatePeriodicTimer));
-    }
-    get [_print]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootPrint));
-    }
-    get [_fork]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootFork));
-    }
-    get [_handleUncaughtError]() {
-      return dart.const(new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError));
-    }
-    get parent() {
-      return null;
-    }
-    get [_map]() {
-      return _RootZone._rootMap;
-    }
-    get [_delegate]() {
-      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)) {
-          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)) {
-          return dart.dcall(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)) {
-          return dart.dcall(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) {
-      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      if (runGuarded) {
-        return (() => this.runGuarded(f)).bind(this);
-      } else {
-        return (() => this.run(f)).bind(this);
-      }
-    }
-    bindUnaryCallback(f, opts) {
-      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      if (runGuarded) {
-        return (arg => this.runUnaryGuarded(f, arg)).bind(this);
-      } else {
-        return (arg => this.runUnary(f, arg)).bind(this);
-      }
-    }
-    bindBinaryCallback(f, opts) {
-      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
-      if (runGuarded) {
-        return ((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this);
-      } else {
-        return ((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this);
-      }
-    }
-    get(key) {
-      return null;
-    }
-    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))
-        return f();
-      return _rootRun(null, null, this, f);
-    }
-    runUnary(f, arg) {
-      if (core.identical(Zone._current, _ROOT_ZONE))
-        return dart.dcall(f, arg);
-      return _rootRunUnary(null, null, this, f, arg);
-    }
-    runBinary(f, arg1, arg2) {
-      if (core.identical(Zone._current, _ROOT_ZONE))
-        return dart.dcall(f, arg1, arg2);
-      return _rootRunBinary(null, null, this, f, arg1, arg2);
-    }
-    registerCallback(f) {
-      return f;
-    }
-    registerUnaryCallback(f) {
-      return f;
-    }
-    registerBinaryCallback(f) {
-      return f;
-    }
-    errorCallback(error, stackTrace) {
-      return null;
-    }
-    scheduleMicrotask(f) {
-      _rootScheduleMicrotask(null, null, this, f);
-    }
-    createTimer(duration, f) {
-      return Timer._createTimer(duration, f);
-    }
-    createPeriodicTimer(duration, f) {
-      return Timer._createPeriodicTimer(duration, f);
-    }
-    print(line) {
-      _internal.printToConsole(line);
-    }
-  }
   _RootZone._rootDelegate = null;
   dart.defineLazyProperties(_RootZone, {
     get _rootMap() {
       return new collection.HashMap();
     },
     set _rootMap(_) {}
   });
-  let _ROOT_ZONE = dart.const(new _RootZone());
   // Function runZoned: (() → dynamic, {zoneValues: Map<dynamic, dynamic>, zoneSpecification: ZoneSpecification, onError: Function}) → dynamic
   function runZoned(body, opts) {
     let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
     let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
     let onError = opts && 'onError' in opts ? opts.onError : null;
     let errorHandler = null;
     if (onError != null) {
       errorHandler = (self, parent, zone, error, stackTrace) => {
         try {
           if (dart.is(onError, ZoneBinaryCallback)) {
@@ skipping 16 matching lines @@
     } else if (errorHandler != null) {
       zoneSpecification = new 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);
     }
   }
-  let __CastType36 = dart.typedef('__CastType36', () => dart.functionType(dart.void, [Timer]));
-  let __CastType38 = dart.typedef('__CastType38', () => dart.functionType(dart.dynamic, [dart.dynamic]));
+  let __CastType36 = dart.typedef('__CastType36', dart.functionType(dart.void, [Timer]));
+  let __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 17 matching lines @@
   exports.StreamTransformer$ = StreamTransformer$;
   exports.StreamTransformer = StreamTransformer;
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamIterator = StreamIterator;
   exports.StreamController$ = StreamController$;
   exports.StreamController = StreamController;
   exports.Timer = Timer;
   exports.ZoneCallback = ZoneCallback;
   exports.ZoneUnaryCallback = ZoneUnaryCallback;
   exports.ZoneBinaryCallback = ZoneBinaryCallback;
+  exports.Zone = Zone;
+  exports.ZoneDelegate = ZoneDelegate;
   exports.HandleUncaughtErrorHandler = HandleUncaughtErrorHandler;
   exports.RunHandler = RunHandler;
   exports.RunUnaryHandler = RunUnaryHandler;
   exports.RunBinaryHandler = RunBinaryHandler;
   exports.RegisterCallbackHandler = RegisterCallbackHandler;
   exports.RegisterUnaryCallbackHandler = RegisterUnaryCallbackHandler;
   exports.RegisterBinaryCallbackHandler = RegisterBinaryCallbackHandler;
   exports.ErrorCallbackHandler = ErrorCallbackHandler;
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
+  exports.ZoneSpecification = ZoneSpecification;
   exports.ForkHandler = ForkHandler;
-  exports.ZoneSpecification = ZoneSpecification;
-  exports.ZoneDelegate = ZoneDelegate;
-  exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async, core, _internal, _js_helper, _isolate_helper, collection);