docs: function (pointer, event, eventTarget, curEventTarget) {
              var endEvent,
                  target = this.target,
                  options = target && target.options,
                  inertiaOptions = options && this.prepared.name && options[this.prepared.name].inertia,
                  inertiaStatus = this.inertiaStatus;
  
              if (this.interacting()) {
  
                  if (inertiaStatus.active && !inertiaStatus.ending) { return; }
  
                  var pointerSpeed,
                      now = new Date().getTime(),
                      inertiaPossible = false,
                      inertia = false,
                      smoothEnd = false,
                      endSnap = checkSnap(target, this.prepared.name) && options[this.prepared.name].snap.endOnly,
                      endRestrict = checkRestrict(target, this.prepared.name) && options[this.prepared.name].restrict.endOnly,
                      dx = 0,
                      dy = 0,
                      startEvent;
  
                  if (this.dragging) {
                      if      (options.drag.axis === 'x' ) { pointerSpeed = Math.abs(this.pointerDelta.client.vx); }
                      else if (options.drag.axis === 'y' ) { pointerSpeed = Math.abs(this.pointerDelta.client.vy); }
                      else   /*options.drag.axis === 'xy'*/{ pointerSpeed = this.pointerDelta.client.speed; }
                  }
                  else {
                      pointerSpeed = this.pointerDelta.client.speed;
                  }
  
                  // check if inertia should be started
                  inertiaPossible = (inertiaOptions && inertiaOptions.enabled
                                     && this.prepared.name !== 'gesture'
                                     && event !== inertiaStatus.startEvent);
  
                  inertia = (inertiaPossible
                             && (now - this.curCoords.timeStamp) < 50
                             && pointerSpeed > inertiaOptions.minSpeed
                             && pointerSpeed > inertiaOptions.endSpeed);
  
                  if (inertiaPossible && !inertia && (endSnap || endRestrict)) {
  
                      var snapRestrict = {};
  
                      snapRestrict.snap = snapRestrict.restrict = snapRestrict;
  
                      if (endSnap) {
                          this.setSnapping(this.curCoords.page, snapRestrict);
                          if (snapRestrict.locked) {
                              dx += snapRestrict.dx;
                              dy += snapRestrict.dy;
                          }
                      }
  
                      if (endRestrict) {
                          this.setRestriction(this.curCoords.page, snapRestrict);
                          if (snapRestrict.restricted) {
                              dx += snapRestrict.dx;
                              dy += snapRestrict.dy;
                          }
                      }
  
                      if (dx || dy) {
                          smoothEnd = true;
                      }
                  }
  
                  if (inertia || smoothEnd) {
                      copyCoords(inertiaStatus.upCoords, this.curCoords);
  
                      this.pointers[0] = inertiaStatus.startEvent = startEvent =
                          new InteractEvent(this, event, this.prepared.name, 'inertiastart', this.element);
  
                      inertiaStatus.t0 = now;
  
                      target.fire(inertiaStatus.startEvent);
  
                      if (inertia) {
                          inertiaStatus.vx0 = this.pointerDelta.client.vx;
                          inertiaStatus.vy0 = this.pointerDelta.client.vy;
                          inertiaStatus.v0 = pointerSpeed;
  
                          this.calcInertia(inertiaStatus);
  
                          var page = extend({}, this.curCoords.page),
                              origin = getOriginXY(target, this.element),
                              statusObject;
  
                          page.x = page.x + inertiaStatus.xe - origin.x;
                          page.y = page.y + inertiaStatus.ye - origin.y;
  
                          statusObject = {
                              useStatusXY: true,
                              x: page.x,
                              y: page.y,
                              dx: 0,
                              dy: 0,
                              snap: null
                          };
  
                          statusObject.snap = statusObject;
  
                          dx = dy = 0;
  
                          if (endSnap) {
                              var snap = this.setSnapping(this.curCoords.page, statusObject);
  
                              if (snap.locked) {
                                  dx += snap.dx;
                                  dy += snap.dy;
                              }
                          }
  
                          if (endRestrict) {
                              var restrict = this.setRestriction(this.curCoords.page, statusObject);
  
                              if (restrict.restricted) {
                                  dx += restrict.dx;
                                  dy += restrict.dy;
                              }
                          }
  
                          inertiaStatus.modifiedXe += dx;
                          inertiaStatus.modifiedYe += dy;
  
                          inertiaStatus.i = reqFrame(this.boundInertiaFrame);
                      }
                      else {
                          inertiaStatus.smoothEnd = true;
                          inertiaStatus.xe = dx;
                          inertiaStatus.ye = dy;
  
                          inertiaStatus.sx = inertiaStatus.sy = 0;
  
                          inertiaStatus.i = reqFrame(this.boundSmoothEndFrame);
                      }
  
                      inertiaStatus.active = true;
                      return;
                  }
  
                  if (endSnap || endRestrict) {
                      // fire a move event at the snapped coordinates
                      this.pointerMove(pointer, event, eventTarget, curEventTarget, true);
                  }
              }
  
              if (this.dragging) {
                  endEvent = new InteractEvent(this, event, 'drag', 'end', this.element);
  
                  var draggableElement = this.element,
                      drop = this.getDrop(endEvent, event, draggableElement);
  
                  this.dropTarget = drop.dropzone;
                  this.dropElement = drop.element;
  
                  var dropEvents = this.getDropEvents(event, endEvent);
  
                  if (dropEvents.leave) { this.prevDropTarget.fire(dropEvents.leave); }
                  if (dropEvents.enter) {     this.dropTarget.fire(dropEvents.enter); }
                  if (dropEvents.drop ) {     this.dropTarget.fire(dropEvents.drop ); }
                  if (dropEvents.deactivate) {
                      this.fireActiveDrops(dropEvents.deactivate);
                  }
  
                  target.fire(endEvent);
              }
              else if (this.resizing) {
                  endEvent = new InteractEvent(this, event, 'resize', 'end', this.element);
                  target.fire(endEvent);
              }
              else if (this.gesturing) {
                  endEvent = new InteractEvent(this, event, 'gesture', 'end', this.element);
                  target.fire(endEvent);
              }
  
              this.stop(event);
          }