anchor.diff:    int _runningInTurn = 0;
   
     /**
  -   * A function called with any errors from the zone.
  -   */
  -  var onError = (e, s, ls) => print('$e\n$s\n$ls');
  -
  -  /**
  -   * A function that is called at the end of each VM turn in which the
  -   * in-zone code or any runAsync callbacks were run.
  -   */
  -  var onTurnDone = () => null;  // Type was ZoneOnTurn: dartbug 13519
  -
  -  /**
  -   * A function that is called when uncaught errors are thrown inside the zone.
  -   */
  -  // var onError = (dynamic e, dynamic s, LongStackTrace ls) => print('EXCEPTION: $e\n$s\n$ls');
  -  // Type was ZoneOnError: dartbug 13519
  +   * Called with any errors from the inner zone.
  +   */
  +  ZoneOnError onError;
  +
  +  /// Prevent silently ignoring uncaught exceptions by forwarding such exceptions to the outer zone.
  +  void _defaultOnError(dynamic e, dynamic s, LongStackTrace ls) =>
  +      _outerZone.handleUncaughtError(e, s);
  +
  +  /**
  +   * Called at the end of each VM turn in which inner zone code runs.
  +   * "At the end" means after the private microtask queue of the inner zone is
  +   * exhausted but before the next VM turn.  Notes
  +   * - This won't wait for microtasks scheduled in zones other than the inner
  +   *   zone, e.g. those scheduled with [runOutsideAngular].
  +   * - [onTurnDone] runs repeatedly until it fails to schedule any more
  +   *   microtasks, so you usually don't want it to schedule any.  For example,
  +   *   if its first line of code is `new Future.value()`, the turn will _never_
  +   *   end.
  +   */
  +  ZoneOnTurn onTurnDone;
  +  void _defaultOnTurnDone() => null;
   
     LongStackTrace _longStacktrace = null;
   
  
positive.code:    */
    dynamic runOutsideAngular(body()) => _outerZone.run(body);
  
    void assertInTurn() {
      assert(_runningInTurn > 0 || _inFinishTurn);
    }
  
    void assertInZone() {
      assertInTurn();
    }
  
negative.code: }
  
  /**
   * A [Zone] wrapper that lets you schedule tasks after its private microtask
   * queue is exhausted but before the next "turn", i.e. event loop iteration.
   * This lets you freely schedule microtasks that prepare data, and set an
   * [onTurnDone] handler that will consume that data after it's ready but before
   * the browser has a chance to re-render.
   * The wrapper maintains an "inner" and "outer" [Zone] and a private queue of
   * all the microtasks scheduled on the inner [Zone].
   *
   * In a typical app, [ngDynamicApp] or [ngStaticApp] will create a singleton
   * [NgZone] whose outer [Zone] is the root [Zone] and whose default [onTurnDone]
   * runs the Angular digest.  A component may want to inject this singleton if it
   * needs to run code _outside_ the Angular digest.
   */
  class NgZone {
    /// an "outer" [Zone], which is the one that created this.
    async.Zone _outerZone;
  
    /// an "inner" [Zone], which is a child of the outer [Zone].
    async.Zone _innerZone;
  
    /**
     * Associates with this
     *
     * Defaults [onError] to forward errors to the outer [Zone].
     * Defaults [onTurnDone] to a no-op.
     */
    NgZone() {
      _outerZone = async.Zone.current;
      _innerZone = _outerZone.fork(specification: new async.ZoneSpecification(
          run: _onRun,
          runUnary: _onRunUnary,
          scheduleMicrotask: _onScheduleMicrotask,
          handleUncaughtError: _uncaughtError
      ));
      onError = _defaultOnError;
      onTurnDone = _defaultOnTurnDone;
    }
  
    List _asyncQueue = [];
    bool _errorThrownFromOnRun = false;
  