       return
 
 
+  # like on() but for combining multiple events.
+  # waits for all specified events to occur before calling the listener.
+  # if there are multiple arguments to one or more event, set `many` option:
+  #   eventa.waitFor(['a', 'b', 'c'], fn, class, {many:true})
+  waitFor: (nameArray, fn, context, options) ->
+
+    array = new Array nameArray.length
+    count = 0
+
+    for event, index in nameArray
+
+      # if we have them all then call the function.
+      @on event, do (index) -> (arg) ->
+
+        unless array[index]? then count++
+        # else # TODO: warn it's overwriting the object...
+
+        array[index] =
+          unless options?.many is true then arg
+          else
+            args = []
+            args.push.apply args, arguments
+            # still check if there's only one to provide it direct
+            if args.length is 1 then args[0] else args
+
+        if count is nameArray.length
+          fn.apply context, array
+          # reset for next round (feature creep? unneeded?)
+          count = 0
+          array = new Array nameArray.length
+
+        return
+
+
 
 module.exports = (options, dir) -> new Eventa options, dir


  # ready the array it uses to store info.
  # accepts `options` as an array of modules/functions to load.
  constructor: (options, dir) ->
    @_info = []

    if Array.isArray options then @load options, dir


  # gets the array of listeners from the info array by searching the

  # so, cleanup() won't clean up if there hasn't been an emit()
  cleanup: ->
    clean = @_cleanListeners
    @_info = @_info.filter (info) ->
      # let's also rebuild the listeners array
      info.listeners = info.listeners.filter (el) -> el?
      clean(info.listeners).length > 0


  # look thru array and shift existing elements left to compact them together.
