very simple event proto module, with delegation

events.js

define("events", ["utils", "dom"], function(utils, dom) {
  var events = []
    , slice = utils.borrow.slice

  function addEvent(/* arguments */) {
    var args = slice.call(arguments)
      , thisEvent = {}

    if(!args[0]._events) {
      args[0]._events = []
    }

    thisEvent.node = args[0]
    thisEvent.type = args[1]

    if (args.length == 3) {
      thisEvent.handler = args[2]
      args[0].addEventListener(args[1], args[2])
    } else {
      thisEvent.delegated = args[2]
      thisEvent.handler = args[3]
      thisEvent.delegatedHandler = checkDelegation(args[2], thisEvent)

      args[0].addEventListener(args[1], thisEvent.delegatedHandler)
    }

    // set an ID
    thisEvent.id = args[0]._events.push(thisEvent)
    events.push(thisEvent)
  }

  function checkDelegation(node, thisEvent) {
    return function(e) {
      var nodeToCheck = e.target
        , delegated = new dom(thisEvent.delegated)
        , domEL = null
      
      // loop on parent and check for possible delegated
      while(!!nodeToCheck) {
        domEl = new dom(nodeToCheck)
        
        if(domEl.is(thisEvent.delegated)) {
          e.delegatedTarget = nodeToCheck
          thisEvent.handler(e)

          return
        }

        nodeToCheck = nodeToCheck.parentNode
      }
    }
  }

  function removeEvent() {
    var args = slice.call(arguments)
      , thisEvents = args[0]._events

    if(!thisEvents) {
      return // LOL WHUT?
    }

    for (var i = 0, max = thisEvents.length, thisEvent; i < max; i++) {
      thisEvent = thisEvents[i]
      
      if (args.length == 3 && args[1] == thisEvent.type && args[2] == thisEvent.handler) {
        args[0].removeEventListener(args[1], args[2])
      } else if (args[1] == thisEvent.type && args[2] == thisEvent.delegated && args[3] == thisEvent.handler) {
        args[0].removeEventListener(args[1], thisEvent.delegatedHandler)
      }
    }
  }

  function flush() {
    var thisEvent

    for (var i = events.length; i--; ) {
      thisEvent = events[i]

      if(!!thisEvent.delegatedHandler) {
        thisEvent.node.removeEventListener(thisEvent.type, thisEvent.delegatedHandler)
      } else {
        thisEvent.node.removeEventListener(thisEvent.type, thisEvent.handler)
      }
    }

    events = []
  }

  return {
    flush: flush,
    addEvent: addEvent,
    removeEvent: removeEvent
  }
})