{"version":3,"file":"js/2087.chunk.js","mappings":"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","sources":["webpack:///./node_modules/bean/bean.js"],"sourcesContent":["/*!\n  * Bean - copyright (c) Jacob Thornton 2011-2012\n  * https://github.com/fat/bean\n  * MIT license\n  */\n(function (name, context, definition) {\n  if (typeof module != 'undefined' && module.exports) module.exports = definition()\n  else if (typeof define == 'function' && define.amd) define(definition)\n  else context[name] = definition()\n})('bean', this, function (name, context) {\n  name    = name    || 'bean'\n  context = context || this\n\n  var win            = window\n    , old            = context[name]\n    , namespaceRegex = /[^\\.]*(?=\\..*)\\.|.*/\n    , nameRegex      = /\\..*/\n    , addEvent       = 'addEventListener'\n    , removeEvent    = 'removeEventListener'\n    , doc            = document || {}\n    , root           = doc.documentElement || {}\n    , W3C_MODEL      = root[addEvent]\n    , eventSupport   = W3C_MODEL ? addEvent : 'attachEvent'\n    , ONE            = {} // singleton for quick matching making add() do one()\n\n    , slice          = Array.prototype.slice\n    , str2arr        = function (s, d) { return s.split(d || ' ') }\n    , isString       = function (o) { return typeof o == 'string' }\n    , isFunction     = function (o) { return typeof o == 'function' }\n\n      // events that we consider to be 'native', anything not in this list will\n      // be treated as a custom event\n    , standardNativeEvents =\n        'click dblclick mouseup mousedown contextmenu '                  + // mouse buttons\n        'mousewheel mousemultiwheel DOMMouseScroll '                     + // mouse wheel\n        'mouseover mouseout mousemove selectstart selectend '            + // mouse movement\n        'keydown keypress keyup '                                        + // keyboard\n        'orientationchange '                                             + // mobile\n        'focus blur change reset select submit '                         + // form elements\n        'load unload beforeunload resize move DOMContentLoaded '         + // window\n        'readystatechange message '                                      + // window\n        'error abort scroll '                                              // misc\n      // element.fireEvent('onXYZ'... is not forgiving if we try to fire an event\n      // that doesn't actually exist, so make sure we only do these on newer browsers\n    , w3cNativeEvents =\n        'show '                                                          + // mouse buttons\n        'input invalid '                                                 + // form elements\n        'touchstart touchmove touchend touchcancel '                     + // touch\n        'gesturestart gesturechange gestureend '                         + // gesture\n        'textinput '                                                     + // TextEvent\n        'readystatechange pageshow pagehide popstate '                   + // window\n        'hashchange offline online '                                     + // window\n        'afterprint beforeprint '                                        + // printing\n        'dragstart dragenter dragover dragleave drag drop dragend '      + // dnd\n        'loadstart progress suspend emptied stalled loadmetadata '       + // media\n        'loadeddata canplay canplaythrough playing waiting seeking '     + // media\n        'seeked ended durationchange timeupdate play pause ratechange '  + // media\n        'volumechange cuechange '                                        + // media\n        'checking noupdate downloading cached updateready obsolete '       // appcache\n\n      // convert to a hash for quick lookups\n    , nativeEvents = (function (hash, events, i) {\n        for (i = 0; i < events.length; i++) events[i] && (hash[events[i]] = 1)\n        return hash\n      }({}, str2arr(standardNativeEvents + (W3C_MODEL ? w3cNativeEvents : ''))))\n\n      // custom events are events that we *fake*, they are not provided natively but\n      // we can use native events to generate them\n    , customEvents = (function () {\n        var isAncestor = 'compareDocumentPosition' in root\n              ? function (element, container) {\n                  return container.compareDocumentPosition && (container.compareDocumentPosition(element) & 16) === 16\n                }\n              : 'contains' in root\n                ? function (element, container) {\n                    container = container.nodeType === 9 || container === window ? root : container\n                    return container !== element && container.contains(element)\n                  }\n                : function (element, container) {\n                    while (element = element.parentNode) if (element === container) return 1\n                    return 0\n                  }\n          , check = function (event) {\n              var related = event.relatedTarget\n              return !related\n                ? related == null\n                : (related !== this && related.prefix !== 'xul' && !/document/.test(this.toString())\n                    && !isAncestor(related, this))\n            }\n\n        return {\n            mouseenter: { base: 'mouseover', condition: check }\n          , mouseleave: { base: 'mouseout', condition: check }\n          , mousewheel: { base: /Firefox/.test(navigator.userAgent) ? 'DOMMouseScroll' : 'mousewheel' }\n        }\n      }())\n\n      // we provide a consistent Event object across browsers by taking the actual DOM\n      // event object and generating a new one from its properties.\n    , Event = (function () {\n            // a whitelist of properties (for different event types) tells us what to check for and copy\n        var commonProps  = str2arr('altKey attrChange attrName bubbles cancelable ctrlKey currentTarget ' +\n              'detail eventPhase getModifierState isTrusted metaKey relatedNode relatedTarget shiftKey '  +\n              'srcElement target timeStamp type view which propertyName')\n          , mouseProps   = commonProps.concat(str2arr('button buttons clientX clientY dataTransfer '      +\n              'fromElement offsetX offsetY pageX pageY screenX screenY toElement'))\n          , mouseWheelProps = mouseProps.concat(str2arr('wheelDelta wheelDeltaX wheelDeltaY wheelDeltaZ ' +\n              'axis')) // 'axis' is FF specific\n          , keyProps     = commonProps.concat(str2arr('char charCode key keyCode keyIdentifier '          +\n              'keyLocation location'))\n          , textProps    = commonProps.concat(str2arr('data'))\n          , touchProps   = commonProps.concat(str2arr('touches targetTouches changedTouches scale rotation'))\n          , messageProps = commonProps.concat(str2arr('data origin source'))\n          , stateProps   = commonProps.concat(str2arr('state'))\n          , overOutRegex = /over|out/\n            // some event types need special handling and some need special properties, do that all here\n          , typeFixers   = [\n                { // key events\n                    reg: /key/i\n                  , fix: function (event, newEvent) {\n                      newEvent.keyCode = event.keyCode || event.which\n                      return keyProps\n                    }\n                }\n              , { // mouse events\n                    reg: /click|mouse(?!(.*wheel|scroll))|menu|drag|drop/i\n                  , fix: function (event, newEvent, type) {\n                      newEvent.rightClick = event.which === 3 || event.button === 2\n                      newEvent.pos = { x: 0, y: 0 }\n                      if (event.pageX || event.pageY) {\n                        newEvent.clientX = event.pageX\n                        newEvent.clientY = event.pageY\n                      } else if (event.clientX || event.clientY) {\n                        newEvent.clientX = event.clientX + doc.body.scrollLeft + root.scrollLeft\n                        newEvent.clientY = event.clientY + doc.body.scrollTop + root.scrollTop\n                      }\n                      if (overOutRegex.test(type)) {\n                        newEvent.relatedTarget = event.relatedTarget\n                          || event[(type == 'mouseover' ? 'from' : 'to') + 'Element']\n                      }\n                      return mouseProps\n                    }\n                }\n              , { // mouse wheel events\n                    reg: /mouse.*(wheel|scroll)/i\n                  , fix: function () { return mouseWheelProps }\n                }\n              , { // TextEvent\n                    reg: /^text/i\n                  , fix: function () { return textProps }\n                }\n              , { // touch and gesture events\n                    reg: /^touch|^gesture/i\n                  , fix: function () { return touchProps }\n                }\n              , { // message events\n                    reg: /^message$/i\n                  , fix: function () { return messageProps }\n                }\n              , { // popstate events\n                    reg: /^popstate$/i\n                  , fix: function () { return stateProps }\n                }\n              , { // everything else\n                    reg: /.*/\n                  , fix: function () { return commonProps }\n                }\n            ]\n          , typeFixerMap = {} // used to map event types to fixer functions (above), a basic cache mechanism\n\n          , Event = function (event, element, isNative) {\n              if (!arguments.length) return\n              event = event || ((element.ownerDocument || element.document || element).parentWindow || win).event\n              this.originalEvent = event\n              this.isNative       = isNative\n              this.isBean         = true\n\n              if (!event) return\n\n              var type   = event.type\n                , target = event.target || event.srcElement\n                , i, l, p, props, fixer\n\n              this.target = target && target.nodeType === 3 ? target.parentNode : target\n\n              if (isNative) { // we only need basic augmentation on custom events, the rest expensive & pointless\n                fixer = typeFixerMap[type]\n                if (!fixer) { // haven't encountered this event type before, map a fixer function for it\n                  for (i = 0, l = typeFixers.length; i < l; i++) {\n                    if (typeFixers[i].reg.test(type)) { // guaranteed to match at least one, last is .*\n                      typeFixerMap[type] = fixer = typeFixers[i].fix\n                      break\n                    }\n                  }\n                }\n\n                props = fixer(event, this, type)\n                for (i = props.length; i--;) {\n                  if (!((p = props[i]) in this) && p in event) this[p] = event[p]\n                }\n              }\n            }\n\n        // preventDefault() and stopPropagation() are a consistent interface to those functions\n        // on the DOM, stop() is an alias for both of them together\n        Event.prototype.preventDefault = function () {\n          if (this.originalEvent.preventDefault) this.originalEvent.preventDefault()\n          else this.originalEvent.returnValue = false\n        }\n        Event.prototype.stopPropagation = function () {\n          if (this.originalEvent.stopPropagation) this.originalEvent.stopPropagation()\n          else this.originalEvent.cancelBubble = true\n        }\n        Event.prototype.stop = function () {\n          this.preventDefault()\n          this.stopPropagation()\n          this.stopped = true\n        }\n        // stopImmediatePropagation() has to be handled internally because we manage the event list for\n        // each element\n        // note that originalElement may be a Bean#Event object in some situations\n        Event.prototype.stopImmediatePropagation = function () {\n          if (this.originalEvent.stopImmediatePropagation) this.originalEvent.stopImmediatePropagation()\n          this.isImmediatePropagationStopped = function () { return true }\n        }\n        Event.prototype.isImmediatePropagationStopped = function () {\n          return this.originalEvent.isImmediatePropagationStopped && this.originalEvent.isImmediatePropagationStopped()\n        }\n        Event.prototype.clone = function (currentTarget) {\n          //TODO: this is ripe for optimisation, new events are *expensive*\n          // improving this will speed up delegated events\n          var ne = new Event(this, this.element, this.isNative)\n          ne.currentTarget = currentTarget\n          return ne\n        }\n\n        return Event\n      }())\n\n      // if we're in old IE we can't do onpropertychange on doc or win so we use doc.documentElement for both\n    , targetElement = function (element, isNative) {\n        return !W3C_MODEL && !isNative && (element === doc || element === win) ? root : element\n      }\n\n      /**\n        * Bean maintains an internal registry for event listeners. We don't touch elements, objects\n        * or functions to identify them, instead we store everything in the registry.\n        * Each event listener has a RegEntry object, we have one 'registry' for the whole instance.\n        */\n    , RegEntry = (function () {\n        // each handler is wrapped so we can handle delegation and custom events\n        var wrappedHandler = function (element, fn, condition, args) {\n            var call = function (event, eargs) {\n                  return fn.apply(element, args ? slice.call(eargs, event ? 0 : 1).concat(args) : eargs)\n                }\n              , findTarget = function (event, eventElement) {\n                  return fn.__beanDel ? fn.__beanDel.ft(event.target, element) : eventElement\n                }\n              , handler = condition\n                  ? function (event) {\n                      var target = findTarget(event, this) // deleated event\n                      if (condition.apply(target, arguments)) {\n                        if (event) event.currentTarget = target\n                        return call(event, arguments)\n                      }\n                    }\n                  : function (event) {\n                      if (fn.__beanDel) event = event.clone(findTarget(event)) // delegated event, fix the fix\n                      return call(event, arguments)\n                    }\n            handler.__beanDel = fn.__beanDel\n            return handler\n          }\n\n        , RegEntry = function (element, type, handler, original, namespaces, args, root) {\n            var customType     = customEvents[type]\n              , isNative\n\n            if (type == 'unload') {\n              // self clean-up\n              handler = once(removeListener, element, type, handler, original)\n            }\n\n            if (customType) {\n              if (customType.condition) {\n                handler = wrappedHandler(element, handler, customType.condition, args)\n              }\n              type = customType.base || type\n            }\n\n            this.isNative      = isNative = nativeEvents[type] && !!element[eventSupport]\n            this.customType    = !W3C_MODEL && !isNative && type\n            this.element       = element\n            this.type          = type\n            this.original      = original\n            this.namespaces    = namespaces\n            this.eventType     = W3C_MODEL || isNative ? type : 'propertychange'\n            this.target        = targetElement(element, isNative)\n            this[eventSupport] = !!this.target[eventSupport]\n            this.root          = root\n            this.handler       = wrappedHandler(element, handler, null, args)\n          }\n\n        // given a list of namespaces, is our entry in any of them?\n        RegEntry.prototype.inNamespaces = function (checkNamespaces) {\n          var i, j, c = 0\n          if (!checkNamespaces) return true\n          if (!this.namespaces) return false\n          for (i = checkNamespaces.length; i--;) {\n            for (j = this.namespaces.length; j--;) {\n              if (checkNamespaces[i] == this.namespaces[j]) c++\n            }\n          }\n          return checkNamespaces.length === c\n        }\n\n        // match by element, original fn (opt), handler fn (opt)\n        RegEntry.prototype.matches = function (checkElement, checkOriginal, checkHandler) {\n          return this.element === checkElement &&\n            (!checkOriginal || this.original === checkOriginal) &&\n            (!checkHandler || this.handler === checkHandler)\n        }\n\n        return RegEntry\n      }())\n\n    , registry = (function () {\n        // our map stores arrays by event type, just because it's better than storing\n        // everything in a single array.\n        // uses '$' as a prefix for the keys for safety and 'r' as a special prefix for\n        // rootListeners so we can look them up fast\n        var map = {}\n\n          // generic functional search of our registry for matching listeners,\n          // `fn` returns false to break out of the loop\n          , forAll = function (element, type, original, handler, root, fn) {\n              var pfx = root ? 'r' : '$'\n              if (!type || type == '*') {\n                // search the whole registry\n                for (var t in map) {\n                  if (t.charAt(0) == pfx) {\n                    forAll(element, t.substr(1), original, handler, root, fn)\n                  }\n                }\n              } else {\n                var i = 0, l, list = map[pfx + type], all = element == '*'\n                if (!list) return\n                for (l = list.length; i < l; i++) {\n                  if ((all || list[i].matches(element, original, handler)) && !fn(list[i], list, i, type)) return\n                }\n              }\n            }\n\n          , has = function (element, type, original, root) {\n              // we're not using forAll here simply because it's a bit slower and this\n              // needs to be fast\n              var i, list = map[(root ? 'r' : '$') + type]\n              if (list) {\n                for (i = list.length; i--;) {\n                  if (!list[i].root && list[i].matches(element, original, null)) return true\n                }\n              }\n              return false\n            }\n\n          , get = function (element, type, original, root) {\n              var entries = []\n              forAll(element, type, original, null, root, function (entry) {\n                return entries.push(entry)\n              })\n              return entries\n            }\n\n          , put = function (entry) {\n              var has = !entry.root && !this.has(entry.element, entry.type, null, false)\n                , key = (entry.root ? 'r' : '$') + entry.type\n              ;(map[key] || (map[key] = [])).push(entry)\n              return has\n            }\n\n          , del = function (entry) {\n              forAll(entry.element, entry.type, null, entry.handler, entry.root, function (entry, list, i) {\n                list.splice(i, 1)\n                entry.removed = true\n                if (list.length === 0) delete map[(entry.root ? 'r' : '$') + entry.type]\n                return false\n              })\n            }\n\n            // dump all entries, used for onunload\n          , entries = function () {\n              var t, entries = []\n              for (t in map) {\n                if (t.charAt(0) == '$') entries = entries.concat(map[t])\n              }\n              return entries\n            }\n\n        return { has: has, get: get, put: put, del: del, entries: entries }\n      }())\n\n      // we need a selector engine for delegated events, use querySelectorAll if it exists\n      // but for older browsers we need Qwery, Sizzle or similar\n    , selectorEngine\n    , setSelectorEngine = function (e) {\n        if (!arguments.length) {\n          selectorEngine = doc.querySelectorAll\n            ? function (s, r) {\n                return r.querySelectorAll(s)\n              }\n            : function () {\n                throw new Error('Bean: No selector engine installed') // eeek\n              }\n        } else {\n          selectorEngine = e\n        }\n      }\n\n      // we attach this listener to each DOM event that we need to listen to, only once\n      // per event type per DOM element\n    , rootListener = function (event, type) {\n        if (!W3C_MODEL && type && event && event.propertyName != '_on' + type) return\n\n        var listeners = registry.get(this, type || event.type, null, false)\n          , l = listeners.length\n          , i = 0\n\n        event = new Event(event, this, true)\n        if (type) event.type = type\n\n        // iterate through all handlers registered for this type, calling them unless they have\n        // been removed by a previous handler or stopImmediatePropagation() has been called\n        for (; i < l && !event.isImmediatePropagationStopped(); i++) {\n          if (!listeners[i].removed) listeners[i].handler.call(this, event)\n        }\n      }\n\n      // add and remove listeners to DOM elements\n    , listener = W3C_MODEL\n        ? function (element, type, add) {\n            // new browsers\n            element[add ? addEvent : removeEvent](type, rootListener, false)\n          }\n        : function (element, type, add, custom) {\n            // IE8 and below, use attachEvent/detachEvent and we have to piggy-back propertychange events\n            // to simulate event bubbling etc.\n            var entry\n            if (add) {\n              registry.put(entry = new RegEntry(\n                  element\n                , custom || type\n                , function (event) { // handler\n                    rootListener.call(element, event, custom)\n                  }\n                , rootListener\n                , null\n                , null\n                , true // is root\n              ))\n              if (custom && element['_on' + custom] == null) element['_on' + custom] = 0\n              entry.target.attachEvent('on' + entry.eventType, entry.handler)\n            } else {\n              entry = registry.get(element, custom || type, rootListener, true)[0]\n              if (entry) {\n                entry.target.detachEvent('on' + entry.eventType, entry.handler)\n                registry.del(entry)\n              }\n            }\n          }\n\n    , once = function (rm, element, type, fn, originalFn) {\n        // wrap the handler in a handler that does a remove as well\n        return function () {\n          fn.apply(this, arguments)\n          rm(element, type, originalFn)\n        }\n      }\n\n    , removeListener = function (element, orgType, handler, namespaces) {\n        var type     = orgType && orgType.replace(nameRegex, '')\n          , handlers = registry.get(element, type, null, false)\n          , removed  = {}\n          , i, l\n\n        for (i = 0, l = handlers.length; i < l; i++) {\n          if ((!handler || handlers[i].original === handler) && handlers[i].inNamespaces(namespaces)) {\n            // TODO: this is problematic, we have a registry.get() and registry.del() that\n            // both do registry searches so we waste cycles doing this. Needs to be rolled into\n            // a single registry.forAll(fn) that removes while finding, but the catch is that\n            // we'll be splicing the arrays that we're iterating over. Needs extra tests to\n            // make sure we don't screw it up. @rvagg\n            registry.del(handlers[i])\n            if (!removed[handlers[i].eventType] && handlers[i][eventSupport])\n              removed[handlers[i].eventType] = { t: handlers[i].eventType, c: handlers[i].type }\n          }\n        }\n        // check each type/element for removed listeners and remove the rootListener where it's no longer needed\n        for (i in removed) {\n          if (!registry.has(element, removed[i].t, null, false)) {\n            // last listener of this type, remove the rootListener\n            listener(element, removed[i].t, false, removed[i].c)\n          }\n        }\n      }\n\n      // set up a delegate helper using the given selector, wrap the handler function\n    , delegate = function (selector, fn) {\n        //TODO: findTarget (therefore $) is called twice, once for match and once for\n        // setting e.currentTarget, fix this so it's only needed once\n        var findTarget = function (target, root) {\n              var i, array = isString(selector) ? selectorEngine(selector, root) : selector\n              for (; target && target !== root; target = target.parentNode) {\n                for (i = array.length; i--;) {\n                  if (array[i] === target) return target\n                }\n              }\n            }\n          , handler = function (e) {\n              var match = findTarget(e.target, this)\n              if (match) fn.apply(match, arguments)\n            }\n\n        // __beanDel isn't pleasant but it's a private function, not exposed outside of Bean\n        handler.__beanDel = {\n            ft       : findTarget // attach it here for customEvents to use too\n          , selector : selector\n        }\n        return handler\n      }\n\n    , fireListener = W3C_MODEL ? function (isNative, type, element) {\n        // modern browsers, do a proper dispatchEvent()\n        var evt = doc.createEvent(isNative ? 'HTMLEvents' : 'UIEvents')\n        evt[isNative ? 'initEvent' : 'initUIEvent'](type, true, true, win, 1)\n        element.dispatchEvent(evt)\n      } : function (isNative, type, element) {\n        // old browser use onpropertychange, just increment a custom property to trigger the event\n        element = targetElement(element, isNative)\n        isNative ? element.fireEvent('on' + type, doc.createEventObject()) : element['_on' + type]++\n      }\n\n      /**\n        * Public API: off(), on(), add(), (remove()), one(), fire(), clone()\n        */\n\n      /**\n        * off(element[, eventType(s)[, handler ]])\n        */\n    , off = function (element, typeSpec, fn) {\n        var isTypeStr = isString(typeSpec)\n          , k, type, namespaces, i\n\n        if (isTypeStr && typeSpec.indexOf(' ') > 0) {\n          // off(el, 't1 t2 t3', fn) or off(el, 't1 t2 t3')\n          typeSpec = str2arr(typeSpec)\n          for (i = typeSpec.length; i--;)\n            off(element, typeSpec[i], fn)\n          return element\n        }\n\n        type = isTypeStr && typeSpec.replace(nameRegex, '')\n        if (type && customEvents[type]) type = customEvents[type].base\n\n        if (!typeSpec || isTypeStr) {\n          // off(el) or off(el, t1.ns) or off(el, .ns) or off(el, .ns1.ns2.ns3)\n          if (namespaces = isTypeStr && typeSpec.replace(namespaceRegex, '')) namespaces = str2arr(namespaces, '.')\n          removeListener(element, type, fn, namespaces)\n        } else if (isFunction(typeSpec)) {\n          // off(el, fn)\n          removeListener(element, null, typeSpec)\n        } else {\n          // off(el, { t1: fn1, t2, fn2 })\n          for (k in typeSpec) {\n            if (typeSpec.hasOwnProperty(k)) off(element, k, typeSpec[k])\n          }\n        }\n\n        return element\n      }\n\n      /**\n        * on(element, eventType(s)[, selector], handler[, args ])\n        */\n    , on = function(element, events, selector, fn) {\n        var originalFn, type, types, i, args, entry, first\n\n        //TODO: the undefined check means you can't pass an 'args' argument, fix this perhaps?\n        if (selector === undefined && typeof events == 'object') {\n          //TODO: this can't handle delegated events\n          for (type in events) {\n            if (events.hasOwnProperty(type)) {\n              on.call(this, element, type, events[type])\n            }\n          }\n          return\n        }\n\n        if (!isFunction(selector)) {\n          // delegated event\n          originalFn = fn\n          args       = slice.call(arguments, 4)\n          fn         = delegate(selector, originalFn, selectorEngine)\n        } else {\n          args       = slice.call(arguments, 3)\n          fn         = originalFn = selector\n        }\n\n        types = str2arr(events)\n\n        // special case for one(), wrap in a self-removing handler\n        if (this === ONE) {\n          fn = once(off, element, events, fn, originalFn)\n        }\n\n        for (i = types.length; i--;) {\n          // add new handler to the registry and check if it's the first for this element/type\n          first = registry.put(entry = new RegEntry(\n              element\n            , types[i].replace(nameRegex, '') // event type\n            , fn\n            , originalFn\n            , str2arr(types[i].replace(namespaceRegex, ''), '.') // namespaces\n            , args\n            , false // not root\n          ))\n          if (entry[eventSupport] && first) {\n            // first event of this type on this element, add root listener\n            listener(element, entry.eventType, true, entry.customType)\n          }\n        }\n\n        return element\n      }\n\n      /**\n        * add(element[, selector], eventType(s), handler[, args ])\n        *\n        * Deprecated: kept (for now) for backward-compatibility\n        */\n    , add = function (element, events, fn, delfn) {\n        return on.apply(\n            null\n          , !isString(fn)\n              ? slice.call(arguments)\n              : [ element, fn, events, delfn ].concat(arguments.length > 3 ? slice.call(arguments, 5) : [])\n        )\n      }\n\n      /**\n        * one(element, eventType(s)[, selector], handler[, args ])\n        */\n    , one = function () {\n        return on.apply(ONE, arguments)\n      }\n\n      /**\n        * fire(element, eventType(s)[, args ])\n        *\n        * The optional 'args' argument must be an array, if no 'args' argument is provided\n        * then we can use the browser's DOM event system, otherwise we trigger handlers manually\n        */\n    , fire = function (element, type, args) {\n        var types = str2arr(type)\n          , i, j, l, names, handlers\n\n        for (i = types.length; i--;) {\n          type = types[i].replace(nameRegex, '')\n          if (names = types[i].replace(namespaceRegex, '')) names = str2arr(names, '.')\n          if (!names && !args && element[eventSupport]) {\n            fireListener(nativeEvents[type], type, element)\n          } else {\n            // non-native event, either because of a namespace, arguments or a non DOM element\n            // iterate over all listeners and manually 'fire'\n            handlers = registry.get(element, type, null, false)\n            args = [false].concat(args)\n            for (j = 0, l = handlers.length; j < l; j++) {\n              if (handlers[j].inNamespaces(names)) {\n                handlers[j].handler.apply(element, args)\n              }\n            }\n          }\n        }\n        return element\n      }\n\n      /**\n        * clone(dstElement, srcElement[, eventType ])\n        *\n        * TODO: perhaps for consistency we should allow the same flexibility in type specifiers?\n        */\n    , clone = function (element, from, type) {\n        var handlers = registry.get(from, type, null, false)\n          , l = handlers.length\n          , i = 0\n          , args, beanDel\n\n        for (; i < l; i++) {\n          if (handlers[i].original) {\n            args = [ element, handlers[i].type ]\n            if (beanDel = handlers[i].handler.__beanDel) args.push(beanDel.selector)\n            args.push(handlers[i].original)\n            on.apply(null, args)\n          }\n        }\n        return element\n      }\n\n    , bean = {\n          'on'                : on\n        , 'add'               : add\n        , 'one'               : one\n        , 'off'               : off\n        , 'remove'            : off\n        , 'clone'             : clone\n        , 'fire'              : fire\n        , 'Event'             : Event\n        , 'setSelectorEngine' : setSelectorEngine\n        , 'noConflict'        : function () {\n            context[name] = old\n            return this\n          }\n      }\n\n  // for IE, clean up on unload to avoid leaks\n  if (win.attachEvent) {\n    var cleanup = function () {\n      var i, entries = registry.entries()\n      for (i in entries) {\n        if (entries[i].type && entries[i].type !== 'unload') off(entries[i].element, entries[i].type)\n      }\n      win.detachEvent('onunload', cleanup)\n      win.CollectGarbage && win.CollectGarbage()\n    }\n    win.attachEvent('onunload', cleanup)\n  }\n\n  // initialize selector engine to internal default (qSA or throw Error)\n  setSelectorEngine()\n\n  return bean\n});\n"],"names":["definition","name","context","this","selectorEngine","map","forAll","isAncestor","check","win","window","old","namespaceRegex","nameRegex","addEvent","doc","document","root","documentElement","W3C_MODEL","eventSupport","ONE","slice","Array","prototype","str2arr","s","d","split","isString","o","isFunction","nativeEvents","hash","events","i","length","customEvents","element","container","compareDocumentPosition","nodeType","contains","parentNode","mouseenter","base","condition","event","related","relatedTarget","prefix","test","toString","mouseleave","mousewheel","navigator","userAgent","Event","commonProps","mouseProps","concat","mouseWheelProps","keyProps","textProps","touchProps","messageProps","stateProps","overOutRegex","typeFixers","reg","fix","newEvent","keyCode","which","type","rightClick","button","pos","x","y","pageX","pageY","clientX","clientY","body","scrollLeft","scrollTop","typeFixerMap","isNative","arguments","ownerDocument","parentWindow","originalEvent","isBean","l","p","props","fixer","target","srcElement","preventDefault","returnValue","stopPropagation","cancelBubble","stop","stopped","stopImmediatePropagation","isImmediatePropagationStopped","clone","currentTarget","ne","targetElement","RegEntry","wrappedHandler","fn","args","call","eargs","apply","findTarget","eventElement","__beanDel","ft","handler","original","namespaces","customType","once","removeListener","eventType","inNamespaces","checkNamespaces","j","c","matches","checkElement","checkOriginal","checkHandler","registry","pfx","list","all","t","charAt","substr","has","get","entries","entry","push","put","key","del","splice","removed","setSelectorEngine","e","querySelectorAll","r","Error","rootListener","propertyName","listeners","listener","add","custom","attachEvent","detachEvent","rm","originalFn","orgType","replace","handlers","fireListener","evt","createEvent","dispatchEvent","fireEvent","createEventObject","off","typeSpec","k","isTypeStr","indexOf","hasOwnProperty","on","selector","types","first","undefined","array","match","delegate","bean","delfn","from","beanDel","names","cleanup","CollectGarbage","module","exports"],"sourceRoot":""}