comparison johndyer-mediaelement-13fa20a/src/js/jeesh.js @ 0:032bc65ebafc

added core components

+/*!
+  * Ender: open module JavaScript framework
+  * copyright Dustin Diaz & Jacob Thornton 2011 (@ded @fat)
+  * https://ender.no.de
+  * License MIT
+  * Build: ender build jeesh --output 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, els) {
+                          // string || node || nodelist || window
+    if (ender._select && (typeof s == 'string' || s.nodeName || s.length && 'item' in s || s == 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.4',
+    ender: function (o, chain) {
+      aug(chain ? boosh : ender, o);
+    },
+    fn: context.$ && context.$.fn || {} // for easy compat to jQuery plugins
+  });
+
+  aug(boosh, {
+    forEach: function (fn, scope, i) {
+      // opt out of native forEach so we can intentionally call our own scope
+      // defaulting to the current item and be able to return self
+      for (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;
+    },
+    $: ender // handy reference to self
+  });
+
+  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, i,
+        isString = typeof(orgEvents) == 'string',
+        names = isString && orgEvents.replace(namespace, ''),
+        rm = removeListener,
+        attached = retrieveEvents(element);
+    if (isString && /\s/.test(orgEvents)) {
+      orgEvents = orgEvents.split(' ');
+      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, i) { // i for internal
+      for (i = this.length; i--;) {
+        b.add.call(this, this[i], 'mouseenter', enter);
+        b.add.call(this, this[i], 'mouseleave', leave);
+      }
+      return this;
+    }
+  };
+
+  var i, shortcuts = [
+    'blur', 'change', 'click', 'dblclick', 'error', 'focus', 'focusin',
+    'focusout', 'keydown', 'keypress', 'keyup', 'load', 'mousedown',
+    'mouseenter', 'mouseleave', 'mouseout', 'mouseover', 'mouseup', 'mousemove',
+    'resize', 'scroll', 'select', 'submit', 'unload'
+  ];
+
+  for (i = shortcuts.length; i--;) {
+    methods[shortcuts[i]] = integrate('add', shortcuts[i]);
+  }
+
+  $.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, win) {
+
+  var doc = context.document,
+      html = doc.documentElement,
+      parentNode = 'parentNode',
+      query = null,
+      byTag = 'getElementsByTagName',
+      specialAttributes = /^checked|value|selected$/,
+      specialTags = /select|fieldset|table|tbody|tfoot|td|tr|colgroup/i,
+      table = 'table',
+      tagMap = { thead: table, tbody: table, tfoot: table, tr: 'tbody', th: 'tr', td: 'tr', fieldset: 'form', option: 'select' },
+      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 = [],
+        nodes = query && typeof target == 'string' && target.charAt(0) != '<' ? function (n) {
+          return (n = query(target)) && (n.selected = 1) && n;
+        }() : target;
+    each(normalize(nodes), function (t) {
+      each(self, function (el) {
+        var n = !el[parentNode] || (el[parentNode] && !el[parentNode][parentNode]) ?
+                  function () {
+                    var c = el.cloneNode(true);
+                    self.$ && self.cloneEvents && self.$(c).cloneEvents(el);
+                    return c;
+                  }() :
+                  el;
+        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;
+    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) {
+        while (el.firstChild) {
+          el.removeChild(el.firstChild);
+        }
+        each(normalize(h), 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, p) {
+      // is this a request for just getting a style?
+      if (v === undefined && typeof o == 'string') {
+        // repurpose 'v'
+        v = this[0];
+        if (!v) {
+          return null;
+        }
+        if (v == doc || v == win) {
+          p = (v == doc) ? bonzo.doc() : bonzo.viewport();
+          return o == 'width' ? p.width :
+            o == 'height' ? p.height : '';
+        }
+        return getStyle(v, 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) {
+    return typeof node == 'string' ? bonzo.create(node) : is(node) ? [node] : node; // assume [nodes]
+  }
+
+  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)) {
+      win.scrollTo(x, y);
+    } else {
+      x != null && (el.scrollLeft = x);
+      y != null && (el.scrollTop = y);
+    }
+    return this;
+  }
+
+  function isBody(element) {
+    return element === win || (/^(?:body|html)$/i).test(element.tagName);
+  }
+
+  function getWindowScroll() {
+    return { x: win.pageXOffset || html.scrollLeft, y: win.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) {
+    return typeof node == 'string' ?
+      function () {
+        var tag = /^<([^\s>]+)/.exec(node);
+        var el = doc.createElement(tag && tagMap[tag[1].toLowerCase()] || '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;
+
+      }() : 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;
+    if (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, window);!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 i, 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 dimension(v, this, 'height')
+    },
+
+    width: function (v) {
+      return dimension(v, this, 'width')
+    }
+  }, true);
+
+  function dimension(v, self, which) {
+    return v ?
+      self.css(which, v) :
+      function (r) {
+        r = parseInt(self.css(which), 10);
+        return isNaN(r) ? self[0]['offset' + which.replace(/^\w/, function (m) {return m.toUpperCase()})] : r
+      }()
+  }
+
+}(ender || $);
+
+!function (context, doc) {
+  var fns = [], ol, fn, f = false,
+      testEl = doc.documentElement,
+      hack = testEl.doScroll,
+      domContentLoaded = 'DOMContentLoaded',
+      addEventListener = 'addEventListener',
+      onreadystatechange = 'onreadystatechange',
+      loaded = /^loade|c/.test(doc.readyState);
+
+  function flush(i) {
+    loaded = 1;
+    while (i = fns.shift()) { i() }
+  }
+  doc[addEventListener] && doc[addEventListener](domContentLoaded, fn = function () {
+    doc.removeEventListener(domContentLoaded, fn, f);
+    flush();
+  }, f);
+
+
+  hack && doc.attachEvent(onreadystatechange, (ol = function () {
+    if (/^c/.test(doc.readyState)) {
+      doc.detachEvent(onreadystatechange, ol);
+      flush();
+    }
+  }));
+
+  context['domReady'] = hack ?
+    function (fn) {
+      self != top ?
+        loaded ? fn() : fns.push(fn) :
+        function () {
+          try {
+            testEl.doScroll('left');
+          } catch (e) {
+            return setTimeout(function() { domReady(fn) }, 50);
+          }
+          fn();
+        }()
+    } :
+    function (fn) {
+      loaded ? fn() : fns.push(fn);
+    };
+
+}(this, document);!function ($) {
+  $.ender({domReady: domReady});
+  $.ender({
+    ready: function (f) {
+      domReady(f);
+      return this;
+    }
+  }, true);
+}(ender);
+/*!
+  * Qwery - A Blazing Fast query selector engine
+  * https://github.com/ded/qwery
+  * copyright Dustin Diaz & Jacob Thornton 2011
+  * MIT License
+  */
+
+!function (context, doc) {
+
+  var c, i, j, k, l, m, o, p, r, v,
+      el, node, len, found, classes, item, items, token,
+      html = doc.documentElement,
+      id = /#([\w\-]+)/,
+      clas = /\.[\w\-]+/g,
+      idOnly = /^#([\w\-]+$)/,
+      classOnly = /^\.([\w\-]+)$/,
+      tagOnly = /^([\w\-]+)$/,
+      tagAndOrClass = /^([\w]+)?\.([\w\-]+)$/,
+      normalizr = /\s*([\s\+\~>])\s*/g,
+      splitters = /[\s\>\+\~]/,
+      splittersMore = /(?![\s\w\-\/\?\&\=\:\.\(\)\!,@#%<>\{\}\$\*\^'"]*\])/,
+      dividers = new RegExp('(' + splitters.source + ')' + splittersMore.source, 'g'),
+      tokenizr = new RegExp(splitters.source + splittersMore.source),
+      specialChars = /([.*+?\^=!:${}()|\[\]\/\\])/g,
+      simple = /^([a-z0-9]+)?(?:([\.\#]+[\w\-\.#]+)?)/,
+      attr = /\[([\w\-]+)(?:([\|\^\$\*\~]?\=)['"]?([ \w\-\/\?\&\=\:\.\(\)\!,@#%<>\{\}\$\*\^]+)["']?)?\]/,
+      pseudo = /:([\w\-]+)(\(['"]?(\w+)['"]?\))?/,
+      chunker = new RegExp(simple.source + '(' + attr.source + ')?' + '(' + pseudo.source + ')?'),
+      walker = {
+    ' ': function (node) {
+      return node && node !== html && node.parentNode
+    },
+    '>': function (node, contestant) {
+      return node && node.parentNode == contestant.parentNode && node.parentNode;
+    },
+    '~': function (node) {
+      return node && node.previousSibling;
+    },
+    '+': function (node, contestant, p1, p2) {
+      if (!node) {
+        return false;
+      }
+      p1 = previous(node);
+      p2 = previous(contestant);
+      return p1 && p2 && p1 == p2 && p1;
+    }
+  };
+  window.tokenizr = tokenizr;
+  window.dividers = dividers;
+  function cache() {
+    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 array(ar) {
+    r = [];
+    for (i = 0, len = ar.length; i < len; i++) {
+      r[i] = ar[i];
+    }
+    return r;
+  }
+
+  function previous(n) {
+    while (n = n.previousSibling) {
+      if (n.nodeType == 1) {
+        break;
+      }
+    }
+    return n
+  }
+
+  function q(query) {
+    return query.match(chunker);
+  }
+
+  // this next method expect at most these args
+  // given => div.hello[title="world"]:foo('bar')
+
+  // div.hello[title="world"]:foo('bar'), div, .hello, [title="world"], title, =, world, :foo('bar'), foo, ('bar'), bar]
+
+  function interpret(whole, tag, idsAndClasses, wholeAttribute, attribute, qualifier, value, wholePseudo, pseudo, wholePseudoVal, pseudoVal) {
+    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 (pseudo && qwery.pseudos[pseudo] && !qwery.pseudos[pseudo](this, pseudoVal)) {
+      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 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 0;
+  }
+
+  function _qwery(selector) {
+    var r = [], ret = [], i, j = 0, k, l, m, p, token, tag, els, root, intr, item, children,
+        tokens = tokenCache.g(selector) || tokenCache.s(selector, selector.split(tokenizr)),
+        dividedTokens = selector.match(dividers), dividedToken;
+    tokens = tokens.slice(0); // this makes a copy of the array so the cached original is not effected
+    if (!tokens.length) {
+      return r;
+    }
+
+    token = tokens.pop();
+    root = tokens.length && (m = tokens[tokens.length - 1].match(idOnly)) ? doc.getElementById(m[1]) : doc;
+    if (!root) {
+      return r;
+    }
+    intr = q(token);
+    els = dividedTokens && /^[+~]$/.test(dividedTokens[dividedTokens.length - 1]) ? function (r) {
+        while (root = root.nextSibling) {
+          root.nodeType == 1 && (intr[1] ? intr[1] == root.tagName.toLowerCase() : 1) && r.push(root)
+        }
+        return r
+      }([]) :
+      root.getElementsByTagName(intr[1] || '*');
+    for (i = 0, l = els.length; i < l; i++) {
+      if (item = interpret.apply(els[i], intr)) {
+        r[j++] = item;
+      }
+    }
+    if (!tokens.length) {
+      return r;
+    }
+
+    // loop through all descendent tokens
+    for (j = 0, l = r.length, k = 0; j < l; j++) {
+      p = r[j];
+      // loop through each token backwards crawling up tree
+      for (i = tokens.length; i--;) {
+        // loop through parent nodes
+        while (p = walker[dividedTokens[i]](p, r[j])) {
+          if (found = interpret.apply(p, q(tokens[i]))) {
+            break;
+          }
+        }
+      }
+      found && (ret[k++] = r[j]);
+    }
+    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) {
+      selector = selector.replace(normalizr, '$1');
+      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;
+  qwery.pseudos = {};
+
+  var oldQwery = context.qwery;
+  qwery.noConflict = function () {
+    context.qwery = oldQwery;
+    return this;
+  };
+  context['qwery'] = qwery;
+
+}(this, document);!function (doc) {
+  var q = qwery.noConflict();
+  var table = 'table',
+      nodeMap = {
+        thead: table,
+        tbody: table,
+        tfoot: table,
+        tr: 'tbody',
+        th: 'tr',
+        td: 'tr',
+        fieldset: 'form',
+        option: 'select'
+      }
+  function create(node, root) {
+    var tag = /^<([^\s>]+)/.exec(node)[1]
+    var el = (root || doc).createElement(nodeMap[tag] || '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);