anchor.diff:  
     // Function closures aren't canonicalized: need to have one pointer for the
     // listener's handler that is added/removed.
  -  EventListener _captureHandler;
  -  EventListener _resizeHandler;
  +  EventListener _captureHandlerInst;
  +  EventListener _resizeHandlerInst;
   
     SparkOverlay.created(): super.created() {
  -    _captureHandler = captureHandler;
  -    _resizeHandler = resizeHandler;
  +    _captureHandlerInst = _captureHandler;
  +    _resizeHandlerInst = _resizeHandler;
     }
   
     bool _opened = false;
  
positive.code:         e..stopPropagation()..preventDefault();
        }
        if (autoClose) {
          autoCloseTask = new Timer(Duration.ZERO, () { opened = false; });
        }
      }
    }
  
    bool isPointInOverlay(Point xyGlobal) {
      return super.getBoundingClientRect().containsPoint(xyGlobal);
    }
  
    void keyDownHandler(KeyboardEvent e) {
      if (e.keyCode == KeyCode.ESC) {
        opened = false;
      }
  
negative.code: 
    void _enableResizeHandler(inEnable) {
      if (inEnable) {
        window.addEventListener('resize', _resizeHandlerInst);
      } else {
        window.removeEventListener('resize', _resizeHandlerInst);
      }
    }
  
    void _enableCaptureHandler(bool enable, Iterable<String> eventTypes) {
      final Function addRemoveFunc =
          enable ? document.addEventListener : document.removeEventListener;
      eventTypes.forEach((et) => addRemoveFunc(et, _captureHandlerInst, true));
    }
  
    void _applyFocus() {
      if (opened) {
        focus();
      } else {
        // Focus the next overlay in the stack.
        _focusOverlay();
      }
    }
  
    void _renderOpened() {
      classes.remove('closing');
      classes.add('revealed');
      // continue styling after delay so display state can change without
      // aborting transitions
      Timer.run(() { _continueRenderOpened(); });
  //    asyncMethod('continueRenderOpened');
    }
  
    void _continueRenderOpened() {
      classes.toggle('opened', opened);
      classes.toggle('closing', !opened);
  //    this.animating = this.asyncMethod('completeOpening', null, this.timeout);
    }
  
    void _completeOpening() {
  //    clearTimeout(this.animating);
      classes.remove('closing');
      classes.toggle('revealed', opened);
      _applyFocus();
    }
  
    void _openedAnimationEnd(AnimationEvent e) {
      if (!opened) {
        classes.remove('animation-in-progress');
      }
      // same steps as when a transition ends
      _openedTransitionEnd(e);
    }
  
    void _openedTransitionEnd(Event e) {
      // TODO(sorvell): Necessary due to
      // https://bugs.webkit.org/show_bug.cgi?id=107892
      // Remove when that bug is addressed.
      if (e.target == this) {
        _completeOpening();
        e.stopImmediatePropagation();
        e.preventDefault();
      }
    }
  
    void _openedAnimationStart(AnimationEvent e) {
      classes.add('animation-in-progress');
      e.stopImmediatePropagation();
      e.preventDefault();
    }
  
    void _tapHandler(MouseEvent e) {
      Element target = e.target;
      if (target != null && target.attributes.containsKey('overlay-toggle')) {
        toggle();
      } else if (_autoCloseTask != null) {
        _autoCloseTask.cancel();
        _autoCloseTask = null;
      }
    }
  
    void _captureHandler(Event e) {
      final bool inOverlay =
          (e is MouseEvent && _isPointInOverlay(e.client)) ||
          this == e.target ||
          this.contains(e.target) ||
          shadowRoot.contains(e.target);
  