themes/classic/source/javascripts/libs/ender.js
aa230616
 /*!
   * Ender: open module JavaScript framework
   * copyright Dustin Diaz & Jacob Thornton 2011 (@ded @fat)
   * https://ender.no.de
   * License MIT
   * Build: ender -b jeesh
   */
 !function (context) {
 
   function aug(o, o2) {
     for (var k in o2) {
       k != 'noConflict' && k != '_VERSION' && (o[k] = o2[k]);
     }
     return o;
   }
 
   function boosh(s, r) {
     var els;
     if (ender._select && typeof s == 'string' || s.nodeName || s.length && 'item' in s || s == window) { //string || node || nodelist || window
       els = ender._select(s, r);
       els.selector = s;
     } else {
       els = isFinite(s.length) ? s : [s];
     }
     return aug(els, boosh);
   }
 
   function ender(s, r) {
     return boosh(s, r);
   }
 
   aug(ender, {
     _VERSION: '0.2.0',
     ender: function (o, chain) {
       aug(chain ? boosh : ender, o);
     }
   });
 
   aug(boosh, {
     forEach: function (fn, scope) {
       // opt out of native forEach so we can intentionally call our own scope
       // defaulting to the current item
       for (var i = 0, l = this.length; i < l; ++i) {
         i in this && fn.call(scope || this[i], this[i], i, this);
       }
       // return self for chaining
       return this;
     }
   });
 
   var old = context.$;
   ender.noConflict = function () {
     context.$ = old;
     return this;
   };
 
   (typeof module !== 'undefined') && module.exports && (module.exports = ender);
   // use subscript notation as extern for Closure compilation
   context['ender'] = context['$'] = ender;
 
 }(this);
 /*!
   * bean.js - copyright Jacob Thornton 2011
   * https://github.com/fat/bean
   * MIT License
   * special thanks to:
   * dean edwards: http://dean.edwards.name/
   * dperini: https://github.com/dperini/nwevents
   * the entire mootools team: github.com/mootools/mootools-core
   */
 !function (context) {
   var __uid = 1, registry = {}, collected = {},
       overOut = /over|out/,
       namespace = /[^\.]*(?=\..*)\.|.*/,
       stripName = /\..*/,
       addEvent = 'addEventListener',
       attachEvent = 'attachEvent',
       removeEvent = 'removeEventListener',
       detachEvent = 'detachEvent',
       doc = context.document || {},
       root = doc.documentElement || {},
       W3C_MODEL = root[addEvent],
       eventSupport = W3C_MODEL ? addEvent : attachEvent,
 
   isDescendant = function (parent, child) {
     var node = child.parentNode;
     while (node != null) {
       if (node == parent) {
         return true;
       }
       node = node.parentNode;
     }
   },
 
   retrieveUid = function (obj, uid) {
     return (obj.__uid = uid || obj.__uid || __uid++);
   },
 
   retrieveEvents = function (element) {
     var uid = retrieveUid(element);
     return (registry[uid] = registry[uid] || {});
   },
 
   listener = W3C_MODEL ? function (element, type, fn, add) {
     element[add ? addEvent : removeEvent](type, fn, false);
   } : function (element, type, fn, add, custom) {
     custom && add && (element['_on' + custom] = element['_on' + custom] || 0);
     element[add ? attachEvent : detachEvent]('on' + type, fn);
   },
 
   nativeHandler = function (element, fn, args) {
     return function (event) {
       event = fixEvent(event || ((this.ownerDocument || this.document || this).parentWindow || context).event);
       return fn.apply(element, [event].concat(args));
     };
   },
 
   customHandler = function (element, fn, type, condition, args) {
     return function (event) {
       if (condition ? condition.call(this, event) : W3C_MODEL ? true : event && event.propertyName == '_on' + type || !event) {
         fn.apply(element, [event].concat(args));
       }
     };
   },
 
   addListener = function (element, orgType, fn, args) {
     var type = orgType.replace(stripName, ''),
         events = retrieveEvents(element),
         handlers = events[type] || (events[type] = {}),
         uid = retrieveUid(fn, orgType.replace(namespace, ''));
     if (handlers[uid]) {
       return element;
     }
     var custom = customEvents[type];
     if (custom) {
       fn = custom.condition ? customHandler(element, fn, type, custom.condition) : fn;
       type = custom.base || type;
     }
     var isNative = nativeEvents[type];
     fn = isNative ? nativeHandler(element, fn, args) : customHandler(element, fn, type, false, args);
     isNative = W3C_MODEL || isNative;
     if (type == 'unload') {
       var org = fn;
       fn = function () {
         removeListener(element, type, fn) && org();
       };
     }
     element[eventSupport] && listener(element, isNative ? type : 'propertychange', fn, true, !isNative && type);
     handlers[uid] = fn;
     fn.__uid = uid;
     return type == 'unload' ? element : (collected[retrieveUid(element)] = element);
   },
 
   removeListener = function (element, orgType, handler) {
     var uid, names, uids, i, events = retrieveEvents(element), type = orgType.replace(stripName, '');
     if (!events || !events[type]) {
       return element;
     }
     names = orgType.replace(namespace, '');
     uids = names ? names.split('.') : [handler.__uid];
     for (i = uids.length; i--;) {
       uid = uids[i];
       handler = events[type][uid];
       delete events[type][uid];
       if (element[eventSupport]) {
         type = customEvents[type] ? customEvents[type].base : type;
         var isNative = W3C_MODEL || nativeEvents[type];
         listener(element, isNative ? type : 'propertychange', handler, false, !isNative && type);
       }
     }
     return element;
   },
 
   del = function (selector, fn, $) {
     return function (e) {
       var array = typeof selector == 'string' ? $(selector, this) : selector;
       for (var target = e.target; target && target != this; target = target.parentNode) {
         for (var i = array.length; i--;) {
           if (array[i] == target) {
             return fn.apply(target, arguments);
           }
         }
       }
     };
   },
 
   add = function (element, events, fn, delfn, $) {
     if (typeof events == 'object' && !fn) {
       for (var type in events) {
         events.hasOwnProperty(type) && add(element, type, events[type]);
       }
     } else {
       var isDel = typeof fn == 'string', types = (isDel ? fn : events).split(' ');
       fn = isDel ? del(events, delfn, $) : fn;
       for (var i = types.length; i--;) {
         addListener(element, types[i], fn, Array.prototype.slice.call(arguments, isDel ? 4 : 3));
       }
     }
     return element;
   },
 
   remove = function (element, orgEvents, fn) {
     var k, type, events,
         isString = typeof(orgEvents) == 'string',
         names = isString && orgEvents.replace(namespace, ''),
         rm = removeListener,
         attached = retrieveEvents(element);
     if (isString && /\s/.test(orgEvents)) {
       orgEvents = orgEvents.split(' ');
       var i = orgEvents.length - 1;
       while (remove(element, orgEvents[i]) && i--) {}
       return element;
     }
     events = isString ? orgEvents.replace(stripName, '') : orgEvents;
     if (!attached || (isString && !attached[events])) {
       return element;
     }
     if (typeof fn == 'function') {
       rm(element, events, fn);
     } else if (names) {
       rm(element, orgEvents);
     } else {
       rm = events ? rm : remove;
       type = isString && events;
       events = events ? (fn || attached[events] || events) : attached;
       for (k in events) {
         events.hasOwnProperty(k) && rm(element, type || k, events[k]);
       }
     }
     return element;
   },
 
   fire = function (element, type, args) {
     var evt, k, i, types = type.split(' ');
     for (i = types.length; i--;) {
       type = types[i].replace(stripName, '');
       var isNative = nativeEvents[type],
           isNamespace = types[i].replace(namespace, ''),
           handlers = retrieveEvents(element)[type];
       if (isNamespace) {
         isNamespace = isNamespace.split('.');
         for (k = isNamespace.length; k--;) {
           handlers[isNamespace[k]] && handlers[isNamespace[k]].apply(element, args);
         }
       } else if (!args && element[eventSupport]) {
         fireListener(isNative, type, element);
       } else {
         for (k in handlers) {
           handlers.hasOwnProperty(k) && handlers[k].apply(element, args);
         }
       }
     }
     return element;
   },
 
   fireListener = W3C_MODEL ? function (isNative, type, element) {
     evt = document.createEvent(isNative ? "HTMLEvents" : "UIEvents");
     evt[isNative ? 'initEvent' : 'initUIEvent'](type, true, true, context, 1);
     element.dispatchEvent(evt);
   } : function (isNative, type, element) {
     isNative ? element.fireEvent('on' + type, document.createEventObject()) : element['_on' + type]++;
   },
 
   clone = function (element, from, type) {
     var events = retrieveEvents(from), obj, k;
     obj = type ? events[type] : events;
     for (k in obj) {
       obj.hasOwnProperty(k) && (type ? add : clone)(element, type || from, type ? obj[k] : k);
     }
     return element;
   },
 
   fixEvent = function (e) {
     var result = {};
     if (!e) {
       return result;
     }
     var type = e.type, target = e.target || e.srcElement;
     result.preventDefault = fixEvent.preventDefault(e);
     result.stopPropagation = fixEvent.stopPropagation(e);
     result.target = target && target.nodeType == 3 ? target.parentNode : target;
     if (~type.indexOf('key')) {
       result.keyCode = e.which || e.keyCode;
     } else if ((/click|mouse|menu/i).test(type)) {
       result.rightClick = e.which == 3 || e.button == 2;
       result.pos = { x: 0, y: 0 };
       if (e.pageX || e.pageY) {
         result.clientX = e.pageX;
         result.clientY = e.pageY;
       } else if (e.clientX || e.clientY) {
         result.clientX = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
         result.clientY = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
       }
       overOut.test(type) && (result.relatedTarget = e.relatedTarget || e[(type == 'mouseover' ? 'from' : 'to') + 'Element']);
     }
     for (var k in e) {
       if (!(k in result)) {
         result[k] = e[k];
       }
     }
     return result;
   };
 
   fixEvent.preventDefault = function (e) {
     return function () {
       if (e.preventDefault) {
         e.preventDefault();
       }
       else {
         e.returnValue = false;
       }
     };
   };
 
   fixEvent.stopPropagation = function (e) {
     return function () {
       if (e.stopPropagation) {
         e.stopPropagation();
       } else {
         e.cancelBubble = true;
       }
     };
   };
 
   var nativeEvents = { click: 1, dblclick: 1, mouseup: 1, mousedown: 1, contextmenu: 1, //mouse buttons
     mousewheel: 1, DOMMouseScroll: 1, //mouse wheel
     mouseover: 1, mouseout: 1, mousemove: 1, selectstart: 1, selectend: 1, //mouse movement
     keydown: 1, keypress: 1, keyup: 1, //keyboard
     orientationchange: 1, // mobile
     touchstart: 1, touchmove: 1, touchend: 1, touchcancel: 1, // touch
     gesturestart: 1, gesturechange: 1, gestureend: 1, // gesture
     focus: 1, blur: 1, change: 1, reset: 1, select: 1, submit: 1, //form elements
     load: 1, unload: 1, beforeunload: 1, resize: 1, move: 1, DOMContentLoaded: 1, readystatechange: 1, //window
     error: 1, abort: 1, scroll: 1 }; //misc
 
   function check(event) {
     var related = event.relatedTarget;
     if (!related) {
       return related == null;
     }
     return (related != this && related.prefix != 'xul' && !/document/.test(this.toString()) && !isDescendant(this, related));
   }
 
   var customEvents = {
     mouseenter: { base: 'mouseover', condition: check },
     mouseleave: { base: 'mouseout', condition: check },
     mousewheel: { base: /Firefox/.test(navigator.userAgent) ? 'DOMMouseScroll' : 'mousewheel' }
   };
 
   var bean = { add: add, remove: remove, clone: clone, fire: fire };
 
   var clean = function (el) {
     var uid = remove(el).__uid;
     if (uid) {
       delete collected[uid];
       delete registry[uid];
     }
   };
 
   if (context[attachEvent]) {
     add(context, 'unload', function () {
       for (var k in collected) {
         collected.hasOwnProperty(k) && clean(collected[k]);
       }
       context.CollectGarbage && CollectGarbage();
     });
   }
 
   var oldBean = context.bean;
   bean.noConflict = function () {
     context.bean = oldBean;
     return this;
   };
 
   (typeof module !== 'undefined' && module.exports) ?
     (module.exports = bean) :
     (context['bean'] = bean);
 
 }(this);!function ($) {
   var b = bean.noConflict(),
       integrate = function (method, type, method2) {
         var _args = type ? [type] : [];
         return function () {
           for (var args, i = 0, l = this.length; i < l; i++) {
             args = [this[i]].concat(_args, Array.prototype.slice.call(arguments, 0));
             args.length == 4 && args.push($);
             !arguments.length && method == 'add' && type && (method = 'fire');
             b[method].apply(this, args);
           }
           return this;
         };
       };
 
   var add = integrate('add'),
       remove = integrate('remove'),
       fire = integrate('fire');
 
   var methods = {
 
     on: add,
     addListener: add,
     bind: add,
     listen: add,
     delegate: add,
 
     unbind: remove,
     unlisten: remove,
     removeListener: remove,
     undelegate: remove,
 
     emit: fire,
     trigger: fire,
 
     cloneEvents: integrate('clone'),
 
     hover: function (enter, leave) {
       for (var i = 0, l = this.length; i < l; i++) {
         b.add.call(this, this[i], 'mouseenter', enter);
         b.add.call(this, this[i], 'mouseleave', leave);
       }
       return this;
     }
   };
 
   var shortcuts = [
     'blur', 'change', 'click', 'dblclick', 'error', 'focus', 'focusin',
     'focusout', 'keydown', 'keypress', 'keyup', 'load', 'mousedown',
     'mouseenter', 'mouseleave', 'mouseout', 'mouseover', 'mouseup',
     'resize', 'scroll', 'select', 'submit', 'unload'
   ];
 
   for (var i = shortcuts.length; i--;) {
     var shortcut = shortcuts[i];
     methods[shortcut] = integrate('add', shortcut);
   }
 
   $.ender(methods, true);
 }(ender);
 /*!
   * bonzo.js - copyright @dedfat 2011
   * https://github.com/ded/bonzo
   * Follow our software http://twitter.com/dedfat
   * MIT License
   */
 !function (context) {
 
   var doc = context.document,
       html = doc.documentElement,
       query = null,
       byTag = 'getElementsByTagName',
       specialAttributes = /^checked|value|selected$/,
       specialTags = /select|map|fieldset|table|tbody|tr|colgroup/i,
       tagMap = { select: 'option', table: 'tbody', tr: 'td' },
       stateAttributes = /^checked|selected$/,
       ie = /msie/i.test(navigator.userAgent),
       uidList = [],
       uuids = 0,
       digit = /^-?[\d\.]+$/,
       px = 'px',
       // commonly used methods
       setAttribute = 'setAttribute',
       getAttribute = 'getAttribute',
       trimReplace = /(^\s*|\s*$)/g,
       unitless = { lineHeight: 1, zoom: 1, zIndex: 1, opacity: 1 };
 
   function classReg(c) {
     return new RegExp("(^|\\s+)" + c + "(\\s+|$)");
   }
 
   function each(ar, fn, scope) {
     for (var i = 0, l = ar.length; i < l; i++) {
       fn.call(scope || ar[i], ar[i], i, ar);
     }
     return ar;
   }
 
   var trim = String.prototype.trim ?
     function (s) {
       return s.trim();
     } :
     function (s) {
       return s.replace(trimReplace, '');
     };
 
   function camelize(s) {
     return s.replace(/-(.)/g, function (m, m1) {
       return m1.toUpperCase();
     });
   }
 
   function is(node) {
     return node && node.nodeName && node.nodeType == 1;
   }
 
   function some(ar, fn, scope) {
     for (var i = 0, j = ar.length; i < j; ++i) {
       if (fn.call(scope, ar[i], i, ar)) {
         return true;
       }
     }
     return false;
   }
 
   var getStyle = doc.defaultView && doc.defaultView.getComputedStyle ?
     function (el, property) {
       var value = null;
       if (property == 'float') {
         property = 'cssFloat';
       }
       var computed = doc.defaultView.getComputedStyle(el, '');
       computed && (value = computed[camelize(property)]);
       return el.style[property] || value;
 
     } : (ie && html.currentStyle) ?
 
     function (el, property) {
       property = camelize(property);
       property = property == 'float' ? 'styleFloat' : property;
 
       if (property == 'opacity') {
         var val = 100;
         try {
           val = el.filters['DXImageTransform.Microsoft.Alpha'].opacity;
         } catch (e1) {
           try {
             val = el.filters('alpha').opacity;
           } catch (e2) {}
         }
         return val / 100;
       }
       var value = el.currentStyle ? el.currentStyle[property] : null;
       return el.style[property] || value;
     } :
 
     function (el, property) {
       return el.style[camelize(property)];
     };
 
   function insert(target, host, fn) {
     var i = 0, self = host || this, r = [];
     each(normalize(query ? query(target) : target), function (t) {
       each(self, function (el) {
         var n = el.cloneNode(true);
         fn(t, n);
         r[i] = n;
         i++;
       });
     }, this);
     each(r, function (e, i) {
       self[i] = e;
     });
     self.length = i;
     return self;
   }
 
   function xy(el, x, y) {
     var $el = bonzo(el),
         style = $el.css('position'),
         offset = $el.offset(),
         rel = 'relative',
         isRel = style == rel,
         delta = [parseInt($el.css('left'), 10), parseInt($el.css('top'), 10)];
 
     if (style == 'static') {
       $el.css('position', rel);
       style = rel;
     }
 
     isNaN(delta[0]) && (delta[0] = isRel ? 0 : el.offsetLeft);
     isNaN(delta[1]) && (delta[1] = isRel ? 0 : el.offsetTop);
 
     x !== null && (el.style.left = x - offset.left + delta[0] + 'px');
     y !== null && (el.style.top = y - offset.top + delta[1] + 'px');
 
   }
 
   function Bonzo(elements) {
     this.length = 0;
     this.original = elements;
     if (elements) {
       elements = typeof elements !== 'string' &&
         !elements.nodeType &&
         typeof elements.length !== 'undefined' ?
           elements :
           [elements];
       this.length = elements.length;
       for (var i = 0; i < elements.length; i++) {
         this[i] = elements[i];
       }
     }
   }
 
   Bonzo.prototype = {
 
     each: function (fn, scope) {
       return each(this, fn, scope);
     },
 
     map: function (fn, reject) {
       var m = [], n, i;
       for (i = 0; i < this.length; i++) {
         n = fn.call(this, this[i]);
         reject ? (reject(n) && m.push(n)) : m.push(n);
       }
       return m;
     },
 
     first: function () {
       return bonzo(this[0]);
     },
 
     last: function () {
       return bonzo(this[this.length - 1]);
     },
 
     html: function (h, text) {
       var method = text ?
         html.textContent == null ?
           'innerText' :
           'textContent' :
         'innerHTML', m;
       function append(el, tag) {
         while (el.firstChild) {
           el.removeChild(el.firstChild);
         }
         each(normalize(h, tag), function (node) {
           el.appendChild(node);
         });
       }
       return typeof h !== 'undefined' ?
           this.each(function (el) {
             (m = el.tagName.match(specialTags)) ?
               append(el, m[0]) :
               (el[method] = h);
           }) :
         this[0] ? this[0][method] : '';
     },
 
     text: function (text) {
       return this.html(text, 1);
     },
 
     addClass: function (c) {
       return this.each(function (el) {
         this.hasClass(el, c) || (el.className = trim(el.className + ' ' + c));
       }, this);
     },
 
     removeClass: function (c) {
       return this.each(function (el) {
         this.hasClass(el, c) && (el.className = trim(el.className.replace(classReg(c), ' ')));
       }, this);
     },
 
     hasClass: function (el, c) {
       return typeof c == 'undefined' ?
         some(this, function (i) {
           return classReg(el).test(i.className);
         }) :
         classReg(c).test(el.className);
     },
 
     toggleClass: function (c, condition) {
       if (typeof condition !== 'undefined' && !condition) {
         return this;
       }
       return this.each(function (el) {
         this.hasClass(el, c) ?
           (el.className = trim(el.className.replace(classReg(c), ' '))) :
           (el.className = trim(el.className + ' ' + c));
       }, this);
     },
 
     show: function (type) {
       return this.each(function (el) {
         el.style.display = type || '';
       });
     },
 
     hide: function (elements) {
       return this.each(function (el) {
         el.style.display = 'none';
       });
     },
 
     append: function (node) {
       return this.each(function (el) {
         each(normalize(node), function (i) {
           el.appendChild(i);
         });
       });
     },
 
     prepend: function (node) {
       return this.each(function (el) {
         var first = el.firstChild;
         each(normalize(node), function (i) {
           el.insertBefore(i, first);
         });
       });
     },
 
     appendTo: function (target, host) {
       return insert.call(this, target, host, function (t, el) {
         t.appendChild(el);
       });
     },
 
     prependTo: function (target, host) {
       return insert.call(this, target, host, function (t, el) {
         t.insertBefore(el, t.firstChild);
       });
     },
 
     next: function () {
       return this.related('nextSibling');
     },
 
     previous: function () {
       return this.related('previousSibling');
     },
 
     related: function (method) {
       return this.map(
         function (el) {
           el = el[method];
           while (el && el.nodeType !== 1) {
             el = el[method];
           }
           return el || 0;
         },
         function (el) {
           return el;
         }
       );
     },
 
     before: function (node) {
       return this.each(function (el) {
         each(bonzo.create(node), function (i) {
           el.parentNode.insertBefore(i, el);
         });
       });
     },
 
     after: function (node) {
       return this.each(function (el) {
         each(bonzo.create(node), function (i) {
           el.parentNode.insertBefore(i, el.nextSibling);
         });
       });
     },
 
     insertBefore: function (target, host) {
       return insert.call(this, target, host, function (t, el) {
         t.parentNode.insertBefore(el, t);
       });
     },
 
     insertAfter: function (target, host) {
       return insert.call(this, target, host, function (t, el) {
         var sibling = t.nextSibling;
         if (sibling) {
           t.parentNode.insertBefore(el, sibling);
         }
         else {
           t.parentNode.appendChild(el);
         }
       });
     },
 
     css: function (o, v) {
       // is this a request for just getting a style?
       if (v === undefined && typeof o == 'string') {
         return getStyle(this[0], o);
       }
       var iter = o;
       if (typeof o == 'string') {
         iter = {};
         iter[o] = v;
       }
 
       if (ie && iter.opacity) {
         // oh this 'ol gamut
         iter.filter = 'alpha(opacity=' + (iter.opacity * 100) + ')';
         // give it layout
         iter.zoom = o.zoom || 1;
         delete iter.opacity;
       }
 
       if (v = iter['float']) {
         // float is a reserved style word. w3 uses cssFloat, ie uses styleFloat
         ie ? (iter.styleFloat = v) : (iter.cssFloat = v);
         delete iter['float'];
       }
 
       var fn = function (el, p, v) {
         for (var k in iter) {
           if (iter.hasOwnProperty(k)) {
             v = iter[k];
             // change "5" to "5px" - unless you're line-height, which is allowed
             (p = camelize(k)) && digit.test(v) && !(p in unitless) && (v += px);
             el.style[p] = v;
           }
         }
       };
       return this.each(fn);
     },
 
     offset: function (x, y) {
       if (x || y) {
         return this.each(function (el) {
           xy(el, x, y);
         });
       }
       var el = this[0];
       var width = el.offsetWidth;
       var height = el.offsetHeight;
       var top = el.offsetTop;
       var left = el.offsetLeft;
       while (el = el.offsetParent) {
         top = top + el.offsetTop;
         left = left + el.offsetLeft;
       }
 
       return {
         top: top,
         left: left,
         height: height,
         width: width
       };
     },
 
     attr: function (k, v) {
       var el = this[0];
       return typeof v == 'undefined' ?
         specialAttributes.test(k) ?
           stateAttributes.test(k) && typeof el[k] == 'string' ?
             true : el[k] : el[getAttribute](k) :
         this.each(function (el) {
           k == 'value' ? (el.value = v) : el[setAttribute](k, v);
         });
     },
 
     val: function (s) {
       return (typeof s == 'string') ? this.attr('value', s) : this[0].value;
     },
 
     removeAttr: function (k) {
       return this.each(function (el) {
         el.removeAttribute(k);
       });
     },
 
     data: function (k, v) {
       var el = this[0];
       if (typeof v === 'undefined') {
         el[getAttribute]('data-node-uid') || el[setAttribute]('data-node-uid', ++uuids);
         var uid = el[getAttribute]('data-node-uid');
         uidList[uid] || (uidList[uid] = {});
         return uidList[uid][k];
       } else {
         return this.each(function (el) {
           el[getAttribute]('data-node-uid') || el[setAttribute]('data-node-uid', ++uuids);
           var uid = el[getAttribute]('data-node-uid');
           var o = {};
           o[k] = v;
           uidList[uid] = o;
         });
       }
     },
 
     remove: function () {
       return this.each(function (el) {
         el.parentNode && el.parentNode.removeChild(el);
       });
     },
 
     empty: function () {
       return this.each(function (el) {
         while (el.firstChild) {
           el.removeChild(el.firstChild);
         }
       });
     },
 
     detach: function () {
       return this.map(function (el) {
         return el.parentNode.removeChild(el);
       });
     },
 
     scrollTop: function (y) {
       return scroll.call(this, null, y, 'y');
     },
 
     scrollLeft: function (x) {
       return scroll.call(this, x, null, 'x');
     }
   };
 
   function normalize(node, tag) {
     return typeof node == 'string' ? bonzo.create(node, tag) : is(node) ? [node] : node;
   }
 
   function scroll(x, y, type) {
     var el = this[0];
     if (x == null && y == null) {
       return (isBody(el) ? getWindowScroll() : { x: el.scrollLeft, y: el.scrollTop })[type];
     }
     if (isBody(el)) {
       window.scrollTo(x, y);
     } else {
       x != null && (el.scrollLeft = x);
       y != null && (el.scrollTop = y);
     }
     return this;
   }
 
   function isBody(element) {
     return element === window || (/^(?:body|html)$/i).test(element.tagName);
   }
 
   function getWindowScroll() {
     return { x: window.pageXOffset || html.scrollLeft, y: window.pageYOffset || html.scrollTop };
   }
 
   function bonzo(els, host) {
     return new Bonzo(els, host);
   }
 
   bonzo.setQueryEngine = function (q) {
     query = q;
     delete bonzo.setQueryEngine;
   };
 
   bonzo.aug = function (o, target) {
     for (var k in o) {
       o.hasOwnProperty(k) && ((target || Bonzo.prototype)[k] = o[k]);
     }
   };
 
   bonzo.create = function (node, tag) {
     return typeof node == 'string' ?
       function () {
         var t = tag ? tagMap[tag.toLowerCase()] : null;
         var el = doc.createElement(t || 'div'), els = [];
         if (tag) {
           var bitches = node.match(new RegExp("<" + t + ">.+?<\\/" + t + ">", "g"));
           each(bitches, function (m) {
             m = m.replace(/<(.+)>(.+?)<\/\1>/, '$2');
             var bah = doc.createElement(t);
             bah.appendChild(doc.createDocumentFragment(m));
             el.appendChild(bah);
           });
         } else {
           el.innerHTML = node;
         }
         var nodes = el.childNodes;
         el = el.firstChild;
         els.push(el);
         while (el = el.nextSibling) {
           (el.nodeType == 1) && els.push(el);
         }
         return els;
 
       }() : is(node) ? [node.cloneNode(true)] : [];
   };
 
   bonzo.doc = function () {
     var w = html.scrollWidth,
         h = html.scrollHeight,
         vp = this.viewport();
     return {
       width: Math.max(w, vp.width),
       height: Math.max(h, vp.height)
     };
   };
 
   bonzo.firstChild = function (el) {
     for (var c = el.childNodes, i = 0, j = (c && c.length) || 0, e; i < j; i++) {
       if (c[i].nodeType === 1) {
         e = c[j = i];
       }
     }
     return e;
   };
 
   bonzo.viewport = function () {
     var h = self.innerHeight,
         w = self.innerWidth;
     ie && (h = html.clientHeight) && (w = html.clientWidth);
     return {
       width: w,
       height: h
     };
   };
 
   bonzo.isAncestor = 'compareDocumentPosition' in html ?
     function (container, element) {
       return (container.compareDocumentPosition(element) & 16) == 16;
     } : 'contains' in html ?
     function (container, element) {
       return container !== element && container.contains(element);
     } :
     function (container, element) {
       while (element = element.parentNode) {
         if (element === container) {
           return true;
         }
       }
       return false;
     };
 
   var old = context.bonzo;
   bonzo.noConflict = function () {
     context.bonzo = old;
     return this;
   };
   context['bonzo'] = bonzo;
 
 }(this);!function ($) {
 
   var b = bonzo;
   b.setQueryEngine($);
   $.ender(b);
   $.ender(b(), true);
   $.ender({
     create: function (node) {
       return $(b.create(node));
     }
   });
 
   $.id = function (id) {
     return $([document.getElementById(id)]);
   };
 
   function indexOf(ar, val) {
     for (var i = 0; i < ar.length; i++) {
       if (ar[i] === val) {
         return i;
       }
     }
     return -1;
   }
 
   function uniq(ar) {
     var a = [], i, j;
     label:
     for (i = 0; i < ar.length; i++) {
       for (j = 0; j < a.length; j++) {
         if (a[j] == ar[i]) {
           continue label;
         }
       }
       a[a.length] = ar[i];
     }
     return a;
   }
 
   $.ender({
     parents: function (selector, closest) {
       var collection = $(selector), j, k, p, r = [];
       for (j = 0, k = this.length; j < k; j++) {
         p = this[j];
         while (p = p.parentNode) {
           if (indexOf(collection, p) !== -1) {
             r.push(p);
             if (closest) break;
           }
         }
       }
       return $(uniq(r));
     },
 
     closest: function (selector) {
       return this.parents(selector, true);
     },
 
     first: function () {
       return $(this[0]);
     },
 
     last: function () {
       return $(this[this.length - 1]);
     },
 
     next: function () {
       return $(b(this).next());
     },
 
     previous: function () {
       return $(b(this).previous());
     },
 
     appendTo: function (t) {
       return b(this.selector).appendTo(t, this);
     },
 
     prependTo: function (t) {
       return b(this.selector).prependTo(t, this);
     },
 
     insertAfter: function (t) {
       return b(this.selector).insertAfter(t, this);
     },
 
     insertBefore: function (t) {
       return b(this.selector).insertBefore(t, this);
     },
 
     siblings: function () {
       var i, l, p, r = [];
       for (i = 0, l = this.length; i < l; i++) {
         p = this[i];
         while (p = p.previousSibling) {
           p.nodeType == 1 && r.push(p);
         }
         p = this[i];
         while (p = p.nextSibling) {
           p.nodeType == 1 && r.push(p);
         }
       }
       return $(r);
     },
 
     children: function () {
       var el, r = [];
       for (i = 0, l = this.length; i < l; i++) {
         if (!(el = b.firstChild(this[i]))) {
           continue;
         }
         r.push(el);
         while (el = el.nextSibling) {
           el.nodeType == 1 && r.push(el);
         }
       }
       return $(uniq(r));
     },
 
     height: function (v) {
       return v ? this.css('height', v) : parseInt(this.css('height'), 10);
     },
 
     width: function (v) {
       return v ? this.css('width', v) : parseInt(this.css('width'), 10);
     }
   }, true);
 
 }(ender || $);
 
 !function () { var exports = {}, module = { exports: exports }; !function (doc) {
   var loaded = 0, fns = [], ol, f = false,
       testEl = doc.createElement('a'),
       domContentLoaded = 'DOMContentLoaded',
       addEventListener = 'addEventListener',
       onreadystatechange = 'onreadystatechange';
 
   /^loade|c/.test(doc.readyState) && (loaded = 1);
 
   function flush() {
     loaded = 1;
     for (var i = 0, l = fns.length; i < l; i++) {
       fns[i]();
     }
   }
   doc[addEventListener] && doc[addEventListener](domContentLoaded, function fn() {
     doc.removeEventListener(domContentLoaded, fn, f);
     flush();
   }, f);
 
 
   testEl.doScroll && doc.attachEvent(onreadystatechange, (ol = function ol() {
     if (/^c/.test(doc.readyState)) {
       doc.detachEvent(onreadystatechange, ol);
       flush();
     }
   }));
 
   var domReady = testEl.doScroll ?
     function (fn) {
       self != top ?
         !loaded ?
           fns.push(fn) :
           fn() :
         !function () {
           try {
             testEl.doScroll('left');
           } catch (e) {
             return setTimeout(function() {
               domReady(fn);
             }, 50);
           }
           fn();
         }();
     } :
     function (fn) {
       loaded ? fn() : fns.push(fn);
     };
 
     (typeof module !== 'undefined') && module.exports ?
       (module.exports = {domReady: domReady}) :
       (window.domReady = domReady);
 
 }(document); $.ender(module.exports); }.call($);
 /*!
   * qwery.js - copyright @dedfat
   * https://github.com/ded/qwery
   * Follow our software http://twitter.com/dedfat
   * MIT License
   */
 
 !function (context, doc) {
 
   var c, i, j, k, l, m, o, p, r, v,
       el, node, len, found, classes, item, items, token,
       id = /#([\w\-]+)/,
       clas = /\.[\w\-]+/g,
       idOnly = /^#([\w\-]+$)/,
       classOnly = /^\.([\w\-]+)$/,
       tagOnly = /^([\w\-]+)$/,
       tagAndOrClass = /^([\w]+)?\.([\w\-]+)$/,
       html = doc.documentElement,
       tokenizr = /\s(?![\s\w\-\/\?\&\=\:\.\(\)\!,@#%<>\{\}\$\*\^'"]*\])/,
       specialChars = /([.*+?\^=!:${}()|\[\]\/\\])/g,
       simple = /^([a-z0-9]+)?(?:([\.\#]+[\w\-\.#]+)?)/,
       attr = /\[([\w\-]+)(?:([\|\^\$\*\~]?\=)['"]?([ \w\-\/\?\&\=\:\.\(\)\!,@#%<>\{\}\$\*\^]+)["']?)?\]/,
       chunker = new RegExp(simple.source + '(' + attr.source + ')?');
 
   function array(ar) {
     r = [];
     for (i = 0, len = ar.length; i < len; i++) {
       r[i] = ar[i];
     }
     return r;
   }
 
   var cache = function () {
     this.c = {};
   };
   cache.prototype = {
     g: function (k) {
       return this.c[k] || undefined;
     },
     s: function (k, v) {
       this.c[k] = v;
       return v;
     }
   };
 
   var classCache = new cache(),
       cleanCache = new cache(),
       attrCache = new cache(),
       tokenCache = new cache();
 
   function q(query) {
     return query.match(chunker);
   }
 
   function interpret(whole, tag, idsAndClasses, wholeAttribute, attribute, qualifier, value) {
     var m, c, k;
     if (tag && this.tagName.toLowerCase() !== tag) {
       return false;
     }
     if (idsAndClasses && (m = idsAndClasses.match(id)) && m[1] !== this.id) {
       return false;
     }
     if (idsAndClasses && (classes = idsAndClasses.match(clas))) {
       for (i = classes.length; i--;) {
         c = classes[i].slice(1);
         if (!(classCache.g(c) || classCache.s(c, new RegExp('(^|\\s+)' + c + '(\\s+|$)'))).test(this.className)) {
           return false;
         }
       }
     }
     if (wholeAttribute && !value) {
       o = this.attributes;
       for (k in o) {
         if (Object.prototype.hasOwnProperty.call(o, k) && (o[k].name || k) == attribute) {
           return this;
         }
       }
     }
     if (wholeAttribute && !checkAttr(qualifier, this.getAttribute(attribute) || '', value)) {
       return false;
     }
     return this;
   }
 
   function loopAll(tokens) {
     var r = [], token = tokens.pop(), intr = q(token), tag = intr[1] || '*', i, l, els,
         root = tokens.length && (m = tokens[0].match(idOnly)) ? doc.getElementById(m[1]) : doc;
     if (!root) {
       return r;
     }
     els = root.getElementsByTagName(tag);
     for (i = 0, l = els.length; i < l; i++) {
       el = els[i];
       if (item = interpret.apply(el, intr)) {
         r.push(item);
       }
     }
     return r;
   }
 
   function clean(s) {
     return cleanCache.g(s) || cleanCache.s(s, s.replace(specialChars, '\\$1'));
   }
 
   function checkAttr(qualify, actual, val) {
     switch (qualify) {
     case '=':
       return actual == val;
     case '^=':
       return actual.match(attrCache.g('^=' + val) || attrCache.s('^=' + val, new RegExp('^' + clean(val))));
     case '$=':
       return actual.match(attrCache.g('$=' + val) || attrCache.s('$=' + val, new RegExp(clean(val) + '$')));
     case '*=':
       return actual.match(attrCache.g(val) || attrCache.s(val, new RegExp(clean(val))));
     case '~=':
       return actual.match(attrCache.g('~=' + val) || attrCache.s('~=' + val, new RegExp('(?:^|\\s+)' + clean(val) + '(?:\\s+|$)')));
     case '|=':
       return actual.match(attrCache.g('|=' + val) || attrCache.s('|=' + val, new RegExp('^' + clean(val) + '(-|$)')));
     }
     return false;
   }
 
   function _qwery(selector) {
     var r = [], ret = [], i, l,
         tokens = tokenCache.g(selector) || tokenCache.s(selector, selector.split(tokenizr));
     tokens = tokens.slice(0);
     if (!tokens.length) {
       return r;
     }
     r = loopAll(tokens);
     if (!tokens.length) {
       return r;
     }
     // loop through all descendent tokens
     for (j = 0, l = r.length, k = 0; j < l; j++) {
       node = r[j];
       p = node;
       // loop through each token
       for (i = tokens.length; i--;) {
         z: // loop through parent nodes
         while (p !== html && (p = p.parentNode)) {
           if (found = interpret.apply(p, q(tokens[i]))) {
             break z;
           }
         }
       }
       found && (ret[k++] = node);
     }
     return ret;
   }
 
   function boilerPlate(selector, _root, fn) {
     var root = (typeof _root == 'string') ? fn(_root)[0] : (_root || doc);
     if (selector === window || isNode(selector)) {
       return !_root || (selector !== window && isNode(root) && isAncestor(selector, root)) ? [selector] : [];
     }
     if (selector && typeof selector === 'object' && isFinite(selector.length)) {
       return array(selector);
     }
     if (m = selector.match(idOnly)) {
       return (el = doc.getElementById(m[1])) ? [el] : [];
     }
     if (m = selector.match(tagOnly)) {
       return array(root.getElementsByTagName(m[1]));
     }
     return false;
   }
 
   function isNode(el) {
     return (el && el.nodeType && (el.nodeType == 1 || el.nodeType == 9));
   }
 
   function uniq(ar) {
     var a = [], i, j;
     label:
     for (i = 0; i < ar.length; i++) {
       for (j = 0; j < a.length; j++) {
         if (a[j] == ar[i]) {
           continue label;
         }
       }
       a[a.length] = ar[i];
     }
     return a;
   }
 
   function qwery(selector, _root) {
     var root = (typeof _root == 'string') ? qwery(_root)[0] : (_root || doc);
     if (!root || !selector) {
       return [];
     }
     if (m = boilerPlate(selector, _root, qwery)) {
       return m;
     }
     return select(selector, root);
   }
 
   var isAncestor = 'compareDocumentPosition' in html ?
     function (element, container) {
       return (container.compareDocumentPosition(element) & 16) == 16;
     } : 'contains' in html ?
     function (element, container) {
       container = container == doc || container == window ? html : container;
       return container !== element && container.contains(element);
     } :
     function (element, container) {
       while (element = element.parentNode) {
         if (element === container) {
           return 1;
         }
       }
       return 0;
     },
 
   select = (doc.querySelector && doc.querySelectorAll) ?
     function (selector, root) {
       if (doc.getElementsByClassName && (m = selector.match(classOnly))) {
         return array((root).getElementsByClassName(m[1]));
       }
       return array((root).querySelectorAll(selector));
     } :
     function (selector, root) {
       var result = [], collection, collections = [], i;
       if (m = selector.match(tagAndOrClass)) {
         items = root.getElementsByTagName(m[1] || '*');
         r = classCache.g(m[2]) || classCache.s(m[2], new RegExp('(^|\\s+)' + m[2] + '(\\s+|$)'));
         for (i = 0, l = items.length, j = 0; i < l; i++) {
           r.test(items[i].className) && (result[j++] = items[i]);
         }
         return result;
       }
       for (i = 0, items = selector.split(','), l = items.length; i < l; i++) {
         collections[i] = _qwery(items[i]);
       }
       for (i = 0, l = collections.length; i < l && (collection = collections[i]); i++) {
         var ret = collection;
         if (root !== doc) {
           ret = [];
           for (j = 0, m = collection.length; j < m && (element = collection[j]); j++) {
             // make sure element is a descendent of root
             isAncestor(element, root) && ret.push(element);
           }
         }
         result = result.concat(ret);
       }
       return uniq(result);
     };
 
   qwery.uniq = uniq;
   var oldQwery = context.qwery;
   qwery.noConflict = function () {
     context.qwery = oldQwery;
     return this;
   };
   context['qwery'] = qwery;
 
 }(this, document);!function (doc) {
   var q = qwery.noConflict();
   function create(node, root) {
     var el = (root || doc).createElement('div'), els = [];
     el.innerHTML = node;
     var nodes = el.childNodes;
     el = el.firstChild;
     els.push(el);
     while (el = el.nextSibling) {
       (el.nodeType == 1) && els.push(el);
     }
     return els;
   };
   $._select = function (s, r) {
     return /^\s*</.test(s) ? create(s, r) : q(s, r);
   };
   $.ender({
     find: function (s) {
       var r = [], i, l, j, k, els;
       for (i = 0, l = this.length; i < l; i++) {
         els = q(s, this[i]);
         for (j = 0, k = els.length; j < k; j++) {
           r.push(els[j]);
         }
       }
       return $(q.uniq(r));
     }
     , and: function (s) {
       var plus = $(s);
       for (var i = this.length, j = 0, l = this.length + plus.length; i < l; i++, j++) {
         this[i] = plus[j];
       }
       return this;
     }
   }, true);
 }(document);