docs: function (eventType, listener, useCapture) {
              var i;
  
              if (isString(eventType) && eventType.search(' ') !== -1) {
                  eventType = eventType.trim().split(/ +/);
              }
  
              if (isArray(eventType)) {
                  for (i = 0; i < eventType.length; i++) {
                      this.off(eventType[i], listener, useCapture);
                  }
  
                  return this;
              }
  
              if (isObject(eventType)) {
                  for (var prop in eventType) {
                      this.off(prop, eventType[prop], listener);
                  }
  
                  return this;
              }
  
              var eventList,
                  index = -1;
  
              // convert to boolean
              useCapture = useCapture? true: false;
  
              if (eventType === 'wheel') {
                  eventType = wheelEvent;
              }
  
              // if it is an action event type
              if (contains(eventTypes, eventType)) {
                  eventList = this._iEvents[eventType];
  
                  if (eventList && (index = indexOf(eventList, listener)) !== -1) {
                      this._iEvents[eventType].splice(index, 1);
                  }
              }
              // delegated event
              else if (this.selector) {
                  var delegated = delegatedEvents[eventType],
                      matchFound = false;
  
                  if (!delegated) { return this; }
  
                  // count from last index of delegated to 0
                  for (index = delegated.selectors.length - 1; index >= 0; index--) {
                      // look for matching selector and context Node
                      if (delegated.selectors[index] === this.selector
                          && delegated.contexts[index] === this._context) {
  
                          var listeners = delegated.listeners[index];
  
                          // each item of the listeners array is an array: [function, useCaptureFlag]
                          for (i = listeners.length - 1; i >= 0; i--) {
                              var fn = listeners[i][0],
                                  useCap = listeners[i][1];
  
                              // check if the listener functions and useCapture flags match
                              if (fn === listener && useCap === useCapture) {
                                  // remove the listener from the array of listeners
                                  listeners.splice(i, 1);
  
                                  // if all listeners for this interactable have been removed
                                  // remove the interactable from the delegated arrays
                                  if (!listeners.length) {
                                      delegated.selectors.splice(index, 1);
                                      delegated.contexts .splice(index, 1);
                                      delegated.listeners.splice(index, 1);
  
                                      // remove delegate function from context
                                      events.remove(this._context, eventType, delegateListener);
                                      events.remove(this._context, eventType, delegateUseCapture, true);
  
                                      // remove the arrays if they are empty
                                      if (!delegated.selectors.length) {
                                          delegatedEvents[eventType] = null;
                                      }
                                  }
  
                                  // only remove one listener
                                  matchFound = true;
                                  break;
                              }
                          }
  
                          if (matchFound) { break; }
                      }
                  }
              }
              // remove listener from this Interatable's element
              else {
                  events.remove(this._element, eventType, listener, useCapture);
              }
  
              return this;
          }