implement mixins in subtype checks, more codegen fixes

lib/runtime/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
@@ skipping 650 matching lines @@
         }).bind(this), onCancel);
         return controller.stream;
       }
     }
     dart.defineNamedConstructor(Stream, 'fromFuture');
     dart.defineNamedConstructor(Stream, 'fromIterable');
     dart.defineNamedConstructor(Stream, 'periodic');
     dart.defineNamedConstructor(Stream, 'eventTransformed');
     return Stream;
   });
-  let Stream = Stream$(dart.dynamic);
+  let Stream = Stream$();
   let _StreamImpl$ = dart.generic(function(T) {
     class _StreamImpl extends Stream$(T) {
       listen(onData, opts) {
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         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) {
         return new (_BufferingStreamSubscription$(T))(onData, onError, onDone, cancelOnError);
       }
       [_onListen](subscription) {}
     }
     return _StreamImpl;
   });
-  let _StreamImpl = _StreamImpl$(dart.dynamic);
+  let _StreamImpl = _StreamImpl$();
   let _ControllerStream$ = dart.generic(function(T) {
     class _ControllerStream extends _StreamImpl$(T) {
       _ControllerStream(controller$) {
         this[_controller] = controller$;
         super._StreamImpl();
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         return this[_controller]._subscribe(onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
         return dart.notNull(this[_controller].hashCode) ^ 892482866;
       }
       ['=='](other) {
         if (core.identical(this, other))
           return true;
         if (!dart.is(other, _ControllerStream))
           return false;
         let otherStream = dart.as(other, _ControllerStream);
         return core.identical(otherStream[_controller], this[_controller]);
       }
     }
     return _ControllerStream;
   });
-  let _ControllerStream = _ControllerStream$(dart.dynamic);
+  let _ControllerStream = _ControllerStream$();
   let _BroadcastStream$ = dart.generic(function(T) {
     class _BroadcastStream extends _ControllerStream$(T) {
       _BroadcastStream(controller) {
         super._ControllerStream(dart.as(controller, _StreamControllerLifecycle$(T)));
       }
       get isBroadcast() {
         return true;
       }
     }
     return _BroadcastStream;
   });
-  let _BroadcastStream = _BroadcastStream$(dart.dynamic);
+  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');
@@ skipping 346 matching lines @@
     _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$(dart.dynamic);
+  let _BufferingStreamSubscription = _BufferingStreamSubscription$();
   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$(dart.dynamic);
+  let _ControllerSubscription = _ControllerSubscription$();
   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]() {
@@ skipping 17 matching lines @@
       }
       [_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$(dart.dynamic);
+  let _BroadcastSubscription = _BroadcastSubscription$();
   let _STATE_INITIAL = Symbol('_STATE_INITIAL');
   let _addStreamState = Symbol('_addStreamState');
   let _doneFuture = Symbol('_doneFuture');
   let _isEmpty = Symbol('_isEmpty');
   let _hasOneListener = Symbol('_hasOneListener');
   let _isAddingStream = Symbol('_isAddingStream');
   let _STATE_ADDSTREAM = Symbol('_STATE_ADDSTREAM');
   let _mayAddEvent = Symbol('_mayAddEvent');
   let _ensureDoneFuture = Symbol('_ensureDoneFuture');
   let _addListener = Symbol('_addListener');
@@ skipping 200 matching lines @@
       }
     }
     _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$(dart.dynamic);
+  let _BroadcastStreamController = _BroadcastStreamController$();
   let _SyncBroadcastStreamController$ = dart.generic(function(T) {
     class _SyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _SyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         if (this[_isEmpty])
           return;
         if (this[_hasOneListener]) {
           this[_state] = _BroadcastStreamController[_STATE_FIRING];
@@ skipping 23 matching lines @@
           }).bind(this), "(_BufferingStreamSubscription<T>) → void"));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture]._asyncComplete(null);
         }
       }
     }
     return _SyncBroadcastStreamController;
   });
-  let _SyncBroadcastStreamController = _SyncBroadcastStreamController$(dart.dynamic);
+  let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
   let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
     class _AsyncBroadcastStreamController extends _BroadcastStreamController$(T) {
       _AsyncBroadcastStreamController(onListen, onCancel) {
         super._BroadcastStreamController(onListen, onCancel);
       }
       [_sendData](data) {
         for (let link = this[_next]; !dart.notNull(core.identical(link, this)); link = link[_next]) {
           let subscription = dart.as(link, _BroadcastSubscription$(T));
           subscription._addPending(new _DelayedData(data));
         }
@@ skipping 12 matching lines @@
           }
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture]._asyncComplete(null);
         }
       }
     }
     return _AsyncBroadcastStreamController;
   });
-  let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$(dart.dynamic);
+  let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$();
   let _addPendingEvent = Symbol('_addPendingEvent');
   let _AsBroadcastStreamController$ = dart.generic(function(T) {
     class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T) {
       _AsBroadcastStreamController(onListen, onCancel) {
         this[_pending] = null;
         super._SyncBroadcastStreamController(onListen, onCancel);
       }
       get [_hasPending]() {
         return dart.notNull(this[_pending] != null) && !dart.notNull(this[_pending].isEmpty);
       }
@@ skipping 41 matching lines @@
         if (this[_hasPending]) {
           this[_pending].clear();
           this[_pending] = null;
         }
         super._callOnCancel();
       }
     }
     _AsBroadcastStreamController[dart.implements] = () => [_EventDispatch$(T)];
     return _AsBroadcastStreamController;
   });
-  let _AsBroadcastStreamController = _AsBroadcastStreamController$(dart.dynamic);
+  let _AsBroadcastStreamController = _AsBroadcastStreamController$();
   let _pauseCount = Symbol('_pauseCount');
   let _resume = Symbol('_resume');
   let _DoneSubscription$ = dart.generic(function(T) {
     class _DoneSubscription extends core.Object {
       _DoneSubscription() {
         this[_pauseCount] = 0;
       }
       onData(handleData) {}
       onError(handleError) {}
       onDone(handleDone) {}
@@ skipping 19 matching lines @@
       }
       asFuture(value) {
         if (value === void 0)
           value = null;
         return new _Future();
       }
     }
     _DoneSubscription[dart.implements] = () => [StreamSubscription$(T)];
     return _DoneSubscription;
   });
-  let _DoneSubscription = _DoneSubscription$(dart.dynamic);
+  let _DoneSubscription = _DoneSubscription$();
   class DeferredLibrary extends core.Object {
     DeferredLibrary(libraryName, opts) {
       let uri = opts && 'uri' in opts ? opts.uri : null;
       this.libraryName = libraryName;
       this.uri = uri;
     }
     load() {
       throw 'DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.';
     }
   }
@@ skipping 164 matching lines @@
     dart.defineNamedConstructor(Future, 'value');
     dart.defineNamedConstructor(Future, 'error');
     dart.defineNamedConstructor(Future, 'delayed');
     dart.defineLazyProperties(Future, {
       get _nullFuture() {
         return new Future.value(null);
       }
     });
     return Future;
   });
-  let Future = Future$(dart.dynamic);
+  let Future = Future$();
   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)
         result = `TimeoutException after ${this.duration}`;
       if (this.message != null)
         result = `${result}: ${this.message}`;
       return result;
     }
   }
   TimeoutException[dart.implements] = () => [core.Exception];
   let Completer$ = dart.generic(function(T) {
     class Completer extends core.Object {
       Completer() {
         return new (_AsyncCompleter$(T))();
       }
       sync() {
         return new (_SyncCompleter$(T))();
       }
     }
     dart.defineNamedConstructor(Completer, 'sync');
     return Completer;
   });
-  let Completer = Completer$(dart.dynamic);
+  let Completer = Completer$();
   // Function _completeWithErrorCallback: (_Future<dynamic>, dynamic, dynamic) → void
   function _completeWithErrorCallback(result, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     result._completeError(error, dart.as(stackTrace, core.StackTrace));
   }
   // Function _nonNullError: (Object) → Object
   function _nonNullError(error) {
     return error != null ? error : new core.NullThrownError();
   }
+  let _FutureOnValue$ = dart.generic(function(T) {
+    class _FutureOnValue extends core.Function {}
+    return _FutureOnValue;
+  });
+  let _FutureOnValue = _FutureOnValue$();
+  class _FutureErrorTest extends core.Function {}
+  class _FutureAction extends core.Function {}
   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]))
           throw new core.StateError("Future already completed");
         let replacement = Zone.current.errorCallback(error, stackTrace);
         if (replacement != null) {
           error = _nonNullError(replacement.error);
           stackTrace = replacement.stackTrace;
         }
         this[_completeError](error, stackTrace);
       }
       get isCompleted() {
         return !dart.notNull(this.future[_mayComplete]);
       }
     }
     _Completer[dart.implements] = () => [Completer$(T)];
     return _Completer;
   });
-  let _Completer = _Completer$(dart.dynamic);
+  let _Completer = _Completer$();
   let _AsyncCompleter$ = dart.generic(function(T) {
     class _AsyncCompleter extends _Completer$(T) {
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
           throw new core.StateError("Future already completed");
         this.future._asyncComplete(value);
       }
       [_completeError](error, stackTrace) {
         this.future._asyncCompleteError(error, stackTrace);
       }
     }
     return _AsyncCompleter;
   });
-  let _AsyncCompleter = _AsyncCompleter$(dart.dynamic);
+  let _AsyncCompleter = _AsyncCompleter$();
   let _SyncCompleter$ = dart.generic(function(T) {
     class _SyncCompleter extends _Completer$(T) {
       complete(value) {
         if (value === void 0)
           value = null;
         if (!dart.notNull(this.future[_mayComplete]))
           throw new core.StateError("Future already completed");
         this.future._complete(value);
       }
       [_completeError](error, stackTrace) {
         this.future._completeError(error, stackTrace);
       }
     }
     return _SyncCompleter;
   });
-  let _SyncCompleter = _SyncCompleter$(dart.dynamic);
+  let _SyncCompleter = _SyncCompleter$();
   let _nextListener = Symbol('_nextListener');
   let _onValue = Symbol('_onValue');
   let _errorTest = Symbol('_errorTest');
   let _whenCompleteAction = Symbol('_whenCompleteAction');
   class _FutureListener extends core.Object {
     then(result, onValue, errorCallback) {
       this.result = result;
       this.callback = onValue;
       this.errorCallback = errorCallback;
       this.state = errorCallback == null ? _FutureListener.STATE_THEN : _FutureListener.STATE_THEN_ONERROR;
@@ skipping 505 matching lines @@
     _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$(dart.dynamic);
+  let _Future = _Future$();
+  class _AsyncCallback extends core.Function {}
   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 121 matching lines @@
     static [_scheduleImmediateWithTimer](callback) {
       Timer._createTimer(core.Duration.ZERO, callback);
     }
   }
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
       return _AsyncRun[_initializeScheduleImmediate]();
     }
   });
   let StreamSubscription$ = dart.generic(function(T) {
-    class StreamSubscription extends core.Object {
-    }
+    class StreamSubscription extends core.Object {}
     return StreamSubscription;
   });
-  let StreamSubscription = StreamSubscription$(dart.dynamic);
+  let StreamSubscription = StreamSubscription$();
   let EventSink$ = dart.generic(function(T) {
-    class EventSink extends core.Object {
-    }
+    class EventSink extends core.Object {}
     EventSink[dart.implements] = () => [core.Sink$(T)];
     return EventSink;
   });
-  let EventSink = EventSink$(dart.dynamic);
+  let EventSink = EventSink$();
   let _stream = Symbol('_stream');
   let StreamView$ = dart.generic(function(T) {
     class StreamView extends Stream$(T) {
       StreamView(stream$) {
         this[_stream] = stream$;
         super.Stream();
       }
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         return this[_stream].asBroadcastStream({onListen: onListen, onCancel: onCancel});
       }
       listen(onData, opts) {
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         return this[_stream].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
       }
     }
     return StreamView;
   });
-  let StreamView = StreamView$(dart.dynamic);
+  let StreamView = StreamView$();
   let StreamConsumer$ = dart.generic(function(S) {
-    class StreamConsumer extends core.Object {
-    }
+    class StreamConsumer extends core.Object {}
     return StreamConsumer;
   });
-  let StreamConsumer = StreamConsumer$(dart.dynamic);
+  let StreamConsumer = StreamConsumer$();
   let StreamSink$ = dart.generic(function(S) {
-    class StreamSink extends core.Object {
-    }
+    class StreamSink extends core.Object {}
     StreamSink[dart.implements] = () => [StreamConsumer$(S), EventSink$(S)];
     return StreamSink;
   });
-  let StreamSink = StreamSink$(dart.dynamic);
+  let StreamSink = StreamSink$();
   let StreamTransformer$ = dart.generic(function(S, T) {
     class StreamTransformer extends core.Object {
       StreamTransformer(transformer) {
         return new _StreamSubscriptionTransformer(transformer);
       }
       fromHandlers(opts) {
         return new _StreamHandlerTransformer(opts);
       }
     }
     dart.defineNamedConstructor(StreamTransformer, 'fromHandlers');
     return StreamTransformer;
   });
-  let StreamTransformer = StreamTransformer$(dart.dynamic, dart.dynamic);
+  let StreamTransformer = StreamTransformer$();
   let StreamIterator$ = dart.generic(function(T) {
     class StreamIterator extends core.Object {
       StreamIterator(stream) {
         return new (_StreamIteratorImpl$(T))(stream);
       }
     }
     return StreamIterator;
   });
-  let StreamIterator = StreamIterator$(dart.dynamic);
+  let StreamIterator = StreamIterator$();
   let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
     class _ControllerEventSinkWrapper extends core.Object {
       _ControllerEventSinkWrapper(sink$) {
         this[_sink] = sink$;
       }
       add(data) {
         this[_sink].add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_sink].addError(error, stackTrace);
       }
       close() {
         this[_sink].close();
       }
     }
     _ControllerEventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     return _ControllerEventSinkWrapper;
   });
-  let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$(dart.dynamic);
+  let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$();
   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));
         }
         return sync ? new (_SyncStreamController$(T))(onListen, onPause, onResume, onCancel) : new (_AsyncStreamController$(T))(onListen, onPause, onResume, onCancel);
       }
       broadcast(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         return sync ? new (_SyncBroadcastStreamController$(T))(onListen, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel);
       }
     }
     StreamController[dart.implements] = () => [StreamSink$(T)];
     dart.defineNamedConstructor(StreamController, 'broadcast');
     return StreamController;
   });
-  let StreamController = StreamController$(dart.dynamic);
+  let StreamController = StreamController$();
   let _StreamControllerLifecycle$ = dart.generic(function(T) {
     class _StreamControllerLifecycle extends core.Object {
       [_recordPause](subscription) {}
       [_recordResume](subscription) {}
       [_recordCancel](subscription) {
         return null;
       }
     }
     return _StreamControllerLifecycle;
   });
-  let _StreamControllerLifecycle = _StreamControllerLifecycle$(dart.dynamic);
+  let _StreamControllerLifecycle = _StreamControllerLifecycle$();
   let _varData = Symbol('_varData');
   let _STATE_SUBSCRIBED = Symbol('_STATE_SUBSCRIBED');
   let _isInitialState = Symbol('_isInitialState');
   let _STATE_SUBSCRIPTION_MASK = Symbol('_STATE_SUBSCRIPTION_MASK');
   let _subscription = Symbol('_subscription');
   let _pendingEvents = Symbol('_pendingEvents');
   let _ensurePendingEvents = Symbol('_ensurePendingEvents');
   let _badEventState = Symbol('_badEventState');
   let _nullFuture = Symbol('_nullFuture');
   let _closeUnchecked = Symbol('_closeUnchecked');
@@ skipping 216 matching lines @@
     }
     _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$(dart.dynamic);
+  let _StreamController = _StreamController$();
   let _SyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _SyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         this[_subscription]._add(data);
       }
       [_sendError](error, stackTrace) {
         this[_subscription]._addError(error, stackTrace);
       }
       [_sendDone]() {
         this[_subscription]._close();
       }
     }
     _SyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     return _SyncStreamControllerDispatch;
   });
-  let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$(dart.dynamic);
+  let _SyncStreamControllerDispatch = _SyncStreamControllerDispatch$();
   let _AsyncStreamControllerDispatch$ = dart.generic(function(T) {
     class _AsyncStreamControllerDispatch extends core.Object {
       [_sendData](data) {
         this[_subscription]._addPending(new _DelayedData(data));
       }
       [_sendError](error, stackTrace) {
         this[_subscription]._addPending(new _DelayedError(error, stackTrace));
       }
       [_sendDone]() {
         this[_subscription]._addPending(new _DelayedDone());
       }
     }
     _AsyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     return _AsyncStreamControllerDispatch;
   });
-  let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$(dart.dynamic);
+  let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$();
   let _AsyncStreamController$ = dart.generic(function(T) {
     class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
       _AsyncStreamController(onListen$, onPause$, onResume$, onCancel$) {
         this[_onListen] = onListen$;
         this[_onPause] = onPause$;
         this[_onResume] = onResume$;
         this[_onCancel] = onCancel$;
         super._StreamController();
       }
     }
     return _AsyncStreamController;
   });
-  let _AsyncStreamController = _AsyncStreamController$(dart.dynamic);
+  let _AsyncStreamController = _AsyncStreamController$();
   let _SyncStreamController$ = dart.generic(function(T) {
     class _SyncStreamController extends dart.mixin(_StreamController$(T), _SyncStreamControllerDispatch$(T)) {
       _SyncStreamController(onListen$, onPause$, onResume$, onCancel$) {
         this[_onListen] = onListen$;
         this[_onPause] = onPause$;
         this[_onResume] = onResume$;
         this[_onCancel] = onCancel$;
         super._StreamController();
       }
     }
     return _SyncStreamController;
   });
-  let _SyncStreamController = _SyncStreamController$(dart.dynamic);
+  let _SyncStreamController = _SyncStreamController$();
   class _NoCallbacks extends core.Object {
     get [_onListen]() {
       return null;
     }
     get [_onPause]() {
       return null;
     }
     get [_onResume]() {
       return null;
     }
     get [_onCancel]() {
       return null;
     }
   }
-  class _NoCallbackAsyncStreamController extends dart.mixin(_AsyncStreamControllerDispatch, _NoCallbacks) {
-  }
-  class _NoCallbackSyncStreamController extends dart.mixin(_SyncStreamControllerDispatch, _NoCallbacks) {
-  }
+  class _NoCallbackAsyncStreamController extends dart.mixin(_AsyncStreamControllerDispatch, _NoCallbacks) {}
+  class _NoCallbackSyncStreamController extends dart.mixin(_SyncStreamControllerDispatch, _NoCallbacks) {}
+  class _NotificationHandler extends core.Function {}
   // 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 23 matching lines @@
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         return this[_target].addStream(source, {cancelOnError: cancelOnError});
       }
       get done() {
         return this[_target].done;
       }
     }
     _StreamSinkWrapper[dart.implements] = () => [StreamSink$(T)];
     return _StreamSinkWrapper;
   });
-  let _StreamSinkWrapper = _StreamSinkWrapper$(dart.dynamic);
+  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], {onError: dart.as(cancelOnError ? _AddStreamState.makeErrorHandler(controller) : controller[_addError], core.Function), onDone: controller[_close], cancelOnError: cancelOnError});
       }
       static makeErrorHandler(controller) {
         return ((e, s) => {
           controller._addError(e, s);
           controller._close();
@@ skipping 14 matching lines @@
         return cancel.whenComplete((() => {
           this.addStreamFuture._asyncComplete(null);
         }).bind(this));
       }
       complete() {
         this.addStreamFuture._asyncComplete(null);
       }
     }
     return _AddStreamState;
   });
-  let _AddStreamState = _AddStreamState$(dart.dynamic);
+  let _AddStreamState = _AddStreamState$();
   let _StreamControllerAddStreamState$ = dart.generic(function(T) {
     class _StreamControllerAddStreamState extends _AddStreamState$(T) {
       _StreamControllerAddStreamState(controller, varData, source, cancelOnError) {
         this.varData = varData;
         super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cancelOnError);
         if (controller.isPaused) {
           this.addSubscription.pause();
         }
       }
     }
     return _StreamControllerAddStreamState;
   });
-  let _StreamControllerAddStreamState = _StreamControllerAddStreamState$(dart.dynamic);
+  let _StreamControllerAddStreamState = _StreamControllerAddStreamState$();
   let _EventSink$ = dart.generic(function(T) {
-    class _EventSink extends core.Object {
-    }
+    class _EventSink extends core.Object {}
     return _EventSink;
   });
-  let _EventSink = _EventSink$(dart.dynamic);
+  let _EventSink = _EventSink$();
   let _EventDispatch$ = dart.generic(function(T) {
-    class _EventDispatch extends core.Object {
-    }
+    class _EventDispatch extends core.Object {}
     return _EventDispatch;
   });
-  let _EventDispatch = _EventDispatch$(dart.dynamic);
+  let _EventDispatch = _EventDispatch$();
+  class _EventGenerator extends core.Function {}
   let _isUsed = Symbol('_isUsed');
   let _GeneratedStreamImpl$ = dart.generic(function(T) {
     class _GeneratedStreamImpl extends _StreamImpl$(T) {
       _GeneratedStreamImpl(pending$) {
         this[_pending] = pending$;
         this[_isUsed] = false;
         super._StreamImpl();
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         if (this[_isUsed])
           throw new core.StateError("Stream has already been listened to.");
         this[_isUsed] = true;
         return ((_$) => {
           _$._setPendingEvents(this[_pending]());
           return _$;
         }).bind(this)(new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError));
       }
     }
     return _GeneratedStreamImpl;
   });
-  let _GeneratedStreamImpl = _GeneratedStreamImpl$(dart.dynamic);
+  let _GeneratedStreamImpl = _GeneratedStreamImpl$();
   let _iterator = Symbol('_iterator');
   let _STATE_UNSCHEDULED = Symbol('_STATE_UNSCHEDULED');
   let _STATE_SCHEDULED = Symbol('_STATE_SCHEDULED');
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
     _PendingEvents() {
       this[_state] = _PendingEvents[_STATE_UNSCHEDULED];
     }
     get isScheduled() {
       return this[_state] == _PendingEvents[_STATE_SCHEDULED];
@@ skipping 58 matching lines @@
         }
       }
       clear() {
         if (this.isScheduled)
           this.cancelSchedule();
         this[_iterator] = null;
       }
     }
     return _IterablePendingEvents;
   });
-  let _IterablePendingEvents = _IterablePendingEvents$(dart.dynamic);
+  let _IterablePendingEvents = _IterablePendingEvents$();
+  let _DataHandler$ = dart.generic(function(T) {
+    class _DataHandler extends core.Function {}
+    return _DataHandler;
+  });
+  let _DataHandler = _DataHandler$();
+  class _DoneHandler extends core.Function {}
   // 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
   function _nullDoneHandler() {
   }
   class _DelayedEvent extends core.Object {
     _DelayedEvent() {
       this.next = null;
     }
   }
   let _DelayedData$ = dart.generic(function(T) {
     class _DelayedData extends _DelayedEvent {
       _DelayedData(value) {
         this.value = value;
         super._DelayedEvent();
       }
       perform(dispatch) {
         dispatch._sendData(this.value);
       }
     }
     return _DelayedData;
   });
-  let _DelayedData = _DelayedData$(dart.dynamic);
+  let _DelayedData = _DelayedData$();
   class _DelayedError extends _DelayedEvent {
     _DelayedError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
       super._DelayedEvent();
     }
     perform(dispatch) {
       dispatch._sendError(this.error, this.stackTrace);
     }
   }
@@ skipping 55 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;
     }
   }
+  class _broadcastCallback extends core.Function {}
   let _schedule = Symbol('_schedule');
   let _isSent = Symbol('_isSent');
   let _DONE_SENT = Symbol('_DONE_SENT');
   let _isScheduled = Symbol('_isScheduled');
   let _SCHEDULED = Symbol('_SCHEDULED');
   let _PAUSED = Symbol('_PAUSED');
   let _DoneStreamSubscription$ = dart.generic(function(T) {
     class _DoneStreamSubscription extends core.Object {
       _DoneStreamSubscription(onDone$) {
         this[_onDone] = onDone$;
@@ skipping 56 matching lines @@
         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$(dart.dynamic);
+  let _DoneStreamSubscription = _DoneStreamSubscription$();
   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 58 matching lines @@
         this[_subscription].resume();
       }
       get [_isSubscriptionPaused]() {
         if (this[_subscription] == null)
           return false;
         return this[_subscription].isPaused;
       }
     }
     return _AsBroadcastStream;
   });
-  let _AsBroadcastStream = _AsBroadcastStream$(dart.dynamic);
+  let _AsBroadcastStream = _AsBroadcastStream$();
   let _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
     class _BroadcastSubscriptionWrapper extends core.Object {
       _BroadcastSubscriptionWrapper(stream$) {
         this[_stream] = stream$;
       }
       onData(handleData) {
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
       onError(handleError) {
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
@@ skipping 18 matching lines @@
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
     }
     _BroadcastSubscriptionWrapper[dart.implements] = () => [StreamSubscription$(T)];
     return _BroadcastSubscriptionWrapper;
   });
-  let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$(dart.dynamic);
+  let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$();
   let _current = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
   let _STATE_FOUND = Symbol('_STATE_FOUND');
   let _STATE_DONE = Symbol('_STATE_DONE');
   let _STATE_MOVING = Symbol('_STATE_MOVING');
   let _STATE_EXTRA_DATA = Symbol('_STATE_EXTRA_DATA');
   let _STATE_EXTRA_ERROR = Symbol('_STATE_EXTRA_ERROR');
   let _clear = Symbol('_clear');
   let _STATE_EXTRA_DONE = Symbol('_STATE_EXTRA_DONE');
   let _StreamIteratorImpl$ = dart.generic(function(T) {
@@ skipping 104 matching lines @@
     }
     _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$(dart.dynamic);
+  let _StreamIteratorImpl = _StreamIteratorImpl$();
   // Function _runUserCode: (() → dynamic, (dynamic) → dynamic, (dynamic, StackTrace) → dynamic) → dynamic
   function _runUserCode(userCode, onSuccess, onError) {
     try {
       dart.dinvokef(onSuccess, userCode());
     } catch (e) {
       let s = dart.stackTrace(e);
       let replacement = Zone.current.errorCallback(e, s);
       if (replacement == null) {
         dart.dinvokef(onError, e, s);
       } else {
@@ skipping 63 matching lines @@
       }
       [_handleError](error, stackTrace, sink) {
         sink._addError(error, stackTrace);
       }
       [_handleDone](sink) {
         sink._close();
       }
     }
     return _ForwardingStream;
   });
-  let _ForwardingStream = _ForwardingStream$(dart.dynamic, dart.dynamic);
+  let _ForwardingStream = _ForwardingStream$();
   let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
     class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
       _ForwardingStreamSubscription(stream$, onData, onError, onDone, cancelOnError) {
         this[_stream] = stream$;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         this[_subscription] = this[_stream][_source].listen(this[_handleData], {onError: this[_handleError], onDone: this[_handleDone]});
       }
       [_add](data) {
         if (this[_isClosed])
@@ skipping 28 matching lines @@
       }
       [_handleError](error, stackTrace) {
         this[_stream]._handleError(error, stackTrace, this);
       }
       [_handleDone]() {
         this[_stream]._handleDone(this);
       }
     }
     return _ForwardingStreamSubscription;
   });
-  let _ForwardingStreamSubscription = _ForwardingStreamSubscription$(dart.dynamic, dart.dynamic);
+  let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
+  let _Predicate$ = dart.generic(function(T) {
+    class _Predicate extends core.Function {}
+    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;
     }
     sink._addError(error, dart.as(stackTrace, core.StackTrace));
   }
   let _test = Symbol('_test');
@@ skipping 13 matching lines @@
           return;
         }
 
         if (satisfies) {
           sink._add(inputEvent);
         }
       }
     }
     return _WhereStream;
   });
-  let _WhereStream = _WhereStream$(dart.dynamic);
+  let _WhereStream = _WhereStream$();
+  let _Transformation$ = dart.generic(function(S, T) {
+    class _Transformation extends core.Function {}
+    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);
       }
       [_handleData](inputEvent, sink) {
         let outputEvent = null;
         try {
           outputEvent = dart.as(dart.dinvokef(this[_transform], inputEvent), T);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         sink._add(outputEvent);
       }
     }
     return _MapStream;
   });
-  let _MapStream = _MapStream$(dart.dynamic, dart.dynamic);
+  let _MapStream = _MapStream$();
   let _expand = Symbol('_expand');
   let _ExpandStream$ = dart.generic(function(S, T) {
     class _ExpandStream extends _ForwardingStream$(S, T) {
       _ExpandStream(source, expand) {
         this[_expand] = expand;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         try {
           for (let value of this[_expand](inputEvent)) {
             sink._add(value);
           }
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
         }
 
       }
     }
     return _ExpandStream;
   });
-  let _ExpandStream = _ExpandStream$(dart.dynamic, dart.dynamic);
+  let _ExpandStream = _ExpandStream$();
+  class _ErrorTest extends core.Function {}
   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) {
         let matches = true;
         if (this[_test] != null) {
@@ skipping 19 matching lines @@
             return;
           }
 
         } else {
           sink._addError(error, stackTrace);
         }
       }
     }
     return _HandleErrorStream;
   });
-  let _HandleErrorStream = _HandleErrorStream$(dart.dynamic);
+  let _HandleErrorStream = _HandleErrorStream$();
   let _remaining = Symbol('_remaining');
   let _TakeStream$ = dart.generic(function(T) {
     class _TakeStream extends _ForwardingStream$(T, T) {
       _TakeStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number'))
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
         if (dart.notNull(this[_remaining]) > 0) {
           sink._add(inputEvent);
           this[_remaining] = 1;
           if (this[_remaining] == 0) {
             sink._close();
           }
         }
       }
     }
     return _TakeStream;
   });
-  let _TakeStream = _TakeStream$(dart.dynamic);
+  let _TakeStream = _TakeStream$();
   let _TakeWhileStream$ = dart.generic(function(T) {
     class _TakeWhileStream extends _ForwardingStream$(T, T) {
       _TakeWhileStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         let satisfies = null;
         try {
           satisfies = this[_test](inputEvent);
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           sink._close();
           return;
         }
 
         if (satisfies) {
           sink._add(inputEvent);
         } else {
           sink._close();
         }
       }
     }
     return _TakeWhileStream;
   });
-  let _TakeWhileStream = _TakeWhileStream$(dart.dynamic);
+  let _TakeWhileStream = _TakeWhileStream$();
   let _SkipStream$ = dart.generic(function(T) {
     class _SkipStream extends _ForwardingStream$(T, T) {
       _SkipStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (dart.notNull(!(typeof count == 'number')) || dart.notNull(count) < 0)
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
         if (dart.notNull(this[_remaining]) > 0) {
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           return;
         }
         sink._add(inputEvent);
       }
     }
     return _SkipStream;
   });
-  let _SkipStream = _SkipStream$(dart.dynamic);
+  let _SkipStream = _SkipStream$();
   let _hasFailed = Symbol('_hasFailed');
   let _SkipWhileStream$ = dart.generic(function(T) {
     class _SkipWhileStream extends _ForwardingStream$(T, T) {
       _SkipWhileStream(source, test) {
         this[_test] = test;
         this[_hasFailed] = false;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         if (this[_hasFailed]) {
@@ skipping 11 matching lines @@
         }
 
         if (!dart.notNull(satisfies)) {
           this[_hasFailed] = true;
           sink._add(inputEvent);
         }
       }
     }
     return _SkipWhileStream;
   });
-  let _SkipWhileStream = _SkipWhileStream$(dart.dynamic);
+  let _SkipWhileStream = _SkipWhileStream$();
+  let _Equality$ = dart.generic(function(T) {
+    class _Equality extends core.Function {}
+    return _Equality;
+  });
+  let _Equality = _Equality$();
   let _SENTINEL = Symbol('_SENTINEL');
   let _equals = Symbol('_equals');
   let _DistinctStream$ = dart.generic(function(T) {
     class _DistinctStream extends _ForwardingStream$(T, T) {
       _DistinctStream(source, equals) {
         this[_previous] = _DistinctStream[_SENTINEL];
         this[_equals] = equals;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
@@ skipping 22 matching lines @@
       }
     }
     dart.defineLazyProperties(_DistinctStream, {
       get _SENTINEL() {
         return new core.Object();
       },
       set _SENTINEL(_) {}
     });
     return _DistinctStream;
   });
-  let _DistinctStream = _DistinctStream$(dart.dynamic);
+  let _DistinctStream = _DistinctStream$();
   let _EventSinkWrapper$ = dart.generic(function(T) {
     class _EventSinkWrapper extends core.Object {
       _EventSinkWrapper(sink$) {
         this[_sink] = sink$;
       }
       add(data) {
         this[_sink]._add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_sink]._addError(error, stackTrace);
       }
       close() {
         this[_sink]._close();
       }
     }
     _EventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     return _EventSinkWrapper;
   });
-  let _EventSinkWrapper = _EventSinkWrapper$(dart.dynamic);
+  let _EventSinkWrapper = _EventSinkWrapper$();
   let _transformerSink = Symbol('_transformerSink');
   let _isSubscribed = Symbol('_isSubscribed');
   let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
     class _SinkTransformerStreamSubscription extends _BufferingStreamSubscription$(T) {
       _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone, cancelOnError) {
         this[_transformerSink] = null;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         let eventSink = new (_EventSinkWrapper$(T))(this);
         this[_transformerSink] = mapper(eventSink);
@@ skipping 66 matching lines @@
           this[_transformerSink].close();
         } catch (e) {
           let s = dart.stackTrace(e);
           this[_addError](e, s);
         }
 
       }
     }
     return _SinkTransformerStreamSubscription;
   });
-  let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$(dart.dynamic, dart.dynamic);
+  let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
+  let _SinkMapper$ = dart.generic(function(S, T) {
+    class _SinkMapper extends core.Function {}
+    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) {
         return new (_BoundSinkStream$(S, T))(stream, this[_sinkMapper]);
       }
     }
     _StreamSinkTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     return _StreamSinkTransformer;
   });
-  let _StreamSinkTransformer = _StreamSinkTransformer$(dart.dynamic, dart.dynamic);
+  let _StreamSinkTransformer = _StreamSinkTransformer$();
   let _BoundSinkStream$ = dart.generic(function(S, T) {
     class _BoundSinkStream extends Stream$(T) {
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
       _BoundSinkStream(stream$, sinkMapper) {
         this[_stream] = stream$;
         this[_sinkMapper] = sinkMapper;
         super.Stream();
       }
       listen(onData, opts) {
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let subscription = new _SinkTransformerStreamSubscription(this[_stream], dart.closureWrap(this[_sinkMapper], "(EventSink<dynamic>) → EventSink"), onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     return _BoundSinkStream;
   });
-  let _BoundSinkStream = _BoundSinkStream$(dart.dynamic, dart.dynamic);
+  let _BoundSinkStream = _BoundSinkStream$();
+  let _TransformDataHandler$ = dart.generic(function(S, T) {
+    class _TransformDataHandler extends core.Function {}
+    return _TransformDataHandler;
+  });
+  let _TransformDataHandler = _TransformDataHandler$();
+  let _TransformErrorHandler$ = dart.generic(function(T) {
+    class _TransformErrorHandler extends core.Function {}
+    return _TransformErrorHandler;
+  });
+  let _TransformErrorHandler = _TransformErrorHandler$();
+  let _TransformDoneHandler$ = dart.generic(function(T) {
+    class _TransformDoneHandler extends core.Function {}
+    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$;
       }
       add(data) {
         return this[_handleData](data, this[_sink]);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         return this[_handleError](error, stackTrace, this[_sink]);
       }
       close() {
         return this[_handleDone](this[_sink]);
       }
     }
     _HandlerEventSink[dart.implements] = () => [EventSink$(S)];
     return _HandlerEventSink;
   });
-  let _HandlerEventSink = _HandlerEventSink$(dart.dynamic, dart.dynamic);
+  let _HandlerEventSink = _HandlerEventSink$();
   let _defaultHandleData = Symbol('_defaultHandleData');
   let _defaultHandleError = Symbol('_defaultHandleError');
   let _defaultHandleDone = Symbol('_defaultHandleDone');
   let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
       _StreamHandlerTransformer(opts) {
         let handleData = opts && 'handleData' in opts ? opts.handleData : null;
         let handleError = opts && 'handleError' in opts ? opts.handleError : null;
         let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
         super._StreamSinkTransformer(dart.closureWrap((outputSink) => {
@@ skipping 14 matching lines @@
       }
       static [_defaultHandleError](error, stackTrace, sink) {
         sink.addError(error);
       }
       static [_defaultHandleDone](sink) {
         sink.close();
       }
     }
     return _StreamHandlerTransformer;
   });
-  let _StreamHandlerTransformer = _StreamHandlerTransformer$(dart.dynamic, dart.dynamic);
+  let _StreamHandlerTransformer = _StreamHandlerTransformer$();
+  let _SubscriptionTransformer$ = dart.generic(function(S, T) {
+    class _SubscriptionTransformer extends core.Function {}
+    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) {
         return new (_BoundSubscriptionStream$(S, T))(stream, this[_transformer]);
       }
     }
     _StreamSubscriptionTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     return _StreamSubscriptionTransformer;
   });
-  let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$(dart.dynamic, dart.dynamic);
+  let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$();
   let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
     class _BoundSubscriptionStream extends Stream$(T) {
       _BoundSubscriptionStream(stream$, transformer$) {
         this[_stream] = stream$;
         this[_transformer] = transformer$;
         super.Stream();
       }
       listen(onData, opts) {
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let result = this[_transformer](this[_stream], cancelOnError);
         result.onData(onData);
         result.onError(onError);
         result.onDone(onDone);
         return result;
       }
     }
     return _BoundSubscriptionStream;
   });
-  let _BoundSubscriptionStream = _BoundSubscriptionStream$(dart.dynamic, dart.dynamic);
+  let _BoundSubscriptionStream = _BoundSubscriptionStream$();
   let _createTimer = Symbol('_createTimer');
   let _createPeriodicTimer = Symbol('_createPeriodicTimer');
   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}));
     }
     periodic(duration, callback) {
@@ skipping 12 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');
+  class ZoneCallback extends core.Function {}
+  class ZoneUnaryCallback extends core.Function {}
+  class ZoneBinaryCallback extends core.Function {}
+  class HandleUncaughtErrorHandler extends core.Function {}
+  class RunHandler extends core.Function {}
+  class RunUnaryHandler extends core.Function {}
+  class RunBinaryHandler extends core.Function {}
+  class RegisterCallbackHandler extends core.Function {}
+  class RegisterUnaryCallbackHandler extends core.Function {}
+  class RegisterBinaryCallbackHandler extends core.Function {}
+  class ErrorCallbackHandler extends core.Function {}
+  class ScheduleMicrotaskHandler extends core.Function {}
+  class CreateTimerHandler extends core.Function {}
+  class CreatePeriodicTimerHandler extends core.Function {}
+  class PrintHandler extends core.Function {}
+  class ForkHandler extends core.Function {}
   class _ZoneFunction extends core.Object {
     _ZoneFunction(zone, func) {
       this.zone = zone;
       this.function = func;
     }
   }
   class ZoneSpecification extends core.Object {
     ZoneSpecification(opts) {
       return new _ZoneSpecification(opts);
     }
@@ skipping 39 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 ZoneDelegate extends core.Object {}
   let _$ = Symbol('_');
   let _enter = Symbol('_enter');
   let _leave = Symbol('_leave');
   class Zone extends core.Object {
     [_$]() {
     }
     static get current() {
       return Zone[_current];
     }
     static [_enter](zone) {
@@ skipping 668 matching lines @@
       return zone.run(body);
     }
   }
   dart.copyProperties(exports, {
     get _hasDocument() {
       return typeof document == 'object';
     }
   });
   // Exports:
   exports.AsyncError = AsyncError;
+  exports.Stream$ = Stream$;
   exports.Stream = Stream;
-  exports.Stream$ = Stream$;
   exports.DeferredLibrary = DeferredLibrary;
   exports.DeferredLoadException = DeferredLoadException;
+  exports.Future$ = Future$;
   exports.Future = Future;
-  exports.Future$ = Future$;
   exports.TimeoutException = TimeoutException;
+  exports.Completer$ = Completer$;
   exports.Completer = Completer;
-  exports.Completer$ = Completer$;
   exports.scheduleMicrotask = scheduleMicrotask;
+  exports.StreamSubscription$ = StreamSubscription$;
   exports.StreamSubscription = StreamSubscription;
-  exports.StreamSubscription$ = StreamSubscription$;
+  exports.EventSink$ = EventSink$;
   exports.EventSink = EventSink;
-  exports.EventSink$ = EventSink$;
+  exports.StreamView$ = StreamView$;
   exports.StreamView = StreamView;
-  exports.StreamView$ = StreamView$;
+  exports.StreamConsumer$ = StreamConsumer$;
   exports.StreamConsumer = StreamConsumer;
-  exports.StreamConsumer$ = StreamConsumer$;
+  exports.StreamSink$ = StreamSink$;
   exports.StreamSink = StreamSink;
-  exports.StreamSink$ = StreamSink$;
+  exports.StreamTransformer$ = StreamTransformer$;
   exports.StreamTransformer = StreamTransformer;
-  exports.StreamTransformer$ = StreamTransformer$;
+  exports.StreamIterator$ = StreamIterator$;
   exports.StreamIterator = StreamIterator;
-  exports.StreamIterator$ = StreamIterator$;
+  exports.StreamController$ = StreamController$;
   exports.StreamController = StreamController;
-  exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
+  exports.ZoneCallback = ZoneCallback;
+  exports.ZoneUnaryCallback = ZoneUnaryCallback;
+  exports.ZoneBinaryCallback = ZoneBinaryCallback;
+  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.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));