docs: function (element, event, callback) {
                  var i, li;
  
                  var normalized = this._normalizeTargetAndEvent(element, event);
                  element = normalized.element;
                  event = normalized.event;
  
                  event = this._getType(event);
  
                  // The element argument can be a string
                  if (this.typesUtil.isString(element)) {
                      element = Aria.$window.document.getElementById(element);
                      if (!element) {
                          return false;
                      }
                  } else if (this._isValidCollection(element)) {
                      var ok = true;
                      for (i = element.length - 1; i > -1; i--) {
                          ok = (this.removeListener(element[i], event, callback) && ok);
                      }
                      return ok;
                  }
  
                  if (!callback || !(callback.call || callback.fn)) {
                      // return false;
                      return this.purgeElement(element, false, event);
                  }
  
                  if ("unload" == event) {
                      if (unloadListeners) {
                          for (i = unloadListeners.length - 1; i > -1; i--) {
                              li = unloadListeners[i];
                              var cbCheck;
                              if (li && ariaUtilsType.isObject(li[FN]) && !li[FN].$Callback) {
                                  cbCheck = ("fn" in callback) && (li[FN].fn == callback.fn);
                              } else {
                                  cbCheck = (li[FN] == callback);
                              }
                              if (li && li[0] == element && li[1] == event && cbCheck) {
                                  if (li[FN] != li[CB]) {
                                      li[CB].$dispose();
                                  }
                                  li[CLEANCB]();
                                  delete li[CLEANCB];
                                  unloadListeners.splice(i, 1);
                                  // unloadListeners[i]=null;
                                  return true;
                              }
                          }
                      }
  
                      return false;
                  }
  
                  var cacheItem = null;
  
                  // The index is a hidden parameter; needed to remove it
                  // from
                  // the method signature because it was tempting users to
                  // try and take advantage of it, which is not possible.
                  var index = arguments[3];
  
                  if ("undefined" === typeof index) {
                      index = this._getCacheIndex(listeners, element, event, callback);
                  }
  
                  if (index >= 0) {
                      cacheItem = listeners[index];
                  }
  
                  if (!element || !cacheItem) {
                      return false;
                  }
  
                  var bCapture = cacheItem[CAPTURE] === true ? true : false;
  
                  try {
                      this._simpleRemove(element, event, cacheItem[WFN], bCapture);
                  } catch (ex) {
                      lastError = ex;
                      return false;
                  }
  
                  // removed the wrapped handler
                  delete listeners[index][WFN];
                  if (listeners[index][FN] != listeners[index][CB]) {
                      listeners[index][CB].$dispose();
                  }
                  listeners[index][CLEANCB]();
                  delete listeners[index][CLEANCB];
  
                  // delete listeners[index][this.callback];
                  listeners.splice(index, 1);
  
                  return true;
  
              }