Add constructors to signatures

lib/runtime/dart/async.js

 var async = dart.defineLibrary(async, {});
 var core = dart.import(core);
 var _internal = dart.import(_internal);
 var _js_helper = dart.lazyImport(_js_helper);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
 var collection = dart.import(collection);
 (function(exports, core, _internal, _js_helper, _isolate_helper, collection) {
   'use strict';
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
@@ skipping 14 matching lines @@
   class AsyncError extends core.Object {
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
     toString() {
       return dart.toString(this.error);
     }
   }
   AsyncError[dart.implements] = () => [core.Error];
+  dart.setSignature(AsyncError, {
+    constructors: () => ({AsyncError: [AsyncError, [core.Object, core.StackTrace]]})
+  });
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
       super.AsyncError(error, _UncaughtAsyncError._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 = dart.notNull(result) + `\nStack Trace:\n${this.stackTrace}`;
       }
       return result;
     }
   }
   dart.setSignature(_UncaughtAsyncError, {
+    constructors: () => ({_UncaughtAsyncError: [_UncaughtAsyncError, [core.Object, core.StackTrace]]}),
     statics: () => ({_getBestStackTrace: [core.StackTrace, [core.Object, core.StackTrace]]}),
     names: ['_getBestStackTrace']
   });
   let __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.Object, [dart.bottom]));
   let _add = Symbol('_add');
   let _closeUnchecked = Symbol('_closeUnchecked');
   let _addError = Symbol('_addError');
   let _completeError = Symbol('_completeError');
   let _complete = Symbol('_complete');
   let _sink = Symbol('_sink');
@@ skipping 646 matching lines @@
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.functionType(dart.void, [])));
         }), onCancel);
         return controller.stream;
       }
     }
     dart.defineNamedConstructor(Stream, 'fromFuture');
     dart.defineNamedConstructor(Stream, 'fromIterable');
     dart.defineNamedConstructor(Stream, 'periodic');
     dart.defineNamedConstructor(Stream, 'eventTransformed');
     dart.setSignature(Stream, {
+      constructors: () => ({
+        Stream: [Stream$(T), []],
+        fromFuture: [Stream$(T), [Future$(T)]],
+        fromIterable: [Stream$(T), [core.Iterable$(T)]],
+        periodic: [Stream$(T), [core.Duration], [dart.functionType(T, [core.int])]],
+        eventTransformed: [Stream$(T), [Stream$(), dart.functionType(EventSink, [EventSink$(T)])]]
+      }),
       methods: () => ({
         asBroadcastStream: [Stream$(T), [], {nListe: dart.functionType(dart.void, [StreamSubscription$(T)]), nCance: dart.functionType(dart.void, [StreamSubscription$(T)])}],
         where: [Stream$(T), [dart.functionType(core.bool, [T])]],
         map: [Stream$(), [dart.functionType(core.Object, [T])]],
         asyncMap: [Stream$(), [dart.functionType(core.Object, [T])]],
         asyncExpand: [Stream$(), [dart.functionType(Stream$(), [T])]],
         handleError: [Stream$(T), [core.Function], {es: dart.functionType(core.bool, [dart.bottom])}],
         expand: [Stream$(), [dart.functionType(core.Iterable, [T])]],
         pipe: [Future, [StreamConsumer$(T)]],
         transform: [Stream$(), [StreamTransformer$(T, core.Object)]],
@@ skipping 75 matching lines @@
       ['=='](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]);
       }
     }
     dart.setSignature(_ControllerStream, {
+      constructors: () => ({_ControllerStream: [_ControllerStream$(T), [_StreamControllerLifecycle$(T)]]}),
       methods: () => ({
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         '==': [core.bool, [core.Object]]
       })
     });
     return _ControllerStream;
   });
   let _ControllerStream = _ControllerStream$();
   let _BroadcastStream$ = dart.generic(function(T) {
     class _BroadcastStream extends _ControllerStream$(T) {
       _BroadcastStream(controller) {
         super._ControllerStream(dart.as(controller, _StreamControllerLifecycle$(T)));
       }
       get isBroadcast() {
         return true;
       }
     }
+    dart.setSignature(_BroadcastStream, {
+      constructors: () => ({_BroadcastStream: [_BroadcastStream$(T), [_StreamControllerLifecycle]]})
+    });
     return _BroadcastStream;
   });
   let _BroadcastStream = _BroadcastStream$();
   let _next = Symbol('_next');
   let _previous = Symbol('_previous');
   class _BroadcastSubscriptionLink extends core.Object {
     _BroadcastSubscriptionLink() {
       this[_next] = null;
       this[_previous] = null;
     }
@@ skipping 325 matching lines @@
           this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_BufferingStreamSubscription$()._STATE_IN_CALLBACK);
           wasInputPaused = isInputPaused;
         }
         if (dart.notNull(this[_hasPending]) && !dart.notNull(this[_isPaused])) {
           this[_pending].schedule(this);
         }
       }
     }
     _BufferingStreamSubscription[dart.implements] = () => [StreamSubscription$(T), _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_BufferingStreamSubscription, {
+      constructors: () => ({_BufferingStreamSubscription: [_BufferingStreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_setPendingEvents]: [dart.void, [_PendingEvents]],
         [_extractPending]: [_PendingEvents, []],
         onData: [dart.void, [dart.functionType(dart.void, [T])]],
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         cancel: [Future, []],
         asFuture: [Future, [], [core.Object]],
@@ skipping 29 matching lines @@
       [_onCancel]() {
         return this[_controller][_recordCancel](this);
       }
       [_onPause]() {
         this[_controller][_recordPause](this);
       }
       [_onResume]() {
         this[_controller][_recordResume](this);
       }
     }
+    dart.setSignature(_ControllerSubscription, {
+      constructors: () => ({_ControllerSubscription: [_ControllerSubscription$(T), [_StreamControllerLifecycle$(T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]})
+    });
     return _ControllerSubscription;
   });
   let _ControllerSubscription = _ControllerSubscription$();
   let _eventState = Symbol('_eventState');
   let _expectsEvent = Symbol('_expectsEvent');
   let _toggleEventId = Symbol('_toggleEventId');
   let _isFiring = Symbol('_isFiring');
   let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
   let _removeAfterFiring = Symbol('_removeAfterFiring');
   let _BroadcastSubscription$ = dart.generic(function(T) {
@@ skipping 22 matching lines @@
         this[_eventState] = dart.notNull(this[_eventState]) | dart.notNull(_BroadcastSubscription$()._STATE_REMOVE_AFTER_FIRING);
       }
       get [_removeAfterFiring]() {
         return (dart.notNull(this[_eventState]) & dart.notNull(_BroadcastSubscription$()._STATE_REMOVE_AFTER_FIRING)) != 0;
       }
       [_onPause]() {}
       [_onResume]() {}
     }
     _BroadcastSubscription[dart.implements] = () => [_BroadcastSubscriptionLink];
     dart.setSignature(_BroadcastSubscription, {
+      constructors: () => ({_BroadcastSubscription: [_BroadcastSubscription$(T), [_StreamControllerLifecycle, dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_expectsEvent]: [core.bool, [core.int]],
         [_toggleEventId]: [dart.void, []],
         [_setRemoveAfterFiring]: [dart.void, []]
       })
     });
     return _BroadcastSubscription;
   });
   let _BroadcastSubscription = _BroadcastSubscription$();
   _BroadcastSubscription._STATE_EVENT_ID = 1;
@@ skipping 214 matching lines @@
       [_callOnCancel]() {
         dart.assert(this[_isEmpty]);
         if (dart.notNull(this.isClosed) && dart.notNull(this[_doneFuture][_mayComplete])) {
           this[_doneFuture][_asyncComplete](null);
         }
         _runGuarded(this[_onCancel]);
       }
     }
     _BroadcastStreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _BroadcastSubscriptionLink, _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_BroadcastStreamController, {
+      constructors: () => ({_BroadcastStreamController: [_BroadcastStreamController$(T), [_NotificationHandler, _NotificationHandler]]}),
       methods: () => ({
         [_ensureDoneFuture]: [_Future, []],
         [_addListener]: [dart.void, [_BroadcastSubscription$(T)]],
         [_removeListener]: [dart.void, [_BroadcastSubscription$(T)]],
         [_subscribe]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         [_recordCancel]: [Future, [StreamSubscription$(T)]],
         [_recordPause]: [dart.void, [StreamSubscription$(T)]],
         [_recordResume]: [dart.void, [StreamSubscription$(T)]],
         [_addEventError]: [core.Error, []],
         add: [dart.void, [T]],
@@ skipping 54 matching lines @@
             subscription[_close]();
           }, core.Object, [_BroadcastSubscription$(T)]), __CastType2));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     dart.setSignature(_SyncBroadcastStreamController, {
+      constructors: () => ({_SyncBroadcastStreamController: [_SyncBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
   let _AsyncBroadcastStreamController$ = dart.generic(function(T) {
@@ skipping 21 matching lines @@
             subscription[_addPending](dart.const(new _DelayedDone()));
           }
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture][_asyncComplete](null);
         }
       }
     }
     dart.setSignature(_AsyncBroadcastStreamController, {
+      constructors: () => ({_AsyncBroadcastStreamController: [_AsyncBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
         [_sendData]: [dart.void, [T]],
         [_sendError]: [dart.void, [core.Object, core.StackTrace]],
         [_sendDone]: [dart.void, []]
       })
     });
     return _AsyncBroadcastStreamController;
   });
   let _AsyncBroadcastStreamController = _AsyncBroadcastStreamController$();
   let _addPendingEvent = Symbol('_addPendingEvent');
@@ skipping 50 matching lines @@
       [_callOnCancel]() {
         if (this[_hasPending]) {
           this[_pending].clear();
           this[_pending] = null;
         }
         super[_callOnCancel]();
       }
     }
     _AsBroadcastStreamController[dart.implements] = () => [_EventDispatch$(T)];
     dart.setSignature(_AsBroadcastStreamController, {
+      constructors: () => ({_AsBroadcastStreamController: [_AsBroadcastStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, [])]]}),
       methods: () => ({
         [_addPendingEvent]: [dart.void, [_DelayedEvent]],
         add: [dart.void, [T]]
       })
     });
     return _AsBroadcastStreamController;
   });
   let _AsBroadcastStreamController = _AsBroadcastStreamController$();
   let _pauseCount = Symbol('_pauseCount');
   let _resume = Symbol('_resume');
@@ skipping 61 matching lines @@
     DeferredLibrary(libraryName, opts) {
       let uri = opts && 'uri' in opts ? opts.uri : null;
       this.libraryName = libraryName;
       this.uri = uri;
     }
     load() {
       throw 'DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.';
     }
   }
   dart.setSignature(DeferredLibrary, {
+    constructors: () => ({DeferredLibrary: [DeferredLibrary, [core.String], {r: core.String}]}),
     methods: () => ({load: [Future$(core.Null), []]})
   });
   let _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
     DeferredLoadException(s) {
       this[_s] = s;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
   DeferredLoadException[dart.implements] = () => [core.Exception];
+  dart.setSignature(DeferredLoadException, {
+    constructors: () => ({DeferredLoadException: [DeferredLoadException, [core.String]]})
+  });
   let _completeWithValue = Symbol('_completeWithValue');
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new (_Future$(T))();
         Timer.run(dart.fn(() => {
           try {
             result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
@@ skipping 143 matching lines @@
         dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
     dart.defineNamedConstructor(Future, 'value');
     dart.defineNamedConstructor(Future, 'error');
     dart.defineNamedConstructor(Future, 'delayed');
     dart.setSignature(Future, {
+      constructors: () => ({
+        Future: [Future$(T), [dart.functionType(core.Object, [])]],
+        microtask: [Future$(T), [dart.functionType(core.Object, [])]],
+        sync: [Future$(T), [dart.functionType(core.Object, [])]],
+        value: [Future$(T), [], [core.Object]],
+        error: [Future$(T), [core.Object], [core.StackTrace]],
+        delayed: [Future$(T), [core.Duration], [dart.functionType(T, [])]]
+      }),
       statics: () => ({
         wait: [Future$(core.List), [core.Iterable$(Future$())], {agerErro: core.bool, leanU: dart.functionType(dart.void, [dart.bottom])}],
         forEach: [Future$(), [core.Iterable, dart.functionType(core.Object, [dart.bottom])]],
         doWhile: [Future$(), [dart.functionType(core.Object, [])]]
       }),
       names: ['wait', 'forEach', 'doWhile']
     });
     return Future;
   });
   let Future = Future$();
@@ skipping 12 matching lines @@
     toString() {
       let result = "TimeoutException";
       if (this.duration != null)
         result = `TimeoutException after ${this.duration}`;
       if (this.message != null)
         result = `${result}: ${this.message}`;
       return result;
     }
   }
   TimeoutException[dart.implements] = () => [core.Exception];
+  dart.setSignature(TimeoutException, {
+    constructors: () => ({TimeoutException: [TimeoutException, [core.String], [core.Duration]]})
+  });
   let Completer$ = dart.generic(function(T) {
     class Completer extends core.Object {
       Completer() {
         return new (_AsyncCompleter$(T))();
       }
       sync() {
         return new (_SyncCompleter$(T))();
       }
     }
     dart.defineNamedConstructor(Completer, 'sync');
+    dart.setSignature(Completer, {
+      constructors: () => ({
+        Completer: [Completer$(T), []],
+        sync: [Completer$(T), []]
+      })
+    });
     return Completer;
   });
   let Completer = Completer$();
   function _completeWithErrorCallback(result, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     result[_completeError](error, dart.as(stackTrace, core.StackTrace));
@@ skipping 152 matching lines @@
     }
     get [_whenCompleteAction]() {
       dart.assert(this.handlesComplete);
       return dart.as(this.callback, _FutureAction);
     }
   }
   dart.defineNamedConstructor(_FutureListener, 'then');
   dart.defineNamedConstructor(_FutureListener, 'catchError');
   dart.defineNamedConstructor(_FutureListener, 'whenComplete');
   dart.defineNamedConstructor(_FutureListener, 'chain');
+  dart.setSignature(_FutureListener, {
+    constructors: () => ({
+      then: [_FutureListener, [_Future, _FutureOnValue, core.Function]],
+      catchError: [_FutureListener, [_Future, core.Function, _FutureErrorTest]],
+      whenComplete: [_FutureListener, [_Future, _FutureAction]],
+      chain: [_FutureListener, [_Future]]
+    })
+  });
   _FutureListener.MASK_VALUE = 1;
   _FutureListener.MASK_ERROR = 2;
   _FutureListener.MASK_TEST_ERROR = 4;
   _FutureListener.MASK_WHENCOMPLETE = 8;
   _FutureListener.STATE_CHAIN = 0;
   _FutureListener.STATE_THEN = _FutureListener.MASK_VALUE;
   _FutureListener.STATE_THEN_ONERROR = dart.notNull(_FutureListener.MASK_VALUE) | dart.notNull(_FutureListener.MASK_ERROR);
   _FutureListener.STATE_CATCHERROR = _FutureListener.MASK_ERROR;
   _FutureListener.STATE_CATCHERROR_TEST = dart.notNull(_FutureListener.MASK_ERROR) | dart.notNull(_FutureListener.MASK_TEST_ERROR);
   _FutureListener.STATE_WHENCOMPLETE = _FutureListener.MASK_WHENCOMPLETE;
@@ skipping 424 matching lines @@
               result[_completeError](e, dart.as(s, core.StackTrace));
             }
           })});
         return result;
       }
     }
     _Future[dart.implements] = () => [Future$(T)];
     dart.defineNamedConstructor(_Future, 'immediate');
     dart.defineNamedConstructor(_Future, 'immediateError');
     dart.setSignature(_Future, {
+      constructors: () => ({
+        _Future: [_Future$(T), []],
+        immediate: [_Future$(T), [core.Object]],
+        immediateError: [_Future$(T), [core.Object], [core.StackTrace]]
+      }),
       methods: () => ({
         then: [Future, [dart.functionType(core.Object, [T])], {nErro: core.Function}],
         catchError: [Future, [core.Function], {es: dart.functionType(core.bool, [dart.bottom])}],
         whenComplete: [Future$(T), [dart.functionType(core.Object, [])]],
         asStream: [Stream$(T), []],
         [_markPendingCompletion]: [dart.void, []],
         [_setValue]: [dart.void, [T]],
         [_setErrorObject]: [dart.void, [AsyncError]],
         [_setError]: [dart.void, [core.Object, core.StackTrace]],
         [_addListener]: [dart.void, [_FutureListener]],
@@ skipping 27 matching lines @@
   let __CastType6 = __CastType6$();
   let __CastType8 = dart.typedef('__CastType8', () => dart.functionType(core.bool, [dart.bottom]));
   let __CastType10 = dart.typedef('__CastType10', () => dart.functionType(core.Object, [dart.bottom]));
   let _AsyncCallback = dart.typedef('_AsyncCallback', () => dart.functionType(dart.void, []));
   class _AsyncCallbackEntry extends core.Object {
     _AsyncCallbackEntry(callback) {
       this.callback = callback;
       this.next = null;
     }
   }
+  dart.setSignature(_AsyncCallbackEntry, {
+    constructors: () => ({_AsyncCallbackEntry: [_AsyncCallbackEntry, [_AsyncCallback]]})
+  });
   exports._nextCallback = null;
   exports._lastCallback = null;
   exports._lastPriorityCallback = null;
   exports._isInCallbackLoop = false;
   function _asyncRunCallbackLoop() {
     while (exports._nextCallback != null) {
       exports._lastPriorityCallback = null;
       let entry = exports._nextCallback;
       exports._nextCallback = entry.next;
       if (exports._nextCallback == null)
@@ skipping 157 matching lines @@
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         return this[_stream].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
       }
     }
     dart.setSignature(StreamView, {
+      constructors: () => ({StreamView: [StreamView$(T), [Stream$(T)]]}),
       methods: () => ({
         asBroadcastStream: [Stream$(T), [], {nListe: dart.functionType(dart.void, [StreamSubscription$(T)]), nCance: dart.functionType(dart.void, [StreamSubscription$(T)])}],
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}]
       })
     });
     return StreamView;
   });
   let StreamView = StreamView$();
   let StreamConsumer$ = dart.generic(function(S) {
     class StreamConsumer extends core.Object {}
     return StreamConsumer;
   });
   let StreamConsumer = StreamConsumer$();
   let StreamSink$ = dart.generic(function(S) {
     class StreamSink extends core.Object {}
     StreamSink[dart.implements] = () => [StreamConsumer$(S), EventSink$(S)];
     return StreamSink;
   });
   let StreamSink = StreamSink$();
   let StreamTransformer$ = dart.generic(function(S, T) {
     class StreamTransformer extends core.Object {
       StreamTransformer(transformer) {
         return new _StreamSubscriptionTransformer(transformer);
       }
       fromHandlers(opts) {
         return new _StreamHandlerTransformer(opts);
       }
     }
     dart.defineNamedConstructor(StreamTransformer, 'fromHandlers');
+    dart.setSignature(StreamTransformer, {
+      constructors: () => ({
+        StreamTransformer: [StreamTransformer$(S, T), [dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool])]],
+        fromHandlers: [StreamTransformer$(S, T), [], {andleDat: dart.functionType(dart.void, [S, EventSink$(T)]), andleErro: dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]), andleDon: dart.functionType(dart.void, [EventSink$(T)])}]
+      })
+    });
     return StreamTransformer;
   });
   let StreamTransformer = StreamTransformer$();
   let StreamIterator$ = dart.generic(function(T) {
     class StreamIterator extends core.Object {
       StreamIterator(stream) {
         return new (_StreamIteratorImpl$(T))(stream);
       }
     }
+    dart.setSignature(StreamIterator, {
+      constructors: () => ({StreamIterator: [StreamIterator$(T), [Stream$(T)]]})
+    });
     return StreamIterator;
   });
   let StreamIterator = StreamIterator$();
   let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
     class _ControllerEventSinkWrapper extends core.Object {
       _ControllerEventSinkWrapper(sink) {
         this[_sink] = sink;
       }
       add(data) {
         dart.as(data, T);
         this[_sink].add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_sink].addError(error, stackTrace);
       }
       close() {
         this[_sink].close();
       }
     }
     _ControllerEventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_ControllerEventSinkWrapper, {
+      constructors: () => ({_ControllerEventSinkWrapper: [_ControllerEventSinkWrapper$(T), [EventSink]]}),
       methods: () => ({
         add: [dart.void, [T]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _ControllerEventSinkWrapper;
   });
   let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$();
   let __CastType12 = dart.typedef('__CastType12', () => dart.functionType(dart.void, [StreamSubscription]));
@@ skipping 15 matching lines @@
       }
       broadcast(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         return sync ? new (_SyncBroadcastStreamController$(T))(onListen, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel);
       }
     }
     StreamController[dart.implements] = () => [StreamSink$(T)];
     dart.defineNamedConstructor(StreamController, 'broadcast');
+    dart.setSignature(StreamController, {
+      constructors: () => ({
+        StreamController: [StreamController$(T), [], {nListe: dart.functionType(dart.void, []), nPaus: dart.functionType(dart.void, []), nResum: dart.functionType(dart.void, []), nCance: dart.functionType(core.Object, []), yn: core.bool}],
+        broadcast: [StreamController$(T), [], {nListe: dart.functionType(dart.void, []), nCance: dart.functionType(dart.void, []), yn: core.bool}]
+      })
+    });
     return StreamController;
   });
   let StreamController = StreamController$();
   let _StreamControllerLifecycle$ = dart.generic(function(T) {
     class _StreamControllerLifecycle extends core.Object {
       [_recordPause](subscription) {
         dart.as(subscription, StreamSubscription$(T));
       }
       [_recordResume](subscription) {
         dart.as(subscription, StreamSubscription$(T));
@@ skipping 237 matching lines @@
         dart.as(subscription, StreamSubscription$(T));
         if (this[_isAddingStream]) {
           let addState = dart.as(this[_varData], _StreamControllerAddStreamState);
           addState.resume();
         }
         _runGuarded(this[_onResume]);
       }
     }
     _StreamController[dart.implements] = () => [StreamController$(T), _StreamControllerLifecycle$(T), _EventSink$(T), _EventDispatch$(T)];
     dart.setSignature(_StreamController, {
+      constructors: () => ({_StreamController: [_StreamController$(T), []]}),
       methods: () => ({
         [_ensurePendingEvents]: [_StreamImplEvents, []],
         [_badEventState]: [core.Error, []],
         addStream: [Future, [Stream$(T)], {ancelOnErro: core.bool}],
         [_ensureDoneFuture]: [Future, []],
         add: [dart.void, [T]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [Future, []],
         [_closeUnchecked]: [dart.void, []],
         [_add]: [dart.void, [T]],
@@ skipping 65 matching lines @@
   let _AsyncStreamController$ = dart.generic(function(T) {
     class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
       _AsyncStreamController(onListen, onPause, onResume, onCancel) {
         this[_onListen] = onListen;
         this[_onPause] = onPause;
         this[_onResume] = onResume;
         this[_onCancel] = onCancel;
         super._StreamController();
       }
     }
+    dart.setSignature(_AsyncStreamController, {
+      constructors: () => ({_AsyncStreamController: [_AsyncStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(core.Object, [])]]})
+    });
     return _AsyncStreamController;
   });
   let _AsyncStreamController = _AsyncStreamController$();
   let _SyncStreamController$ = dart.generic(function(T) {
     class _SyncStreamController extends dart.mixin(_StreamController$(T), _SyncStreamControllerDispatch$(T)) {
       _SyncStreamController(onListen, onPause, onResume, onCancel) {
         this[_onListen] = onListen;
         this[_onPause] = onPause;
         this[_onResume] = onResume;
         this[_onCancel] = onCancel;
         super._StreamController();
       }
     }
+    dart.setSignature(_SyncStreamController, {
+      constructors: () => ({_SyncStreamController: [_SyncStreamController$(T), [dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(dart.void, []), dart.functionType(core.Object, [])]]})
+    });
     return _SyncStreamController;
   });
   let _SyncStreamController = _SyncStreamController$();
   class _NoCallbacks extends core.Object {
     get [_onListen]() {
       return null;
     }
     get [_onPause]() {
       return null;
     }
@@ skipping 44 matching lines @@
         dart.as(source, Stream$(T));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         return this[_target].addStream(source, {cancelOnError: cancelOnError});
       }
       get done() {
         return this[_target].done;
       }
     }
     _StreamSinkWrapper[dart.implements] = () => [StreamSink$(T)];
     dart.setSignature(_StreamSinkWrapper, {
+      constructors: () => ({_StreamSinkWrapper: [_StreamSinkWrapper$(T), [StreamController]]}),
       methods: () => ({
         add: [dart.void, [T]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [Future, []],
         addStream: [Future, [Stream$(T)], {ancelOnErro: core.bool}]
       })
     });
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$();
@@ skipping 23 matching lines @@
         }
         return cancel.whenComplete(dart.fn((() => {
           this.addStreamFuture[_asyncComplete](null);
         }).bind(this)));
       }
       complete() {
         this.addStreamFuture[_asyncComplete](null);
       }
     }
     dart.setSignature(_AddStreamState, {
+      constructors: () => ({_AddStreamState: [_AddStreamState$(T), [_EventSink$(T), Stream, core.bool]]}),
       methods: () => ({
         pause: [dart.void, []],
         resume: [dart.void, []],
         cancel: [Future, []],
         complete: [dart.void, []]
       }),
       statics: () => ({makeErrorHandler: [core.Object, [_EventSink]]}),
       names: ['makeErrorHandler']
     });
     return _AddStreamState;
   });
   let _AddStreamState = _AddStreamState$();
   let _StreamControllerAddStreamState$ = dart.generic(function(T) {
     class _StreamControllerAddStreamState extends _AddStreamState$(T) {
       _StreamControllerAddStreamState(controller, varData, source, cancelOnError) {
         this.varData = varData;
         super._AddStreamState(dart.as(controller, _EventSink$(T)), source, cancelOnError);
         if (controller.isPaused) {
           this.addSubscription.pause();
         }
       }
     }
+    dart.setSignature(_StreamControllerAddStreamState, {
+      constructors: () => ({_StreamControllerAddStreamState: [_StreamControllerAddStreamState$(T), [_StreamController, core.Object, Stream, core.bool]]})
+    });
     return _StreamControllerAddStreamState;
   });
   let _StreamControllerAddStreamState = _StreamControllerAddStreamState$();
   let _EventSink$ = dart.generic(function(T) {
     class _EventSink extends core.Object {}
     return _EventSink;
   });
   let _EventSink = _EventSink$();
   let _EventDispatch$ = dart.generic(function(T) {
     class _EventDispatch extends core.Object {}
@@ skipping 24 matching lines @@
           throw new core.StateError("Stream has already been listened to.");
         this[_isUsed] = true;
         return dart.as((() => {
           let _ = new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
           _[_setPendingEvents](this[_pending]());
           return _;
         }).bind(this)(), StreamSubscription$(T));
       }
     }
     dart.setSignature(_GeneratedStreamImpl, {
+      constructors: () => ({_GeneratedStreamImpl: [_GeneratedStreamImpl$(T), [_EventGenerator]]}),
       methods: () => ({[_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]})
     });
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$();
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
     _PendingEvents() {
       this[_state] = _PendingEvents._STATE_UNSCHEDULED;
     }
@@ skipping 63 matching lines @@
           dispatch[_sendDone]();
         }
       }
       clear() {
         if (this.isScheduled)
           this.cancelSchedule();
         this[_iterator] = null;
       }
     }
     dart.setSignature(_IterablePendingEvents, {
+      constructors: () => ({_IterablePendingEvents: [_IterablePendingEvents$(T), [core.Iterable$(T)]]}),
       methods: () => ({
         handleNext: [dart.void, [_EventDispatch]],
         clear: [dart.void, []]
       })
     });
     return _IterablePendingEvents;
   });
   let _IterablePendingEvents = _IterablePendingEvents$();
   let _DataHandler$ = dart.generic(function(T) {
     let _DataHandler = dart.typedef('_DataHandler', () => dart.functionType(dart.void, [T]));
@@ skipping 27 matching lines @@
       _DelayedData(value) {
         this.value = value;
         super._DelayedEvent();
       }
       perform(dispatch) {
         dart.as(dispatch, _EventDispatch$(T));
         dispatch[_sendData](this.value);
       }
     }
     dart.setSignature(_DelayedData, {
+      constructors: () => ({_DelayedData: [_DelayedData$(T), [T]]}),
       methods: () => ({perform: [dart.void, [_EventDispatch$(T)]]})
     });
     return _DelayedData;
   });
   let _DelayedData = _DelayedData$();
   class _DelayedError extends _DelayedEvent {
     _DelayedError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
       super._DelayedEvent();
     }
     perform(dispatch) {
       dispatch[_sendError](this.error, this.stackTrace);
     }
   }
   dart.setSignature(_DelayedError, {
+    constructors: () => ({_DelayedError: [_DelayedError, [core.Object, core.StackTrace]]}),
     methods: () => ({perform: [dart.void, [_EventDispatch]]})
   });
   class _DelayedDone extends core.Object {
     _DelayedDone() {
     }
     perform(dispatch) {
       dispatch[_sendDone]();
     }
     get next() {
       return null;
     }
     set next(_) {
       throw new core.StateError("No events after a done.");
     }
   }
   _DelayedDone[dart.implements] = () => [_DelayedEvent];
   dart.setSignature(_DelayedDone, {
+    constructors: () => ({_DelayedDone: [_DelayedDone, []]}),
     methods: () => ({perform: [dart.void, [_EventDispatch]]})
   });
   _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();
@@ skipping 122 matching lines @@
         this[_state] = dart.notNull(this[_state]) & ~dart.notNull(_DoneStreamSubscription$()._SCHEDULED);
         if (this.isPaused)
           return;
         this[_state] = dart.notNull(this[_state]) | dart.notNull(_DoneStreamSubscription$()._DONE_SENT);
         if (this[_onDone] != null)
           this[_zone].runGuarded(this[_onDone]);
       }
     }
     _DoneStreamSubscription[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_DoneStreamSubscription, {
+      constructors: () => ({_DoneStreamSubscription: [_DoneStreamSubscription$(T), [_DoneHandler]]}),
       methods: () => ({
         [_schedule]: [dart.void, []],
         onData: [dart.void, [dart.functionType(dart.void, [T])]],
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         cancel: [Future, []],
         asFuture: [Future, [], [core.Object]],
         [_sendDone]: [dart.void, []]
@@ skipping 77 matching lines @@
           return;
         this[_subscription].resume();
       }
       get [_isSubscriptionPaused]() {
         if (this[_subscription] == null)
           return false;
         return this[_subscription].isPaused;
       }
     }
     dart.setSignature(_AsBroadcastStream, {
+      constructors: () => ({_AsBroadcastStream: [_AsBroadcastStream$(T), [Stream$(T), dart.functionType(dart.void, [StreamSubscription]), dart.functionType(dart.void, [StreamSubscription])]]}),
       methods: () => ({
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}],
         [_onCancel]: [dart.void, []],
         [_onListen]: [dart.void, []],
         [_cancelSubscription]: [dart.void, []],
         [_pauseSubscription]: [dart.void, [Future]],
         [_resumeSubscription]: [dart.void, []]
       })
     });
     return _AsBroadcastStream;
@@ skipping 31 matching lines @@
         return this[_stream][_isSubscriptionPaused];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
     }
     _BroadcastSubscriptionWrapper[dart.implements] = () => [StreamSubscription$(T)];
     dart.setSignature(_BroadcastSubscriptionWrapper, {
+      constructors: () => ({_BroadcastSubscriptionWrapper: [_BroadcastSubscriptionWrapper$(T), [_AsBroadcastStream]]}),
       methods: () => ({
         onData: [dart.void, [dart.functionType(dart.void, [T])]],
         onError: [dart.void, [core.Function]],
         onDone: [dart.void, [dart.functionType(dart.void, [])]],
         pause: [dart.void, [], [Future]],
         resume: [dart.void, []],
         cancel: [Future, []],
         asFuture: [Future, [], [core.Object]]
       })
     });
@@ skipping 105 matching lines @@
           hasNext[_complete](false);
           return;
         }
         this[_subscription].pause();
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl$()._STATE_EXTRA_DONE;
       }
     }
     _StreamIteratorImpl[dart.implements] = () => [StreamIterator$(T)];
     dart.setSignature(_StreamIteratorImpl, {
+      constructors: () => ({_StreamIteratorImpl: [_StreamIteratorImpl$(T), [Stream$(T)]]}),
       methods: () => ({
         moveNext: [Future$(core.bool), []],
         [_clear]: [dart.void, []],
         cancel: [Future, []],
         [_onData]: [dart.void, [T]],
         [_onError]: [dart.void, [core.Object], [core.StackTrace]],
         [_onDone]: [dart.void, []]
       })
     });
     return _StreamIteratorImpl;
@@ skipping 95 matching lines @@
       [_handleError](error, stackTrace, sink) {
         dart.as(sink, _EventSink$(T));
         sink[_addError](error, stackTrace);
       }
       [_handleDone](sink) {
         dart.as(sink, _EventSink$(T));
         sink[_close]();
       }
     }
     dart.setSignature(_ForwardingStream, {
+      constructors: () => ({_ForwardingStream: [_ForwardingStream$(S, T), [Stream$(S)]]}),
       methods: () => ({
         listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}],
         [_createSubscription]: [StreamSubscription$(T), [dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]],
         [_handleData]: [dart.void, [S, _EventSink$(T)]],
         [_handleError]: [dart.void, [core.Object, core.StackTrace, _EventSink$(T)]],
         [_handleDone]: [dart.void, [_EventSink$(T)]]
       })
     });
     return _ForwardingStream;
   });
@@ skipping 40 matching lines @@
         this[_stream][_handleData](data, this);
       }
       [_handleError](error, stackTrace) {
         this[_stream][_handleError](error, stackTrace, this);
       }
       [_handleDone]() {
         this[_stream][_handleDone](this);
       }
     }
     dart.setSignature(_ForwardingStreamSubscription, {
+      constructors: () => ({_ForwardingStreamSubscription: [_ForwardingStreamSubscription$(S, T), [_ForwardingStream$(S, T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
         [_handleError]: [dart.void, [core.Object, core.StackTrace]],
         [_handleDone]: [dart.void, []]
       })
     });
     return _ForwardingStreamSubscription;
   });
   let _ForwardingStreamSubscription = _ForwardingStreamSubscription$();
@@ skipping 29 matching lines @@
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         if (satisfies) {
           sink[_add](inputEvent);
         }
       }
     }
     dart.setSignature(_WhereStream, {
+      constructors: () => ({_WhereStream: [_WhereStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _WhereStream;
   });
   let _WhereStream = _WhereStream$();
   let _Transformation$ = dart.generic(function(S, T) {
     let _Transformation = dart.typedef('_Transformation', () => dart.functionType(T, [S]));
     return _Transformation;
   });
   let _Transformation = _Transformation$();
@@ skipping 13 matching lines @@
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
           return;
         }
 
         sink[_add](outputEvent);
       }
     }
     dart.setSignature(_MapStream, {
+      constructors: () => ({_MapStream: [_MapStream$(S, T), [Stream$(S), dart.functionType(T, [S])]]}),
       methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
     });
     return _MapStream;
   });
   let _MapStream = _MapStream$();
   let _expand = Symbol('_expand');
   let _ExpandStream$ = dart.generic(function(S, T) {
     class _ExpandStream extends _ForwardingStream$(S, T) {
       _ExpandStream(source, expand) {
         this[_expand] = expand;
         super._ForwardingStream(source);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, S);
         dart.as(sink, _EventSink$(T));
         try {
           for (let value of this[_expand](inputEvent)) {
             sink[_add](value);
           }
         } catch (e) {
           let s = dart.stackTrace(e);
           _addErrorWithReplacement(sink, e, s);
         }
 
       }
     }
     dart.setSignature(_ExpandStream, {
+      constructors: () => ({_ExpandStream: [_ExpandStream$(S, T), [Stream$(S), dart.functionType(core.Iterable$(T), [S])]]}),
       methods: () => ({[_handleData]: [dart.void, [S, _EventSink$(T)]]})
     });
     return _ExpandStream;
   });
   let _ExpandStream = _ExpandStream$();
   let _ErrorTest = dart.typedef('_ErrorTest', () => dart.functionType(core.bool, [dart.bottom]));
   let _HandleErrorStream$ = dart.generic(function(T) {
     class _HandleErrorStream extends _ForwardingStream$(T, T) {
       _HandleErrorStream(source, onError, test) {
         this[_transform] = onError;
@@ skipping 25 matching lines @@
             }
             return;
           }
 
         } else {
           sink[_addError](error, stackTrace);
         }
       }
     }
     dart.setSignature(_HandleErrorStream, {
+      constructors: () => ({_HandleErrorStream: [_HandleErrorStream$(T), [Stream$(T), core.Function, dart.functionType(core.bool, [dart.bottom])]]}),
       methods: () => ({[_handleError]: [dart.void, [core.Object, core.StackTrace, _EventSink$(T)]]})
     });
     return _HandleErrorStream;
   });
   let _HandleErrorStream = _HandleErrorStream$();
   let _remaining = Symbol('_remaining');
   let _TakeStream$ = dart.generic(function(T) {
     class _TakeStream extends _ForwardingStream$(T, T) {
       _TakeStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number'))
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
           sink[_add](inputEvent);
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           if (this[_remaining] == 0) {
             sink[_close]();
           }
         }
       }
     }
     dart.setSignature(_TakeStream, {
+      constructors: () => ({_TakeStream: [_TakeStream$(T), [Stream$(T), core.int]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _TakeStream;
   });
   let _TakeStream = _TakeStream$();
   let _TakeWhileStream$ = dart.generic(function(T) {
     class _TakeWhileStream extends _ForwardingStream$(T, T) {
       _TakeWhileStream(source, test) {
         this[_test] = test;
         super._ForwardingStream(source);
@@ skipping 12 matching lines @@
         }
 
         if (satisfies) {
           sink[_add](inputEvent);
         } else {
           sink[_close]();
         }
       }
     }
     dart.setSignature(_TakeWhileStream, {
+      constructors: () => ({_TakeWhileStream: [_TakeWhileStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _TakeWhileStream;
   });
   let _TakeWhileStream = _TakeWhileStream$();
   let _SkipStream$ = dart.generic(function(T) {
     class _SkipStream extends _ForwardingStream$(T, T) {
       _SkipStream(source, count) {
         this[_remaining] = count;
         super._ForwardingStream(source);
         if (!(typeof count == 'number') || dart.notNull(count) < 0)
           throw new core.ArgumentError(count);
       }
       [_handleData](inputEvent, sink) {
         dart.as(inputEvent, T);
         dart.as(sink, _EventSink$(T));
         if (dart.notNull(this[_remaining]) > 0) {
           this[_remaining] = dart.notNull(this[_remaining]) - 1;
           return;
         }
         sink[_add](inputEvent);
       }
     }
     dart.setSignature(_SkipStream, {
+      constructors: () => ({_SkipStream: [_SkipStream$(T), [Stream$(T), core.int]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _SkipStream;
   });
   let _SkipStream = _SkipStream$();
   let _hasFailed = Symbol('_hasFailed');
   let _SkipWhileStream$ = dart.generic(function(T) {
     class _SkipWhileStream extends _ForwardingStream$(T, T) {
       _SkipWhileStream(source, test) {
         this[_test] = test;
@@ skipping 17 matching lines @@
           return;
         }
 
         if (!dart.notNull(satisfies)) {
           this[_hasFailed] = true;
           sink[_add](inputEvent);
         }
       }
     }
     dart.setSignature(_SkipWhileStream, {
+      constructors: () => ({_SkipWhileStream: [_SkipWhileStream$(T), [Stream$(T), dart.functionType(core.bool, [T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _SkipWhileStream;
   });
   let _SkipWhileStream = _SkipWhileStream$();
   let _Equality$ = dart.generic(function(T) {
     let _Equality = dart.typedef('_Equality', () => dart.functionType(core.bool, [T, T]));
     return _Equality;
   });
   let _Equality = _Equality$();
@@ skipping 26 matching lines @@
           }
 
           if (!dart.notNull(isEqual)) {
             sink[_add](inputEvent);
             this[_previous] = inputEvent;
           }
         }
       }
     }
     dart.setSignature(_DistinctStream, {
+      constructors: () => ({_DistinctStream: [_DistinctStream$(T), [Stream$(T), dart.functionType(core.bool, [T, T])]]}),
       methods: () => ({[_handleData]: [dart.void, [T, _EventSink$(T)]]})
     });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$();
   dart.defineLazyProperties(_DistinctStream, {
     get _SENTINEL() {
       return new core.Object();
     },
     set _SENTINEL(_) {}
@@ skipping 11 matching lines @@
         if (stackTrace === void 0)
           stackTrace = null;
         this[_sink][_addError](error, stackTrace);
       }
       close() {
         this[_sink][_close]();
       }
     }
     _EventSinkWrapper[dart.implements] = () => [EventSink$(T)];
     dart.setSignature(_EventSinkWrapper, {
+      constructors: () => ({_EventSinkWrapper: [_EventSinkWrapper$(T), [_EventSink]]}),
       methods: () => ({
         add: [dart.void, [T]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _EventSinkWrapper;
   });
   let _EventSinkWrapper = _EventSinkWrapper$();
   let _transformerSink = Symbol('_transformerSink');
@@ skipping 76 matching lines @@
           this[_subscription] = null;
           this[_transformerSink].close();
         } catch (e) {
           let s = dart.stackTrace(e);
           this[_addError](e, s);
         }
 
       }
     }
     dart.setSignature(_SinkTransformerStreamSubscription, {
+      constructors: () => ({_SinkTransformerStreamSubscription: [_SinkTransformerStreamSubscription$(S, T), [Stream$(S), _SinkMapper$(S, T), dart.functionType(dart.void, [T]), core.Function, dart.functionType(dart.void, []), core.bool]]}),
       methods: () => ({
         [_add]: [dart.void, [T]],
         [_handleData]: [dart.void, [S]],
         [_handleError]: [dart.void, [core.Object], [core.Object]],
         [_handleDone]: [dart.void, []]
       })
     });
     return _SinkTransformerStreamSubscription;
   });
   let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$();
   let _SinkMapper$ = dart.generic(function(S, T) {
     let _SinkMapper = dart.typedef('_SinkMapper', () => dart.functionType(EventSink$(S), [EventSink$(T)]));
     return _SinkMapper;
   });
   let _SinkMapper = _SinkMapper$();
   let _sinkMapper = Symbol('_sinkMapper');
   let _StreamSinkTransformer$ = dart.generic(function(S, T) {
     class _StreamSinkTransformer extends core.Object {
       _StreamSinkTransformer(sinkMapper) {
         this[_sinkMapper] = sinkMapper;
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return new (_BoundSinkStream$(S, T))(stream, this[_sinkMapper]);
       }
     }
     _StreamSinkTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     dart.setSignature(_StreamSinkTransformer, {
+      constructors: () => ({_StreamSinkTransformer: [_StreamSinkTransformer$(S, T), [_SinkMapper$(S, T)]]}),
       methods: () => ({bind: [Stream$(T), [Stream$(S)]]})
     });
     return _StreamSinkTransformer;
   });
   let _StreamSinkTransformer = _StreamSinkTransformer$();
   let _BoundSinkStream$ = dart.generic(function(S, T) {
     class _BoundSinkStream extends Stream$(T) {
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
       _BoundSinkStream(stream, sinkMapper) {
         this[_stream] = stream;
         this[_sinkMapper] = sinkMapper;
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let subscription = new (_SinkTransformerStreamSubscription$(core.Object, T))(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     dart.setSignature(_BoundSinkStream, {
+      constructors: () => ({_BoundSinkStream: [_BoundSinkStream$(S, T), [Stream$(S), _SinkMapper$(S, T)]]}),
       methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}]})
     });
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$();
   let _TransformDataHandler$ = dart.generic(function(S, T) {
     let _TransformDataHandler = dart.typedef('_TransformDataHandler', () => dart.functionType(dart.void, [S, EventSink$(T)]));
     return _TransformDataHandler;
   });
   let _TransformDataHandler = _TransformDataHandler$();
@@ skipping 23 matching lines @@
         if (stackTrace === void 0)
           stackTrace = null;
         return this[_handleError](error, stackTrace, this[_sink]);
       }
       close() {
         return this[_handleDone](this[_sink]);
       }
     }
     _HandlerEventSink[dart.implements] = () => [EventSink$(S)];
     dart.setSignature(_HandlerEventSink, {
+      constructors: () => ({_HandlerEventSink: [_HandlerEventSink$(S, T), [_TransformDataHandler$(S, T), _TransformErrorHandler$(T), _TransformDoneHandler$(T), EventSink$(T)]]}),
       methods: () => ({
         add: [dart.void, [S]],
         addError: [dart.void, [core.Object], [core.StackTrace]],
         close: [dart.void, []]
       })
     });
     return _HandlerEventSink;
   });
   let _HandlerEventSink = _HandlerEventSink$();
   let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
@@ skipping 21 matching lines @@
         sink.add(data);
       }
       static _defaultHandleError(error, stackTrace, sink) {
         sink.addError(error);
       }
       static _defaultHandleDone(sink) {
         sink.close();
       }
     }
     dart.setSignature(_StreamHandlerTransformer, {
+      constructors: () => ({_StreamHandlerTransformer: [_StreamHandlerTransformer$(S, T), [], {andleDat: dart.functionType(dart.void, [S, EventSink$(T)]), andleErro: dart.functionType(dart.void, [core.Object, core.StackTrace, EventSink$(T)]), andleDon: dart.functionType(dart.void, [EventSink$(T)])}]}),
       methods: () => ({bind: [Stream$(T), [Stream$(S)]]}),
       statics: () => ({
         _defaultHandleData: [dart.void, [core.Object, EventSink]],
         _defaultHandleError: [dart.void, [core.Object, core.StackTrace, EventSink]],
         _defaultHandleDone: [dart.void, [EventSink]]
       }),
       names: ['_defaultHandleData', '_defaultHandleError', '_defaultHandleDone']
     });
     return _StreamHandlerTransformer;
   });
   let _StreamHandlerTransformer = _StreamHandlerTransformer$();
   let _SubscriptionTransformer$ = dart.generic(function(S, T) {
     let _SubscriptionTransformer = dart.typedef('_SubscriptionTransformer', () => dart.functionType(StreamSubscription$(T), [Stream$(S), core.bool]));
     return _SubscriptionTransformer;
   });
   let _SubscriptionTransformer = _SubscriptionTransformer$();
   let _transformer = Symbol('_transformer');
   let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
     class _StreamSubscriptionTransformer extends core.Object {
       _StreamSubscriptionTransformer(transformer) {
         this[_transformer] = transformer;
       }
       bind(stream) {
         dart.as(stream, Stream$(S));
         return new (_BoundSubscriptionStream$(S, T))(stream, this[_transformer]);
       }
     }
     _StreamSubscriptionTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     dart.setSignature(_StreamSubscriptionTransformer, {
+      constructors: () => ({_StreamSubscriptionTransformer: [_StreamSubscriptionTransformer$(S, T), [_SubscriptionTransformer$(S, T)]]}),
       methods: () => ({bind: [Stream$(T), [Stream$(S)]]})
     });
     return _StreamSubscriptionTransformer;
   });
   let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$();
   let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
     class _BoundSubscriptionStream extends Stream$(T) {
       _BoundSubscriptionStream(stream, transformer) {
         this[_stream] = stream;
         this[_transformer] = transformer;
         super.Stream();
       }
       listen(onData, opts) {
         dart.as(onData, dart.functionType(dart.void, [T]));
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         dart.as(onDone, dart.functionType(dart.void, []));
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let result = this[_transformer](this[_stream], cancelOnError);
         result.onData(onData);
         result.onError(onError);
         result.onDone(onDone);
         return result;
       }
     }
     dart.setSignature(_BoundSubscriptionStream, {
+      constructors: () => ({_BoundSubscriptionStream: [_BoundSubscriptionStream$(S, T), [Stream$(S), _SubscriptionTransformer$(S, T)]]}),
       methods: () => ({listen: [StreamSubscription$(T), [dart.functionType(dart.void, [T])], {nErro: core.Function, nDon: dart.functionType(dart.void, []), ancelOnErro: core.bool}]})
     });
     return _BoundSubscriptionStream;
   });
   let _BoundSubscriptionStream = _BoundSubscriptionStream$();
   let __CastType27$ = dart.generic(function(S, T) {
     let __CastType27 = dart.typedef('__CastType27', () => dart.functionType(dart.void, [S, EventSink$(T)]));
     return __CastType27;
   });
   let __CastType27 = __CastType27$();
@@ skipping 26 matching lines @@
     }
     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');
   dart.setSignature(Timer, {
+    constructors: () => ({
+      Timer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
+      periodic: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
+    }),
     statics: () => ({
       run: [dart.void, [dart.functionType(dart.void, [])]],
       _createTimer: [Timer, [core.Duration, dart.functionType(dart.void, [])]],
       _createPeriodicTimer: [Timer, [core.Duration, dart.functionType(dart.void, [Timer])]]
     }),
     names: ['run', '_createTimer', '_createPeriodicTimer']
   });
   let __CastType34 = dart.typedef('__CastType34', () => dart.functionType(dart.void, [Timer]));
   let ZoneCallback = dart.typedef('ZoneCallback', () => dart.functionType(core.Object, []));
   let ZoneUnaryCallback = dart.typedef('ZoneUnaryCallback', () => dart.functionType(core.Object, [dart.bottom]));
@@ skipping 10 matching lines @@
   let CreateTimerHandler = dart.typedef('CreateTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]));
   let CreatePeriodicTimerHandler = dart.typedef('CreatePeriodicTimerHandler', () => dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]));
   let PrintHandler = dart.typedef('PrintHandler', () => dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]));
   let ForkHandler = dart.typedef('ForkHandler', () => dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map]));
   class _ZoneFunction extends core.Object {
     _ZoneFunction(zone, func) {
       this.zone = zone;
       this.function = func;
     }
   }
+  dart.setSignature(_ZoneFunction, {
+    constructors: () => ({_ZoneFunction: [_ZoneFunction, [_Zone, core.Function]]})
+  });
   class ZoneSpecification extends core.Object {
     ZoneSpecification(opts) {
       return new _ZoneSpecification(opts);
     }
     from(other, opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
       let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
       let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
       let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.scheduleMicrotask : null;
       let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
       let createPeriodicTimer = opts && 'createPeriodicTimer' in opts ? opts.createPeriodicTimer : null;
       let print = opts && 'print' in opts ? opts.print : null;
       let fork = opts && 'fork' in opts ? opts.fork : null;
       return new ZoneSpecification({handleUncaughtError: handleUncaughtError != null ? handleUncaughtError : other.handleUncaughtError, run: run != null ? run : other.run, runUnary: runUnary != null ? runUnary : other.runUnary, runBinary: runBinary != null ? runBinary : other.runBinary, registerCallback: registerCallback != null ? registerCallback : other.registerCallback, registerUnaryCallback: registerUnaryCallback != null ? registerUnaryCallback : other.registerUnaryCallback, registerBinaryCallback: registerBinaryCallback != null ? registerBinaryCallback : other.registerBinaryCallback, errorCallback: errorCallback != null ? errorCallback : other.errorCallback, scheduleMicrotask: scheduleMicrotask != null ? scheduleMicrotask : other.scheduleMicrotask, createTimer: createTimer != null ? createTimer : other.createTimer, createPeriodicTimer: createPeriodicTimer != null ? createPeriodicTimer : other.createPeriodicTimer, print: print != null ? print : other.print, fork: fork != null ? fork : other.fork});
     }
   }
   dart.defineNamedConstructor(ZoneSpecification, 'from');
+  dart.setSignature(ZoneSpecification, {
+    constructors: () => ({
+      ZoneSpecification: [ZoneSpecification, [], {andleUncaughtErro: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.bottom, core.StackTrace]), u: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), unUnar: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom]), dart.bottom]), unBinar: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom]), dart.bottom, dart.bottom]), egisterCallbac: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), egisterUnaryCallbac: dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom])]), egisterBinaryCallbac: dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom])]), rrorCallbac: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]), cheduleMicrotas: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), reateTime: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]), reatePeriodicTime: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]), rin: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]), or: dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map])}],
+      from: [ZoneSpecification, [ZoneSpecification], {andleUncaughtErro: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.bottom, core.StackTrace]), u: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), unUnar: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom]), dart.bottom]), unBinar: dart.functionType(core.Object, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom]), dart.bottom, dart.bottom]), egisterCallbac: dart.functionType(ZoneCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), egisterUnaryCallbac: dart.functionType(ZoneUnaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom])]), egisterBinaryCallbac: dart.functionType(ZoneBinaryCallback, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom])]), rrorCallbac: dart.functionType(AsyncError, [Zone, ZoneDelegate, Zone, core.Object, core.StackTrace]), cheduleMicrotas: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, dart.functionType(core.Object, [])]), reateTime: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [])]), reatePeriodicTime: dart.functionType(Timer, [Zone, ZoneDelegate, Zone, core.Duration, dart.functionType(dart.void, [Timer])]), rin: dart.functionType(dart.void, [Zone, ZoneDelegate, Zone, core.String]), or: dart.functionType(Zone, [Zone, ZoneDelegate, Zone, ZoneSpecification, core.Map])}]
+    })
+  });
   class _ZoneSpecification extends core.Object {
     _ZoneSpecification(opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
       let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
       let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
@@ skipping 11 matching lines @@
       this.registerBinaryCallback = registerBinaryCallback;
       this.errorCallback = errorCallback;
       this.scheduleMicrotask = scheduleMicrotask;
       this.createTimer = createTimer;
       this.createPeriodicTimer = createPeriodicTimer;
       this.print = print;
       this.fork = fork;
     }
   }
   _ZoneSpecification[dart.implements] = () => [ZoneSpecification];
+  dart.setSignature(_ZoneSpecification, {
+    constructors: () => ({_ZoneSpecification: [_ZoneSpecification, [], {andleUncaughtErro: core.Object, u: core.Object, unUnar: core.Object, unBinar: core.Object, egisterCallbac: core.Object, egisterUnaryCallbac: core.Object, egisterBinaryCallbac: core.Object, rrorCallbac: core.Object, cheduleMicrotas: core.Object, reateTime: core.Object, reatePeriodicTime: core.Object, rin: core.Object, or: core.Object}]})
+  });
   class ZoneDelegate extends core.Object {}
   class Zone extends core.Object {
     _() {
     }
     static get current() {
       return Zone._current;
     }
     static _enter(zone) {
       dart.assert(zone != null);
       dart.assert(!dart.notNull(core.identical(zone, Zone._current)));
       let previous = Zone._current;
       Zone._current = zone;
       return previous;
     }
     static _leave(previous) {
       dart.assert(previous != null);
       Zone._current = previous;
     }
   }
   dart.defineNamedConstructor(Zone, '_');
   dart.setSignature(Zone, {
+    constructors: () => ({_: [Zone, []]}),
     statics: () => ({
       _enter: [Zone, [Zone]],
       _leave: [dart.void, [Zone]]
     }),
     names: ['_enter', '_leave']
   });
   class _Zone extends core.Object {
     _Zone() {
     }
     inSameErrorZone(otherZone) {
       return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
     }
   }
   _Zone[dart.implements] = () => [Zone];
   dart.setSignature(_Zone, {
+    constructors: () => ({_Zone: [_Zone, []]}),
     methods: () => ({inSameErrorZone: [core.bool, [Zone]]})
   });
   let _run = Symbol('_run');
   let _runUnary = Symbol('_runUnary');
   let _runBinary = Symbol('_runBinary');
   let _registerCallback = Symbol('_registerCallback');
   let _registerUnaryCallback = Symbol('_registerUnaryCallback');
   let _registerBinaryCallback = Symbol('_registerBinaryCallback');
   let _errorCallback = Symbol('_errorCallback');
   let _scheduleMicrotask = Symbol('_scheduleMicrotask');
@@ skipping 166 matching lines @@
       return Timer._createTimer(duration, f);
     }
     createPeriodicTimer(duration, f) {
       return Timer._createPeriodicTimer(duration, f);
     }
     print(line) {
       _internal.printToConsole(line);
     }
   }
   dart.setSignature(_RootZone, {
+    constructors: () => ({_RootZone: [_RootZone, []]}),
     methods: () => ({
       runGuarded: [core.Object, [dart.functionType(core.Object, [])]],
       runUnaryGuarded: [core.Object, [dart.functionType(core.Object, [dart.bottom]), core.Object]],
       runBinaryGuarded: [core.Object, [dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]],
       bindCallback: [ZoneCallback, [dart.functionType(core.Object, [])], {unGuarde: core.bool}],
       bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(core.Object, [dart.bottom])], {unGuarde: core.bool}],
       bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(core.Object, [dart.bottom, dart.bottom])], {unGuarde: core.bool}],
       get: [core.Object, [core.Object]],
       handleUncaughtError: [core.Object, [core.Object, core.StackTrace]],
       fork: [Zone, [], {pecificatio: ZoneSpecification, oneValue: core.Map}],
@@ skipping 87 matching lines @@
       dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, line);
     }
     fork(zone, specification, zoneValues) {
       let implementation = this[_delegationTarget][_fork];
       let implZone = implementation.zone;
       return dart.as(dart.dcall(implementation.function, implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
     }
   }
   _ZoneDelegate[dart.implements] = () => [ZoneDelegate];
   dart.setSignature(_ZoneDelegate, {
+    constructors: () => ({_ZoneDelegate: [_ZoneDelegate, [_Zone]]}),
     methods: () => ({
       handleUncaughtError: [core.Object, [Zone, core.Object, core.StackTrace]],
       run: [core.Object, [Zone, dart.functionType(core.Object, [])]],
       runUnary: [core.Object, [Zone, dart.functionType(core.Object, [dart.bottom]), core.Object]],
       runBinary: [core.Object, [Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]],
       registerCallback: [ZoneCallback, [Zone, dart.functionType(core.Object, [])]],
       registerUnaryCallback: [ZoneUnaryCallback, [Zone, dart.functionType(core.Object, [dart.bottom])]],
       registerBinaryCallback: [ZoneBinaryCallback, [Zone, dart.functionType(core.Object, [dart.bottom, dart.bottom])]],
       errorCallback: [AsyncError, [Zone, core.Object, core.StackTrace]],
       scheduleMicrotask: [dart.void, [Zone, dart.functionType(core.Object, [])]],
@@ skipping 192 matching lines @@
       return dart.as(dart.dcall(implementation.function, implementation.zone, parentDelegate, this, duration, f), Timer);
     }
     print(line) {
       let implementation = this[_print];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
       return dart.dcall(implementation.function, implementation.zone, parentDelegate, this, line);
     }
   }
   dart.setSignature(_CustomZone, {
+    constructors: () => ({_CustomZone: [_CustomZone, [_Zone, ZoneSpecification, core.Map]]}),
     methods: () => ({
       runGuarded: [core.Object, [dart.functionType(core.Object, [])]],
       runUnaryGuarded: [core.Object, [dart.functionType(core.Object, [dart.bottom]), core.Object]],
       runBinaryGuarded: [core.Object, [dart.functionType(core.Object, [dart.bottom, dart.bottom]), core.Object, core.Object]],
       bindCallback: [ZoneCallback, [dart.functionType(core.Object, [])], {unGuarde: core.bool}],
       bindUnaryCallback: [ZoneUnaryCallback, [dart.functionType(core.Object, [dart.bottom])], {unGuarde: core.bool}],
       bindBinaryCallback: [ZoneBinaryCallback, [dart.functionType(core.Object, [dart.bottom, dart.bottom])], {unGuarde: core.bool}],
       get: [core.Object, [core.Object]],
       handleUncaughtError: [core.Object, [core.Object, core.StackTrace]],
       fork: [Zone, [], {pecificatio: ZoneSpecification, oneValue: core.Map}],
@@ skipping 250 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async, core, _internal, _js_helper, _isolate_helper, collection);