anchor.diff:  
   class RouteEvent {
     final String path;
  -  Function _responseCall;
  -
  -  RouteEvent(this.path, Function this._responseCall);
  -
  -  void allowLeave(Future<bool> veto) {
  -    _responseCall(veto);
  -  }
  -
  -  RouteEvent _clone(Function newRespCall) => new RouteEvent(path, newRespCall);
  +  Future<bool> _allowLeaveFuture;
  +
  +  RouteEvent(this.path);
  +
  +  void allowLeave(Future<bool> allow) {
  +    _allowLeaveFuture = allow;
  +  }
  +
  +  RouteEvent _clone() => new RouteEvent(path);
   }
   
   abstract class Routable {
  
positive.code:    * with the path version of the URL by converting the # to a /.
     */
    Future handle(String path) {
      Completer completer = new Completer();
      List matchingRoutes = _routes.where((r) => matchesPrefix(r.path, path)).toList();
      if (!matchingRoutes.isEmpty) {
        if (matchingRoutes.length > 1) {
          _logger.warning("More than one route matches $path");
  
negative.code:       } else {
          _logger.info("Unhandled path: $path");
        }
      }
      return new Future.value();
    }
  
    Future _processNewRoute(String path, String tailPath, Match match,
                            _Route route) {
      var headPath = path.substring(0, match.end);
      var event = new RouteEvent(headPath);
      // before we make this a new current route, leave the old
      return _leaveCurrentRoute(event).then((bool allowNavigation) {
        if (allowNavigation) {
          _currentRoute = route;
          if (route.enter != null) {
            route.enter(event);
          }
          if (route.child != null) {
            return route.child.handle(tailPath);
          }
        }
      });
    }
  
    Future<bool> _leaveCurrentRoute(RouteEvent e) =>
        Future.wait(_leaveCurrentRouteHelper(e))
            .then((values) => values.fold(true, (c, v) => c && v));
  
    List<Future<bool>> _leaveCurrentRouteHelper(RouteEvent e) {
      var futures = [];
      if (_currentRoute != null) {
        List<Future<bool>> pendingResponses = <Future<bool>>[];
        // We create a copy of the route event
        var event = e._clone();
        if (_currentRoute.leave != null) {
          _currentRoute.leave(event);
        }
        if (event._allowLeaveFuture != null) {
          futures.add(event._allowLeaveFuture);
        }
        if (_currentRoute.child != null) {
          futures.addAll(_currentRoute.child._leaveCurrentRoute(event));
        }
      }
      return futures;
    }
  
    /**
  