more care around generated names, fixes #60 #82 and #97

lib/runtime/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
   }
   // Function _registerErrorHandler: (Function, Zone) → Function
   function _registerErrorHandler(errorHandler, zone) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return zone.registerBinaryCallback(errorHandler);
     } else {
       return zone.registerUnaryCallback(dart.as(errorHandler, dart.throw_("Unimplemented type (dynamic) → dynamic")));
     }
   }
-  let _getBestStackTrace = Symbol('_getBestStackTrace');
+  let _getBestStackTrace$ = Symbol('_getBestStackTrace');
   class AsyncError extends core.Object {
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
     toString() {
       return dart.as(dart.dinvoke(this.error, 'toString'), core.String);
     }
   }
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
       super.AsyncError(error, _getBestStackTrace(error, stackTrace));
     }
-    static [_getBestStackTrace](error, stackTrace) {
+    static [_getBestStackTrace$](error, stackTrace) {
       if (stackTrace !== null)
         return stackTrace;
       if (dart.is(error, core.Error)) {
         return dart.as(dart.dload(error, 'stackTrace'), core.StackTrace);
       }
       return null;
     }
     toString() {
       let result = `Uncaught Error: ${this.error}`;
       if (this.stackTrace !== null) {
@@ skipping 32 matching lines @@
           computation = null;
         if (computation === null)
           computation = dart.closureWrap((i) => null, "(int) → T");
         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));
+          let data = computation(((x) => computationCount = dart.notNull(x$) + 1, x$)(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: (() => {
@@ skipping 18 matching lines @@
             timer = null;
           }).bind(this)});
         return controller.stream;
       }
       Stream$eventTransformed(source, mapSink) {
         return dart.as(new _BoundSinkStream(source, dart.closureWrap(mapSink, "(EventSink<dynamic>) → EventSink")), Stream$(T));
       }
       get isBroadcast() {
         return false;
       }
-      asBroadcastStream(opt$) {
-        let onListen = opt$ && 'onListen' in opt$ ? opt$.onListen : null;
-        let onCancel = opt$ && 'onCancel' in opt$ ? opt$.onCancel : null;
+      asBroadcastStream(opts) {
+        let onListen = opts && 'onListen' in opts ? opts.onListen : null;
+        let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         return new _AsBroadcastStream(this, dart.closureWrap(onListen, "(StreamSubscription<dynamic>) → void"), dart.closureWrap(onCancel, "(StreamSubscription<dynamic>) → void"));
       }
       where(test) {
         return new _WhereStream(this, test);
       }
       map(convert) {
         return new _MapStream(this, convert);
       }
       asyncMap(convert) {
         let controller = null;
@@ skipping 68 matching lines @@
           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' in opt$ ? opt$.test : null;
+      handleError(onError, opts) {
+        let test = opts && 'test' in opts ? opts.test : null;
         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);
@@ skipping 252 matching lines @@
             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' in opt$ ? opt$.defaultValue : null;
+      firstWhere(test, opts) {
+        let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((value) => {
           _runUserCode(() => test(value), (isMatch) => {
             if (isMatch) {
               _cancelAndValue(subscription, future, value);
             }
           }, 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' in opt$ ? opt$.defaultValue : null;
+      lastWhere(test, opts) {
+        let defaultValue = opts && 'defaultValue' in opts ? opts.defaultValue : null;
         let future = new _Future();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           _runUserCode(() => true === test(value), (isMatch) => {
             if (isMatch) {
               foundResult = true;
               result = value;
             }
@@ skipping 64 matching lines @@
           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' in opt$ ? opt$.onTimeout : null;
+      timeout(timeLimit, opts) {
+        let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         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")));
@@ skipping 49 matching lines @@
     }
     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' in opt$ ? opt$.onError : null;
-        let onDone = opt$ && 'onDone' in opt$ ? opt$.onDone : null;
-        let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : null;
+      listen(onData, opts) {
+        let onError = opts && 'onError' in opts ? opts.onError : null;
+        let onDone = opts && 'onDone' in opts ? opts.onDone : null;
+        let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let subscription = this[_createSubscription](onData, onError, onDone, cancelOnError);
         this[_onListen](subscription);
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         return new _BufferingStreamSubscription(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;
+      _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))
@@ skipping 369 matching lines @@
     _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;
+      _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);
@@ skipping 52 matching lines @@
   let _recordCancel = Symbol('_recordCancel');
   let _callOnCancel = Symbol('_callOnCancel');
   let _recordPause = Symbol('_recordPause');
   let _recordResume = Symbol('_recordResume');
   let _addEventError = Symbol('_addEventError');
   let _forEachListener = Symbol('_forEachListener');
   let _STATE_FIRING = Symbol('_STATE_FIRING');
   let _mayComplete = Symbol('_mayComplete');
   let _BroadcastStreamController$ = dart.generic(function(T) {
     class _BroadcastStreamController extends core.Object {
-      _BroadcastStreamController($_onListen, $_onCancel) {
-        this[_onListen] = $_onListen;
-        this[_onCancel] = $_onCancel;
+      _BroadcastStreamController(onListen$, onCancel$) {
+        this[_onListen] = onListen$;
+        this[_onCancel] = onCancel$;
         this[_state] = _BroadcastStreamController._STATE_INITIAL;
         this[_next] = null;
         this[_previous] = null;
         this[_addStreamState] = null;
         this[_doneFuture] = null;
         this[_next] = this[_previous] = this;
       }
       get stream() {
         return new _BroadcastStream(this);
       }
@@ skipping 110 matching lines @@
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         this[_state] = _BroadcastStreamController._STATE_CLOSED;
         let doneFuture = this[_ensureDoneFuture]();
         this[_sendDone]();
         return doneFuture;
       }
       get done() {
         return this[_ensureDoneFuture]();
       }
-      addStream(stream, opt$) {
-        let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : true;
+      addStream(stream, opts) {
+        let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_addEventError]();
         this[_state] = _BroadcastStreamController._STATE_ADDSTREAM;
         this[_addStreamState] = dart.as(new _AddStreamState(this, stream, cancelOnError), _AddStreamState$(T));
         return this[_addStreamState].addStreamFuture;
       }
       [_add](data) {
         this[_sendData](data);
       }
       [_addError](error, stackTrace) {
@@ skipping 223 matching lines @@
       asFuture(value) {
         if (value === void 0)
           value = null;
         return new _Future();
       }
     }
     return _DoneSubscription;
   });
   let _DoneSubscription = _DoneSubscription$(dart.dynamic);
   class DeferredLibrary extends core.Object {
-    DeferredLibrary(libraryName, opt$) {
-      let uri = opt$ && 'uri' in opt$ ? opt$.uri : null;
+    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.';
     }
   }
   let _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
-    DeferredLoadException($_s) {
-      this[_s] = $_s;
+    DeferredLoadException(s$) {
+      this[_s] = s$;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new _Future();
         Timer.run((() => {
@@ skipping 56 matching lines @@
           try {
             result._complete(computation === null ? null : computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         }).bind(this));
         return dart.as(result, Future$(T));
       }
-      static wait(futures, opt$) {
-        let eagerError = opt$ && 'eagerError' in opt$ ? opt$.eagerError : false;
-        let cleanUp = opt$ && 'cleanUp' in opt$ ? opt$.cleanUp : null;
+      static wait(futures, opts) {
+        let eagerError = opts && 'eagerError' in opts ? opts.eagerError : false;
+        let cleanUp = opts && 'cleanUp' in opts ? opts.cleanUp : null;
         let result = new _Future();
         let values = null;
         let remaining = 0;
         let error = null;
         let stackTrace = null;
         // Function handleError: (dynamic, dynamic) → void
         function handleError(theError, theStackTrace) {
           remaining = dart.notNull(remaining) - 1;
           if (values !== null) {
             if (cleanUp !== null) {
@@ skipping 10 matching lines @@
               result._completeError(theError, dart.as(theStackTrace, core.StackTrace));
             } else {
               error = theError;
               stackTrace = dart.as(theStackTrace, core.StackTrace);
             }
           } else if (remaining === 0 && !dart.notNull(eagerError)) {
             result._completeError(error, stackTrace);
           }
         }
         for (let future of futures) {
-          let pos = (($tmp) => remaining = dart.notNull($tmp) + 1, $tmp)(remaining);
+          let pos = ((x) => remaining = dart.notNull(x$) + 1, x$)(remaining);
           future.then(((value) => {
             remaining = dart.notNull(remaining) - 1;
             if (values !== null) {
               values.set(pos, value);
               if (remaining === 0) {
                 result._completeWithValue(values);
               }
             } else {
               if (dart.notNull(cleanUp !== null) && dart.notNull(value !== null)) {
                 new Future.sync(() => {
@@ skipping 231 matching lines @@
   let _isComplete = Symbol('_isComplete');
   let _hasValue = Symbol('_hasValue');
   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 _chainForeignFuture$ = Symbol('_chainForeignFuture');
+  let _chainCoreFuture$ = Symbol('_chainCoreFuture');
   let _completeWithValue = Symbol('_completeWithValue');
-  let _propagateToListeners = Symbol('_propagateToListeners');
+  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) {
         this[_zone] = Zone.current;
         this[_state] = _Future._INCOMPLETE;
@@ skipping 25 matching lines @@
       }
       set [_isChained](value) {
         if (value) {
           dart.assert(!dart.notNull(this[_isComplete]));
           this[_state] = _Future._CHAINED;
         } else {
           dart.assert(this[_isChained]);
           this[_state] = _Future._INCOMPLETE;
         }
       }
-      then(f, opt$) {
-        let onError = opt$ && 'onError' in opt$ ? opt$.onError : null;
+      then(f, opts) {
+        let onError = opts && 'onError' in opts ? opts.onError : null;
         let result = new _Future();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           f = dart.closureWrap(result[_zone].registerUnaryCallback(f), "(T) → dynamic");
           if (onError !== null) {
             onError = _registerErrorHandler(onError, result[_zone]);
           }
         }
         this[_addListener](new _FutureListener.then(result, f, onError));
         return result;
       }
-      catchError(onError, opt$) {
-        let test = opt$ && 'test' in opt$ ? opt$.test : null;
+      catchError(onError, opts) {
+        let test = opts && 'test' in opts ? opts.test : null;
         let result = new _Future();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           onError = _registerErrorHandler(onError, result[_zone]);
           if (test !== null)
             test = dart.closureWrap(result[_zone].registerUnaryCallback(test), "(dynamic) → bool");
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
@@ skipping 50 matching lines @@
         this[_resultOrListeners] = null;
         let prev = null;
         while (current !== null) {
           let next = current[_nextListener];
           current[_nextListener] = prev;
           prev = current;
           current = next;
         }
         return prev;
       }
-      static [_chainForeignFuture](source, target) {
+      static [_chainForeignFuture$](source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(!dart.is(source, _Future));
         target[_isChained] = true;
         source.then(((value) => {
           dart.assert(target[_isChained]);
           target._completeWithValue(value);
         }).bind(this), {onError: ((error, stackTrace) => {
             if (stackTrace === void 0)
               stackTrace = null;
             dart.assert(target[_isChained]);
             target._completeError(error, dart.as(stackTrace, core.StackTrace));
           }).bind(this)});
       }
-      static [_chainCoreFuture](source, target) {
+      static [_chainCoreFuture$](source, target) {
         dart.assert(!dart.notNull(target[_isComplete]));
         dart.assert(dart.is(source, _Future));
         target[_isChained] = true;
         let listener = new _FutureListener.chain(target);
         if (source[_isComplete]) {
           _propagateToListeners(source, listener);
         } else {
           source._addListener(listener);
         }
       }
@@ skipping 53 matching lines @@
           this[_completeWithValue](value);
         }).bind(this));
       }
       [_asyncCompleteError](error, stackTrace) {
         dart.assert(!dart.notNull(this[_isComplete]));
         this[_markPendingCompletion]();
         this[_zone].scheduleMicrotask((() => {
           this[_completeError](error, stackTrace);
         }).bind(this));
       }
-      static [_propagateToListeners](source, listeners) {
+      static [_propagateToListeners$](source, listeners) {
         while (true) {
           dart.assert(source[_isComplete]);
           let hasError = source[_hasError];
           if (listeners === null) {
             if (hasError) {
               let asyncError = source[_error];
               source[_zone].handleUncaughtError(asyncError.error, asyncError.stackTrace);
             }
             return;
           }
@@ skipping 139 matching lines @@
           listeners = result._removeListeners();
           if (listenerHasValue) {
             result._setValue(listenerValueOrError);
           } else {
             let asyncError = dart.as(listenerValueOrError, AsyncError);
             result._setErrorObject(asyncError);
           }
           source = result;
         }
       }
-      timeout(timeLimit, opt$) {
-        let onTimeout = opt$ && 'onTimeout' in opt$ ? opt$.onTimeout : null;
+      timeout(timeLimit, opts) {
+        let onTimeout = opts && 'onTimeout' in opts ? opts.onTimeout : null;
         if (this[_isComplete])
           return new _Future.immediate(this);
         let result = new _Future();
         let timer = null;
         if (onTimeout === null) {
           timer = new Timer(timeLimit, (() => {
             result._completeError(new TimeoutException("Future not completed", timeLimit));
           }).bind(this));
         } else {
           let zone = Zone.current;
@@ skipping 98 matching lines @@
   }
   // Function scheduleMicrotask: (() → void) → void
   function scheduleMicrotask(callback) {
     if (core.identical(_ROOT_ZONE, Zone.current)) {
       _rootScheduleMicrotask(null, null, _ROOT_ZONE, callback);
       return;
     }
     Zone.current.scheduleMicrotask(Zone.current.bindCallback(callback, {runGuarded: true}));
   }
   let _scheduleImmediate = Symbol('_scheduleImmediate');
-  let _initializeScheduleImmediate = Symbol('_initializeScheduleImmediate');
-  let _scheduleImmediateJsOverride = Symbol('_scheduleImmediateJsOverride');
-  let _scheduleImmediateWithSetImmediate = Symbol('_scheduleImmediateWithSetImmediate');
-  let _scheduleImmediateWithTimer = Symbol('_scheduleImmediateWithTimer');
+  let _initializeScheduleImmediate$ = Symbol('_initializeScheduleImmediate');
+  let _scheduleImmediateJsOverride$ = Symbol('_scheduleImmediateJsOverride');
+  let _scheduleImmediateWithSetImmediate$ = Symbol('_scheduleImmediateWithSetImmediate');
+  let _scheduleImmediateWithTimer$ = Symbol('_scheduleImmediateWithTimer');
   class _AsyncRun extends core.Object {
     static [_scheduleImmediate](callback) {
       dart.dinvokef(scheduleImmediateClosure, callback);
     }
-    static [_initializeScheduleImmediate]() {
+    static [_initializeScheduleImmediate$]() {
       _js_helper.requiresPreamble();
       if (self.scheduleImmediate !== null) {
         return _scheduleImmediateJsOverride;
       }
       if (dart.notNull(self.MutationObserver !== null) && dart.notNull(self.document !== null)) {
         let div = self.document.createElement("div");
         let span = self.document.createElement("span");
         let storedCallback = null;
         // Function internalCallback: (dynamic) → dynamic
         function internalCallback(_) {
           _isolate_helper.leaveJsAsync();
           let f = storedCallback;
           storedCallback = null;
           dart.dinvokef(f);
         }
         ;
         let observer = new self.MutationObserver(_js_helper.convertDartClosureToJS(internalCallback, 1));
         observer.observe(div, {childList: true});
         return (callback) => {
           dart.assert(storedCallback === null);
           _isolate_helper.enterJsAsync();
           storedCallback = callback;
           div.firstChild ? div.removeChild(span) : div.appendChild(span);
         };
       } else if (self.setImmediate !== null) {
         return _scheduleImmediateWithSetImmediate;
       }
       return _scheduleImmediateWithTimer;
     }
-    static [_scheduleImmediateJsOverride](callback) {
+    static [_scheduleImmediateJsOverride$](callback) {
       // Function internalCallback: () → dynamic
       function internalCallback() {
         _isolate_helper.leaveJsAsync();
         callback();
       }
       ;
       _isolate_helper.enterJsAsync();
       self.scheduleImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
     }
-    static [_scheduleImmediateWithSetImmediate](callback) {
+    static [_scheduleImmediateWithSetImmediate$](callback) {
       // Function internalCallback: () → dynamic
       function internalCallback() {
         _isolate_helper.leaveJsAsync();
         callback();
       }
       ;
       _isolate_helper.enterJsAsync();
       self.setImmediate(_js_helper.convertDartClosureToJS(internalCallback, 0));
     }
-    static [_scheduleImmediateWithTimer](callback) {
+    static [_scheduleImmediateWithTimer$](callback) {
       Timer._createTimer(core.Duration.ZERO, callback);
     }
   }
   dart.defineLazyProperties(_AsyncRun, {
     get scheduleImmediateClosure() {
       return _initializeScheduleImmediate();
     }
   });
   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;
   });
   let EventSink = EventSink$(dart.dynamic);
   let _stream = Symbol('_stream');
   let StreamView$ = dart.generic(function(T) {
     class StreamView extends Stream$(T) {
-      StreamView($_stream) {
-        this[_stream] = $_stream;
+      StreamView(stream$) {
+        this[_stream] = stream$;
         super.Stream();
       }
       get isBroadcast() {
         return this[_stream].isBroadcast;
       }
-      asBroadcastStream(opt$) {
-        let onListen = opt$ && 'onListen' in opt$ ? opt$.onListen : null;
-        let onCancel = opt$ && 'onCancel' in opt$ ? opt$.onCancel : null;
+      asBroadcastStream(opts) {
+        let onListen = opts && 'onListen' in opts ? opts.onListen : null;
+        let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         return this[_stream].asBroadcastStream({onListen: onListen, onCancel: onCancel});
       }
-      listen(onData, opt$) {
-        let onError = opt$ && 'onError' in opt$ ? opt$.onError : null;
-        let onDone = opt$ && 'onDone' in opt$ ? opt$.onDone : null;
-        let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : null;
+      listen(onData, opts) {
+        let onError = opts && 'onError' in opts ? opts.onError : null;
+        let onDone = opts && 'onDone' in opts ? opts.onDone : null;
+        let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         return this[_stream].listen(onData, {onError: onError, onDone: onDone, cancelOnError: cancelOnError});
       }
     }
     return StreamView;
   });
   let StreamView = StreamView$(dart.dynamic);
   let StreamConsumer$ = dart.generic(function(S) {
     class StreamConsumer extends core.Object {
     }
     return StreamConsumer;
   });
   let StreamConsumer = StreamConsumer$(dart.dynamic);
   let StreamSink$ = dart.generic(function(S) {
     class StreamSink extends core.Object {
     }
     return StreamSink;
   });
   let StreamSink = StreamSink$(dart.dynamic);
   let StreamTransformer$ = dart.generic(function(S, T) {
     class StreamTransformer extends core.Object {
       StreamTransformer(transformer) {
         return new _StreamSubscriptionTransformer(transformer);
       }
-      StreamTransformer$fromHandlers(opt$) {
-        return new _StreamHandlerTransformer(opt$);
+      StreamTransformer$fromHandlers(opts) {
+        return new _StreamHandlerTransformer(opts);
       }
     }
     dart.defineNamedConstructor(StreamTransformer, 'fromHandlers');
     return StreamTransformer;
   });
   let StreamTransformer = StreamTransformer$(dart.dynamic, dart.dynamic);
   let StreamIterator$ = dart.generic(function(T) {
     class StreamIterator extends core.Object {
       StreamIterator(stream) {
         return new _StreamIteratorImpl(stream);
       }
     }
     return StreamIterator;
   });
   let StreamIterator = StreamIterator$(dart.dynamic);
   let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
     class _ControllerEventSinkWrapper extends core.Object {
-      _ControllerEventSinkWrapper($_sink) {
-        this[_sink] = $_sink;
+      _ControllerEventSinkWrapper(sink$) {
+        this[_sink] = sink$;
       }
       add(data) {
         this[_sink].add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_sink].addError(error, stackTrace);
       }
       close() {
         this[_sink].close();
       }
     }
     return _ControllerEventSinkWrapper;
   });
   let _ControllerEventSinkWrapper = _ControllerEventSinkWrapper$(dart.dynamic);
   let StreamController$ = dart.generic(function(T) {
     class StreamController extends core.Object {
-      StreamController(opt$) {
-        let onListen = opt$ && 'onListen' in opt$ ? opt$.onListen : null;
-        let onPause = opt$ && 'onPause' in opt$ ? opt$.onPause : null;
-        let onResume = opt$ && 'onResume' in opt$ ? opt$.onResume : null;
-        let onCancel = opt$ && 'onCancel' in opt$ ? opt$.onCancel : null;
-        let sync = opt$ && 'sync' in opt$ ? opt$.sync : false;
+      StreamController(opts) {
+        let onListen = opts && 'onListen' in opts ? opts.onListen : null;
+        let onPause = opts && 'onPause' in opts ? opts.onPause : null;
+        let onResume = opts && 'onResume' in opts ? opts.onResume : null;
+        let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
+        let sync = opts && 'sync' in opts ? opts.sync : false;
         if (dart.notNull(onListen === null) && dart.notNull(onPause === null) && dart.notNull(onResume === null) && dart.notNull(onCancel === null)) {
           return dart.as(sync ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
         }
         return sync ? new _SyncStreamController(onListen, onPause, onResume, onCancel) : new _AsyncStreamController(onListen, onPause, onResume, onCancel);
       }
-      StreamController$broadcast(opt$) {
-        let onListen = opt$ && 'onListen' in opt$ ? opt$.onListen : null;
-        let onCancel = opt$ && 'onCancel' in opt$ ? opt$.onCancel : null;
-        let sync = opt$ && 'sync' in opt$ ? opt$.sync : false;
+      StreamController$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(onListen, onCancel) : new _AsyncBroadcastStreamController(onListen, onCancel);
       }
     }
     dart.defineNamedConstructor(StreamController, 'broadcast');
     return StreamController;
   });
   let StreamController = StreamController$(dart.dynamic);
   let _StreamControllerLifecycle$ = dart.generic(function(T) {
     class _StreamControllerLifecycle extends core.Object {
       [_recordPause](subscription) {}
@@ skipping 75 matching lines @@
         }
         return dart.as(this[_varData], _ControllerSubscription);
       }
       [_badEventState]() {
         if (this.isClosed) {
           return new core.StateError("Cannot add event after closing");
         }
         dart.assert(this[_isAddingStream]);
         return new core.StateError("Cannot add event while adding a stream");
       }
-      addStream(source, opt$) {
-        let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : true;
+      addStream(source, opts) {
+        let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         if (!dart.notNull(this[_mayAddEvent]))
           throw this[_badEventState]();
         if (this[_isCanceled])
           return new _Future.immediate(null);
         let addState = new _StreamControllerAddStreamState(this, this[_varData], source, cancelOnError);
         this[_varData] = addState;
         this[_state] = _StreamController._STATE_ADDSTREAM;
         return addState.addStreamFuture;
       }
       get done() {
@@ skipping 88 matching lines @@
           result = addState.cancel();
         }
         this[_varData] = null;
         this[_state] = dart.notNull(this[_state]) & ~(dart.notNull(_StreamController._STATE_SUBSCRIBED) | dart.notNull(_StreamController._STATE_ADDSTREAM)) | dart.notNull(_StreamController._STATE_CANCELED);
         if (this[_onCancel] !== null) {
           if (result === null) {
             try {
               result = dart.as(this[_onCancel](), Future);
             } catch (e) {
               let s = dart.stackTrace(e);
-              result = ((_) => {
-                _._asyncCompleteError(e, s);
-                return _;
+              result = ((_$) => {
+                _$._asyncCompleteError(e, s);
+                return _$;
               }).bind(this)(new _Future());
             }
 
           } else {
             result = result.whenComplete(this[_onCancel]);
           }
         }
         // Function complete: () → void
         function complete() {
           if (dart.notNull(this[_doneFuture] !== null) && dart.notNull(this[_doneFuture][_mayComplete])) {
@@ skipping 56 matching lines @@
       }
       [_sendDone]() {
         this[_subscription]._addPending(new _DelayedDone());
       }
     }
     return _AsyncStreamControllerDispatch;
   });
   let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$(dart.dynamic);
   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;
+      _AsyncStreamController(onListen$, onPause$, onResume$, onCancel$) {
+        this[_onListen] = onListen$;
+        this[_onPause] = onPause$;
+        this[_onResume] = onResume$;
+        this[_onCancel] = onCancel$;
         super._StreamController();
       }
     }
     return _AsyncStreamController;
   });
   let _AsyncStreamController = _AsyncStreamController$(dart.dynamic);
   let _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;
+      _SyncStreamController(onListen$, onPause$, onResume$, onCancel$) {
+        this[_onListen] = onListen$;
+        this[_onPause] = onPause$;
+        this[_onResume] = onResume$;
+        this[_onCancel] = onCancel$;
         super._StreamController();
       }
     }
     return _SyncStreamController;
   });
   let _SyncStreamController = _SyncStreamController$(dart.dynamic);
   class _NoCallbacks extends core.Object {
     get [_onListen]() {
       return null;
     }
@@ skipping 22 matching lines @@
       return null;
     } catch (e) {
       let s = dart.stackTrace(e);
       Zone.current.handleUncaughtError(e, s);
     }
 
   }
   let _target = Symbol('_target');
   let _StreamSinkWrapper$ = dart.generic(function(T) {
     class _StreamSinkWrapper extends core.Object {
-      _StreamSinkWrapper($_target) {
-        this[_target] = $_target;
+      _StreamSinkWrapper(target$) {
+        this[_target] = target$;
       }
       add(data) {
         this[_target].add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_target].addError(error, stackTrace);
       }
       close() {
         return this[_target].close();
       }
-      addStream(source, opt$) {
-        let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : true;
+      addStream(source, opts) {
+        let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : true;
         return this[_target].addStream(source, {cancelOnError: cancelOnError});
       }
       get done() {
         return this[_target].done;
       }
     }
     return _StreamSinkWrapper;
   });
   let _StreamSinkWrapper = _StreamSinkWrapper$(dart.dynamic);
   let _AddStreamState$ = dart.generic(function(T) {
@@ skipping 52 matching lines @@
   let _EventSink = _EventSink$(dart.dynamic);
   let _EventDispatch$ = dart.generic(function(T) {
     class _EventDispatch extends core.Object {
     }
     return _EventDispatch;
   });
   let _EventDispatch = _EventDispatch$(dart.dynamic);
   let _isUsed = Symbol('_isUsed');
   let _GeneratedStreamImpl$ = dart.generic(function(T) {
     class _GeneratedStreamImpl extends _StreamImpl$(T) {
-      _GeneratedStreamImpl($_pending) {
-        this[_pending] = $_pending;
+      _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 _;
+        return ((_$) => {
+          _$._setPendingEvents(this[_pending]());
+          return _$;
         }).bind(this)(new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError));
       }
     }
     return _GeneratedStreamImpl;
   });
   let _GeneratedStreamImpl = _GeneratedStreamImpl$(dart.dynamic);
   let _iterator = Symbol('_iterator');
   let _eventScheduled = Symbol('_eventScheduled');
   class _PendingEvents extends core.Object {
     _PendingEvents() {
@@ skipping 172 matching lines @@
       newNext[_previous] = this[_previous];
       this[_previous][_next] = newNext;
       this[_previous] = newPrevious;
     }
   }
   let _schedule = Symbol('_schedule');
   let _isSent = Symbol('_isSent');
   let _isScheduled = Symbol('_isScheduled');
   let _DoneStreamSubscription$ = dart.generic(function(T) {
     class _DoneStreamSubscription extends core.Object {
-      _DoneStreamSubscription($_onDone) {
-        this[_onDone] = $_onDone;
+      _DoneStreamSubscription(onDone$) {
+        this[_onDone] = onDone$;
         this[_zone] = Zone.current;
         this[_state] = 0;
         this[_schedule]();
       }
       get [_isSent]() {
         return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription._DONE_SENT)) !== 0;
       }
       get [_isScheduled]() {
         return (dart.notNull(this[_state]) & dart.notNull(_DoneStreamSubscription._SCHEDULED)) !== 0;
       }
@@ skipping 55 matching lines @@
   let _DoneStreamSubscription = _DoneStreamSubscription$(dart.dynamic);
   let _source = Symbol('_source');
   let _onListenHandler = Symbol('_onListenHandler');
   let _onCancelHandler = Symbol('_onCancelHandler');
   let _cancelSubscription = Symbol('_cancelSubscription');
   let _pauseSubscription = Symbol('_pauseSubscription');
   let _resumeSubscription = Symbol('_resumeSubscription');
   let _isSubscriptionPaused = Symbol('_isSubscriptionPaused');
   let _AsBroadcastStream$ = dart.generic(function(T) {
     class _AsBroadcastStream extends Stream$(T) {
-      _AsBroadcastStream($_source, onListenHandler, onCancelHandler) {
-        this[_source] = $_source;
+      _AsBroadcastStream(source$, onListenHandler, onCancelHandler) {
+        this[_source] = source$;
         this[_onListenHandler] = dart.closureWrap(Zone.current.registerUnaryCallback(onListenHandler), "(StreamSubscription<dynamic>) → void");
         this[_onCancelHandler] = dart.closureWrap(Zone.current.registerUnaryCallback(onCancelHandler), "(StreamSubscription<dynamic>) → void");
         this[_zone] = Zone.current;
         this[_controller] = null;
         this[_subscription] = null;
         super.Stream();
         this[_controller] = new _AsBroadcastStreamController(this[_onListen], this[_onCancel]);
       }
       get isBroadcast() {
         return true;
       }
-      listen(onData, opt$) {
-        let onError = opt$ && 'onError' in opt$ ? opt$.onError : null;
-        let onDone = opt$ && 'onDone' in opt$ ? opt$.onDone : null;
-        let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : null;
+      listen(onData, opts) {
+        let onError = opts && 'onError' in opts ? opts.onError : null;
+        let onDone = opts && 'onDone' in opts ? opts.onDone : null;
+        let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         if (dart.notNull(this[_controller] === null) || dart.notNull(this[_controller].isClosed)) {
           return new _DoneStreamSubscription(onDone);
         }
         if (this[_subscription] === null) {
           this[_subscription] = this[_source].listen(this[_controller].add, {onError: this[_controller].addError, onDone: this[_controller].close});
         }
         cancelOnError = core.identical(true, cancelOnError);
         return this[_controller]._subscribe(onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
@@ skipping 35 matching lines @@
         if (this[_subscription] === null)
           return false;
         return this[_subscription].isPaused;
       }
     }
     return _AsBroadcastStream;
   });
   let _AsBroadcastStream = _AsBroadcastStream$(dart.dynamic);
   let _BroadcastSubscriptionWrapper$ = dart.generic(function(T) {
     class _BroadcastSubscriptionWrapper extends core.Object {
-      _BroadcastSubscriptionWrapper($_stream) {
-        this[_stream] = $_stream;
+      _BroadcastSubscriptionWrapper(stream$) {
+        this[_stream] = stream$;
       }
       onData(handleData) {
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
       onError(handleError) {
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
       onDone(handleDone) {
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
@@ skipping 14 matching lines @@
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
     }
     return _BroadcastSubscriptionWrapper;
   });
   let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$(dart.dynamic);
-  let _current = Symbol('_current');
+  let _current$ = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
   let _clear = Symbol('_clear');
   let _StreamIteratorImpl$ = dart.generic(function(T) {
     class _StreamIteratorImpl extends core.Object {
       _StreamIteratorImpl(stream) {
         this[_subscription] = null;
-        this[_current] = null;
+        this[_current$] = null;
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl._STATE_FOUND;
         this[_subscription] = stream.listen(this[_onData], {onError: this[_onError], onDone: this[_onDone], cancelOnError: true});
       }
       get current() {
-        return this[_current];
+        return this[_current$];
       }
       moveNext() {
         if (this[_state] === _StreamIteratorImpl._STATE_DONE) {
           return new _Future.immediate(false);
         }
         if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
           throw new core.StateError("Already waiting for next.");
         }
         if (this[_state] === _StreamIteratorImpl._STATE_FOUND) {
           this[_state] = _StreamIteratorImpl._STATE_MOVING;
-          this[_current] = null;
+          this[_current$] = null;
           this[_futureOrPrefetch] = new _Future();
           return dart.as(this[_futureOrPrefetch], Future$(core.bool));
         } else {
           dart.assert(dart.notNull(this[_state]) >= dart.notNull(_StreamIteratorImpl._STATE_EXTRA_DATA));
           switch (this[_state]) {
             case _StreamIteratorImpl._STATE_EXTRA_DATA:
               this[_state] = _StreamIteratorImpl._STATE_FOUND;
-              this[_current] = dart.as(this[_futureOrPrefetch], T);
+              this[_current$] = dart.as(this[_futureOrPrefetch], T);
               this[_futureOrPrefetch] = null;
               this[_subscription].resume();
               return new _Future.immediate(true);
             case _StreamIteratorImpl._STATE_EXTRA_ERROR:
               let prefetch = dart.as(this[_futureOrPrefetch], AsyncError);
               this[_clear]();
               return new _Future.immediateError(prefetch.error, prefetch.stackTrace);
             case _StreamIteratorImpl._STATE_EXTRA_DONE:
               this[_clear]();
               return new _Future.immediate(false);
           }
         }
       }
       [_clear]() {
         this[_subscription] = null;
         this[_futureOrPrefetch] = null;
-        this[_current] = null;
+        this[_current$] = null;
         this[_state] = _StreamIteratorImpl._STATE_DONE;
       }
       cancel() {
         let subscription = this[_subscription];
         if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_clear]();
           hasNext._complete(false);
         } else {
           this[_clear]();
         }
         return subscription.cancel();
       }
       [_onData](data) {
         if (this[_state] === _StreamIteratorImpl._STATE_MOVING) {
-          this[_current] = data;
+          this[_current$] = data;
           let hasNext = dart.as(this[_futureOrPrefetch], _Future$(core.bool));
           this[_futureOrPrefetch] = null;
           this[_state] = _StreamIteratorImpl._STATE_FOUND;
           hasNext._complete(true);
           return;
         }
         this[_subscription].pause();
         dart.assert(this[_futureOrPrefetch] === null);
         this[_futureOrPrefetch] = data;
         this[_state] = _StreamIteratorImpl._STATE_EXTRA_DATA;
@@ skipping 79 matching lines @@
       cancelFuture.whenComplete(() => future._complete(value));
     } else {
       future._complete(value);
     }
   }
   let _handleData = Symbol('_handleData');
   let _handleError = Symbol('_handleError');
   let _handleDone = Symbol('_handleDone');
   let _ForwardingStream$ = dart.generic(function(S, T) {
     class _ForwardingStream extends Stream$(T) {
-      _ForwardingStream($_source) {
-        this[_source] = $_source;
+      _ForwardingStream(source$) {
+        this[_source] = source$;
         super.Stream();
       }
       get isBroadcast() {
         return this[_source].isBroadcast;
       }
-      listen(onData, opt$) {
-        let onError = opt$ && 'onError' in opt$ ? opt$.onError : null;
-        let onDone = opt$ && 'onDone' in opt$ ? opt$.onDone : null;
-        let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : null;
+      listen(onData, opts) {
+        let onError = opts && 'onError' in opts ? opts.onError : null;
+        let onDone = opts && 'onDone' in opts ? opts.onDone : null;
+        let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         return this[_createSubscription](onData, onError, onDone, cancelOnError);
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         return new _ForwardingStreamSubscription(this, onData, onError, onDone, cancelOnError);
       }
       [_handleData](data, sink) {
         let outputData = data;
         sink._add(outputData);
       }
       [_handleError](error, stackTrace, sink) {
         sink._addError(error, stackTrace);
       }
       [_handleDone](sink) {
         sink._close();
       }
     }
     return _ForwardingStream;
   });
   let _ForwardingStream = _ForwardingStream$(dart.dynamic, dart.dynamic);
   let _ForwardingStreamSubscription$ = dart.generic(function(S, T) {
     class _ForwardingStreamSubscription extends _BufferingStreamSubscription$(T) {
-      _ForwardingStreamSubscription($_stream, onData, onError, onDone, cancelOnError) {
-        this[_stream] = $_stream;
+      _ForwardingStreamSubscription(stream$, onData, onError, onDone, cancelOnError) {
+        this[_stream] = stream$;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
         this[_subscription] = this[_stream][_source].listen(this[_handleData], {onError: this[_handleError], onDone: this[_handleDone]});
       }
       [_add](data) {
         if (this[_isClosed])
           return;
         super._add(data);
       }
       [_addError](error, stackTrace) {
@@ skipping 288 matching lines @@
       get _SENTINEL() {
         return new core.Object();
       },
       set _SENTINEL(_) {}
     });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$(dart.dynamic);
   let _EventSinkWrapper$ = dart.generic(function(T) {
     class _EventSinkWrapper extends core.Object {
-      _EventSinkWrapper($_sink) {
-        this[_sink] = $_sink;
+      _EventSinkWrapper(sink$) {
+        this[_sink] = sink$;
       }
       add(data) {
         this[_sink]._add(data);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_sink]._addError(error, stackTrace);
       }
       close() {
@@ skipping 86 matching lines @@
         }
 
       }
     }
     return _SinkTransformerStreamSubscription;
   });
   let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$(dart.dynamic, dart.dynamic);
   let _sinkMapper = Symbol('_sinkMapper');
   let _StreamSinkTransformer$ = dart.generic(function(S, T) {
     class _StreamSinkTransformer extends core.Object {
-      _StreamSinkTransformer($_sinkMapper) {
-        this[_sinkMapper] = $_sinkMapper;
+      _StreamSinkTransformer(sinkMapper) {
+        this[_sinkMapper] = sinkMapper;
       }
       bind(stream) {
         return new _BoundSinkStream(stream, this[_sinkMapper]);
       }
     }
     return _StreamSinkTransformer;
   });
   let _StreamSinkTransformer = _StreamSinkTransformer$(dart.dynamic, dart.dynamic);
   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;
+      _BoundSinkStream(stream$, sinkMapper) {
+        this[_stream] = stream$;
+        this[_sinkMapper] = sinkMapper;
         super.Stream();
       }
-      listen(onData, opt$) {
-        let onError = opt$ && 'onError' in opt$ ? opt$.onError : null;
-        let onDone = opt$ && 'onDone' in opt$ ? opt$.onDone : null;
-        let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : null;
+      listen(onData, opts) {
+        let onError = opts && 'onError' in opts ? opts.onError : null;
+        let onDone = opts && 'onDone' in opts ? opts.onDone : null;
+        let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let subscription = dart.as(new _SinkTransformerStreamSubscription(this[_stream], dart.closureWrap(this[_sinkMapper], "(EventSink<dynamic>) → EventSink"), onData, onError, onDone, cancelOnError), StreamSubscription$(T));
         return subscription;
       }
     }
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$(dart.dynamic, dart.dynamic);
   let _HandlerEventSink$ = dart.generic(function(S, T) {
     class _HandlerEventSink extends core.Object {
-      _HandlerEventSink($_handleData, $_handleError, $_handleDone, $_sink) {
-        this[_handleData] = $_handleData;
-        this[_handleError] = $_handleError;
-        this[_handleDone] = $_handleDone;
-        this[_sink] = $_sink;
+      _HandlerEventSink(handleData$, handleError$, handleDone$, sink$) {
+        this[_handleData] = handleData$;
+        this[_handleError] = handleError$;
+        this[_handleDone] = handleDone$;
+        this[_sink] = sink$;
       }
       add(data) {
         return this[_handleData](data, this[_sink]);
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         return this[_handleError](error, stackTrace, this[_sink]);
       }
       close() {
         return this[_handleDone](this[_sink]);
       }
     }
     return _HandlerEventSink;
   });
   let _HandlerEventSink = _HandlerEventSink$(dart.dynamic, dart.dynamic);
-  let _defaultHandleData = Symbol('_defaultHandleData');
-  let _defaultHandleError = Symbol('_defaultHandleError');
-  let _defaultHandleDone = Symbol('_defaultHandleDone');
+  let _defaultHandleData$ = Symbol('_defaultHandleData');
+  let _defaultHandleError$ = Symbol('_defaultHandleError');
+  let _defaultHandleDone$ = Symbol('_defaultHandleDone');
   let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
-      _StreamHandlerTransformer(opt$) {
-        let handleData = opt$ && 'handleData' in opt$ ? opt$.handleData : null;
-        let handleError = opt$ && 'handleError' in opt$ ? opt$.handleError : null;
-        let handleDone = opt$ && 'handleDone' in opt$ ? opt$.handleDone : null;
+      _StreamHandlerTransformer(opts) {
+        let handleData = opts && 'handleData' in opts ? opts.handleData : null;
+        let handleError = opts && 'handleError' in opts ? opts.handleError : null;
+        let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
         super._StreamSinkTransformer(dart.closureWrap((outputSink) => {
           if (handleData === null)
             handleData = dart.closureWrap(_defaultHandleData, "(S, EventSink<T>) → void");
           if (handleError === null)
             handleError = dart.closureWrap(_defaultHandleError, "(Object, StackTrace, EventSink<T>) → void");
           if (handleDone === null)
             handleDone = _defaultHandleDone;
           return new _HandlerEventSink(handleData, handleError, handleDone, outputSink);
         }, "(EventSink<T>) → EventSink<S>"));
       }
       bind(stream) {
         return super.bind(stream);
       }
-      static [_defaultHandleData](data, sink) {
+      static [_defaultHandleData$](data, sink) {
         sink.add(data);
       }
-      static [_defaultHandleError](error, stackTrace, sink) {
+      static [_defaultHandleError$](error, stackTrace, sink) {
         sink.addError(error);
       }
-      static [_defaultHandleDone](sink) {
+      static [_defaultHandleDone$](sink) {
         sink.close();
       }
     }
     return _StreamHandlerTransformer;
   });
   let _StreamHandlerTransformer = _StreamHandlerTransformer$(dart.dynamic, dart.dynamic);
   let _transformer = Symbol('_transformer');
   let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
     class _StreamSubscriptionTransformer extends core.Object {
-      _StreamSubscriptionTransformer($_transformer) {
-        this[_transformer] = $_transformer;
+      _StreamSubscriptionTransformer(transformer$) {
+        this[_transformer] = transformer$;
       }
       bind(stream) {
         return new _BoundSubscriptionStream(stream, this[_transformer]);
       }
     }
     return _StreamSubscriptionTransformer;
   });
   let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$(dart.dynamic, dart.dynamic);
   let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
     class _BoundSubscriptionStream extends Stream$(T) {
-      _BoundSubscriptionStream($_stream, $_transformer) {
-        this[_stream] = $_stream;
-        this[_transformer] = $_transformer;
+      _BoundSubscriptionStream(stream$, transformer$) {
+        this[_stream] = stream$;
+        this[_transformer] = transformer$;
         super.Stream();
       }
-      listen(onData, opt$) {
-        let onError = opt$ && 'onError' in opt$ ? opt$.onError : null;
-        let onDone = opt$ && 'onDone' in opt$ ? opt$.onDone : null;
-        let cancelOnError = opt$ && 'cancelOnError' in opt$ ? opt$.cancelOnError : null;
+      listen(onData, opts) {
+        let onError = opts && 'onError' in opts ? opts.onError : null;
+        let onDone = opts && 'onDone' in opts ? opts.onDone : null;
+        let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
         let result = this[_transformer](this[_stream], cancelOnError);
         result.onData(onData);
         result.onError(onError);
         result.onDone(onDone);
         return result;
       }
     }
     return _BoundSubscriptionStream;
   });
@@ skipping 24 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');
   class _ZoneFunction extends core.Object {
-    _ZoneFunction(zone, function) {
+    _ZoneFunction(zone, func) {
       this.zone = zone;
-      this['function'] = function;
+      this.function = func;
     }
   }
   class ZoneSpecification extends core.Object {
-    ZoneSpecification(opt$) {
-      return new _ZoneSpecification(opt$);
+    ZoneSpecification(opts) {
+      return new _ZoneSpecification(opts);
     }
-    ZoneSpecification$from(other, opt$) {
-      let handleUncaughtError = opt$ && 'handleUncaughtError' in opt$ ? opt$.handleUncaughtError : null;
-      let run = opt$ && 'run' in opt$ ? opt$.run : null;
-      let runUnary = opt$ && 'runUnary' in opt$ ? opt$.runUnary : null;
-      let runBinary = opt$ && 'runBinary' in opt$ ? opt$.runBinary : null;
-      let registerCallback = opt$ && 'registerCallback' in opt$ ? opt$.registerCallback : null;
-      let registerUnaryCallback = opt$ && 'registerUnaryCallback' in opt$ ? opt$.registerUnaryCallback : null;
-      let registerBinaryCallback = opt$ && 'registerBinaryCallback' in opt$ ? opt$.registerBinaryCallback : null;
-      let errorCallback = opt$ && 'errorCallback' in opt$ ? opt$.errorCallback : null;
-      let scheduleMicrotask = opt$ && 'scheduleMicrotask' in opt$ ? opt$.scheduleMicrotask : null;
-      let createTimer = opt$ && 'createTimer' in opt$ ? opt$.createTimer : null;
-      let createPeriodicTimer = opt$ && 'createPeriodicTimer' in opt$ ? opt$.createPeriodicTimer : null;
-      let print = opt$ && 'print' in opt$ ? opt$.print : null;
-      let fork = opt$ && 'fork' in opt$ ? opt$.fork : null;
+    ZoneSpecification$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: dart.as(handleUncaughtError !== null ? handleUncaughtError : other.handleUncaughtError, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, dynamic, StackTrace) → dynamic")), run: dart.as(run !== null ? run : other.run, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, () → dynamic) → dynamic")), runUnary: dart.as(runUnary !== null ? runUnary : other.runUnary, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dynamic) → dynamic")), runBinary: dart.as(runBinary !== null ? runBinary : other.runBinary, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dynamic")), registerCallback: dart.as(registerCallback !== null ? registerCallback : other.registerCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback")), registerUnaryCallback: dart.as(registerUnaryCallback !== null ? registerUnaryCallback : other.registerUnaryCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic) → dynamic) → ZoneUnaryCallback")), registerBinaryCallback: dart.as(registerBinaryCallback !== null ? registerBinaryCallback : other.registerBinaryCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic) → ZoneBinaryCallback")), errorCallback: dart.as(errorCallback !== null ? errorCallback : other.errorCallback, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, Object, StackTrace) → AsyncError")), scheduleMicrotask: dart.as(scheduleMicrotask !== null ? scheduleMicrotask : other.scheduleMicrotask, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, () → dynamic) → void")), createTimer: dart.as(createTimer !== null ? createTimer : other.createTimer, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer")), createPeriodicTimer: dart.as(createPeriodicTimer !== null ? createPeriodicTimer : other.createPeriodicTimer, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, Duration, (Timer) → void) → Timer")), print: dart.as(print !== null ? print : other.print, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, String) → void")), fork: dart.as(fork !== null ? fork : other.fork, dart.throw_("Unimplemented type (Zone, ZoneDelegate, Zone, ZoneSpecification, Map<dynamic, dynamic>) → Zone"))});
     }
   }
   dart.defineNamedConstructor(ZoneSpecification, 'from');
   class _ZoneSpecification extends core.Object {
-    _ZoneSpecification(opt$) {
-      let handleUncaughtError = opt$ && 'handleUncaughtError' in opt$ ? opt$.handleUncaughtError : null;
-      let run = opt$ && 'run' in opt$ ? opt$.run : null;
-      let runUnary = opt$ && 'runUnary' in opt$ ? opt$.runUnary : null;
-      let runBinary = opt$ && 'runBinary' in opt$ ? opt$.runBinary : null;
-      let registerCallback = opt$ && 'registerCallback' in opt$ ? opt$.registerCallback : null;
-      let registerUnaryCallback = opt$ && 'registerUnaryCallback' in opt$ ? opt$.registerUnaryCallback : null;
-      let registerBinaryCallback = opt$ && 'registerBinaryCallback' in opt$ ? opt$.registerBinaryCallback : null;
-      let errorCallback = opt$ && 'errorCallback' in opt$ ? opt$.errorCallback : null;
-      let scheduleMicrotask = opt$ && 'scheduleMicrotask' in opt$ ? opt$.scheduleMicrotask : null;
-      let createTimer = opt$ && 'createTimer' in opt$ ? opt$.createTimer : null;
-      let createPeriodicTimer = opt$ && 'createPeriodicTimer' in opt$ ? opt$.createPeriodicTimer : null;
-      let print = opt$ && 'print' in opt$ ? opt$.print : null;
-      let fork = opt$ && 'fork' in opt$ ? opt$.fork : null;
+    _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;
+      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;
       this.handleUncaughtError = handleUncaughtError;
       this.run = run;
       this.runUnary = runUnary;
       this.runBinary = runBinary;
       this.registerCallback = registerCallback;
       this.registerUnaryCallback = registerUnaryCallback;
       this.registerBinaryCallback = registerBinaryCallback;
       this.errorCallback = errorCallback;
       this.scheduleMicrotask = scheduleMicrotask;
       this.createTimer = createTimer;
@@ skipping 14 matching lines @@
     }
     static [_enter](zone) {
       dart.assert(zone !== null);
       dart.assert(!dart.notNull(core.identical(zone, _current)));
       let previous = _current;
       _current = zone;
       return previous;
     }
     static [_leave](previous) {
       dart.assert(previous !== null);
-      Zone[_current] = previous;
+      Zone[_current$] = previous;
     }
   }
   dart.defineNamedConstructor(Zone, '_');
   Zone.ROOT = _ROOT_ZONE;
   Zone._current = _ROOT_ZONE;
   let _delegate = Symbol('_delegate');
   // Function _parentDelegate: (_Zone) → ZoneDelegate
   function _parentDelegate(zone) {
     if (zone.parent === null)
       return null;
     return zone.parent[_delegate];
   }
   let _delegationTarget = Symbol('_delegationTarget');
   let _handleUncaughtError = Symbol('_handleUncaughtError');
   let _run = Symbol('_run');
   let _runUnary = Symbol('_runUnary');
   let _runBinary = Symbol('_runBinary');
   let _registerCallback = Symbol('_registerCallback');
   let _registerUnaryCallback = Symbol('_registerUnaryCallback');
   let _registerBinaryCallback = Symbol('_registerBinaryCallback');
   let _errorCallback = Symbol('_errorCallback');
   let _scheduleMicrotask = Symbol('_scheduleMicrotask');
   let _print = Symbol('_print');
   let _fork = Symbol('_fork');
   class _ZoneDelegate extends core.Object {
-    _ZoneDelegate($_delegationTarget) {
-      this[_delegationTarget] = $_delegationTarget;
+    _ZoneDelegate(delegationTarget) {
+      this[_delegationTarget] = delegationTarget;
     }
     handleUncaughtError(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_handleUncaughtError];
       let implZone = implementation.zone;
-      return dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, error, stackTrace);
+      return dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace);
     }
     run(zone, f) {
       let implementation = this[_delegationTarget][_run];
       let implZone = implementation.zone;
-      return dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, f);
+      return dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f);
     }
     runUnary(zone, f, arg) {
       let implementation = this[_delegationTarget][_runUnary];
       let implZone = implementation.zone;
-      return dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, f, arg);
+      return dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f, arg);
     }
     runBinary(zone, f, arg1, arg2) {
       let implementation = this[_delegationTarget][_runBinary];
       let implZone = implementation.zone;
-      return dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, f, arg1, arg2);
+      return dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f, arg1, arg2);
     }
     registerCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerCallback];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, f), ZoneCallback);
+      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneCallback);
     }
     registerUnaryCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerUnaryCallback];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, f), ZoneUnaryCallback);
+      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneUnaryCallback);
     }
     registerBinaryCallback(zone, f) {
       let implementation = this[_delegationTarget][_registerBinaryCallback];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, f), ZoneBinaryCallback);
+      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f), ZoneBinaryCallback);
     }
     errorCallback(zone, error, stackTrace) {
       let implementation = this[_delegationTarget][_errorCallback];
       let implZone = implementation.zone;
       if (core.identical(implZone, _ROOT_ZONE))
         return null;
-      return dart.as(dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, error, stackTrace), AsyncError);
+      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, error, stackTrace), AsyncError);
     }
     scheduleMicrotask(zone, f) {
       let implementation = this[_delegationTarget][_scheduleMicrotask];
       let implZone = implementation.zone;
-      dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, f);
+      dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, f);
     }
     createTimer(zone, duration, f) {
       let implementation = this[_delegationTarget][_createTimer];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, duration, f), Timer);
+      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, duration, f), Timer);
     }
     createPeriodicTimer(zone, period, f) {
       let implementation = this[_delegationTarget][_createPeriodicTimer];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, period, f), Timer);
+      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, period, f), Timer);
     }
     print(zone, line) {
       let implementation = this[_delegationTarget][_print];
       let implZone = implementation.zone;
-      dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, line);
+      dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, line);
     }
     fork(zone, specification, zoneValues) {
       let implementation = this[_delegationTarget][_fork];
       let implZone = implementation.zone;
-      return dart.as(dart.dinvokef(implementation['function'], implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
+      return dart.as(dart.dinvokef(implementation.function, implZone, _parentDelegate(implZone), zone, specification, zoneValues), Zone);
     }
   }
   class _Zone extends core.Object {
     _Zone() {
     }
     inSameErrorZone(otherZone) {
       return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
     }
   }
   let _delegateCache = Symbol('_delegateCache');
   let _map = Symbol('_map');
   class _CustomZone extends _Zone {
     get [_delegate]() {
       if (this[_delegateCache] !== null)
         return this[_delegateCache];
       this[_delegateCache] = new _ZoneDelegate(this);
       return this[_delegateCache];
     }
-    _CustomZone(parent, specification, $_map) {
+    _CustomZone(parent, specification, map) {
       this.parent = parent;
-      this[_map] = $_map;
+      this[_map] = map;
       this[_runUnary] = null;
       this[_run] = null;
       this[_runBinary] = null;
       this[_registerCallback] = null;
       this[_registerUnaryCallback] = null;
       this[_registerBinaryCallback] = null;
       this[_errorCallback] = null;
       this[_scheduleMicrotask] = null;
       this[_createTimer] = null;
       this[_createPeriodicTimer] = null;
@@ skipping 39 matching lines @@
     }
     runBinaryGuarded(f, arg1, arg2) {
       try {
         return this.runBinary(f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
-    bindCallback(f, opt$) {
-      let runGuarded = opt$ && 'runGuarded' in opt$ ? opt$.runGuarded : true;
+    bindCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerCallback(f);
       if (runGuarded) {
         return (() => this.runGuarded(registered)).bind(this);
       } else {
         return (() => this.run(registered)).bind(this);
       }
     }
-    bindUnaryCallback(f, opt$) {
-      let runGuarded = opt$ && 'runGuarded' in opt$ ? opt$.runGuarded : true;
+    bindUnaryCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerUnaryCallback(f);
       if (runGuarded) {
         return ((arg) => this.runUnaryGuarded(registered, arg)).bind(this);
       } else {
         return ((arg) => this.runUnary(registered, arg)).bind(this);
       }
     }
-    bindBinaryCallback(f, opt$) {
-      let runGuarded = opt$ && 'runGuarded' in opt$ ? opt$.runGuarded : true;
+    bindBinaryCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerBinaryCallback(f);
       if (runGuarded) {
         return ((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).bind(this);
       } else {
         return ((arg1, arg2) => this.runBinary(registered, arg1, arg2)).bind(this);
       }
     }
     get(key) {
       let result = this[_map].get(key);
       if (dart.notNull(result !== null) || dart.notNull(this[_map].containsKey(key)))
         return result;
       if (this.parent !== null) {
         let value = this.parent.get(key);
         if (value !== null) {
           this[_map].set(key, value);
         }
         return value;
       }
       dart.assert(dart.equals(this, _ROOT_ZONE));
       return null;
     }
     handleUncaughtError(error, stackTrace) {
       let implementation = this[_handleUncaughtError];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, error, stackTrace);
+      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, error, stackTrace);
     }
-    fork(opt$) {
-      let specification = opt$ && 'specification' in opt$ ? opt$.specification : null;
-      let zoneValues = opt$ && 'zoneValues' in opt$ ? opt$.zoneValues : null;
+    fork(opts) {
+      let specification = opts && 'specification' in opts ? opts.specification : null;
+      let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
       let implementation = this[_fork];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, specification, zoneValues), Zone);
+      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, specification, zoneValues), Zone);
     }
     run(f) {
       let implementation = this[_run];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, f);
+      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f);
     }
     runUnary(f, arg) {
       let implementation = this[_runUnary];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, f, arg);
+      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f, arg);
     }
     runBinary(f, arg1, arg2) {
       let implementation = this[_runBinary];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, f, arg1, arg2);
+      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f, arg1, arg2);
     }
     registerCallback(f) {
       let implementation = this[_registerCallback];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, f), ZoneCallback);
+      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f), ZoneCallback);
     }
     registerUnaryCallback(f) {
       let implementation = this[_registerUnaryCallback];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, f), ZoneUnaryCallback);
+      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f), ZoneUnaryCallback);
     }
     registerBinaryCallback(f) {
       let implementation = this[_registerBinaryCallback];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, f), ZoneBinaryCallback);
+      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f), ZoneBinaryCallback);
     }
     errorCallback(error, stackTrace) {
       let implementation = this[_errorCallback];
       dart.assert(implementation !== null);
       let implementationZone = implementation.zone;
       if (core.identical(implementationZone, _ROOT_ZONE))
         return null;
       let parentDelegate = _parentDelegate(dart.as(implementationZone, _Zone));
-      return dart.as(dart.dinvokef(implementation['function'], implementationZone, parentDelegate, this, error, stackTrace), AsyncError);
+      return dart.as(dart.dinvokef(implementation.function, implementationZone, parentDelegate, this, error, stackTrace), AsyncError);
     }
     scheduleMicrotask(f) {
       let implementation = this[_scheduleMicrotask];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, f);
+      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, f);
     }
     createTimer(duration, f) {
       let implementation = this[_createTimer];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, duration, f), Timer);
+      return dart.as(dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, duration, f), Timer);
     }
     createPeriodicTimer(duration, f) {
       let implementation = this[_createPeriodicTimer];
       dart.assert(implementation !== null);
       let parentDelegate = _parentDelegate(implementation.zone);
-      return dart.as(dart.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, duration, f), Timer);
+      return dart.as(dart.dinvokef(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.dinvokef(implementation['function'], implementation.zone, parentDelegate, this, line);
+      return dart.dinvokef(implementation.function, implementation.zone, parentDelegate, this, line);
     }
   }
   // Function _rootHandleUncaughtError: (Zone, ZoneDelegate, Zone, dynamic, StackTrace) → void
   function _rootHandleUncaughtError(self, parent, zone, error, stackTrace) {
     _schedulePriorityAsyncCallback(() => {
       throw new _UncaughtAsyncError(error, stackTrace);
     });
   }
   // Function _rootRun: (Zone, ZoneDelegate, Zone, () → dynamic) → dynamic
   function _rootRun(self, parent, zone, f) {
-    if (dart.equals(Zone[_current], zone))
+    if (dart.equals(Zone[_current$], zone))
       return f();
     let old = Zone._enter(zone);
     try {
       return f();
     } finally {
       Zone._leave(old);
     }
   }
   // Function _rootRunUnary: (Zone, ZoneDelegate, Zone, (dynamic) → dynamic, dynamic) → dynamic
   function _rootRunUnary(self, parent, zone, f, arg) {
-    if (dart.equals(Zone[_current], zone))
+    if (dart.equals(Zone[_current$], zone))
       return dart.dinvokef(f, arg);
     let old = Zone._enter(zone);
     try {
       return dart.dinvokef(f, arg);
     } finally {
       Zone._leave(old);
     }
   }
   // Function _rootRunBinary: (Zone, ZoneDelegate, Zone, (dynamic, dynamic) → dynamic, dynamic, dynamic) → dynamic
   function _rootRunBinary(self, parent, zone, f, arg1, arg2) {
-    if (dart.equals(Zone[_current], zone))
+    if (dart.equals(Zone[_current$], zone))
       return dart.dinvokef(f, arg1, arg2);
     let old = Zone._enter(zone);
     try {
       return dart.dinvokef(f, arg1, arg2);
     } finally {
       Zone._leave(old);
     }
   }
   // Function _rootRegisterCallback: (Zone, ZoneDelegate, Zone, () → dynamic) → ZoneCallback
   function _rootRegisterCallback(self, parent, zone, f) {
@@ skipping 154 matching lines @@
     get [_delegate]() {
       if (_rootDelegate !== null)
         return _rootDelegate;
       return _rootDelegate = new _ZoneDelegate(this);
     }
     get errorZone() {
       return this;
     }
     runGuarded(f) {
       try {
-        if (core.identical(_ROOT_ZONE, Zone[_current])) {
+        if (core.identical(_ROOT_ZONE, Zone[_current$])) {
           return f();
         }
         return _rootRun(null, null, this, f);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runUnaryGuarded(f, arg) {
       try {
-        if (core.identical(_ROOT_ZONE, Zone[_current])) {
+        if (core.identical(_ROOT_ZONE, Zone[_current$])) {
           return dart.dinvokef(f, arg);
         }
         return _rootRunUnary(null, null, this, f, arg);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
     runBinaryGuarded(f, arg1, arg2) {
       try {
-        if (core.identical(_ROOT_ZONE, Zone[_current])) {
+        if (core.identical(_ROOT_ZONE, Zone[_current$])) {
           return dart.dinvokef(f, arg1, arg2);
         }
         return _rootRunBinary(null, null, this, f, arg1, arg2);
       } catch (e) {
         let s = dart.stackTrace(e);
         return this.handleUncaughtError(e, s);
       }
 
     }
-    bindCallback(f, opt$) {
-      let runGuarded = opt$ && 'runGuarded' in opt$ ? opt$.runGuarded : true;
+    bindCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
         return (() => this.runGuarded(f)).bind(this);
       } else {
         return (() => this.run(f)).bind(this);
       }
     }
-    bindUnaryCallback(f, opt$) {
-      let runGuarded = opt$ && 'runGuarded' in opt$ ? opt$.runGuarded : true;
+    bindUnaryCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
         return ((arg) => this.runUnaryGuarded(f, arg)).bind(this);
       } else {
         return ((arg) => this.runUnary(f, arg)).bind(this);
       }
     }
-    bindBinaryCallback(f, opt$) {
-      let runGuarded = opt$ && 'runGuarded' in opt$ ? opt$.runGuarded : true;
+    bindBinaryCallback(f, opts) {
+      let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       if (runGuarded) {
         return ((arg1, arg2) => this.runBinaryGuarded(f, arg1, arg2)).bind(this);
       } else {
         return ((arg1, arg2) => this.runBinary(f, arg1, arg2)).bind(this);
       }
     }
     get(key) {
       return null;
     }
     handleUncaughtError(error, stackTrace) {
       return _rootHandleUncaughtError(null, null, this, error, stackTrace);
     }
-    fork(opt$) {
-      let specification = opt$ && 'specification' in opt$ ? opt$.specification : null;
-      let zoneValues = opt$ && 'zoneValues' in opt$ ? opt$.zoneValues : null;
+    fork(opts) {
+      let specification = opts && 'specification' in opts ? opts.specification : null;
+      let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
       return _rootFork(null, null, this, specification, zoneValues);
     }
     run(f) {
-      if (core.identical(Zone[_current], _ROOT_ZONE))
+      if (core.identical(Zone[_current$], _ROOT_ZONE))
         return f();
       return _rootRun(null, null, this, f);
     }
     runUnary(f, arg) {
-      if (core.identical(Zone[_current], _ROOT_ZONE))
+      if (core.identical(Zone[_current$], _ROOT_ZONE))
         return dart.dinvokef(f, arg);
       return _rootRunUnary(null, null, this, f, arg);
     }
     runBinary(f, arg1, arg2) {
-      if (core.identical(Zone[_current], _ROOT_ZONE))
+      if (core.identical(Zone[_current$], _ROOT_ZONE))
         return dart.dinvokef(f, arg1, arg2);
       return _rootRunBinary(null, null, this, f, arg1, arg2);
     }
     registerCallback(f) {
       return f;
     }
     registerUnaryCallback(f) {
       return f;
     }
     registerBinaryCallback(f) {
@@ skipping 17 matching lines @@
   }
   _RootZone._rootDelegate = null;
   dart.defineLazyProperties(_RootZone, {
     get _rootMap() {
       return new collection.HashMap();
     },
     set _rootMap(_) {}
   });
   let _ROOT_ZONE = new _RootZone();
   // Function runZoned: (() → dynamic, {zoneValues: Map<dynamic, dynamic>, zoneSpecification: ZoneSpecification, onError: Function}) → dynamic
-  function runZoned(body, opt$) {
-    let zoneValues = opt$ && 'zoneValues' in opt$ ? opt$.zoneValues : null;
-    let zoneSpecification = opt$ && 'zoneSpecification' in opt$ ? opt$.zoneSpecification : null;
-    let onError = opt$ && 'onError' in opt$ ? opt$.onError : null;
+  function runZoned(body, opts) {
+    let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
+    let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
+    let onError = opts && 'onError' in opts ? opts.onError : null;
     let errorHandler = null;
     if (onError !== null) {
       errorHandler = (self, parent, zone, error, stackTrace) => {
         try {
           if (dart.is(onError, ZoneBinaryCallback)) {
             return self.parent.runBinary(onError, error, stackTrace);
           }
           return self.parent.runUnary(dart.as(onError, dart.throw_("Unimplemented type (dynamic) → dynamic")), error);
         } catch (e) {
           let s = dart.stackTrace(e);
@@ skipping 50 matching lines @@
   exports.StreamIterator = StreamIterator;
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamController = StreamController;
   exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));