anchor.diff:    }
   
   
  +  /**
  +   * Registers a scope-based event listener to intercept events triggered by
  +   * [$broadcast] (from any parent scopes) or [$emit] (from child scopes) that
  +   * match the given event name. $on accepts two arguments:
  +   * 
  +   * * [name] - Refers to the event name that the scope will listen on. 
  +   * * [listener] - Refers to the callback function which is executed when the event
  +   *   is intercepted.
  +   *
  +   *
  +   * When the listener function is executed, an instance of [ScopeEvent] will be passed
  +   * as the first parameter to the function.
  +   *
  +   * Any additional parameters available within the listener callback function are those that
  +   * are set by the $broadcast or $emit scope methods (which are set by the origin scope which
  +   * is the scope that first triggered the scope event).
  +   */
     $on(name, listener) {
       var namedListeners = _listeners[name];
       if (!_listeners.containsKey(name)) {
  
positive.code: 
  
  /**
   * Used by [Scope.$on] to notify the listeners of events.
   */
  class ScopeEvent {
    String name;
    Scope targetScope;
    Scope currentScope;
    bool propagationStopped = false;
    bool defaultPrevented = false;
  
    ScopeEvent(this.name, this.targetScope);
  
    stopPropagation () => propagationStopped = true;
    preventDefault() => defaultPrevented = true;
  }
  
  
negative.code:   }
  
  
    /**
     * Removes the current scope (and all of its children) from the parent scope. Removal implies
     * that calls to $digest() will no longer propagate to the current scope and its children.
     * Removal also implies that the current scope is eligible for garbage collection.
     *
     * The `$destroy()` operation is usually used within directives that perform transclusion on
     * multiple child elements (like ngRepeat) which create multiple child scopes.
     *
     * Just before a scope is destroyed, a `$destroy` event is broadcasted on this scope. This is
     * a great way for child scopes (such as shared directives or controllers) to detect to and
     * perform any necessary cleanup before the scope is removed from the application.
     *
     * Note that, in AngularDart, there is also a `$destroy` jQuery DOM event, which can be used to
     * clean up DOM bindings before an element is removed from the DOM.
     */
    $destroy() {
      if ($root == this) return; // we can't remove the root node;
  
  