diff --git a/backbone.js b/backbone.js
index 3f3671bc..0c703cf9 100644
--- a/backbone.js
+++ b/backbone.js
@@ -31,8 +31,8 @@
var _ = root._;
if (!_ && (typeof require !== 'undefined')) _ = require('underscore')._;
- // For Backbone's purposes, jQuery or Zepto owns the `$` variable.
- var $ = root.jQuery || root.Zepto;
+ // For Backbone's purposes, jQuery, Zepto, or Ender owns the `$` variable.
+ var $ = root.jQuery || root.Zepto || root.ender;
// Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
// to its previous owner. Returns a reference to this Backbone object.
diff --git a/test/test-ender.html b/test/test-ender.html
new file mode 100644
index 00000000..b3e4e9b2
--- /dev/null
+++ b/test/test-ender.html
@@ -0,0 +1,30 @@
+
+
+
+ Backbone Test Suite
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/test/vendor/ender-jeesh.js b/test/vendor/ender-jeesh.js
new file mode 100644
index 00000000..70084705
--- /dev/null
+++ b/test/vendor/ender-jeesh.js
@@ -0,0 +1,1678 @@
+/*!
+ * =============================================================
+ * Ender: open module JavaScript framework (https://ender.no.de)
+ * Build: ender build jeesh
+ * =============================================================
+ */
+
+/*!
+ * Ender-JS: open module JavaScript framework (client-lib)
+ * copyright Dustin Diaz & Jacob Thornton 2011 (@ded @fat)
+ * https://ender.no.de
+ * License MIT
+ */
+!function (context) {
+
+ // a global object for node.js module compatiblity
+ // ============================================
+
+ context['global'] = context;
+
+ // Implements simple module system
+ // losely based on CommonJS Modules spec v1.1.1
+ // ============================================
+
+ var modules = {};
+
+ function require (identifier) {
+ var module = modules[identifier] || window[identifier];
+ if (!module) throw new Error("Requested module '" + identifier + "' has not been defined.");
+ return module;
+ }
+
+ function provide (name, what) {
+ return modules[name] = what;
+ }
+
+ context['provide'] = provide;
+ context['require'] = require;
+
+ // Implements Ender's $ global access object
+ // =========================================
+
+ 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.5',
+ 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['$'] = context['ender'] || ender;
+
+}(this);
+
+!function () {
+
+ var module = { exports: {} }, exports = module.exports;
+
+ /*!
+ * 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 (e) {
+ if (condition ? condition.apply(this, arguments) : W3C_MODEL ? true : e && e.propertyName == '_on' + type || !e) {
+ fn.apply(element, Array.prototype.slice.call(arguments, e ? 0 : 1).concat(args));
+ }
+ };
+ },
+
+ addListener = function (element, orgType, fn, args) {
+ var type = orgType.replace(stripName, ''),
+ events = retrieveEvents(element),
+ handlers = events[type] || (events[type] = {}),
+ originalFn = fn,
+ 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;
+ fn.__originalFn = originalFn;
+ 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];
+
+ function destroyHandler(uid) {
+ handler = events[type][uid];
+ if (!handler) return;
+ 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);
+ }
+ }
+
+ destroyHandler(names) //get combos
+ for (i = uids.length; i--; destroyHandler(uids[i])); //get singles
+
+ 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])) {
+ if (attached && names) {
+ for (k in attached) {
+ if (attached.hasOwnProperty(k)) {
+ for (i in attached[k]) {
+ attached[k].hasOwnProperty(i) && new RegExp('^' + names + '(\\..*)?$').test(i) && rm(element, [k, i].join('.'));
+ }
+ }
+ }
+ }
+ 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) {
+ if (events.hasOwnProperty(k)) {
+ rm(element, type || k, events[k]);
+ delete events[k]; // remove unused leaf keys
+ }
+ }
+ }
+ 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 && handlers[isNamespace[k]] && handlers[isNamespace[k]].apply(element, [false].concat(args));
+ }
+ } else if (!args && element[eventSupport]) {
+ fireListener(isNative, type, element);
+ } else {
+ for (k in handlers) {
+ handlers.hasOwnProperty(k) && handlers[k].apply(element, [false].concat(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;
+ var uid = retrieveUid(element);
+ obj = type ? events[type] : events;
+ for (k in obj) {
+ obj.hasOwnProperty(k) && (type ? add : clone)(element, type || from, type ? obj[k].__originalFn : 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);
+
+ provide("bean", module.exports);
+
+ !function ($) {
+ var b = require('bean'),
+ 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);
+
+}();
+
+!function () {
+
+ var module = { exports: {} }, exports = module.exports;
+
+ /*!
+ * 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,
+ 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 = {
+
+ get: function (index) {
+ return this[index];
+ },
+
+ 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], 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 (typeof x == 'number' || typeof y == 'number') {
+ return this.each(function (el) {
+ xy(el, x, y);
+ });
+ }
+ var el = this[0],
+ width = el.offsetWidth,
+ height = el.offsetHeight,
+ top = el.offsetTop,
+ 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];
+ if (typeof k != 'string' && !(k instanceof String)) {
+ for (var n in k) {
+ k.hasOwnProperty(n) && this.attr(n, k[n]);
+ }
+ return this;
+ }
+ 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 vp = this.viewport();
+ return {
+ width: Math.max(doc.body.scrollWidth, html.scrollWidth, vp.width),
+ height: Math.max(doc.body.scrollHeight, html.scrollHeight, 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 () {
+ return {
+ width: ie ? html.clientWidth : self.innerWidth,
+ height: ie ? html.clientHeight : self.innerHeight
+ };
+ };
+
+ 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);
+
+
+ provide("bonzo", module.exports);
+
+ !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 () {
+
+ var module = { exports: {} }, exports = module.exports;
+
+ !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() { context['domReady'](fn) }, 50);
+ }
+ fn();
+ }()
+ } :
+ function (fn) {
+ loaded ? fn() : fns.push(fn);
+ };
+
+ }(this, document);
+
+
+ provide("domready", module.exports);
+
+ !function ($) {
+ $.ender({domReady: domReady});
+ $.ender({
+ ready: function (f) {
+ domReady(f);
+ return this;
+ }
+ }, true);
+ }(ender);
+
+}();
+
+!function () {
+
+ var module = { exports: {} }, exports = module.exports;
+
+ /*!
+ * 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;
+ }
+ };
+ 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);
+
+ provide("qwery", module.exports);
+
+ !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*