/*!

* Bean - copyright (c) Jacob Thornton 2011-2012

* https://github.com/fat/bean

* MIT license

*/

(function (name, context, definition) {

if (typeof module != 'undefined' && module.exports) module.exports = definition()

else if (typeof define == 'function' && define.amd) define(definition)

else context[name] = definition()

})('bean', this, function (name, context) {

name = name || 'bean'

context = context || this

var win = window

, old = context[name]

, namespaceRegex = /[^\.]*(?=\..*)\.|.*/

, nameRegex = /\..*/

, addEvent = 'addEventListener'

, removeEvent = 'removeEventListener'

, doc = document || {}

, root = doc.documentElement || {}

, W3C_MODEL = root[addEvent]

, eventSupport = W3C_MODEL ? addEvent : 'attachEvent'

, // singleton for quick matching making add() do one()

, slice = Array.prototype.slice

, str2arr = function (s, d) { return s.split(d || ' ') }

, isString = function (o) { return typeof o == 'string' }

, isFunction = function (o) { return typeof o == 'function' }

// events that we consider to be 'native', anything not in this list will

// be treated as a custom event

, standardNativeEvents =

'click dblclick mouseup mousedown contextmenu ' + // mouse buttons

'mousewheel mousemultiwheel DOMMouseScroll ' + // mouse wheel

'mouseover mouseout mousemove selectstart selectend ' + // mouse movement

'keydown keypress keyup ' + // keyboard

'orientationchange ' + // mobile

'focus blur change reset select submit ' + // form elements

'load unload beforeunload resize move DOMContentLoaded ' + // window

'readystatechange message ' + // window

'error abort scroll ' // misc

// element.fireEvent('onXYZ'... is not forgiving if we try to fire an event

// that doesn't actually exist, so make sure we only do these on newer browsers

, w3cNativeEvents =

'show ' + // mouse buttons

'input invalid ' + // form elements

'touchstart touchmove touchend touchcancel ' + // touch

'gesturestart gesturechange gestureend ' + // gesture

'textinput ' + // TextEvent

'readystatechange pageshow pagehide popstate ' + // window

'hashchange offline online ' + // window

'afterprint beforeprint ' + // printing

'dragstart dragenter dragover dragleave drag drop dragend ' + // dnd

'loadstart progress suspend emptied stalled loadmetadata ' + // media

'loadeddata canplay canplaythrough playing waiting seeking ' + // media

'seeked ended durationchange timeupdate play pause ratechange ' + // media

'volumechange cuechange ' + // media

'checking noupdate downloading cached updateready obsolete ' // appcache

// convert to a hash for quick lookups

, nativeEvents = (function (hash, events, i) {

for (i = 0; i < events.length; i++) events[i] && (hash[events[i]] = 1)

return hash

}({}, str2arr(standardNativeEvents + (W3C_MODEL ? w3cNativeEvents : ''))))

// custom events are events that we *fake*, they are not provided natively but

// we can use native events to generate them

, customEvents = (function () {

var isAncestor = 'compareDocumentPosition' in root

? function (element, container) {

return container.compareDocumentPosition && (container.compareDocumentPosition(element) & 16) === 16

}

: 'contains' in root

? function (element, container) {

container = container.nodeType === 9 || container === window ? root : container

return container !== element && container.contains(element)

}

: function (element, container) {

while (element = element.parentNode) if (element === container) return 1

return 0

}

, check = function (event) {

}

return {

mouseenter: { base: 'mouseover', condition: check }

, mouseleave: { base: 'mouseout', condition: check }

, mousewheel: { base: /Firefox/.test(navigator.userAgent) ? 'DOMMouseScroll' : 'mousewheel' }

}

}())

// we provide a consistent Event object across browsers by taking the actual DOM

// event object and generating a new one from its properties.

, Event = (function () {

// a whitelist of properties (for different event types) tells us what to check for and copy

var commonProps = str2arr('altKey attrChange attrName bubbles cancelable ctrlKey currentTarget ' +

'detail eventPhase getModifierState isTrusted metaKey relatedNode relatedTarget shiftKey ' +

'srcElement target timeStamp type view which propertyName')

, mouseProps = commonProps.concat(str2arr('button buttons clientX clientY dataTransfer ' +

'fromElement offsetX offsetY pageX pageY screenX screenY toElement'))

, mouseWheelProps = mouseProps.concat(str2arr('wheelDelta wheelDeltaX wheelDeltaY wheelDeltaZ ' +

'axis')) // 'axis' is FF specific

, keyProps = commonProps.concat(str2arr('char charCode key keyCode keyIdentifier ' +

'keyLocation location'))

, textProps = commonProps.concat(str2arr('data'))

, touchProps = commonProps.concat(str2arr('touches targetTouches changedTouches scale rotation'))

, messageProps = commonProps.concat(str2arr('data origin source'))

, stateProps = commonProps.concat(str2arr('state'))

, overOutRegex = /over|out/

// some event types need special handling and some need special properties, do that all here

, typeFixers = [

{ // key events

reg: /key/i

, fix: function (event, newEvent) {

newEvent.keyCode = event.keyCode || event.which

return keyProps

}

}

, { // mouse events

reg: /click|mouse(?!(.*wheel|scroll))|menu|drag|drop/i

, fix: function (event, newEvent, type) {

}

}

, { // mouse wheel events

reg: /mouse.*(wheel|scroll)/i

, fix: function () { return mouseWheelProps }

}

, { // TextEvent

reg: /^text/i

, fix: function () { return textProps }

}

, { // touch and gesture events

reg: /^touch|^gesture/i

, fix: function () { return touchProps }

}

, { // message events

reg: /^message$/i

, fix: function () { return messageProps }

}

, { // popstate events

reg: /^popstate$/i

, fix: function () { return stateProps }

}

, { // everything else

reg: /.*/

, fix: function () { return commonProps }

}

]

, typeFixerMap = {} // used to map event types to fixer functions (above), a basic cache mechanism

, Event = function (event, element, isNative) {

}

// preventDefault() and stopPropagation() are a consistent interface to those functions

// on the DOM, stop() is an alias for both of them together

Event.prototype.preventDefault = function () {

if (this.originalEvent.preventDefault) this.originalEvent.preventDefault()

else this.originalEvent.returnValue = false

}

Event.prototype.stopPropagation = function () {

if (this.originalEvent.stopPropagation) this.originalEvent.stopPropagation()

else this.originalEvent.cancelBubble = true

}

Event.prototype.stop = function () {

}

// stopImmediatePropagation() has to be handled internally because we manage the event list for

// each element

// note that originalElement may be a Bean#Event object in some situations

Event.prototype.stopImmediatePropagation = function () {

if (this.originalEvent.stopImmediatePropagation) this.originalEvent.stopImmediatePropagation()

this.isImmediatePropagationStopped = function () { return true }

}

Event.prototype.isImmediatePropagationStopped = function () {

return this.originalEvent.isImmediatePropagationStopped && this.originalEvent.isImmediatePropagationStopped()

}

Event.prototype.clone = function (currentTarget) {

}

return Event

}())

// if we're in old IE we can't do onpropertychange on doc or win so we use doc.documentElement for both

, targetElement = function (element, isNative) {

return !W3C_MODEL && !isNative && (element === doc || element === win) ? root : element

}

/**

* Bean maintains an internal registry for event listeners. We don't touch elements, objects

* or functions to identify them, instead we store everything in the registry.

* Each event listener has a RegEntry object, we have one 'registry' for the whole instance.

*/

, RegEntry = (function () {

// each handler is wrapped so we can handle delegation and custom events

var wrappedHandler = function (element, fn, condition, args) {

}

, RegEntry = function (element, type, handler, original, namespaces, args, root) {

}

// given a list of namespaces, is our entry in any of them?

RegEntry.prototype.inNamespaces = function (checkNamespaces) {

}

// match by element, original fn (opt), handler fn (opt)

RegEntry.prototype.matches = function (checkElement, checkOriginal, checkHandler) {

}

return RegEntry

}())

, registry = (function () {

// our map stores arrays by event type, just because it's better than storing

// everything in a single array.

// uses '$' as a prefix for the keys for safety and 'r' as a special prefix for

// rootListeners so we can look them up fast

var map = {}

// generic functional search of our registry for matching listeners,

// `fn` returns false to break out of the loop

, forAll = function (element, type, original, handler, root, fn) {

}

, has = function (element, type, original, root) {

}

, get = function (element, type, original, root) {

}

, put = function (entry) {

}

, del = function (entry) {

}

// dump all entries, used for onunload

, entries = function () {

}

return { has: has, get: get, put: put, del: del, entries: entries }

}())

// we need a selector engine for delegated events, use querySelectorAll if it exists

// but for older browsers we need Qwery, Sizzle or similar

, selectorEngine

, setSelectorEngine = function (e) {

}

// we attach this listener to each DOM event that we need to listen to, only once

// per event type per DOM element

, rootListener = function (event, type) {

}

// add and remove listeners to DOM elements

, listener = W3C_MODEL

? function (element, type, add) {

// new browsers

element[add ? addEvent : removeEvent](type, rootListener, false)

}

: function (element, type, add, custom) {

// IE8 and below, use attachEvent/detachEvent and we have to piggy-back propertychange events

// to simulate event bubbling etc.

var entry

if (add) {

registry.put(entry = new RegEntry(

element

, custom || type

, function (event) { // handler

rootListener.call(element, event, custom)

}

, rootListener

, null

, null

, true // is root

))

if (custom && element['_on' + custom] == null) element['_on' + custom] = 0

entry.target.attachEvent('on' + entry.eventType, entry.handler)

} else {

entry = registry.get(element, custom || type, rootListener, true)[0]

if (entry) {

entry.target.detachEvent('on' + entry.eventType, entry.handler)

registry.del(entry)

}

}

}

, (rm, element, type, fn, originalFn) {

}

, removeListener = function (element, orgType, handler, namespaces) {

}

// set up a delegate helper using the given selector, wrap the handler function

, delegate = function (selector, fn) {

}

, fireListener = W3C_MODEL ? function (isNative, type, element) {

// modern browsers, do a proper dispatchEvent()

var evt = doc.createEvent(isNative ? 'HTMLEvents' : 'UIEvents')

evt[isNative ? 'initEvent' : 'initUIEvent'](type, true, true, win, 1)

element.dispatchEvent(evt)

} : function (isNative, type, element) {

// old browser use onpropertychange, just increment a custom property to trigger the event

element = targetElement(element, isNative)

isNative ? element.fireEvent('on' + type, doc.createEventObject()) : element['_on' + type]++

}

/**

* Public API: off(), on(), add(), (remove()), one(), fire(), clone()

*/

/**

* off(element[, eventType(s)[, handler ]])

*/

, off = function (element, typeSpec, fn) {

}

/**

* on(element, eventType(s)[, selector], handler[, args ])

*/

, on = function(element, events, selector, fn) {

}

/**

* add(element[, selector], eventType(s), handler[, args ])

*

* Deprecated: kept (for now) for backward-compatibility

*/

, add = function (element, events, fn, delfn) {

}

/**

* one(element, eventType(s)[, selector], handler[, args ])

*/

, () {

return on.apply(ONE, arguments)

}

/**

* fire(element, eventType(s)[, args ])

*

* The optional 'args' argument must be an array, if no 'args' argument is provided

* then we can use the browser's DOM event system, otherwise we trigger handlers manually

*/

, fire = function (element, type, args) {

}

/**

* clone(dstElement, srcElement[, eventType ])

*

* TODO: perhaps for consistency we should allow the same flexibility in type specifiers?

*/

, clone = function (element, from, type) {

}

, bean = {

'on' : on

, 'add' : add

, 'one' : one

, 'off' : off

, 'remove' : off

, 'clone' : clone

, 'fire' : fire

, 'Event' : Event

, 'setSelectorEngine' : setSelectorEngine

, 'noConflict' : function () {

context[name] = old

return this

}

}

// for IE, clean up on unload to avoid leaks

if (win.attachEvent) {

var cleanup = function () {

}

win.attachEvent('onunload', cleanup)

}

// initialize selector engine to internal default (qSA or throw Error)

setSelectorEngine()

return bean

});