anchor.diff:    /// See [Draggable] constructor.
     AvatarHandler avatarHandler;
   
  -  /// When set to true, only horizontal dragging is tracked. This enables 
  +  /// When set to true, only horizontal dragging is tracked. This enables
     /// vertical touch dragging to be used for scrolling.
     bool horizontalOnly;
  -  
  -  /// When set to true, only vertical dragging is tracked. This enables 
  +
  +  /// When set to true, only vertical dragging is tracked. This enables
     /// horizontal touch dragging to be used for scrolling.
     bool verticalOnly;
   
  -  /// Restricts dragging from starting to the [handle]. 
  +  /// Restricts dragging from starting to the [handle].
     /// See [Draggable] constructor.
     String handle;
  -  
  -  /// Prevents dragging from starting on specified elements. 
  +
  +  /// Prevents dragging from starting on specified elements.
     /// See [Draggable] constructor.
     String cancel;
  -  
  +
     /// CSS class set to the dragged element during a drag.
     /// See [Draggable] constructor.
     String draggingClass;
  -  
  -  /// CSS class set to the html body tag during a drag. 
  +
  +  /// CSS class set to the html body tag during a drag.
     /// See [Draggable] constructor.
     String draggingClassBody;
  -  
  +
     // -------------------
     // Events
     // -------------------
     StreamController<DraggableEvent> _onDragStart;
     StreamController<DraggableEvent> _onDrag;
     StreamController<DraggableEvent> _onDragEnd;
  -  
  -  /// Fired when the user starts dragging. 
  -  /// 
  -  /// Note: The [onDragStart] is fired not on touchStart or mouseDown but as 
  -  /// soon as there is a drag movement. When a drag is started an [onDrag] event 
  +
  +  /// Fired when the user starts dragging.
  +  ///
  +  /// Note: The [onDragStart] is fired not on touchStart or mouseDown but as
  +  /// soon as there is a drag movement. When a drag is started an [onDrag] event
     /// will also be fired.
     Stream<DraggableEvent> get onDragStart {
       if (_onDragStart == null) {
  -      _onDragStart = new StreamController<DraggableEvent>.broadcast(sync: true, 
  +      _onDragStart = new StreamController<DraggableEvent>.broadcast(sync: true,
             onCancel: () => _onDragStart = null);
       }
       return _onDragStart.stream;
     }
  -  
  -  /// Fired periodically throughout the drag operation. 
  +
  +  /// Fired periodically throughout the drag operation.
     Stream<DraggableEvent> get onDrag {
       if (_onDrag == null) {
  -      _onDrag = new StreamController<DraggableEvent>.broadcast(sync: true, 
  +      _onDrag = new StreamController<DraggableEvent>.broadcast(sync: true,
             onCancel: () => _onDrag = null);
       }
       return _onDrag.stream;
     }
  -  
  -  /// Fired when the user ends the dragging. 
  -  /// Is also fired when the user clicks the 'esc'-key or the window loses focus. 
  +
  +  /// Fired when the user ends the dragging.
  +  /// Is also fired when the user clicks the 'esc'-key or the window loses focus.
     Stream<DraggableEvent> get onDragEnd {
       if (_onDragEnd == null) {
  -      _onDragEnd = new StreamController<DraggableEvent>.broadcast(sync: true, 
  +      _onDragEnd = new StreamController<DraggableEvent>.broadcast(sync: true,
             onCancel: () => _onDragEnd = null);
       }
       return _onDragEnd.stream;
     }
  -  
  +
     // -------------------
     // Private Properties
     // -------------------
     /// The [Element] or [ElementList] on which a drag is detected.
     final _elementOrElementList;
  -  
  +
     /// Managers for browser events.
     final List<_EventManager> _eventManagers = [];
  -  
  -  /// Creates a new [Draggable] for [elementOrElementList]. The 
  +
  +  /// Creates a new [Draggable] for [elementOrElementList]. The
     /// [elementOrElementList] must be of type [Element] or [ElementList].
  -  /// 
  -  /// 
  +  ///
  +  ///
     /// ## Options
  -  /// 
  -  /// The [avatarHandler]  is responsible for creating, position, and 
  +  ///
  +  /// The [avatarHandler]  is responsible for creating, position, and
     /// removing a drag avatar. A drag avatar provides visual feedback during a
     /// drag operation. Here are possible options for the [avatarHandler] :
  -  /// 
  +  ///
     /// * null (the default) - will not create a drag avatar
  -  /// * new [AvatarHandler.original] - handler that uses the original 
  +  /// * new [AvatarHandler.original] - handler that uses the original
     ///   draggable as avatar. See [OriginalAvatarHandler].
  -  /// * new [AvatarHandler.clone] - handler that uses a clone of the draggable 
  +  /// * new [AvatarHandler.clone] - handler that uses a clone of the draggable
     ///   element as avatar. See [CloneAvatarHandler].
  -  /// * A custom [AvatarHandler] - you can provide your own implementation of 
  +  /// * A custom [AvatarHandler] - you can provide your own implementation of
     ///   [AvatarHandler].
  -  /// 
  +  ///
     /// If [horizontalOnly] is set to true, only horizontal dragging is tracked.
     /// This enables vertical touch dragging to be used for scrolling.
  -  /// 
  +  ///
     /// If [verticalOnly] is set to true, only vertical dragging is tracked.
     /// This enables horizontal touch dragging to be used for scrolling.
  -  /// 
  -  /// If a [handle] query String is specified, it restricts the dragging from 
  -  /// starting unless it occurs on the specified element(s). Only elements that 
  -  /// descend from [elementOrElementList] are permitted. 
  -  /// 
  -  /// If [cancel] query String is specified, drag starting is prevented on 
  +  ///
  +  /// If a [handle] query String is specified, it restricts the dragging from
  +  /// starting unless it occurs on the specified element(s). Only elements that
  +  /// descend from [elementOrElementList] are permitted.
  +  ///
  +  /// If [cancel] query String is specified, drag starting is prevented on
     /// specified elements.
  -  /// 
  -  /// The [draggingClass] is the css class set to the dragged element 
  +  ///
  +  /// The [draggingClass] is the css class set to the dragged element
     /// during a drag. If set to null, no such css class is added.
  -  /// 
  +  ///
     /// The [draggingClassBody] is the css class set to the html body tag
     /// during a drag. If set to null, no such css class is added.
  -  Draggable(elementOrElementList, 
  +  Draggable(elementOrElementList,
         { this.avatarHandler: null,
  -        this.horizontalOnly: false, 
  -        this.verticalOnly: false, 
  -        this.handle: null, 
  +        this.horizontalOnly: false,
  +        this.verticalOnly: false,
  +        this.handle: null,
           this.cancel: 'input, textarea, button, select, option',
           this.draggingClass: 'dnd-dragging',
  -        this.draggingClassBody: 'dnd-drag-occurring'}) 
  -        
  +        this.draggingClassBody: 'dnd-drag-occurring'})
  +
         : this._elementOrElementList = elementOrElementList {
  -    
  +
       // Detect IE Pointer Event Support.
       JsObject jsWindow = new JsObject.fromBrowserObject(window);
       JsObject jsNavigator = jsWindow['navigator'];
  -    
  +
       if (jsNavigator.hasProperty('pointerEnabled')) {
         // We're on IE11 or higher supporting pointerEvents.
         _eventManagers.add(new _PointerManager(this));
  -      
  +
       } else if (jsNavigator.hasProperty('msPointerEnabled')){
         // We're on IE10 supporting msPointerEvents.
         _eventManagers.add(new _PointerManager(this, msPrefix: true));
  -      
  +
       } else {
         // We're on other browsers. Install touch and mouse listeners.
         if (TouchEvent.supported) {
  
positive.code:         document.body.classes.remove(draggingClassBody);
        }
      }
      
      // Reset.
      _resetCurrentDrag();
    }
    
    /// Makes sure that a potential click event is ignored. This is necessary for
    /// [MouseEvent]s. We have to wait for and cancel a potential click event 
    /// happening after the mouseUp event. 
    void _suppressClickEvent() {
      StreamSubscription clickPreventer = _elementOrElementList.onClick.listen((event) {
        event.stopPropagation();
        event.preventDefault();
      });
      
      // Wait until the end of event loop to see if a click event is fired.
      // Then cancel the listener.
      new Future(() {
  
negative.code:       _eventManagers.add(new _MouseManager(this));
      }
    }
  
    /// Handles the drag start. The [moveEvent] might either be a
    /// [TouchEvent] or a [MouseEvent].
    void _handleDragStart(UIEvent moveEvent) {
      // Set the drag started flag.
      _currentDrag.started = true;
  
      // Pass event to AvatarHandler.
      if (avatarHandler != null) {
        avatarHandler.dragStart(_currentDrag.element, _currentDrag.position);
      }
  
      // Fire the drag start event with start position.
      if (_onDragStart != null) {
        // The dragStart has the same for startPosition and current position.
        _onDragStart.add(new DraggableEvent._(moveEvent, _currentDrag));
      }
  
      // Add the css classes during the drag operation.
      if (draggingClass != null) {
        _currentDrag.element.classes.add(draggingClass);
  