sort classes in dependency order, or load lazily if needed, fixes #78

test/codegen/expect/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
   }
   // Function _registerErrorHandler: (Function, Zone) → Function
   function _registerErrorHandler(errorHandler, zone) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return zone.registerBinaryCallback(errorHandler);
     } else {
       return zone.registerUnaryCallback(dart.as(errorHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")));
     }
   }
   let _getBestStackTrace = Symbol('_getBestStackTrace');
+  class AsyncError extends core.Object {
+    AsyncError(error, stackTrace) {
+      this.error = error;
+      this.stackTrace = stackTrace;
+    }
+    toString() {
+      return dart.as(dart.dinvoke(this.error, 'toString'), core.String);
+    }
+  }
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
       super.AsyncError(error, _getBestStackTrace(error, stackTrace));
     }
     static [_getBestStackTrace](error, stackTrace) {
       if (stackTrace !== null)
         return stackTrace;
       if (dart.is(error, core.Error)) {
         return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
       }
       return null;
     }
     toString() {
       let result = `Uncaught Error: ${this.error}`;
       if (this.stackTrace !== null) {
         result = `\nStack Trace:\n${this.stackTrace}`;
       }
       return result;
     }
   }
+  let _controller = Symbol('_controller');
+  let _createSubscription = Symbol('_createSubscription');
+  let _onListen = Symbol('_onListen');
+  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() {
+      }
+      Stream$fromFuture(future) {
+        let controller = dart.as(new StreamController({sync: true}), _StreamController$(T));
+        future.then(((value) => {
+          controller._add(dart.as(value, T));
+          controller._closeUnchecked();
+        }).bind(this), {onError: ((error, stackTrace) => {
+            controller._addError(error, dart.as(stackTrace, core.StackTrace));
+            controller._closeUnchecked();
+          }).bind(this)});
+        return controller.stream;
+      }
+      Stream$fromIterable(data) {
+        return new _GeneratedStreamImpl(() => new _IterablePendingEvents(data));
+      }
+      Stream$periodic(period, computation) {
+        if (computation === void 0)
+          computation = null;
+        if (computation === null)
+          computation = (i) => null;
+        let timer = null;
+        let computationCount = 0;
+        let controller = null;
+        let watch = new core.Stopwatch();
+        // Function sendEvent: () → void
+        function sendEvent() {
+          watch.reset();
+          let data = computation((($tmp) => computationCount = dart.notNull($tmp) + 1, $tmp)(computationCount));
+          controller.add(data);
+        }
+        // Function startPeriodicTimer: () → void
+        function startPeriodicTimer() {
+          dart.assert(timer === null);
+          timer = new Timer.periodic(period, (timer) => {
+            sendEvent();
+          });
+        }
+        controller = new StreamController({sync: true, onListen: (() => {
+            watch.start();
+            startPeriodicTimer();
+          }).bind(this), onPause: (() => {
+            timer.cancel();
+            timer = null;
+            watch.stop();
+          }).bind(this), onResume: (() => {
+            dart.assert(timer === null);
+            let elapsed = watch.elapsed;
+            watch.start();
+            timer = new Timer(period['-'](elapsed), () => {
+              timer = null;
+              startPeriodicTimer();
+              sendEvent();
+            });
+          }).bind(this), onCancel: (() => {
+            if (timer !== null)
+              timer.cancel();
+            timer = null;
+          }).bind(this)});
+        return controller.stream;
+      }
+      Stream$eventTransformed(source, mapSink) {
+        return dart.as(new _BoundSinkStream(source, dart.as(mapSink, _SinkMapper)), Stream$(T));
+      }
+      get isBroadcast() {
+        return false;
+      }
+      asBroadcastStream(opt$) {
+        let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
+        let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
+        return new _AsBroadcastStream(this, dart.as(onListen, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")), dart.as(onCancel, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")));
+      }
+      where(test) {
+        return new _WhereStream(this, test);
+      }
+      map(convert) {
+        return new _MapStream(this, convert);
+      }
+      asyncMap(convert) {
+        let controller = null;
+        let subscription = null;
+        // Function onListen: () → void
+        function onListen() {
+          let add = controller.add;
+          dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
+          let eventSink = controller;
+          let addError = eventSink[_addError];
+          subscription = this.listen(((event) => {
+            let newValue = null;
+            try {
+              newValue = convert(event);
+            } catch (e) {
+              let s = dart.stackTrace(e);
+              controller.addError(e, s);
+              return;
+            }
+
+            if (dart.is(newValue, Future)) {
+              subscription.pause();
+              dart.dinvoke(dart.dinvoke(newValue, 'then', add, {onError: addError}), 'whenComplete', subscription.resume);
+            } else {
+              controller.add(newValue);
+            }
+          }).bind(this), {onError: dart.as(addError, core.Function), onDone: controller.close});
+        }
+        if (this.isBroadcast) {
+          controller = new StreamController.broadcast({onListen: onListen, onCancel: (() => {
+              subscription.cancel();
+            }).bind(this), sync: true});
+        } else {
+          controller = new StreamController({onListen: onListen, onPause: (() => {
+              subscription.pause();
+            }).bind(this), onResume: (() => {
+              subscription.resume();
+            }).bind(this), onCancel: (() => {
+              subscription.cancel();
+            }).bind(this), sync: true});
+        }
+        return controller.stream;
+      }
+      asyncExpand(convert) {
+        let controller = null;
+        let subscription = null;
+        // Function onListen: () → void
+        function onListen() {
+          dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
+          let eventSink = controller;
+          subscription = this.listen(((event) => {
+            let newStream = null;
+            try {
+              newStream = convert(event);
+            } catch (e) {
+              let s = dart.stackTrace(e);
+              controller.addError(e, s);
+              return;
+            }
+
+            if (newStream !== null) {
+              subscription.pause();
+              controller.addStream(newStream).whenComplete(subscription.resume);
+            }
+          }).bind(this), {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close});
+        }
+        if (this.isBroadcast) {
+          controller = new StreamController.broadcast({onListen: onListen, onCancel: (() => {
+              subscription.cancel();
+            }).bind(this), sync: true});
+        } else {
+          controller = new StreamController({onListen: onListen, onPause: (() => {
+              subscription.pause();
+            }).bind(this), onResume: (() => {
+              subscription.resume();
+            }).bind(this), onCancel: (() => {
+              subscription.cancel();
+            }).bind(this), sync: true});
+        }
+        return controller.stream;
+      }
+      handleError(onError, opt$) {
+        let test = opt$.test === void 0 ? null : opt$.test;
+        return new _HandleErrorStream(this, onError, test);
+      }
+      expand(convert) {
+        return new _ExpandStream(this, convert);
+      }
+      pipe(streamConsumer) {
+        return streamConsumer.addStream(this).then(((_) => streamConsumer.close()).bind(this));
+      }
+      transform(streamTransformer) {
+        return streamTransformer.bind(this);
+      }
+      reduce(combine) {
+        let result = new _Future();
+        let seenFirst = false;
+        let value = null;
+        let subscription = null;
+        subscription = this.listen((element) => {
+          if (seenFirst) {
+            _runUserCode(() => combine(value, element), dart.as((newValue) => {
+              value = newValue;
+            }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+          } else {
+            value = element;
+            seenFirst = true;
+          }
+        }, {onError: result[_completeError], onDone: (() => {
+            if (!dart.notNull(seenFirst)) {
+              try {
+                throw _internal.IterableElementError.noElement();
+              } catch (e) {
+                let s = dart.stackTrace(e);
+                _completeWithErrorCallback(result, e, s);
+              }
+
+            } else {
+              result._complete(value);
+            }
+          }).bind(this), cancelOnError: true});
+        return result;
+      }
+      fold(initialValue, combine) {
+        let result = new _Future();
+        let value = initialValue;
+        let subscription = null;
+        subscription = this.listen((element) => {
+          _runUserCode(() => combine(value, element), (newValue) => {
+            value = newValue;
+          }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+        }, {onError: ((e, st) => {
+            result._completeError(e, dart.as(st, core.StackTrace));
+          }).bind(this), onDone: (() => {
+            result._complete(value);
+          }).bind(this), cancelOnError: true});
+        return result;
+      }
+      join(separator) {
+        if (separator === void 0)
+          separator = "";
+        let result = new _Future();
+        let buffer = new core.StringBuffer();
+        let subscription = null;
+        let first = true;
+        subscription = this.listen(((element) => {
+          if (!dart.notNull(first)) {
+            buffer.write(separator);
+          }
+          first = false;
+          try {
+            buffer.write(element);
+          } catch (e) {
+            let s = dart.stackTrace(e);
+            _cancelAndErrorWithReplacement(subscription, result, e, s);
+          }
+
+        }).bind(this), {onError: ((e) => {
+            result._completeError(e);
+          }).bind(this), onDone: (() => {
+            result._complete(buffer.toString());
+          }).bind(this), cancelOnError: true});
+        return result;
+      }
+      contains(needle) {
+        let future = new _Future();
+        let subscription = null;
+        subscription = this.listen((element) => {
+          _runUserCode(() => dart.equals(element, needle), dart.as((isMatch) => {
+            if (isMatch) {
+              _cancelAndValue(subscription, future, true);
+            }
+          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+        }, {onError: future[_completeError], onDone: (() => {
+            future._complete(false);
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      forEach(action) {
+        let future = new _Future();
+        let subscription = null;
+        subscription = this.listen((element) => {
+          _runUserCode(() => action(element), (_) => {
+          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+        }, {onError: future[_completeError], onDone: (() => {
+            future._complete(null);
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      every(test) {
+        let future = new _Future();
+        let subscription = null;
+        subscription = this.listen((element) => {
+          _runUserCode(() => test(element), dart.as((isMatch) => {
+            if (!dart.notNull(isMatch)) {
+              _cancelAndValue(subscription, future, false);
+            }
+          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+        }, {onError: future[_completeError], onDone: (() => {
+            future._complete(true);
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      any(test) {
+        let future = new _Future();
+        let subscription = null;
+        subscription = this.listen((element) => {
+          _runUserCode(() => test(element), dart.as((isMatch) => {
+            if (isMatch) {
+              _cancelAndValue(subscription, future, true);
+            }
+          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+        }, {onError: future[_completeError], onDone: (() => {
+            future._complete(false);
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      get length() {
+        let future = new _Future();
+        let count = 0;
+        this.listen((_) => {
+          count = dart.notNull(count) + 1;
+        }, {onError: future[_completeError], onDone: (() => {
+            future._complete(count);
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      get isEmpty() {
+        let future = new _Future();
+        let subscription = null;
+        subscription = this.listen((_) => {
+          _cancelAndValue(subscription, future, false);
+        }, {onError: future[_completeError], onDone: (() => {
+            future._complete(true);
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      toList() {
+        let result = new List.from([]);
+        let future = new _Future();
+        this.listen(((data) => {
+          result.add(data);
+        }).bind(this), {onError: future[_completeError], onDone: (() => {
+            future._complete(result);
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      toSet() {
+        let result = new core.Set();
+        let future = new _Future();
+        this.listen(((data) => {
+          result.add(data);
+        }).bind(this), {onError: future[_completeError], onDone: (() => {
+            future._complete(result);
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      drain(futureValue) {
+        if (futureValue === void 0)
+          futureValue = null;
+        return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
+      }
+      take(count) {
+        return dart.as(new _TakeStream(this, count), Stream$(T));
+      }
+      takeWhile(test) {
+        return dart.as(new _TakeWhileStream(this, dart.as(test, dart.throw_("Unimplemented type (dynamic) → bool"))), Stream$(T));
+      }
+      skip(count) {
+        return dart.as(new _SkipStream(this, count), Stream$(T));
+      }
+      skipWhile(test) {
+        return dart.as(new _SkipWhileStream(this, dart.as(test, dart.throw_("Unimplemented type (dynamic) → bool"))), Stream$(T));
+      }
+      distinct(equals) {
+        if (equals === void 0)
+          equals = null;
+        return dart.as(new _DistinctStream(this, dart.as(equals, dart.throw_("Unimplemented type (dynamic, dynamic) → bool"))), Stream$(T));
+      }
+      get first() {
+        let future = new _Future();
+        let subscription = null;
+        subscription = this.listen((value) => {
+          _cancelAndValue(subscription, future, value);
+        }, {
+          onError: future[_completeError],
+          onDone: () => {
+            try {
+              throw _internal.IterableElementError.noElement();
+            } catch (e) {
+              let s = dart.stackTrace(e);
+              _completeWithErrorCallback(future, e, s);
+            }
+
+          },
+          cancelOnError: true
+        });
+        return future;
+      }
+      get last() {
+        let future = new _Future();
+        let result = null;
+        let foundResult = false;
+        let subscription = null;
+        subscription = this.listen((value) => {
+          foundResult = true;
+          result = value;
+        }, {onError: future[_completeError], onDone: (() => {
+            if (foundResult) {
+              future._complete(result);
+              return;
+            }
+            try {
+              throw _internal.IterableElementError.noElement();
+            } catch (e) {
+              let s = dart.stackTrace(e);
+              _completeWithErrorCallback(future, e, s);
+            }
+
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      get single() {
+        let future = new _Future();
+        let result = null;
+        let foundResult = false;
+        let subscription = null;
+        subscription = this.listen((value) => {
+          if (foundResult) {
+            try {
+              throw _internal.IterableElementError.tooMany();
+            } catch (e) {
+              let s = dart.stackTrace(e);
+              _cancelAndErrorWithReplacement(subscription, future, e, s);
+            }
+
+            return;
+          }
+          foundResult = true;
+          result = value;
+        }, {onError: future[_completeError], onDone: (() => {
+            if (foundResult) {
+              future._complete(result);
+              return;
+            }
+            try {
+              throw _internal.IterableElementError.noElement();
+            } catch (e) {
+              let s = dart.stackTrace(e);
+              _completeWithErrorCallback(future, e, s);
+            }
+
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      firstWhere(test, opt$) {
+        let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultValue;
+        let future = new _Future();
+        let subscription = null;
+        subscription = this.listen((value) => {
+          _runUserCode(() => test(value), dart.as((isMatch) => {
+            if (isMatch) {
+              _cancelAndValue(subscription, future, value);
+            }
+          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+        }, {onError: future[_completeError], onDone: (() => {
+            if (defaultValue !== null) {
+              _runUserCode(defaultValue, future[_complete], future[_completeError]);
+              return;
+            }
+            try {
+              throw _internal.IterableElementError.noElement();
+            } catch (e) {
+              let s = dart.stackTrace(e);
+              _completeWithErrorCallback(future, e, s);
+            }
+
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      lastWhere(test, opt$) {
+        let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultValue;
+        let future = new _Future();
+        let result = null;
+        let foundResult = false;
+        let subscription = null;
+        subscription = this.listen((value) => {
+          _runUserCode(() => true === test(value), dart.as((isMatch) => {
+            if (isMatch) {
+              foundResult = true;
+              result = value;
+            }
+          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+        }, {onError: future[_completeError], onDone: (() => {
+            if (foundResult) {
+              future._complete(result);
+              return;
+            }
+            if (defaultValue !== null) {
+              _runUserCode(defaultValue, future[_complete], future[_completeError]);
+              return;
+            }
+            try {
+              throw _internal.IterableElementError.noElement();
+            } catch (e) {
+              let s = dart.stackTrace(e);
+              _completeWithErrorCallback(future, e, s);
+            }
+
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      singleWhere(test) {
+        let future = new _Future();
+        let result = null;
+        let foundResult = false;
+        let subscription = null;
+        subscription = this.listen((value) => {
+          _runUserCode(() => true === test(value), dart.as((isMatch) => {
+            if (isMatch) {
+              if (foundResult) {
+                try {
+                  throw _internal.IterableElementError.tooMany();
+                } catch (e) {
+                  let s = dart.stackTrace(e);
+                  _cancelAndErrorWithReplacement(subscription, future, e, s);
+                }
+
+                return;
+              }
+              foundResult = true;
+              result = value;
+            }
+          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
+        }, {onError: future[_completeError], onDone: (() => {
+            if (foundResult) {
+              future._complete(result);
+              return;
+            }
+            try {
+              throw _internal.IterableElementError.noElement();
+            } catch (e) {
+              let s = dart.stackTrace(e);
+              _completeWithErrorCallback(future, e, s);
+            }
+
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      elementAt(index) {
+        if (dart.notNull(!(typeof index == number)) || dart.notNull(index) < 0)
+          throw new core.ArgumentError(index);
+        let future = new _Future();
+        let subscription = null;
+        let elementIndex = 0;
+        subscription = this.listen((value) => {
+          if (index === elementIndex) {
+            _cancelAndValue(subscription, future, value);
+            return;
+          }
+          elementIndex = 1;
+        }, {onError: future[_completeError], onDone: (() => {
+            future._completeError(new core.RangeError.index(index, this, "index", null, elementIndex));
+          }).bind(this), cancelOnError: true});
+        return future;
+      }
+      timeout(timeLimit, opt$) {
+        let onTimeout = opt$.onTimeout === void 0 ? null : opt$.onTimeout;
+        let controller = null;
+        let subscription = null;
+        let timer = null;
+        let zone = null;
+        let timeout = null;
+        // Function onData: (T) → void
+        function onData(event) {
+          timer.cancel();
+          controller.add(event);
+          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
+        }
+        // Function onError: (dynamic, StackTrace) → void
+        function onError(error, stackTrace) {
+          timer.cancel();
+          dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
+          let eventSink = controller;
+          dart.dinvoke(eventSink, '_addError', error, stackTrace);
+          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
+        }
+        // Function onDone: () → void
+        function onDone() {
+          timer.cancel();
+          controller.close();
+        }
+        // Function onListen: () → void
+        function onListen() {
+          zone = Zone.current;
+          if (onTimeout === null) {
+            timeout = (() => {
+              controller.addError(new TimeoutException("No stream event", timeLimit), null);
+            }).bind(this);
+          } else {
+            onTimeout = zone.registerUnaryCallback(dart.as(onTimeout, dart.throw_("Unimplemented type (dynamic) → dynamic")));
+            let wrapper = new _ControllerEventSinkWrapper(null);
+            timeout = (() => {
+              wrapper[_sink] = controller;
+              zone.runUnaryGuarded(dart.as(onTimeout, dart.throw_("Unimplemented type (dynamic) → dynamic")), wrapper);
+              wrapper[_sink] = null;
+            }).bind(this);
+          }
+          subscription = this.listen(onData, {onError: onError, onDone: onDone});
+          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
+        }
+        // Function onCancel: () → Future<dynamic>
+        function onCancel() {
+          timer.cancel();
+          let result = subscription.cancel();
+          subscription = null;
+          return result;
+        }
+        controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, (() => {
+          timer.cancel();
+          subscription.pause();
+        }).bind(this), (() => {
+          subscription.resume();
+          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
+        }).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 _StreamImpl$ = dart.generic(function(T) {
+    class _StreamImpl extends Stream$(T) {
+      listen(onData, opt$) {
+        let onError = opt$.onError === void 0 ? null : opt$.onError;
+        let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
+        let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
+        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(onData, onError, onDone, cancelOnError);
+      }
+      [_onListen](subscription) {}
+    }
+    return _StreamImpl;
+  });
+  let _StreamImpl = _StreamImpl$(dart.dynamic);
+  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 _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 _next = Symbol('_next');
   let _previous = Symbol('_previous');
   class _BroadcastSubscriptionLink extends core.Object {
     _BroadcastSubscriptionLink() {
       this[_next] = null;
       this[_previous] = null;
     }
   }
   let _eventState = Symbol('_eventState');
-  let _controller = Symbol('_controller');
   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 _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 _decrementPauseCount = Symbol('_decrementPauseCount');
+  let _hasPending = Symbol('_hasPending');
+  let _mayResumeInput = Symbol('_mayResumeInput');
+  let _cancel = Symbol('_cancel');
+  let _isClosed = Symbol('_isClosed');
+  let _waitsForCancel = Symbol('_waitsForCancel');
+  let _canFire = Symbol('_canFire');
+  let _cancelOnError = Symbol('_cancelOnError');
+  let _incrementPauseCount = Symbol('_incrementPauseCount');
+  let _add = Symbol('_add');
+  let _sendData = Symbol('_sendData');
+  let _addPending = Symbol('_addPending');
+  let _sendError = Symbol('_sendError');
+  let _close = Symbol('_close');
+  let _sendDone = Symbol('_sendDone');
+  let _checkState = Symbol('_checkState');
+  let _BufferingStreamSubscription$ = dart.generic(function(T) {
+    class _BufferingStreamSubscription extends core.Object {
+      _BufferingStreamSubscription(onData, onError, onDone, cancelOnError) {
+        this[_zone] = Zone.current;
+        this[_state] = cancelOnError ? _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR : 0;
+        this[_onData] = null;
+        this[_onError] = null;
+        this[_onDone] = null;
+        this[_cancelFuture] = null;
+        this[_pending] = null;
+        this.onData(onData);
+        this.onError(onError);
+        this.onDone(onDone);
+      }
+      [_setPendingEvents](pendingEvents) {
+        dart.assert(this[_pending] === null);
+        if (pendingEvents === null)
+          return;
+        this[_pending] = pendingEvents;
+        if (!dart.notNull(pendingEvents.isEmpty)) {
+          this[_state] = _BufferingStreamSubscription._STATE_HAS_PENDING;
+          this[_pending].schedule(this);
+        }
+      }
+      [_extractPending]() {
+        dart.assert(this[_isCanceled]);
+        let events = this[_pending];
+        this[_pending] = null;
+        return events;
+      }
+      onData(handleData) {
+        if (handleData === null)
+          handleData = _nullDataHandler;
+        this[_onData] = this[_zone].registerUnaryCallback(dart.as(handleData, dart.throw_("Unimplemented type (dynamic) → dynamic")));
+      }
+      onError(handleError) {
+        if (handleError === null)
+          handleError = _nullErrorHandler;
+        this[_onError] = _registerErrorHandler(handleError, this[_zone]);
+      }
+      onDone(handleDone) {
+        if (handleDone === null)
+          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);
+        if (resumeSignal !== null)
+          resumeSignal.whenComplete(this.resume);
+        if (!dart.notNull(wasPaused) && dart.notNull(this[_pending] !== null))
+          this[_pending].cancelSchedule();
+        if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
+          this[_guardCallback](this[_onPause]);
+      }
+      resume() {
+        if (this[_isCanceled])
+          return;
+        if (this[_isPaused]) {
+          this[_decrementPauseCount]();
+          if (!dart.notNull(this[_isPaused])) {
+            if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_pending].isEmpty)) {
+              this[_pending].schedule(this);
+            } else {
+              dart.assert(this[_mayResumeInput]);
+              this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
+              if (!dart.notNull(this[_inCallback]))
+                this[_guardCallback](this[_onResume]);
+            }
+          }
+        }
+      }
+      cancel() {
+        this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL);
+        if (this[_isCanceled])
+          return this[_cancelFuture];
+        this[_cancel]();
+        return this[_cancelFuture];
+      }
+      asFuture(futureValue) {
+        if (futureValue === void 0)
+          futureValue = null;
+        let result = new _Future();
+        this[_onDone] = (() => {
+          result._complete(futureValue);
+        }).bind(this);
+        this[_onError] = ((error, stackTrace) => {
+          this.cancel();
+          result._completeError(error, dart.as(stackTrace, core.StackTrace));
+        }).bind(this);
+        return result;
+      }
+      get [_isInputPaused]() {
+        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED)) !== 0;
+      }
+      get [_isClosed]() {
+        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_CLOSED)) !== 0;
+      }
+      get [_isCanceled]() {
+        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;
+      }
+      get [_inCallback]() {
+        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;
+      }
+      get [_isPaused]() {
+        return dart.notNull(this[_state]) >= dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT);
+      }
+      get [_canFire]() {
+        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;
+      }
+      get isPaused() {
+        return this[_isPaused];
+      }
+      [_cancel]() {
+        this[_state] = _BufferingStreamSubscription._STATE_CANCELED;
+        if (this[_hasPending]) {
+          this[_pending].cancelSchedule();
+        }
+        if (!dart.notNull(this[_inCallback]))
+          this[_pending] = null;
+        this[_cancelFuture] = this[_onCancel]();
+      }
+      [_incrementPauseCount]() {
+        this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
+      }
+      [_decrementPauseCount]() {
+        dart.assert(this[_isPaused]);
+        this[_state] = _BufferingStreamSubscription._STATE_PAUSE_COUNT;
+      }
+      [_add](data) {
+        dart.assert(!dart.notNull(this[_isClosed]));
+        if (this[_isCanceled])
+          return;
+        if (this[_canFire]) {
+          this[_sendData](data);
+        } else {
+          this[_addPending](new _DelayedData(data));
+        }
+      }
+      [_addError](error, stackTrace) {
+        if (this[_isCanceled])
+          return;
+        if (this[_canFire]) {
+          this[_sendError](error, stackTrace);
+        } else {
+          this[_addPending](new _DelayedError(error, stackTrace));
+        }
+      }
+      [_close]() {
+        dart.assert(!dart.notNull(this[_isClosed]));
+        if (this[_isCanceled])
+          return;
+        this[_state] = _BufferingStreamSubscription._STATE_CLOSED;
+        if (this[_canFire]) {
+          this[_sendDone]();
+        } else {
+          this[_addPending](new _DelayedDone());
+        }
+      }
+      [_onPause]() {
+        dart.assert(this[_isInputPaused]);
+      }
+      [_onResume]() {
+        dart.assert(!dart.notNull(this[_isInputPaused]));
+      }
+      [_onCancel]() {
+        dart.assert(this[_isCanceled]);
+        return null;
+      }
+      [_addPending](event) {
+        let pending = dart.as(this[_pending], _StreamImplEvents);
+        if (this[_pending] === null)
+          pending = this[_pending] = new _StreamImplEvents();
+        pending.add(event);
+        if (!dart.notNull(this[_hasPending])) {
+          this[_state] = _BufferingStreamSubscription._STATE_HAS_PENDING;
+          if (!dart.notNull(this[_isPaused])) {
+            this[_pending].schedule(this);
+          }
+        }
+      }
+      [_sendData](data) {
+        dart.assert(!dart.notNull(this[_isCanceled]));
+        dart.assert(!dart.notNull(this[_isPaused]));
+        dart.assert(!dart.notNull(this[_inCallback]));
+        let wasInputPaused = this[_isInputPaused];
+        this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
+        this[_zone].runUnaryGuarded(dart.as(this[_onData], dart.throw_("Unimplemented type (dynamic) → dynamic")), data);
+        this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        this[_checkState](wasInputPaused);
+      }
+      [_sendError](error, stackTrace) {
+        dart.assert(!dart.notNull(this[_isCanceled]));
+        dart.assert(!dart.notNull(this[_isPaused]));
+        dart.assert(!dart.notNull(this[_inCallback]));
+        let wasInputPaused = this[_isInputPaused];
+        // Function sendError: () → void
+        function sendError() {
+          if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
+            return;
+          this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
+          if (dart.is(this[_onError], ZoneBinaryCallback)) {
+            this[_zone].runBinaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic, dynamic) → dynamic")), error, stackTrace);
+          } else {
+            this[_zone].runUnaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic) → dynamic")), error);
+          }
+          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        }
+        if (this[_cancelOnError]) {
+          this[_state] = _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL;
+          this[_cancel]();
+          if (dart.is(this[_cancelFuture], Future)) {
+            this[_cancelFuture].whenComplete(sendError);
+          } else {
+            sendError();
+          }
+        } else {
+          sendError();
+          this[_checkState](wasInputPaused);
+        }
+      }
+      [_sendDone]() {
+        dart.assert(!dart.notNull(this[_isCanceled]));
+        dart.assert(!dart.notNull(this[_isPaused]));
+        dart.assert(!dart.notNull(this[_inCallback]));
+        // Function sendDone: () → void
+        function sendDone() {
+          if (!dart.notNull(this[_waitsForCancel]))
+            return;
+          this[_state] = dart.notNull(_BufferingStreamSubscription._STATE_CANCELED) | dart.notNull(_BufferingStreamSubscription._STATE_CLOSED) | dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+          this[_zone].runGuarded(this[_onDone]);
+          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        }
+        this[_cancel]();
+        this[_state] = _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL;
+        if (dart.is(this[_cancelFuture], Future)) {
+          this[_cancelFuture].whenComplete(sendDone);
+        } else {
+          sendDone();
+        }
+      }
+      [_guardCallback](callback) {
+        dart.assert(!dart.notNull(this[_inCallback]));
+        let wasInputPaused = this[_isInputPaused];
+        this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
+        dart.dinvokef(callback);
+        this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+        this[_checkState](wasInputPaused);
+      }
+      [_checkState](wasInputPaused) {
+        dart.assert(!dart.notNull(this[_inCallback]));
+        if (dart.notNull(this[_hasPending]) && dart.notNull(this[_pending].isEmpty)) {
+          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_HAS_PENDING);
+          if (dart.notNull(this[_isInputPaused]) && dart.notNull(this[_mayResumeInput])) {
+            this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
+          }
+        }
+        while (true) {
+          if (this[_isCanceled]) {
+            this[_pending] = null;
+            return;
+          }
+          let isInputPaused = this[_isInputPaused];
+          if (wasInputPaused === isInputPaused)
+            break;
+          this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
+          if (isInputPaused) {
+            this[_onPause]();
+          } else {
+            this[_onResume]();
+          }
+          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
+          wasInputPaused = isInputPaused;
+        }
+        if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
+          this[_pending].schedule(this);
+        }
+      }
+    }
+    _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
+    _BufferingStreamSubscription._STATE_CLOSED = 2;
+    _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
+    _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 _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 _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._STATE_EVENT_ID = 1;
     _BroadcastSubscription._STATE_FIRING = 2;
     _BroadcastSubscription._STATE_REMOVE_AFTER_FIRING = 4;
     return _BroadcastSubscription;
   });
   let _BroadcastSubscription = _BroadcastSubscription$(dart.dynamic);
-  let _onListen = Symbol('_onListen');
-  let _onCancel = Symbol('_onCancel');
-  let _state = Symbol('_state');
   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 _subscribe = Symbol('_subscribe');
   let _recordCancel = Symbol('_recordCancel');
   let _callOnCancel = Symbol('_callOnCancel');
   let _recordPause = Symbol('_recordPause');
   let _recordResume = Symbol('_recordResume');
   let _addEventError = Symbol('_addEventError');
-  let _sendData = Symbol('_sendData');
-  let _sendError = Symbol('_sendError');
-  let _sendDone = Symbol('_sendDone');
-  let _add = Symbol('_add');
-  let _addError = Symbol('_addError');
-  let _close = Symbol('_close');
   let _forEachListener = Symbol('_forEachListener');
   let _STATE_FIRING = Symbol('_STATE_FIRING');
   let _mayComplete = Symbol('_mayComplete');
   let _BroadcastStreamController$ = dart.generic(function(T) {
     class _BroadcastStreamController extends core.Object {
       _BroadcastStreamController($_onListen, $_onCancel) {
         this[_onListen] = $_onListen;
         this[_onCancel] = $_onCancel;
         this[_state] = _BroadcastStreamController._STATE_INITIAL;
         this[_next] = null;
@@ skipping 261 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 _pending = Symbol('_pending');
-  let _hasPending = Symbol('_hasPending');
   let _addPendingEvent = Symbol('_addPendingEvent');
   let _STATE_CLOSED = Symbol('_STATE_CLOSED');
   let _AsBroadcastStreamController$ = dart.generic(function(T) {
     class _AsBroadcastStreamController extends _SyncBroadcastStreamController$(T) {
       _AsBroadcastStreamController(onListen, onCancel) {
         this[_pending] = null;
         super._SyncBroadcastStreamController(onListen, onCancel);
       }
       get [_hasPending]() {
         return dart.notNull(this[_pending] !== null) && !dart.notNull(this[_pending].isEmpty);
@@ skipping 100 matching lines @@
   }
   let _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
     DeferredLoadException($_s) {
       this[_s] = $_s;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
-  let _completeError = Symbol('_completeError');
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new _Future();
         Timer.run((() => {
           try {
             result._complete(computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
@@ skipping 245 matching lines @@
         this.future._complete(value);
       }
       [_completeError](error, stackTrace) {
         this.future._completeError(error, stackTrace);
       }
     }
     return _SyncCompleter;
   });
   let _SyncCompleter = _SyncCompleter$(dart.dynamic);
   let _nextListener = Symbol('_nextListener');
-  let _zone = Symbol('_zone');
   let _onValue = Symbol('_onValue');
-  let _onError = Symbol('_onError');
   let _errorTest = Symbol('_errorTest');
   let _whenCompleteAction = Symbol('_whenCompleteAction');
   class _FutureListener extends core.Object {
     _FutureListener$then(result, onValue, errorCallback) {
       this.result = result;
       this.callback = onValue;
       this.errorCallback = errorCallback;
       this.state = errorCallback === null ? _FutureListener.STATE_THEN : _FutureListener.STATE_THEN_ONERROR;
       this[_nextListener] = null;
     }
@@ skipping 72 matching lines @@
   let _hasError = Symbol('_hasError');
   let _markPendingCompletion = Symbol('_markPendingCompletion');
   let _value = Symbol('_value');
   let _error = Symbol('_error');
   let _setValue = Symbol('_setValue');
   let _setErrorObject = Symbol('_setErrorObject');
   let _setError = Symbol('_setError');
   let _removeListeners = Symbol('_removeListeners');
   let _chainForeignFuture = Symbol('_chainForeignFuture');
   let _chainCoreFuture = Symbol('_chainCoreFuture');
-  let _complete = Symbol('_complete');
   let _completeWithValue = Symbol('_completeWithValue');
   let _propagateToListeners = Symbol('_propagateToListeners');
   let _Future$ = dart.generic(function(T) {
     class _Future extends core.Object {
       _Future() {
         this[_zone] = Zone.current;
         this[_state] = _Future._INCOMPLETE;
         this[_resultOrListeners] = null;
       }
       _Future$immediate(value) {
@@ skipping 546 matching lines @@
     }
     static [_scheduleImmediateWithTimer](callback) {
       Timer._createTimer(core.Duration.ZERO, callback);
     }
   }
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
       return _initializeScheduleImmediate();
     }
   });
-  let _sink = Symbol('_sink');
-  let Stream$ = dart.generic(function(T) {
-    class Stream extends core.Object {
-      Stream() {
-      }
-      Stream$fromFuture(future) {
-        let controller = dart.as(new StreamController({sync: true}), _StreamController$(T));
-        future.then(((value) => {
-          controller._add(dart.as(value, T));
-          controller._closeUnchecked();
-        }).bind(this), {onError: ((error, stackTrace) => {
-            controller._addError(error, dart.as(stackTrace, core.StackTrace));
-            controller._closeUnchecked();
-          }).bind(this)});
-        return controller.stream;
-      }
-      Stream$fromIterable(data) {
-        return new _GeneratedStreamImpl(() => new _IterablePendingEvents(data));
-      }
-      Stream$periodic(period, computation) {
-        if (computation === void 0)
-          computation = null;
-        if (computation === null)
-          computation = (i) => null;
-        let timer = null;
-        let computationCount = 0;
-        let controller = null;
-        let watch = new core.Stopwatch();
-        // Function sendEvent: () → void
-        function sendEvent() {
-          watch.reset();
-          let data = computation((($tmp) => computationCount = dart.notNull($tmp) + 1, $tmp)(computationCount));
-          controller.add(data);
-        }
-        // Function startPeriodicTimer: () → void
-        function startPeriodicTimer() {
-          dart.assert(timer === null);
-          timer = new Timer.periodic(period, (timer) => {
-            sendEvent();
-          });
-        }
-        controller = new StreamController({sync: true, onListen: (() => {
-            watch.start();
-            startPeriodicTimer();
-          }).bind(this), onPause: (() => {
-            timer.cancel();
-            timer = null;
-            watch.stop();
-          }).bind(this), onResume: (() => {
-            dart.assert(timer === null);
-            let elapsed = watch.elapsed;
-            watch.start();
-            timer = new Timer(period['-'](elapsed), () => {
-              timer = null;
-              startPeriodicTimer();
-              sendEvent();
-            });
-          }).bind(this), onCancel: (() => {
-            if (timer !== null)
-              timer.cancel();
-            timer = null;
-          }).bind(this)});
-        return controller.stream;
-      }
-      Stream$eventTransformed(source, mapSink) {
-        return dart.as(new _BoundSinkStream(source, dart.as(mapSink, _SinkMapper)), Stream$(T));
-      }
-      get isBroadcast() {
-        return false;
-      }
-      asBroadcastStream(opt$) {
-        let onListen = opt$.onListen === void 0 ? null : opt$.onListen;
-        let onCancel = opt$.onCancel === void 0 ? null : opt$.onCancel;
-        return new _AsBroadcastStream(this, dart.as(onListen, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")), dart.as(onCancel, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")));
-      }
-      where(test) {
-        return new _WhereStream(this, test);
-      }
-      map(convert) {
-        return new _MapStream(this, convert);
-      }
-      asyncMap(convert) {
-        let controller = null;
-        let subscription = null;
-        // Function onListen: () → void
-        function onListen() {
-          let add = controller.add;
-          dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
-          let eventSink = controller;
-          let addError = eventSink[_addError];
-          subscription = this.listen(((event) => {
-            let newValue = null;
-            try {
-              newValue = convert(event);
-            } catch (e) {
-              let s = dart.stackTrace(e);
-              controller.addError(e, s);
-              return;
-            }
-
-            if (dart.is(newValue, Future)) {
-              subscription.pause();
-              dart.dinvoke(dart.dinvoke(newValue, 'then', add, {onError: addError}), 'whenComplete', subscription.resume);
-            } else {
-              controller.add(newValue);
-            }
-          }).bind(this), {onError: dart.as(addError, core.Function), onDone: controller.close});
-        }
-        if (this.isBroadcast) {
-          controller = new StreamController.broadcast({onListen: onListen, onCancel: (() => {
-              subscription.cancel();
-            }).bind(this), sync: true});
-        } else {
-          controller = new StreamController({onListen: onListen, onPause: (() => {
-              subscription.pause();
-            }).bind(this), onResume: (() => {
-              subscription.resume();
-            }).bind(this), onCancel: (() => {
-              subscription.cancel();
-            }).bind(this), sync: true});
-        }
-        return controller.stream;
-      }
-      asyncExpand(convert) {
-        let controller = null;
-        let subscription = null;
-        // Function onListen: () → void
-        function onListen() {
-          dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
-          let eventSink = controller;
-          subscription = this.listen(((event) => {
-            let newStream = null;
-            try {
-              newStream = convert(event);
-            } catch (e) {
-              let s = dart.stackTrace(e);
-              controller.addError(e, s);
-              return;
-            }
-
-            if (newStream !== null) {
-              subscription.pause();
-              controller.addStream(newStream).whenComplete(subscription.resume);
-            }
-          }).bind(this), {onError: dart.as(eventSink[_addError], core.Function), onDone: controller.close});
-        }
-        if (this.isBroadcast) {
-          controller = new StreamController.broadcast({onListen: onListen, onCancel: (() => {
-              subscription.cancel();
-            }).bind(this), sync: true});
-        } else {
-          controller = new StreamController({onListen: onListen, onPause: (() => {
-              subscription.pause();
-            }).bind(this), onResume: (() => {
-              subscription.resume();
-            }).bind(this), onCancel: (() => {
-              subscription.cancel();
-            }).bind(this), sync: true});
-        }
-        return controller.stream;
-      }
-      handleError(onError, opt$) {
-        let test = opt$.test === void 0 ? null : opt$.test;
-        return new _HandleErrorStream(this, onError, test);
-      }
-      expand(convert) {
-        return new _ExpandStream(this, convert);
-      }
-      pipe(streamConsumer) {
-        return streamConsumer.addStream(this).then(((_) => streamConsumer.close()).bind(this));
-      }
-      transform(streamTransformer) {
-        return streamTransformer.bind(this);
-      }
-      reduce(combine) {
-        let result = new _Future();
-        let seenFirst = false;
-        let value = null;
-        let subscription = null;
-        subscription = this.listen((element) => {
-          if (seenFirst) {
-            _runUserCode(() => combine(value, element), dart.as((newValue) => {
-              value = newValue;
-            }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-          } else {
-            value = element;
-            seenFirst = true;
-          }
-        }, {onError: result[_completeError], onDone: (() => {
-            if (!dart.notNull(seenFirst)) {
-              try {
-                throw _internal.IterableElementError.noElement();
-              } catch (e) {
-                let s = dart.stackTrace(e);
-                _completeWithErrorCallback(result, e, s);
-              }
-
-            } else {
-              result._complete(value);
-            }
-          }).bind(this), cancelOnError: true});
-        return result;
-      }
-      fold(initialValue, combine) {
-        let result = new _Future();
-        let value = initialValue;
-        let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => combine(value, element), (newValue) => {
-            value = newValue;
-          }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: ((e, st) => {
-            result._completeError(e, dart.as(st, core.StackTrace));
-          }).bind(this), onDone: (() => {
-            result._complete(value);
-          }).bind(this), cancelOnError: true});
-        return result;
-      }
-      join(separator) {
-        if (separator === void 0)
-          separator = "";
-        let result = new _Future();
-        let buffer = new core.StringBuffer();
-        let subscription = null;
-        let first = true;
-        subscription = this.listen(((element) => {
-          if (!dart.notNull(first)) {
-            buffer.write(separator);
-          }
-          first = false;
-          try {
-            buffer.write(element);
-          } catch (e) {
-            let s = dart.stackTrace(e);
-            _cancelAndErrorWithReplacement(subscription, result, e, s);
-          }
-
-        }).bind(this), {onError: ((e) => {
-            result._completeError(e);
-          }).bind(this), onDone: (() => {
-            result._complete(buffer.toString());
-          }).bind(this), cancelOnError: true});
-        return result;
-      }
-      contains(needle) {
-        let future = new _Future();
-        let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => dart.equals(element, needle), dart.as((isMatch) => {
-            if (isMatch) {
-              _cancelAndValue(subscription, future, true);
-            }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
-            future._complete(false);
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      forEach(action) {
-        let future = new _Future();
-        let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => action(element), (_) => {
-          }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
-            future._complete(null);
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      every(test) {
-        let future = new _Future();
-        let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => test(element), dart.as((isMatch) => {
-            if (!dart.notNull(isMatch)) {
-              _cancelAndValue(subscription, future, false);
-            }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
-            future._complete(true);
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      any(test) {
-        let future = new _Future();
-        let subscription = null;
-        subscription = this.listen((element) => {
-          _runUserCode(() => test(element), dart.as((isMatch) => {
-            if (isMatch) {
-              _cancelAndValue(subscription, future, true);
-            }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
-            future._complete(false);
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      get length() {
-        let future = new _Future();
-        let count = 0;
-        this.listen((_) => {
-          count = dart.notNull(count) + 1;
-        }, {onError: future[_completeError], onDone: (() => {
-            future._complete(count);
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      get isEmpty() {
-        let future = new _Future();
-        let subscription = null;
-        subscription = this.listen((_) => {
-          _cancelAndValue(subscription, future, false);
-        }, {onError: future[_completeError], onDone: (() => {
-            future._complete(true);
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      toList() {
-        let result = new List.from([]);
-        let future = new _Future();
-        this.listen(((data) => {
-          result.add(data);
-        }).bind(this), {onError: future[_completeError], onDone: (() => {
-            future._complete(result);
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      toSet() {
-        let result = new core.Set();
-        let future = new _Future();
-        this.listen(((data) => {
-          result.add(data);
-        }).bind(this), {onError: future[_completeError], onDone: (() => {
-            future._complete(result);
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      drain(futureValue) {
-        if (futureValue === void 0)
-          futureValue = null;
-        return this.listen(null, {cancelOnError: true}).asFuture(futureValue);
-      }
-      take(count) {
-        return dart.as(new _TakeStream(this, count), Stream$(T));
-      }
-      takeWhile(test) {
-        return dart.as(new _TakeWhileStream(this, dart.as(test, dart.throw_("Unimplemented type (dynamic) → bool"))), Stream$(T));
-      }
-      skip(count) {
-        return dart.as(new _SkipStream(this, count), Stream$(T));
-      }
-      skipWhile(test) {
-        return dart.as(new _SkipWhileStream(this, dart.as(test, dart.throw_("Unimplemented type (dynamic) → bool"))), Stream$(T));
-      }
-      distinct(equals) {
-        if (equals === void 0)
-          equals = null;
-        return dart.as(new _DistinctStream(this, dart.as(equals, dart.throw_("Unimplemented type (dynamic, dynamic) → bool"))), Stream$(T));
-      }
-      get first() {
-        let future = new _Future();
-        let subscription = null;
-        subscription = this.listen((value) => {
-          _cancelAndValue(subscription, future, value);
-        }, {
-          onError: future[_completeError],
-          onDone: () => {
-            try {
-              throw _internal.IterableElementError.noElement();
-            } catch (e) {
-              let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
-            }
-
-          },
-          cancelOnError: true
-        });
-        return future;
-      }
-      get last() {
-        let future = new _Future();
-        let result = null;
-        let foundResult = false;
-        let subscription = null;
-        subscription = this.listen((value) => {
-          foundResult = true;
-          result = value;
-        }, {onError: future[_completeError], onDone: (() => {
-            if (foundResult) {
-              future._complete(result);
-              return;
-            }
-            try {
-              throw _internal.IterableElementError.noElement();
-            } catch (e) {
-              let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
-            }
-
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      get single() {
-        let future = new _Future();
-        let result = null;
-        let foundResult = false;
-        let subscription = null;
-        subscription = this.listen((value) => {
-          if (foundResult) {
-            try {
-              throw _internal.IterableElementError.tooMany();
-            } catch (e) {
-              let s = dart.stackTrace(e);
-              _cancelAndErrorWithReplacement(subscription, future, e, s);
-            }
-
-            return;
-          }
-          foundResult = true;
-          result = value;
-        }, {onError: future[_completeError], onDone: (() => {
-            if (foundResult) {
-              future._complete(result);
-              return;
-            }
-            try {
-              throw _internal.IterableElementError.noElement();
-            } catch (e) {
-              let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
-            }
-
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      firstWhere(test, opt$) {
-        let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultValue;
-        let future = new _Future();
-        let subscription = null;
-        subscription = this.listen((value) => {
-          _runUserCode(() => test(value), dart.as((isMatch) => {
-            if (isMatch) {
-              _cancelAndValue(subscription, future, value);
-            }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
-            if (defaultValue !== null) {
-              _runUserCode(defaultValue, future[_complete], future[_completeError]);
-              return;
-            }
-            try {
-              throw _internal.IterableElementError.noElement();
-            } catch (e) {
-              let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
-            }
-
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      lastWhere(test, opt$) {
-        let defaultValue = opt$.defaultValue === void 0 ? null : opt$.defaultValue;
-        let future = new _Future();
-        let result = null;
-        let foundResult = false;
-        let subscription = null;
-        subscription = this.listen((value) => {
-          _runUserCode(() => true === test(value), dart.as((isMatch) => {
-            if (isMatch) {
-              foundResult = true;
-              result = value;
-            }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
-            if (foundResult) {
-              future._complete(result);
-              return;
-            }
-            if (defaultValue !== null) {
-              _runUserCode(defaultValue, future[_complete], future[_completeError]);
-              return;
-            }
-            try {
-              throw _internal.IterableElementError.noElement();
-            } catch (e) {
-              let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
-            }
-
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      singleWhere(test) {
-        let future = new _Future();
-        let result = null;
-        let foundResult = false;
-        let subscription = null;
-        subscription = this.listen((value) => {
-          _runUserCode(() => true === test(value), dart.as((isMatch) => {
-            if (isMatch) {
-              if (foundResult) {
-                try {
-                  throw _internal.IterableElementError.tooMany();
-                } catch (e) {
-                  let s = dart.stackTrace(e);
-                  _cancelAndErrorWithReplacement(subscription, future, e, s);
-                }
-
-                return;
-              }
-              foundResult = true;
-              result = value;
-            }
-          }, dart.throw_("Unimplemented type (dynamic) → dynamic")), dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
-        }, {onError: future[_completeError], onDone: (() => {
-            if (foundResult) {
-              future._complete(result);
-              return;
-            }
-            try {
-              throw _internal.IterableElementError.noElement();
-            } catch (e) {
-              let s = dart.stackTrace(e);
-              _completeWithErrorCallback(future, e, s);
-            }
-
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      elementAt(index) {
-        if (dart.notNull(!(typeof index == number)) || dart.notNull(index) < 0)
-          throw new core.ArgumentError(index);
-        let future = new _Future();
-        let subscription = null;
-        let elementIndex = 0;
-        subscription = this.listen((value) => {
-          if (index === elementIndex) {
-            _cancelAndValue(subscription, future, value);
-            return;
-          }
-          elementIndex = 1;
-        }, {onError: future[_completeError], onDone: (() => {
-            future._completeError(new core.RangeError.index(index, this, "index", null, elementIndex));
-          }).bind(this), cancelOnError: true});
-        return future;
-      }
-      timeout(timeLimit, opt$) {
-        let onTimeout = opt$.onTimeout === void 0 ? null : opt$.onTimeout;
-        let controller = null;
-        let subscription = null;
-        let timer = null;
-        let zone = null;
-        let timeout = null;
-        // Function onData: (T) → void
-        function onData(event) {
-          timer.cancel();
-          controller.add(event);
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
-        }
-        // Function onError: (dynamic, StackTrace) → void
-        function onError(error, stackTrace) {
-          timer.cancel();
-          dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
-          let eventSink = controller;
-          dart.dinvoke(eventSink, '_addError', error, stackTrace);
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
-        }
-        // Function onDone: () → void
-        function onDone() {
-          timer.cancel();
-          controller.close();
-        }
-        // Function onListen: () → void
-        function onListen() {
-          zone = Zone.current;
-          if (onTimeout === null) {
-            timeout = (() => {
-              controller.addError(new TimeoutException("No stream event", timeLimit), null);
-            }).bind(this);
-          } else {
-            onTimeout = zone.registerUnaryCallback(dart.as(onTimeout, dart.throw_("Unimplemented type (dynamic) → dynamic")));
-            let wrapper = new _ControllerEventSinkWrapper(null);
-            timeout = (() => {
-              wrapper[_sink] = controller;
-              zone.runUnaryGuarded(dart.as(onTimeout, dart.throw_("Unimplemented type (dynamic) → dynamic")), wrapper);
-              wrapper[_sink] = null;
-            }).bind(this);
-          }
-          subscription = this.listen(onData, {onError: onError, onDone: onDone});
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
-        }
-        // Function onCancel: () → Future<dynamic>
-        function onCancel() {
-          timer.cancel();
-          let result = subscription.cancel();
-          subscription = null;
-          return result;
-        }
-        controller = this.isBroadcast ? new _SyncBroadcastStreamController(onListen, onCancel) : new _SyncStreamController(onListen, (() => {
-          timer.cancel();
-          subscription.pause();
-        }).bind(this), (() => {
-          subscription.resume();
-          timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
-        }).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 StreamSubscription$ = dart.generic(function(T) {
     class StreamSubscription extends core.Object {
     }
     return StreamSubscription;
   });
   let StreamSubscription = StreamSubscription$(dart.dynamic);
   let EventSink$ = dart.generic(function(T) {
     class EventSink extends core.Object {
     }
     return EventSink;
@@ skipping 107 matching lines @@
       [_recordPause](subscription) {}
       [_recordResume](subscription) {}
       [_recordCancel](subscription) {
         return null;
       }
     }
     return _StreamControllerLifecycle;
   });
   let _StreamControllerLifecycle = _StreamControllerLifecycle$(dart.dynamic);
   let _varData = Symbol('_varData');
-  let _isCanceled = Symbol('_isCanceled');
   let _isInitialState = Symbol('_isInitialState');
   let _subscription = Symbol('_subscription');
-  let _isInputPaused = Symbol('_isInputPaused');
   let _pendingEvents = Symbol('_pendingEvents');
   let _ensurePendingEvents = Symbol('_ensurePendingEvents');
   let _badEventState = Symbol('_badEventState');
   let _nullFuture = Symbol('_nullFuture');
   let _closeUnchecked = Symbol('_closeUnchecked');
   let _StreamController$ = dart.generic(function(T) {
     class _StreamController extends core.Object {
       _StreamController() {
         this[_varData] = null;
         this[_state] = _StreamController._STATE_INITIAL;
@@ skipping 300 matching lines @@
       let result = notificationHandler();
       if (dart.is(result, Future))
         return dart.as(result, Future);
       return null;
     } catch (e) {
       let s = dart.stackTrace(e);
       Zone.current.handleUncaughtError(e, s);
     }
 
   }
-  let _createSubscription = Symbol('_createSubscription');
-  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 _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 _target = Symbol('_target');
   let _StreamSinkWrapper$ = dart.generic(function(T) {
     class _StreamSinkWrapper extends core.Object {
       _StreamSinkWrapper($_target) {
         this[_target] = $_target;
       }
       add(data) {
         this[_target].add(data);
       }
       addError(error, stackTrace) {
@@ skipping 68 matching lines @@
     }
     return _EventSink;
   });
   let _EventSink = _EventSink$(dart.dynamic);
   let _EventDispatch$ = dart.generic(function(T) {
     class _EventDispatch extends core.Object {
     }
     return _EventDispatch;
   });
   let _EventDispatch = _EventDispatch$(dart.dynamic);
-  let _onData = Symbol('_onData');
-  let _onDone = Symbol('_onDone');
-  let _cancelFuture = Symbol('_cancelFuture');
-  let _setPendingEvents = Symbol('_setPendingEvents');
-  let _extractPending = Symbol('_extractPending');
-  let _isPaused = Symbol('_isPaused');
-  let _inCallback = Symbol('_inCallback');
-  let _guardCallback = Symbol('_guardCallback');
-  let _decrementPauseCount = Symbol('_decrementPauseCount');
-  let _mayResumeInput = Symbol('_mayResumeInput');
-  let _cancel = Symbol('_cancel');
-  let _isClosed = Symbol('_isClosed');
-  let _waitsForCancel = Symbol('_waitsForCancel');
-  let _canFire = Symbol('_canFire');
-  let _cancelOnError = Symbol('_cancelOnError');
-  let _incrementPauseCount = Symbol('_incrementPauseCount');
-  let _addPending = Symbol('_addPending');
-  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[_onData] = null;
-        this[_onError] = null;
-        this[_onDone] = null;
-        this[_cancelFuture] = null;
-        this[_pending] = null;
-        this.onData(onData);
-        this.onError(onError);
-        this.onDone(onDone);
-      }
-      [_setPendingEvents](pendingEvents) {
-        dart.assert(this[_pending] === null);
-        if (pendingEvents === null)
-          return;
-        this[_pending] = pendingEvents;
-        if (!dart.notNull(pendingEvents.isEmpty)) {
-          this[_state] = _BufferingStreamSubscription._STATE_HAS_PENDING;
-          this[_pending].schedule(this);
-        }
-      }
-      [_extractPending]() {
-        dart.assert(this[_isCanceled]);
-        let events = this[_pending];
-        this[_pending] = null;
-        return events;
-      }
-      onData(handleData) {
-        if (handleData === null)
-          handleData = _nullDataHandler;
-        this[_onData] = this[_zone].registerUnaryCallback(dart.as(handleData, dart.throw_("Unimplemented type (dynamic) → dynamic")));
-      }
-      onError(handleError) {
-        if (handleError === null)
-          handleError = _nullErrorHandler;
-        this[_onError] = _registerErrorHandler(handleError, this[_zone]);
-      }
-      onDone(handleDone) {
-        if (handleDone === null)
-          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);
-        if (resumeSignal !== null)
-          resumeSignal.whenComplete(this.resume);
-        if (!dart.notNull(wasPaused) && dart.notNull(this[_pending] !== null))
-          this[_pending].cancelSchedule();
-        if (!dart.notNull(wasInputPaused) && !dart.notNull(this[_inCallback]))
-          this[_guardCallback](this[_onPause]);
-      }
-      resume() {
-        if (this[_isCanceled])
-          return;
-        if (this[_isPaused]) {
-          this[_decrementPauseCount]();
-          if (!dart.notNull(this[_isPaused])) {
-            if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_pending].isEmpty)) {
-              this[_pending].schedule(this);
-            } else {
-              dart.assert(this[_mayResumeInput]);
-              this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
-              if (!dart.notNull(this[_inCallback]))
-                this[_guardCallback](this[_onResume]);
-            }
-          }
-        }
-      }
-      cancel() {
-        this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL);
-        if (this[_isCanceled])
-          return this[_cancelFuture];
-        this[_cancel]();
-        return this[_cancelFuture];
-      }
-      asFuture(futureValue) {
-        if (futureValue === void 0)
-          futureValue = null;
-        let result = new _Future();
-        this[_onDone] = (() => {
-          result._complete(futureValue);
-        }).bind(this);
-        this[_onError] = ((error, stackTrace) => {
-          this.cancel();
-          result._completeError(error, dart.as(stackTrace, core.StackTrace));
-        }).bind(this);
-        return result;
-      }
-      get [_isInputPaused]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED)) !== 0;
-      }
-      get [_isClosed]() {
-        return (dart.notNull(this[_state]) & dart.notNull(_BufferingStreamSubscription._STATE_CLOSED)) !== 0;
-      }
-      get [_isCanceled]() {
-        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;
-      }
-      get [_inCallback]() {
-        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;
-      }
-      get [_isPaused]() {
-        return dart.notNull(this[_state]) >= dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT);
-      }
-      get [_canFire]() {
-        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;
-      }
-      get isPaused() {
-        return this[_isPaused];
-      }
-      [_cancel]() {
-        this[_state] = _BufferingStreamSubscription._STATE_CANCELED;
-        if (this[_hasPending]) {
-          this[_pending].cancelSchedule();
-        }
-        if (!dart.notNull(this[_inCallback]))
-          this[_pending] = null;
-        this[_cancelFuture] = this[_onCancel]();
-      }
-      [_incrementPauseCount]() {
-        this[_state] = dart.notNull(this[_state]) + dart.notNull(_BufferingStreamSubscription._STATE_PAUSE_COUNT) | dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
-      }
-      [_decrementPauseCount]() {
-        dart.assert(this[_isPaused]);
-        this[_state] = _BufferingStreamSubscription._STATE_PAUSE_COUNT;
-      }
-      [_add](data) {
-        dart.assert(!dart.notNull(this[_isClosed]));
-        if (this[_isCanceled])
-          return;
-        if (this[_canFire]) {
-          this[_sendData](data);
-        } else {
-          this[_addPending](new _DelayedData(data));
-        }
-      }
-      [_addError](error, stackTrace) {
-        if (this[_isCanceled])
-          return;
-        if (this[_canFire]) {
-          this[_sendError](error, stackTrace);
-        } else {
-          this[_addPending](new _DelayedError(error, stackTrace));
-        }
-      }
-      [_close]() {
-        dart.assert(!dart.notNull(this[_isClosed]));
-        if (this[_isCanceled])
-          return;
-        this[_state] = _BufferingStreamSubscription._STATE_CLOSED;
-        if (this[_canFire]) {
-          this[_sendDone]();
-        } else {
-          this[_addPending](new _DelayedDone());
-        }
-      }
-      [_onPause]() {
-        dart.assert(this[_isInputPaused]);
-      }
-      [_onResume]() {
-        dart.assert(!dart.notNull(this[_isInputPaused]));
-      }
-      [_onCancel]() {
-        dart.assert(this[_isCanceled]);
-        return null;
-      }
-      [_addPending](event) {
-        let pending = dart.as(this[_pending], _StreamImplEvents);
-        if (this[_pending] === null)
-          pending = this[_pending] = new _StreamImplEvents();
-        pending.add(event);
-        if (!dart.notNull(this[_hasPending])) {
-          this[_state] = _BufferingStreamSubscription._STATE_HAS_PENDING;
-          if (!dart.notNull(this[_isPaused])) {
-            this[_pending].schedule(this);
-          }
-        }
-      }
-      [_sendData](data) {
-        dart.assert(!dart.notNull(this[_isCanceled]));
-        dart.assert(!dart.notNull(this[_isPaused]));
-        dart.assert(!dart.notNull(this[_inCallback]));
-        let wasInputPaused = this[_isInputPaused];
-        this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
-        this[_zone].runUnaryGuarded(dart.as(this[_onData], dart.throw_("Unimplemented type (dynamic) → dynamic")), data);
-        this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
-        this[_checkState](wasInputPaused);
-      }
-      [_sendError](error, stackTrace) {
-        dart.assert(!dart.notNull(this[_isCanceled]));
-        dart.assert(!dart.notNull(this[_isPaused]));
-        dart.assert(!dart.notNull(this[_inCallback]));
-        let wasInputPaused = this[_isInputPaused];
-        // Function sendError: () → void
-        function sendError() {
-          if (dart.notNull(this[_isCanceled]) && !dart.notNull(this[_waitsForCancel]))
-            return;
-          this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
-          if (dart.is(this[_onError], ZoneBinaryCallback)) {
-            this[_zone].runBinaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic, dynamic) → dynamic")), error, stackTrace);
-          } else {
-            this[_zone].runUnaryGuarded(dart.as(this[_onError], dart.throw_("Unimplemented type (dynamic) → dynamic")), error);
-          }
-          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
-        }
-        if (this[_cancelOnError]) {
-          this[_state] = _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL;
-          this[_cancel]();
-          if (dart.is(this[_cancelFuture], Future)) {
-            this[_cancelFuture].whenComplete(sendError);
-          } else {
-            sendError();
-          }
-        } else {
-          sendError();
-          this[_checkState](wasInputPaused);
-        }
-      }
-      [_sendDone]() {
-        dart.assert(!dart.notNull(this[_isCanceled]));
-        dart.assert(!dart.notNull(this[_isPaused]));
-        dart.assert(!dart.notNull(this[_inCallback]));
-        // Function sendDone: () → void
-        function sendDone() {
-          if (!dart.notNull(this[_waitsForCancel]))
-            return;
-          this[_state] = dart.notNull(_BufferingStreamSubscription._STATE_CANCELED) | dart.notNull(_BufferingStreamSubscription._STATE_CLOSED) | dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
-          this[_zone].runGuarded(this[_onDone]);
-          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
-        }
-        this[_cancel]();
-        this[_state] = _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL;
-        if (dart.is(this[_cancelFuture], Future)) {
-          this[_cancelFuture].whenComplete(sendDone);
-        } else {
-          sendDone();
-        }
-      }
-      [_guardCallback](callback) {
-        dart.assert(!dart.notNull(this[_inCallback]));
-        let wasInputPaused = this[_isInputPaused];
-        this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
-        dart.dinvokef(callback);
-        this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
-        this[_checkState](wasInputPaused);
-      }
-      [_checkState](wasInputPaused) {
-        dart.assert(!dart.notNull(this[_inCallback]));
-        if (dart.notNull(this[_hasPending]) && dart.notNull(this[_pending].isEmpty)) {
-          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_HAS_PENDING);
-          if (dart.notNull(this[_isInputPaused]) && dart.notNull(this[_mayResumeInput])) {
-            this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_INPUT_PAUSED);
-          }
-        }
-        while (true) {
-          if (this[_isCanceled]) {
-            this[_pending] = null;
-            return;
-          }
-          let isInputPaused = this[_isInputPaused];
-          if (wasInputPaused === isInputPaused)
-            break;
-          this[_state] = _BufferingStreamSubscription._STATE_IN_CALLBACK;
-          if (isInputPaused) {
-            this[_onPause]();
-          } else {
-            this[_onResume]();
-          }
-          this[_state] = ~dart.notNull(_BufferingStreamSubscription._STATE_IN_CALLBACK);
-          wasInputPaused = isInputPaused;
-        }
-        if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
-          this[_pending].schedule(this);
-        }
-      }
-    }
-    _BufferingStreamSubscription._STATE_CANCEL_ON_ERROR = 1;
-    _BufferingStreamSubscription._STATE_CLOSED = 2;
-    _BufferingStreamSubscription._STATE_INPUT_PAUSED = 4;
-    _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 _StreamImpl$ = dart.generic(function(T) {
-    class _StreamImpl extends Stream$(T) {
-      listen(onData, opt$) {
-        let onError = opt$.onError === void 0 ? null : opt$.onError;
-        let onDone = opt$.onDone === void 0 ? null : opt$.onDone;
-        let cancelOnError = opt$.cancelOnError === void 0 ? null : opt$.cancelOnError;
-        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(onData, onError, onDone, cancelOnError);
-      }
-      [_onListen](subscription) {}
-    }
-    return _StreamImpl;
-  });
-  let _StreamImpl = _StreamImpl$(dart.dynamic);
   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(dart.as(onData, dart.throw_("Unimplemented type (dynamic) → void")), onError, onDone, cancelOnError));
       }
     }
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$(dart.dynamic);
   let _iterator = Symbol('_iterator');
+  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);
+    }
+    schedule(dispatch) {
+      if (this.isScheduled)
+        return;
+      dart.assert(!dart.notNull(this.isEmpty));
+      if (this[_eventScheduled]) {
+        dart.assert(this[_state] === _PendingEvents._STATE_CANCELED);
+        this[_state] = _PendingEvents._STATE_SCHEDULED;
+        return;
+      }
+      scheduleMicrotask((() => {
+        let oldState = this[_state];
+        this[_state] = _PendingEvents._STATE_UNSCHEDULED;
+        if (oldState === _PendingEvents._STATE_CANCELED)
+          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 _IterablePendingEvents$ = dart.generic(function(T) {
     class _IterablePendingEvents extends _PendingEvents {
       _IterablePendingEvents(data) {
         this[_iterator] = data.iterator;
         super._PendingEvents();
       }
       get isEmpty() {
         return this[_iterator] === null;
       }
       handleNext(dispatch) {
@@ skipping 72 matching lines @@
     perform(dispatch) {
       dispatch._sendDone();
     }
     get next() {
       return null;
     }
     set next(_) {
       throw new core.StateError("No events after a done.");
     }
   }
-  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);
-    }
-    schedule(dispatch) {
-      if (this.isScheduled)
-        return;
-      dart.assert(!dart.notNull(this.isEmpty));
-      if (this[_eventScheduled]) {
-        dart.assert(this[_state] === _PendingEvents._STATE_CANCELED);
-        this[_state] = _PendingEvents._STATE_SCHEDULED;
-        return;
-      }
-      scheduleMicrotask((() => {
-        let oldState = this[_state];
-        this[_state] = _PendingEvents._STATE_UNSCHEDULED;
-        if (oldState === _PendingEvents._STATE_CANCELED)
-          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;
   class _StreamImplEvents extends _PendingEvents {
     _StreamImplEvents() {
       this.firstPendingEvent = null;
       this.lastPendingEvent = null;
       super._PendingEvents();
     }
     get isEmpty() {
       return this.lastPendingEvent === null;
     }
     add(event) {
@@ skipping 994 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 AsyncError extends core.Object {
-    AsyncError(error, stackTrace) {
-      this.error = error;
-      this.stackTrace = stackTrace;
-    }
-    toString() {
-      return dart.as(dart.dinvoke(this.error, 'toString'), core.String);
-    }
-  }
   class _ZoneFunction extends core.Object {
     _ZoneFunction(zone, function) {
       this.zone = zone;
       this['function'] = function;
     }
   }
   class ZoneSpecification extends core.Object {
     ZoneSpecification(opt$) {
       return new _ZoneSpecification(opt$);
     }
@@ skipping 721 matching lines @@
     } else {
       return zone.run(body);
     }
   }
   dart.copyProperties(exports, {
     get _hasDocument() {
       return dart.equals(typeof document, 'object');
     }
   });
   // Exports:
+  exports.AsyncError = AsyncError;
+  exports.Stream = Stream;
+  exports.Stream$ = Stream$;
   exports.DeferredLibrary = DeferredLibrary;
   exports.DeferredLoadException = DeferredLoadException;
   exports.Future = Future;
   exports.Future$ = Future$;
   exports.TimeoutException = TimeoutException;
   exports.Completer = Completer;
   exports.Completer$ = Completer$;
   exports.scheduleMicrotask = scheduleMicrotask;
-  exports.Stream = Stream;
-  exports.Stream$ = Stream$;
   exports.StreamSubscription = StreamSubscription;
   exports.StreamSubscription$ = StreamSubscription$;
   exports.EventSink = EventSink;
   exports.EventSink$ = EventSink$;
   exports.StreamView = StreamView;
   exports.StreamView$ = StreamView$;
   exports.StreamConsumer = StreamConsumer;
   exports.StreamConsumer$ = StreamConsumer$;
   exports.StreamSink = StreamSink;
   exports.StreamSink$ = StreamSink$;
   exports.StreamTransformer = StreamTransformer;
   exports.StreamTransformer$ = StreamTransformer$;
   exports.StreamIterator = StreamIterator;
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamController = StreamController;
   exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
-  exports.AsyncError = AsyncError;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));