/*!
 * Karmagination 0.2 - Fast and Easy
 * http://www.karmagination.com
 * Released under the MIT, BSD, and GPL Licenses - Choose one that fit your needs
 * Copyright (c) 2009 Kean Loong Tan 
 * Start date: 2009-04-01
 * Build Time: 2009-09-23 07:19:42 AM
 * Build: 2871
 *
 * Attribution:
 * onDOMready based on many JS experts' input especially Dean Edwards, see the unminified source code for names
 * Custom events based on Dean Edwards' blog post enlightenment
 * CSS and browser detection copyright Valerio Proietti of Mootools
 * Offsets, dimensions, and extend, eq copyright John Resig of jQuery
 * Selector engine, Sizzle, founded by John Resig, copyright Dojo Foundation
 * Common Feature Test, event support detection copyright Juriy Zaytsev/kangax
 * Animation based loosely on Ryan Morr's FX library which in turn is influenced by YUI 2
 * Many thanks to John David Dalton for the support and pointers :{D
 * And to many of those that contributed to the projects above
 */
 
//start expression
(function karma_anonymous(window){ 

// speeding up reference in non-JIT bytecode browsers
var document = window.document,
	_Karma = window.Karma,
	_$ = window.$;

// Constructor Function
var Karma = this.$ = this.Karma = function( query, context ) {
	// note: if Karma has not been instatiated, this === global object, interpreted by most browsers as window
	// I did not use instance of because window instanceof leaks memory in IE, what a shame
	// if (!(this instanceof Karma)) return new Karma( query, context );
	// this pollutes FF with a contructor in window WHY?
	if (this.constructor !== Karma) return new Karma( query, context );
	
	query = query || document;
	this.context = context = context || document;
	
	// the stack to track callee Karma objects
	this.KarmaStack = [];
	
	// result can be empty
	var result = [];
	
	// if a node is passed
	if (query.nodeType || query === window) {
		this[0] = query;
		this.length = 1;
		this.query = query;
		return; // do not return 'this' because it's a constructor, return just to break from function
	}
	
	// string is most used query
	else if(typeof query == "string") {
		this.query = query = Karma.trim(query);
		if(!query.length) {
			this[0] = document;
			this.length = 1;
			this.query = query;
			return; // do not return 'this' because it's a constructor, return just to break from function
		}

		var context = this.context.ownerDocument || this.context;
		
		// if HTML string passed
		result = Karma.isHTML(query) ? Karma.HTMLtoNode(query, context) : Karma.Sizzle(query, context);
	}
	
	// onDOMready
	else if (typeof query == "function") {
		(!Karma.isReady) ? Karma.readyQueue(function readyQueue(){ query(Karma);}) :	query(Karma);
		return;
	}

	// if array, object or Karma object, or some unknown, make it into an array
	else { 
		result = query; 
		if(query.query)	this.query = query.query;
	}
	
	// push all the elements that we have gotten into the Karmagination Instance
	this.populate(result);
};

var _Object = Object, _Array = Array;
/*
//if(window.addEventListener && !window.ActiveXObject){
	var _div = document.createElement("div");
	_div.innerHTML = '<iframe name="Karmagination" src="javascript:void 0" style="display:none"></iframe>';
	var iframe = _div.firstChild;
	document.documentElement.insertBefore(iframe, document.documentElement.firstChild);
	
	var host = self.location.hostname == 'localhost' ? '' : 'document.domain = ' + self.location.hostname;
	
	frames['Karmagination'].document.write("<script>"+host+"<\/script>");
	
	_Object = frames['Karmagination'].Object;
	_Array = frames['Karmagination'].Array;
//}
*/
Karma.fn = Karma.prototype;

// use no Karmagination syntax in extend function (pure js) cause they will fail
Karma.extend = Karma.fn.extend = function() {
	// copy reference to target object
	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;

	// Handle a deep copy situation
	if ( typeof target == 'boolean' ) {
		deep = target;
		target = arguments[1] || {};
		// skip the boolean and the target
		i = 2;
	}

	// Handle case when target is a string or something (possible in deep copy)
	if ( typeof target != 'object' && typeof target != 'function' )
		target = {};

	// extend Karma itself if only one argument is passed
	if ( length == i ) {
		target = this;
		--i;
	}

	for ( ; i < length; i++ )
		// Only deal with non-null/undefined values
		if ( (options = arguments[ i ]) != null )
			// Extend the base object
			for ( var name in options ) {
				var src = target[ name ], copy = options[ name ];

				// Prevent never-ending loop
				if ( target === copy )
					continue;

				// Recurse if we're merging object values
				if ( deep && copy && typeof copy == "object" && !copy.nodeType )
					target[ name ] = Karma.extend( deep, 
						// Never move original objects, clone them
						src || ( copy.length != null ? [ ] : { } )
					, copy );

				// Don't bring in undefined values
				else if ( typeof copy != 'undefined' )
					target[ name ] = copy;
			}

	// Return the modified object
	return target;
};

Karma.fn.extend({
	// populate nodes into Karma, starting from index n
	populate: function(elements ,n) {
		n = n || 0;
		// make a clean array
		this.length = n;
		
		elements = Karma.makeArray(elements);

		// exit if no elements found
		if (!elements.length) return this;
		
		// push elements into Karma, faster way than just just a for loop
		_Array.prototype.push.apply(this, elements);
		return this;
	},
	
	// empty all elements store in Karma, starting from index n,
	wipe: function(n){
		n = n || 0;
		
		for(var i=n; i<this.length; i++)
			delete this[i];

		this.length = n;
		
		return this;
	},
	
	// stacking Karma for chainability
	stack: function(o){
		this.query = o.query;
		this.KarmaStack.push(o);
		return this;
	},
	
	// getting into the previous chain
	end: function() {
		return this.KarmaStack[0];
	},
	
	// how many elements in Karma, initially set to 0
	length: 0,
	
	// query that created the current instance of Karma
	query: null,
	
	version: 0.2	
});

Karma.extend({
	version: 0.2,
	/* special thanks to jQuery's cases so I don't have to manually hunt down the special cases myself */	 
	HTMLtoNode: function(query, context) {
		context = context.ownerDocument || context;
		//var query = Karma.cleanHTML(query);
		var tmp = context.createElement('DIV'), 
			subquery = query.substring(0, 8).toLowerCase();

		// lesson learned again and again never use Regex when indexOf can replace the job.
		// td
		if(!subquery.indexOf('<tr')) {
			query = '<table>' + query + '</table>';
			tmp.innerHTML=query;
			tmp = tmp.firstChild.firstChild;
		}
		// td or th
		else if(!subquery.indexOf("<td") || !subquery.indexOf("<th")) {
			query = '<table><tr>' + query + '</tr></table>';
			tmp.innerHTML=query;
			tmp = tmp.firstChild.firstChild.firstChild;
		}
		// legend
		else if(!subquery.indexOf("<legend")) {
			query = '<fieldset>' + query + '</fieldset>';
			tmp.innerHTML=query;
			tmp = tmp.firstChild;
		}
		// option
		else if(!subquery.indexOf("<option")) {
			query = '<select multiple="multiple">' + query + '</select>';
			tmp.innerHTML=query;
			tmp = tmp.firstChild;
		}
		
		// thead etc, well we made subquery soooo short it should not be a problem
		else if(/^<thead|tbody|tfoot|colg|capt/.test(subquery)) {
			query = '<table>' + query + '</table>';
			tmp.innerHTML=query;
			tmp = tmp.firstChild;
		}
		
		// col
		else if(!subquery.indexOf("<col")) {
			query = '<table><colgroup>' + query + '</colgroup></table>';
			tmp.innerHTML=query;
			tmp = tmp.firstChild.firstChild.firstChild;
		}
		// script and link
		else if (!subquery.indexOf("<script") || !subquery.indexOf("<link") ) {
			query = 'div<div>' + query + '</div>';
			tmp.innerHTML=query;
			tmp = tmp.lastChild;
		}

		// others
		else {
			tmp.innerHTML = query;
		}
		
		return tmp.childNodes.length ? Karma.makeArray(tmp.childNodes) : [];
		
	},
	 
	// type detection, Miller method for those special cases otherwise typeof is faster, 
	isArray: function(o){ return _Object.prototype.toString.call(o) == "[object Array]" },
	isObject: function(o){ return _Object.prototype.toString.call(o) == "[object Object]" },
	isDate: function(o){ return _Object.prototype.toString.call(o) == "[object Date]" },
	isGenericObject: function(o) { return typeof o == "object" },
	isFunction: function(o) { return typeof o == "function" },
	isString: function(o) { return typeof o == "string" },
	isNumber: function(o){ return typeof o == "number" },
	isValue: function(o){ return typeof o == "number" || typeof o == "string" },
	isBoolean: function(o){ return typeof o == "boolean" },
	// undefined munging is slower in all modern browser, use is not recommended
	isDefined: function(o) { return typeof o != "undefined" },
	// isXML: function(o) { return 'innerHTML' in (o || o.ownerDocument).documentElement },
	// unreliable detection, using documentation to prevent mistake instead
	isHTML: function(o) { return Karma.isString(o) ? /^<.+/.test(o.substring(0,3)) : false; },
	isKarma: function(o) { return o.constructor === Karma },

	
	// browser detection, TAKEN FROM MOOTOOLS with modifications, if you are new to JS, !! mean cast as boolean type
	// learned something new today from BING, a new-old IE feature detection that's probably better
	// old method !!(window.ActiveXObject && !window.opera) 
	// new method !window.addEventListener, we used that for feature detection but it turns out to be an IE detector too
	isIE: !!(!window.addEventListener && window.ActiveXObject),
	isIE6: typeof document.createElement('DIV').style.maxHeight == "undefined",
	isIE7: !!(!window.addEventListener && window.XMLHttpRequest && !document.querySelectorAll),
	isIE8: !!(!window.addEventListener && document.querySelectorAll),
	isGecko: navigator.product == 'Gecko',
	isOpera: !!window.opera,
	isWebkit: !!(!window.opera && !navigator.taintEnable && document.evaluate && navigator.product != 'Gecko'),
	
	// trim front/ending whitespaces and newlines so innerHTML won't go crazy
	/*cleanHTML: function(HTML){ return HTML.replace ? HTML.replace(/[\n\r]/g, ' ') : HTML; },*/
	
	// used internally, only works for array-like objects
	makeArray: function(o) {
		if (Karma.isArray(o)) return o; // makes sense, doesn't it?
		if (Karma.support.nodeListToArray) return _Array.prototype.slice.call(o);
		
		var ret;
		
		// some array-like objects will have length
		if (o.length) {
			var length = new Number(o.length);
			ret = new Array(length);
			while (--length >= 0) {
		        ret[length] = o[length];
		    }
		}
		else {
			ret = [];
			for(var prop in o) {
				if (o.hasOwnProperty(prop))
					ret.push(o[prop]);
			}
		}
		return ret;
	},
	
	noConflict: function(extreme){
		window.$ = _$;
		if (extreme)
			window.Karma = _Karma;
		return Karma;
	},
	
	// returns a unique set of array
	unique: function(array) {
		var ret = [];
		o:for(var i = 0, n = array.length; i < n; i++) {
			for(var x = i + 1 ; x < n; x++) {
				if(array[x] === array[i])
					continue o; 
			}
			ret.push(array[i]);
		}
		return ret;
	},
	
	// functions to fire onDOMready
	readyFunctions: [],
	
	// onDOMready yet?
	isReady: false, 
	
	// add functions to Karma.fns
	readyQueue: function(fn){
		if(Karma.isFunction(fn))
			Karma.readyFunctions.push(fn);
	},
	
	// reliable onDOMready code, thanks to Dean Edwards/Diego Perini/Byron McGregor/John Resig/Matthias Miller et al
	// view the contributors here, http://dean.edwards.name/weblog/2006/06/again/
	// modified so that onDOMready runs once for each frame it's being used, speeds up when you have multiple onDOMready statements
	ready: function(){
		var init = function() {
			if(Karma.isReady) return;
			Karma.isReady = true;
			
			// run all functions that are associated with ready
			for(var i=0; i< Karma.readyFunctions.length; i++) {
				Karma.readyFunctions[i](Karma);
			}
		}
		
		if(Karma.support.addEventListener)
			document.addEventListener('DOMContentLoaded', init, false);

		else if(document.documentElement.doScroll) {
			try {
				document.createElement('div').doScroll('left');
				return init();
			} catch(e) {}
		}
		else if (/loaded|complete/.test(document.readyState)) return init();
		 
		// loop every 50 ms is good enough
		if (!Karma.isReady) setTimeout(arguments.callee, 50);
	}
});

// added this for jQuery compatibility
Karma.browser = {
	safari: Karma.isWebkit,
	opera: Karma.isOpera,
	mozilla: Karma.isGecko,
	msie: Karma.isIE,
	version: Karma.isIE6 ? 6 : Karma.isIE7 ? 7 : ''
}
// some simulations below to feature test the capabilities of the current browser
// also populates known attribute names that are problematic
// values are stored for future use
Karma.temp = {
	div: document.createElement('DIV'),
	fragment: document.createDocumentFragment(),
	camelCase: {},
	nodeListToArray: function(){
		try { return _Array.prototype.slice.call(document.forms, 0) instanceof _Array; } catch (e) { return false; }
	},
	/*
	htmlCreation: function(){
		try { document.createElement('<input id="a" />'); } catch(e) { return false; }
		return true;
	},*/
	
	attrMap: {
		'for': 'htmlFor',
		'class': 'className',
		maxlength: 'maxLength',
		readonly: 'readOnly',
		rowspan: 'rowSpan',
		colspan: 'colSpan',
		codebase: 'codeBase',
		ismap: 'isMap',
		accesskey: 'accessKey',
		longdesc: 'longDesc',
		tabindex: 'tabIndex',
		valign: 'vAlign',
		cellspacing: 'cellSpacing',
		cellpadding: 'cellPadding',
		id: 'id',
		href: 'href',
		dir: 'dir',
		title: 'title'
	},
	
	offsets: function(){
		var body = document.body,
			container = document.createElement('div'), 
			innerDiv,
			checkDiv,
			table,
			td,
			rules,
			cur_prop,
			bodyMarginTop = document.body.style.marginTop,
			html = '<div style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;" cellpadding="0" cellspacing="0"><tr><td></td></tr></table>';

		var rules = { position: 'absolute', top: 0, left: 0, margin: 0, border: 0, width: '1px', height: '1px', visibility: 'hidden' };
		for ( cur_prop in rules ) container.style[cur_prop] = rules[cur_prop];

		container.innerHTML = html;
		body.insertBefore(container, body.firstChild);
		innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild;

		this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
		this.doesAddBorderForTableAndCells = (td.offsetTop === 5);

		innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative';
		this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);

		body.style.marginTop = '1px';
		this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0);
		body.style.marginTop = bodyMarginTop;

		body.removeChild(container);
	
	},
	
	calculatedOffsets: false
}

Karma.uniqueId = 0;
Karma.storage = {};

// know the current browser's capabilities, we calculate here and use everywhere without recalculating
// why isDefined is reliable here, REASON: we just created the ELEMENT and can be sure they are not polluted
Karma.support = {
	//htmlCreation: Karma.temp.htmlCreation(),
	cssText: 'cssText' in Karma.temp.div.style,
	cssFloat: 'cssFloat' in Karma.temp.div.style,
	styleFloat: 'styleFloat' in Karma.temp.div.style,
	opacity: 'opacity' in Karma.temp.div.style,
	filter: 'filter' in Karma.temp.div.style,
	outerHTML: 'outerHTML' in Karma.temp.div,
	addEventListener: 'addEventListener' in Karma.temp.div,
	attachEvent: 'attachEvent' in Karma.temp.div,
	dispatchEvent: 'dispatchEvent' in Karma.temp.div,
	fireEvent : 'fireEvent' in Karma.temp.div,
	createEvent: 'createEvent' in document,
	createEventObject: 'createEventObject' in document,
	nodeListToArray: Karma.temp.nodeListToArray(),
	currentDocIsHTML: 'innerHTML' in document.documentElement
};

// run the function to wait for onDOMready
Karma.ready();
Karma.fn.extend({
			 
	append: function(o) {
		var els = Karma(o);
		if(!this.length || !els.length) return this;

		return Karma.temp.manipulate('append', els, this, els.query);
	},
	
	appendTo: function(o) {
		var els = Karma(o);
		if(!this.length || !els.length) return this;
		
		return Karma.temp.manipulate('append', this, els, this.query, 1);
	},
	
	prepend: function(o) {
		var els = Karma(o);
		if(!this.length || !els.length) return this;

		return Karma.temp.manipulate('prepend', els, this, els.query);
	},
	
	prependTo: function(o) {
		var els = Karma(o);
		if(!this.length || !els.length) return this;
		
		return Karma.temp.manipulate('prepend', this, els, this.query, 1);
	},
	
	before: function(o) {
		var els = Karma(o);
		if(!this.length || !els.length) return this;
		
		return Karma.temp.manipulate('before', els, this, els.query);
	},
	
	insertBefore: function(o){
		var els = Karma(o);
		if(!this.length || !els.length) return this;
		
		return Karma.temp.manipulate('before', this, els, this.query, 1);
		
	},
	
	after: function(o) {
		var els = Karma(o);
		if(!this.length || !els.length) return this;
		
		return Karma.temp.manipulate('after', els, this, els.query);
	},
	
	insertAfter: function(o){
		var els = Karma(o);
		if(!this.length || !els.length) return this;

		return Karma.temp.manipulate('after', this, els, this.query, 1);
	},
	
	// removes all events attached including current node
	empty: function() {
		for (var i=0; i< this.length; i++) {
			if (Karma.support.currentDocIsHTML) {
				// no garbage collection here, we do it on unload then
				// performance comes first vs pseudo leak
				this[i].innerHTML = '';
			}
			// if is XML document
			else {
				while (this[i].firstChild) {
					// garbage collection, it's not perfect but will reduce memory usage while balancing performance
					if (this[i].firstChild.KarmaMap) Karma.storage[this[i].KarmaMap] = null;
					this[i].removeChild(this[i].firstChild);
				}
			}
		}
		return this;
	},
	
	html: function(value) {
		if(Karma.isValue(value)) {
			for (var i=0; i< this.length; i++)
				this[i].innerHTML = value;
		
			return this;
		}
		return this.length? this[0].innerHTML: null;
	},
	
	text: function(value) {
		if(Karma.isValue(value)) {
			for(var i=0; i< this.length; i++)
				this[i].innerText ?	this[i].innerText = value :	this[i].textContent = value;
			return this;
		}
		
		var text = [];
		for(var i=0; i< this.length; i++) {
			text.push(this[i].innerText || this[i].textContent);
		}
		
		return text.join(' ');
	},
	
	remove: function(query){
		var result = Karma.isString(query) ? Karma.Sizzle.filter(query, this) : this.length ? this : [];
		
		for (var i=0; i< result.length; i++) {
			if (result[i].KarmaMap) Karma.storage[result[i].KarmaMap] = null;
			result[i].parentNode.removeChild(result[i]);
		}
		
		return this;
	},
	
	// TODO: clone events
	clone: function(events){
		var clone = [],
			$child;

		for(var i=0;i<this.length;i++) {
			if (Karma.support.outerHTML) {
				clone.push(Karma(this[i].outerHTML, this[i].ownerDocument||this[i])[0]);
				$child = Karma(clone[i]);
				$child[0].KarmaMap = ++Karma.uniqueId;
				Karma.storage[$child[0].KarmaMap] = {};

				// wow outerHTML will copy even elem.KarmaMap which screwed up my rebindings
				if(events) {
					for (var ev in Karma.storage[this[i].KarmaMap].KarmaEvent) {
						Karma.storage[$child[0].KarmaMap][ev] = [];
						for (var fn in Karma.storage[this[i].KarmaMap].KarmaEvent[ev])
							Karma.storage[$child[0].KarmaMap][ev][fn] = Karma.storage[this[i].KarmaMap].KarmaEvent[ev][fn];
					}
				}
			}
			else {
				clone.push(this[i].cloneNode(true));
				$child = Karma(clone[i]);
				
				if(events) {
					for (var ev in Karma.storage[this[i].KarmaMap].KarmaEvent) 
						for (var fn in Karma.storage[this[i].KarmaMap].KarmaEvent[ev]) 
							$child.bind( ev, Karma.storage[this[i].KarmaMap].KarmaEvent[ev][fn] );
				}
			}

		}

		return Karma(clone).stack(this);
	},

	wrap: function(str){
		for(var i=0;i<this.length;i++) {
			var	cloned = Karma(str, this[i].ownerDocument||this[i]).clone()[0];
				
			this[i].parentNode.replaceChild(cloned, this[i]);
			cloned.appendChild(this[i]);
		}
		return this;
	}

});

Karma.extend(Karma.temp, {
	manipulate: function (method, child, parent, query, ret) {
		var fragment = child[0];
		
		if (child.length > 1) {
			fragment = Karma.temp.fragment.cloneNode(false);
			
			for (var i=0; i< child.length; i++)
				fragment.appendChild(child[i]);
		}
		
		if (Karma.isHTML(query)) {
			var cloned = [];
				
			for (var i=0; i< parent.length; i++) {
				var newClones = parent.length > 1 ? fragment.cloneNode(true) : fragment;
				if (ret) {
					 if(newClones.nodeType === 11) {
						var children = Karma.makeArray(newClones.childNodes);
          				for(var j=0; j < children.length; j++)
           					 cloned.push(children[j]);
					 }
       				 else
          				cloned.push(newClones);
				}
				
				if (method == 'append')
					parent[i].appendChild(newClones);
				else if (method == 'prepend')
					parent[i].insertBefore(newClones, parent[i].firstChild);
				else if (method == 'before')
					parent[i].parentNode.insertBefore(newClones, parent[i]);
				else if (method == 'after') {
					parent[i].nextSibling ? 
						parent[i].parentNode.insertBefore(newClones, parent[i].nextSibling):
						parent[i].parentNode.appendChild(newClones);
				}
			}
			
			return ret ? Karma(cloned) : parent;
		}
		else if (method == 'append')
			parent[0].appendChild(fragment);
		else if (method == 'prepend')
			parent[0].insertBefore(fragment, parent[0].firstChild);
		else if (method == 'before')
			parent[0].parentNode.insertBefore(fragment, parent[0]);
		else if (method == 'after') {
			parent[0].nextSibling ? 
				parent[0].parentNode.insertBefore(fragment, parent[0].nextSibling):
				parent[0].parentNode.appendChild(fragment);
		}
		
		return ret ? child : parent;
	}
});


Karma.fn.extend({
	
	// walking the DOM, going forward or backward
	pedal: function(extreme, direction, query) {
		var elements = [];

		for (var i=0; i< this.length; i++) {
			var next=this[i][direction];

			while(next) {
				if (next.nodeType == 1) {
					elements.push(next);
					if (!extreme)
						break;
				}
				next = next[direction];
			}
	
		};
		
		elements = (Karma.isString(query)) ? Karma.Sizzle.filter(query, Karma.unique(elements)) : Karma.unique(elements);
		return Karma(elements).stack(this);
	},

	next: function(query) {
		return this.pedal(false, 'nextSibling' ,query);
	},
	
	nextAll: function(query) {
		return this.pedal(true, 'nextSibling' ,query);
	},

	prev: function(query) {
		return this.pedal(false, 'previousSibling' ,query);
	},
	
	prevAll: function(query) {
		return this.pedal(true, 'previousSibling' ,query);
	},
	
	siblings: function(query) {
		var $ = this, 
			siblings = [];
		
		for (var i=0; i< $.length; i++) {
			var origin = $[i],
				cur = $[i].parentNode;
			for(var j=0; j<cur.childNodes.length; j++) {
				var node = cur.childNodes[j]; 
				if(node.nodeType == 1 && node != origin)
					siblings.push(node);
			}
		}
		
		siblings = (Karma.isString(query)) ? Karma.Sizzle.filter(query, Karma.unique(siblings)) : Karma.unique(siblings);
		
		return Karma(siblings).stack(this);
	},
	
	parent: function(query) {
		var $ = this,
			parent = [];
			
		for (var i=0; i< $.length; i++) {
			if ($[i].parentNode)
				parent.push($[i].parentNode);
		}
	
		parent = (Karma.isString(query)) ? Karma.Sizzle.filter(query, Karma.unique(parent)) : Karma.unique(parent);
			
		return Karma(parent).stack(this);
	},
	
	ancestors: function(query) {
		var $ = this,
			ancestors = [];
		
		for (var i=0; i< $.length; i++) {
			var parent = $[i].parentNode;
			while(parent !== document) {
				ancestors.push(parent);
				parent = parent.parentNode || document;
			}
		}
		ancestors = (Karma.isString(query)) ? Karma.Sizzle.filter(query, Karma.unique(ancestors)) : Karma.unique(ancestorss);

		return Karma(ancestors).stack(this);
	},
	
	children: function(query) {
		var $ = this,
			children = [];
			
		for (var i=0; i< $.length; i++) {
			for(var j=0; j<$[i].childNodes.length; j++)
				if($[i].childNodes[j].nodeType == 1)
					children.push($[i].childNodes[j]);
		}
		
		if (Karma.isString(query))
			children = Karma.Sizzle.filter(query, children);
		
		return Karma(children).stack(this);
		
	},
	
	index: function(o){
		if (o) {
			var el = (o.nodeType) ? o : Karma(o)[0];
			return Karma.inArray(el, this);
		}
		else if (this[0]){
			return Karma.inArray(this[0], Karma(this[0].parentNode).children())
		}
		return -1;
	},
	
	slice: function(){
		return Karma(_Array.prototype.slice.apply(this, arguments)).stack(this);
	},
	
	eq: function( i ) {
		return i === -1 ?
			this.slice(i) :
			this.slice(i, +i + 1);
	},

	first: function() {
		return this.eq(0);
	},

	last: function() {
		return this.eq(-1);
	},
	
	// get elements as array, return the array
	get: function(num) {
		return Karma.isValue(num) ?
			Karma.makeArray(this) : 
			this[ num ];
	},
	
	toArray: function() {
		return this.get();
	},
	
	// possibly need to make the result unique, will see how people use the find method
	descendents: function(query) {
		var ret = [];
		for(var i=0; i<this.length; i++)
			ret = Karma.merge(ret, Karma.Sizzle(query, this[i]));
		
		return Karma(Karma.unique(ret)).stack(this);
	},
	
	filter: function(query) {
		return query ? Karma(Karma.Sizzle.filter(query, this)).stack(this) : this;
	},
	
	is: function(query) {
		return query ? !!Karma.Sizzle.filter(query, this).length : false;
	},
	
	not: function(query) {
		return query ? Karma(Karma.Sizzle(':not('+query+')', this)).stack(this) : this;
	},
	
	// adding elements
	add: function(query) {
		return query? Karma(this).populate(Karma(query), this.length).stack(this) : this;
	},
	
		// adding self to chain
	andSelf: function() {
		return this.KarmaStack.length ? Karma(this).populate(this.KarmaStack[0], this.length).stack(this): this;
	},
	
	each: function(fn){
		for (var i=0; i< this.length; i++)
			fn.call(this[i], i);
		return this;
	},
	
	map: function(fn) {
		var ret = [];
		for (var i=0; i< this.length; i++)
			ret.push(fn.call(this[i], i));
		return ret;
	},
	
	grep: function(fn) {
		var ret = [];
		for (var i=0; i< this.length; i++) {
			var result = fn.call(this[i], i);
			if (result !== false)
				ret.push(result);
		}
		return this;
	}
});

// for jQuery compatibility
Karma.fn.extend({
	find: Karma.fn.descendents,
	parents: Karma.fn.ancestors
});


Karma.fn.extend({
			 
	attr: function(prop, val){
		if(Karma.isString(prop) && (Karma.isValue(val))) {
			
			for(var i=0; i<this.length; i++) {
				if (Karma.temp.attrMap[prop] && Karma.isDefined(this[i][Karma.temp.attrMap[prop]]))
					this[i][Karma.temp.attrMap[prop]] = val;
				else if (prop == "style" && Karma.support.cssText)
					this[i].style.cssText = val;
				else {
					this[i].setAttribute(prop, val);
				}
			}
			return this;
		}
		// setting multiple property
		else if(Karma.isObject(prop)) {
			for (property in prop)
				this.attr(property, prop[property]);
			return this;
		}
		
		// getting property of first element
		return this.length? this[0].getAttribute(prop): null;
	},
	
	removeAttr: function(prop) {
		for(var i=0; i<this.length; i++) {
			if (Karma.temp.attrMap[prop] && Karma.isDefined(this[i][Karma.temp.attrMap[prop]]))
				this[i][Karma.temp.attrMap[prop]] = '';
			else if (prop == "style" && Karma.support.cssText) 
				this[i].style.cssText = '';

			try { this[i].removeAttribute(prop); } catch(e){};
		}
			
		return this;
	},
	
	data: function(key, value) {
		// key can be number or string
		// value can be anything even function except for undefined
		if(Karma.isDefined(value)) {
			for (var i=0; i< this.length; i++)
				Karma.data(this[i], key, value);
			return this;
		}
	
		return this[0] ? Karma.data(this[0], key) : null;
	},
	
	removeData: function(key) {
		if(Karma.isValue(key)) {
			for (var i=0; i< this.length; i++) {
				try { Karma.storage[this[i].KarmaMap].KarmaData[key] = null; } catch(e){}
			}
		}
		return this;
	},
	
	addClass: function(str){
		var _str = ' ' + str + ' ';
		
		for(var i=0; i< this.length; i++) {
			if (this[i].classList)
				this[i].classList.add(str);
			else {
				if( (' ' + this[i].className + ' ').indexOf(_str) < 0) 
					this[i].className.length ? this[i].className += ' ' + str : this[i].className = str;
			}
		}
			
		return this;
	},
	
	removeClass: function(str) {
		for(var i=0; i< this.length; i++)
			this[i].classList ? this[i].classList.remove(str) : this[i].className = Karma.trim(this[i].className.replace(str, ''));

		return this;
	},
	
	hasClass: function(str) {
		var _str = ' ' + str + ' ',
			ret = false;
		
		if(this.length)
			ret = this[0].classList ? this[0].classList.contains(str) : (' ' + this[0].className + ' ').indexOf(_str) >= 0;
		
		return ret;
	},
	
	toggleClass: function(str) {
		var _str = ' ' + str + ' ';
		for(var i=0; i< this.length; i++) {
			if(this[i].classList)
				this[i].classList.toggle(str);
			else {
				var classname = ' ' + this[i].className + ' ';
				this[i].className = classname.indexOf(_str) >= 0 ? classname.replace(_str, '') : classname += _str;
				this[i].className = Karma.trim(this[i].className);
			}
		}
		return this;
	},
	
	val: function(str){
		// setting values
		if(Karma.isValue(str)) { // if the str passed is a value
			for(var i=0; i< this.length; i++)
				if (Karma.isDefined(this[i].value)) // determine if the value property exists in the current element
					this[i].value = str;

			return this;
		}
		// getting value
		return (this[0] && Karma.isString(this[0].value)) ? this[0].value : null;
	},
	
	serialize: function() {
		var ret = '';
		for(var i=0; i< this.length; i++) {
			var name = this[i].getAttribute('name');
			if (name && name.length) {
				var value = this[i].value || '';
				
				if (this[i].nodeName.toLowerCase() == 'input' && this[i].getAttribute('type').toLowerCase() == 'checkbox' && !this[i].checked)
					ret += encodeURIComponent(name) + '=&';
				else
					ret += encodeURIComponent(name) + '=' + encodeURIComponent(value) + '&';
			}
		}
		return ret.length ? ret.substring(0, ret.length-1) : '';
	}

});

Karma.extend({
	data: function(el, key, value) {
		// key can be number or string
		// value can be anything except for undefined
		if(Karma.isDefined(value)) {
			var map = 0;
			if (el !== window) 
				map = el.KarmaMap = el.KarmaMap || ++Karma.uniqueId;
				
			Karma.storage[map] = Karma.storage[map] || {};
			Karma.storage[map].KarmaData = Karma.storage[map].KarmaData || {};
			Karma.storage[map].KarmaData[key] = value;
		}
	
		return Karma.storage && Karma.storage[el.KarmaMap] && Karma.storage[el.KarmaMap].KarmaData && Karma.isDefined(Karma.storage[el.KarmaMap].KarmaData[key]) ? Karma.storage[el.KarmaMap].KarmaData[key] : null;
	}
});
Karma.extend({

	ajax: function(o) {

		o = Karma.extend({
			type: 'GET',
			data: null,
			url: '',
			contentType: null,
			cache: false,
			loading: function(){},
			success: function(){},
			error: function(){},
			XHR: window.XMLHttpRequest? new XMLHttpRequest(): new ActiveXObject("Microsoft.XMLHTTP")
		 }, o);

		if (o.XHR === null || typeof o.XHR == "undefined" || !o.url.length) return;
		
		o.XHR.onreadystatechange=function(){
			try {
				if (o.XHR.readyState === 4 && !o.successDone){
					o.success(o.XHR.responseText);
					o.successDone = true;
				}
				
				if (o.XHR.status != 200 && !o.errorDone) {
					o.error(o.XHR.responseText);
					o.successDone = true;
					o.errorDone = true;
				}
			} catch(e) {};
		}
		var _url = o.url;
		if (o.type.toLowerCase() == 'get' && o.data)
			o.cache ? _url += '?karma_ts=' + new Date().getTime() + '&' + o.data : _url += '?' + o.data;
		
		
		o.XHR.open(o.type, _url, true);
		o.loading();
		
		if(o.contentType)
			o.XHR.setRequestHeader("Content-Type", o.contentType);
		
		(o.type.toLowerCase() == 'post' && o.data) ?
			o.XHR.send(o.data) :
			o.XHR.send(null);
	}

});


Karma.extend({

	getScript: function(url, success) {
		var counter = 0,
			script = [],
			isDone = false,
			mylength = url.length || 1;
		
		var callback = function(){
			counter++;
			
			if (!isDone && counter >= mylength) {
				isDone = true;
				success();
			}
		};

		for (var i = 0; i < mylength; i++) {
			script[i] = document.createElement('SCRIPT');
			script[i].type = 'text/javascript';
			script[i].src = url[i] || url;
			
			// prevent KB917927, also document.getElementsByTagName('head') is not always available
			document.documentElement.insertBefore(script[i], document.documentElement.firstChild);
			
			if (script[i].readyState) {
				script[i].onreadystatechange = function() {
					if (script[i].readyState == "loaded" || script[i].readyState == "complete") {
						script[i].onreadystatechange = null;
						callback();
					}
				}
			}
	
			else script[i].onload = callback;
		}
	}
});

Karma.include = Karma.getScript;


Karma.fn.extend({

	bind: function(str, fn, livequery) {
		if (!this.length || !Karma.isString(str) || !Karma.isFunction(fn)) return this;
	
		str = str.split(/\s+/);

		x:for(var j=0; j< str.length; j++) {
			var ns = str[j].split('.');
			if (Karma.event.special[ns[0]]) {
				var args = [];
				args.push(ns[1] ? '.'+ ns[1] : '');
				for(var i = 0; i < arguments.length; i++)
					if(Karma.isFunction(arguments[i]))
						args.push(arguments[i]);
						
				Karma.event.special[ns[0]].setup.apply(this, args);
				continue x;
			}
			
			for(var i=0; i< this.length; i++) {
				if (!(this[i].nodeType == 3 || this[i].nodeType == 8)) {
					var map = 0;
					if (this[i] !== window)
						map = this[i].KarmaMap = this[i].KarmaMap || ++Karma.uniqueId;
						
					Karma.storage[map] = Karma.storage[map] || {};
					
					var $ = Karma.storage[map].KarmaEvent = Karma.storage[map].KarmaEvent || {};
					
					$[ns[0]] = $[ns[0]] || [];
					
					if(livequery) {
						var data = Karma.data(this.context, 'KarmaLive') || {};
						data[ns[0]] = data[ns[0]] || {};
						data[ns[0]][livequery] = data[ns[0]][livequery] || [];
						
						if(ns.length == 1)
							data[ns[0]][livequery].push(fn);
						
						else if(ns.length == 2)
							data[ns[0]][livequery][ns[1]] = fn;
							
						Karma.data(this.context, 'KarmaLive', data);
					}
					
					else if (ns.length == 1)
						$[ns[0]].push(fn);
	
					else if (ns.length == 2)
						$[ns[0]][ns[1]] = fn;
						
					if(Karma.event.isSupported(ns[0])) {
						if(!Karma.isFunction(this[i]['on'+ns[0]]))
							this[i]['on'+ns[0]] = Karma.event.caller;
					}
					// custom event
					else if(document.addEventListener) {
						var total = 0;
						for(var event in $[ns[0]]) {
							total++;
						}
	
						if(!total)
							this[i].addEventListener(ns[0], Karma.event.caller, false);
					}
					// custom/proprietary event for M$
					else {
						this[i].customEvents = 0;
						if(!Karma.isFunction(this[i].onpropertychange))
							this[i].onpropertychange = Karma.event.caller;
					}
				}
			}
		}
		return this;
	},
		
	unbind: function(str, fn, livequery) {
		if (!str || !this.length) return this;
		var token = str.split(/\s+/);
		
		y:for(var j=0; j< token.length; j++) {
			var ns = token[j].split('.');
			if (Karma.event.special[ns[0]]) {
				var args = [];
				args.push(ns[1] ? '.'+ ns[1] : '');
				for(var i = 0; i < arguments.length; i++)
					if(Karma.isFunction(arguments[i]))
						args.push(arguments[i]);
						
				Karma.event.special[ns[0]].teardown.apply(this, args);
				continue y;
			}
			
			for(var i=0; i< this.length; i++) {
				var map = this === window ? 0 : this[i].KarmaMap;
				var data = Karma.data(this[i], 'KarmaLive');
				if (livequery) {
					if(data && data[ns[0]] && data[ns[0]][livequery]) {
						if (ns.length > 1) {
							data[ns[0]][livequery][ns[1]] = null;
							delete data[ns[0]][livequery][ns[1]];
						}
						else if (Karma.isFunction(fn)) {
							for (var fn in data[ns[0]][livequery])
								if (data[ns[0]][livequery][fn] == fn) {
									data[ns[0]][livequery][fn] = null;
									delete data[ns[0]][livequery][fn];
								}
						}
						else if(ns.length == 1) {
							data[ns[0]][livequery] = null;
							delete data[ns[0]][livequery];
						}
					}
				}

				else if (Karma.storage[map] && Karma.storage[map].KarmaEvent) {
					var $ = Karma.storage[map].KarmaEvent;
					if (ns.length > 1 && $[ns[0]]) {
						$[ns[0]][ns[1]] = null;
						delete $[ns[0]][ns[1]];
					}
					else if (Karma.isFunction(fn)) {
						for (var prop in $[ns[0]])
							if ($[ns[0]][prop] == fn) {
								$[ns[0]][prop] = null;
								delete $[ns[0]][prop];
							}
					}
					
					else if($[ns[0]]) {
						this[i]['on'+ns[0]] = null;
						delete $[ns[0]];
					}
				}
			}
		}
		return this;
	},
	
	one: function(str, fn) {
		this.on(str, fn);
					
		if (this.data('triggerOnce') === null);
			this.data('triggerOnce', []);
		
		this.data('triggerOnce').push(fn);
		
		return this;
		
	},
	
	triggerHandler: function(eventName) {
		this.trigger(eventName, true);
	},
	
	trigger: function(eventName, prevent) {
		try {
			for(var i=0; i<this.length; i++)
				var element = this[i];

			// W3C compatible browsers
			if(Karma.support.createEvent){
				
				// Safari 3 doesn't have window.dispatchEvent()
				if(!element.dispatchEvent)
					element=document; 
				
				var curEvent= Karma.event[eventName];
				
				if(curEvent){
					var event = document.createEvent(curEvent.type);
					curEvent.init(event, {});
					
					if(prevent) {
						event.stopPropagation();
						event.preventDefault();
					}
					
					element.dispatchEvent(event);
				}
				else {
					var fakeEvent = document.createEvent("UIEvents");
					fakeEvent.initEvent(eventName, false, false);
					
					if(prevent) {
						fakeEvent.stopPropagation();
						fakeEvent.preventDefault();
					}
					
					element.dispatchEvent(fakeEvent);
				}
			}
			// m$ methods
			else if(Karma.support.createEventObject){
				if(Karma.event.support[eventName]) {
					element = (element === document || element === window ) ? document.documentElement : element;
				
					var event = document.createEventObject();
					if(prevent) {
						event.cancelBubble = true;
						event.returnValue = false;
					}
					
					/*for(var property in properties)
						event[property]=properties[property];*/
		
					element.fireEvent("on"+eventName, event);
				}
				else {
					var current = Karma(element).data('fireEvent') || [];
					current.push(eventName);
					
					Karma(element).data('fireEvent', current);
					element.customEvents++;
				}
			}

		} catch(e){};
		
		return this;
	},
	
	// preventDefault and stopPropagation might not be 100% complete for live yet
	live: function(str, fn){
		return Karma(this.context).bind(str, fn, this.query);
	},
	
	die: function(str, fn) {
		return Karma(this.context).unbind(str, fn, this.query);
	}

});

// create events for w3c browser
if(Karma.support.createEvent)
Karma.event = {
	load:{
		type:"HTMLEvents",
		init: function(e){
			e.initEvent("load",false,false);
		}
	},
	
	unload:{
		type:"HTMLEvents",
		init:function(e){
			e.initEvent("unload",false,false);
		}
	},
	
	select:{
		type:"HTMLEvents",
		init:function(e){
			e.initEvent("select",true,false);
		}
	},
	
	change:{
		type:"HTMLEvents",
		init:function(e){
			e.initEvent("change",true,false);
		}
	},
	
	submit:{
		type:"HTMLEvents",
		init:function(e,p){
			e.initEvent("submit",true,true);
		}
	},
	
	reset:{
		type:"HTMLEvents",
		init:function(e){
			e.initEvent("reset",true,false);
		}
	},
	
	resize:{
		type:"HTMLEvents",
		init:function(e){
			e.initEvent("resize",true,false);
		}
	},
	
	scroll:{
		type:"HTMLEvents",
		init:function(e){
			e.initEvent("scroll",true,false);
		}
	},
	
	click:{
		type:"MouseEvents",
		init:function(e,p){
			e.initMouseEvent("click",true,true,window,1,p.screenX||0,p.screenY||0,p.clientX||0,p.clientY||0,p.ctrlKey||false,p.altKey||false,p.shiftKey||false,p.metaKey||false,p.button||0,p.relatedTarget||null);
		}
	},
	
	dblclick:{
		type:"MouseEvents",
		init:function(e,p){
			e.initMouseEvent("click",true,true,window,2,p.screenX||0,p.screenY||0,p.clientX||0,p.clientY||0,p.ctrlKey||false,p.altKey||false,p.shiftKey||false,p.metaKey||false,p.button||0,p.relatedTarget||null);
		}
	},
	
	mousedown:{
		type:"MouseEvents",
		init:function(e,p){
			e.initMouseEvent("mousedown",true,true,window,1,p.screenX||0,p.screenY||0,p.clientX||0,p.clientY||0,p.ctrlKey||false,p.altKey||false,p.shiftKey||false,p.metaKey||false,p.button||0,p.relatedTarget||null);
		}
	},
	
	mouseup:{
		type:"MouseEvents",
		init:function(e,p){
			e.initMouseEvent("mouseup",true,true,window,1,p.screenX||0,p.screenY||0,p.clientX||0,p.clientY||0,p.ctrlKey||false,p.altKey||false,p.shiftKey||false,p.metaKey||false,p.button||0,p.relatedTarget||null);
		}
	},
	
	mouseover:{
		type:"MouseEvents",
		init:function(e,p){
			e.initMouseEvent("mouseover",true,true,window,1,p.screenX||0,p.screenY||0,p.clientX||0,p.clientY||0,p.ctrlKey||false,p.altKey||false,p.shiftKey||false,p.metaKey||false,p.button||0,p.relatedTarget||null);
		}
	},
	
	mousemove:{
		type:"MouseEvents",
		init:function(e,p){
			e.initMouseEvent("mousemove",true,true,window,1,p.screenX||0,p.screenY||0,p.clientX||0,p.clientY||0,p.ctrlKey||false,p.altKey||false,p.shiftKey||false,p.metaKey||false,p.button||0,p.relatedTarget||null);
		}
	},
	
	mouseout:{
		type:"MouseEvents",
		init:function(e,p){
			e.initMouseEvent("mouseout",true,true,window,1,p.screenX||0,p.screenY||0,p.clientX||0,p.clientY||0,p.ctrlKey||false,p.altKey||false,p.shiftKey||false,p.metaKey||false,p.button||0,p.relatedTarget||null);
		}
	},
	
	focusin:{
		type:"UIEvents",
		init:function(e){
			e.initUIEvent("focusin",true,false,window,1);
		}
	},
	
	focusout:{
		type:"UIEvents",
		init:function(e){
			e.initUIEvent("focusout",true,false,window,1);
		}
	},
	
	activate:{
		type:"UIEvents",
		init:function(e){
			e.initUIEvent("activate",true,true,window,1);
		}
	},
	
	focus:{
		type:"UIEvents",
		init:function(e){
			e.initUIEvent("focus",false,false,window,1);
		}
	},
	
	blur:{
		type:"UIEvents",
		init:function(e){
			e.initUIEvent("blur",false,false,window,1);
		}
	}
}

else Karma.event = {};

Karma.event.support = {};
Karma.event.special = {
	hover: {
		setup: function(ns, fn, fn2, livequery){
			this.bind('mouseover' + ns, function(e){ 
				e.stopPropagation();
				return fn.call(this, e); 
			}, livequery).bind('mouseout' + ns, function(e){ 
				e.stopPropagation();
				return fn2.call(this, e); 
			}, livequery);
		},
		teardown: function(ns, fn, fn2, livequery){
			this.unbind('mouseover' + ns, fn, livequery).unbind('mouseout'+ ns, fn2, livequery);
		}
	},
	
	mouseenter: {
		setup: function(ns, fn, livequery){
			this.bind('mouseover'+ ns, function(e) {
				e.stopPropagation();
				return fn.call(this, e); 
			}, livequery);
		},
		
		teardown: function(ns, fn, livequery){
			this.unbind('mouseover'+ ns, fn, livequery);
		}
	},
	
	mouseleave: {
		setup: function(ns, fn, livequery){
			this.bind('mouseout' + ns, function(e){
				e.stopPropagation();
				return fn.call(this, e);
			}, livequery);
		},
		
		teardown: function(ns, fn, livequery){
			this.unbind('mouseout' + ns, fn, livequery);
		}
	}
}

// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
Karma.event.isSupported = function(eventName, element) {
	if (eventName in Karma.event.support && !element) return Karma.event.support[eventName];

	var TAGNAMES = {
			'select':'input',
			'change':'input',
			'submit':'form',
			'reset':'form',
			'error':'img',
			'load':'img',
			'abort':'img'
		}, 
	
		el = element ? 
				element : 
					TAGNAMES[eventName] ? 
						document.createElement(TAGNAMES[eventName]) : 
						Karma.temp.div,	
		
		onEventName = 'on' + eventName,
		isSupported = onEventName in el;

	
	if (!isSupported && el.setAttribute && el.removeAttribute) {
		el.setAttribute(onEventName, 'return;');
		isSupported = typeof el[onEventName] == 'function';
		
		if (onEventName in el)
        	el[onEventName] = void 0;

	}
	
	// last test
	if (!isSupported && !element) {
		isSupported = onEventName in window;
	}
	
	el = null;
	Karma.event.support[eventName] = isSupported;
	return isSupported;
}

// caller the determines how events are fired, also normalizes events
// hardest freakin bitch function to code in Karmagination
Karma.event.caller = function(e) {
	var cur_map = this === window ? 0 : this.KarmaMap;
	e = window.event || e;
	
	// some basic normalization of event
	if(!e.stopPropagation && window.event) 
		e.stopPropagation = function(){ window.event.cancelBubble = true; };
	
	if(!e.preventDefault && window.event)
		e.preventDefault = function(){ window.event.returnValue = false; };
		
	if(!e.target && e.srcElement)
		e.target = e.srcElement || document;
	
	try {
		if(e.type == 'mouseover' && !('relatedTarget' in e))
			 e.relatedTarget = e.fromElement;
	
		else if(e.type == 'mouseout' && !('relatedTarget' in e))
			e.relatedTarget = e.toElement;
			
		if(e.wheelDelta) {
			e.wheelDiff = e.wheelDelta/120;
			if(Karma.isOpera)
				e.wheelDiff = -e.wheelDiff;
		}
		else if (e.detail)
			e.wheelDiff = -e.detail/3;
			
		// fix for safari textnode
		if (e.target.nodeType == 3)
			e.target = e.target.parentNode;

		// Calculate pageX/Y if missing and clientX/Y available
		if ( e.pageX == null && e.clientX != null ) {
			var doc = document.documentElement, body = document.body;
			e.pageX = e.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
			e.pageY = e.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
		}
	
		// Add which for key events
		if ( !e.which && ((e.charCode || e.charCode === 0) ? e.charCode : e.keyCode) )
			e.which = e.charCode || e.keyCode;
	
		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
		if ( !e.metaKey && e.ctrlKey )
			e.metaKey = e.ctrlKey;
	
		// Add which for click: 1 == left; 2 == middle; 3 == right
		// Note: button is not normalized, so don't use it
		if ( !e.which && e.button )
			e.which = (e.button & 1 ? 1 : ( e.button & 2 ? 3 : ( e.button & 4 ? 2 : 0 ) ));
		
	} catch(e){}
	
	var live = Karma.data(this.ownerDocument || document, 'KarmaLive');
	if (live && live[e.type]) {
		var passed = [],
			node = [],
			ancestors = [],
			cur = e.target;
		
		// get a list of ancestors e.target including e.target
		while(cur) {
			ancestors.push(cur);
			cur = cur.parentNode;
		}

		// see which live query is more specific to the e.target
		for(var query in live[e.type]) {
			var result = Karma.Sizzle.filter(query, ancestors);
			if (result.length) {
				for(var i = 0; i < ancestors.length; i++) {
					if (ancestors[i] === result[0]) {
						passed[i] = query;
						node[i] = result[0];
					}
				}
			}
		}
		
		// stop event done 99% right, WOOT
		for(var i=0; i < passed.length; i++) {
			if (passed[i] && live[e.type][passed[i]]) {
				var stopped = 0;
				for(var stacked in live[e.type][passed[i]]) {
					if(live[e.type][passed[i]][stacked].call(node[i], e) === false) {
						e.preventDefault();
						e.stopPropagation();
						stopped++;
					}
				}
				if (stopped) break;
			}
		}
	}
		
	if(e.propertyName == "customEvents") {
		var events = $(this).data('fireEvent');
		
		for(var index in events) {
			try {
				for(var functions in Karma.storage[cur_map].KarmaEvent[events[index]]) {
					if(Karma.storage[cur_map].KarmaEvent[events[index]][functions].call(this, e) === false) {
						e.stopPropagation();
						e.preventDefault();	
					}	
				}
				events[index] = null;
			} 
			catch(e){};
		}
		$(this).data('fireEvent', events);
	}
	
	else if(Karma.storage[cur_map] && Karma.storage[cur_map].KarmaEvent && Karma.storage[cur_map].KarmaEvent[e.type]) {
		for(var functions in Karma.storage[cur_map].KarmaEvent[e.type]) {
			if(Karma.storage[cur_map].KarmaEvent[e.type][functions].call(this, e) === false) {
				e.stopPropagation();
				e.preventDefault();	
			}
			
			var once = Karma(this).data('triggerOnce');
			if(once) {
				for (var i = 0; i < once.length; i++) {
					if(once[i] === Karma.storage[cur_map].KarmaEvent[e.type][functions]) {
						Karma.storage[cur_map].KarmaEvent[e.type][functions] = null;
						delete Karma.storage[cur_map].KarmaEvent[e.type][functions];
					}
				}
			}
			
		}
	}
}


Karma.fn.extend({
	style: function(property, value) {
		if (Karma.isString(property) && Karma.isValue(value))
			return this.setStyle(property, value);
			
		if (Karma.isObject(property)) {
			for(var current in property)
				this.setStyle(current, property[current]);
			return this;
		}

		return this.getStyle(property);
	},

	setStyle: function(property, value){
		if(!this.length) return this;
		
		property = Karma.camelCase(property);		

		if (property == 'opacity') {
			for (var i=0; i < this.length; i++) {
				// webkit and opera support filter, which is BS
				// lesson learnt: feature test W3C standard before proprietary standard 
				if(Karma.support.opacity) this[i].style.opacity = value;
				// if we have full opacity, better to remove it to restore the antialiasing ability of IE
				else if(Karma.support.filter) {
					// OMFG, MS needs hasLayout for opacity, or it will just work on body
					this[i].style.zoom = 1;
					this[i].style.filter = (parseInt(value, 10) == 1) ? '' : 'alpha(opacity=' + (value * 100) + ')';
				}
			}
			
			return this;
		}
		
		if (property == 'scrollTop' || property == 'scrollLeft') {
			for (var i=0; i < this.length; i++) {
				if (this[i] === document.documentElement || this[i] === document || this[i] === document.body || this[i] === window) {
					document.body[property] = value;
					document.documentElement[property] = value;
				}
				else
					this[i][property] = value;
			}
			return this;
		}
		
		if (property == 'float')
			property = Karma.support.styleFloat ? 'styleFloat' : 'cssFloat';
		
		// concat integers/integer-like strings with px;
		var curval = +value;
		if ( curval || curval === 0 ) value = curval + 'px';
		
		
		if(Karma.isString(value)) // just to be safe
		for (var i=0; i < this.length; i++)
			this[i].style[property] = value;
		
		return this;
	},
	
	getStyle: function(property) {
		if(!this.length) return null;
		
		property = Karma.camelCase(property);
		
		if (property == 'scrollTop' || property == 'scrollLeft')
			return (this[0]===document || this[0]===document.documentElement || this[0]===window)? document.body[property]: this[0][property];
		
		if (property == 'float')
			property = Karma.support.styleFloat ? 'styleFloat' : 'cssFloat';
		
		else if (property == 'opacity' && this[0].filters) {
			// i didn't want to use try catch but this mfker throws error
			try { var opacity = this[0].filters('alpha').opacity; }	catch(e){ return 1; }
			return opacity/100;
		}
		
		// check if the current node is stylable or not, i.e. window cannot be styled
		if(this[0].style) {
			// ie	
			if (this[0].currentStyle) {
				if (this[0].currentStyle[property] == 'auto' && this[0].style[property] == '') {
					if(/width|height/i.test(property)) return this.width();
					if(/left|top|right|bottom/i.test(property)) return 0;
				}

				return this[0].currentStyle[property] ? this[0].currentStyle[property] : this[0].style[property];
			}
			// w3c
			else if ( "getComputedStyle" in document.defaultView ) {
				var computed = document.defaultView.getComputedStyle(this[0], null)[property];
				
				if (!computed || !computed.length) computed = this[0].style[property];
							
				if (property.toLowerCase().indexOf('color') >= 0) {
					var color = computed.match(/rgba?\([\d\s,]+\)/);
					if (color)
						computed = Karma.rgbToHex(color[0].match(/\d{1,3}/g));
				}
				return computed;
			}
		}
		return '';
	},
	
	dimension: function(name, border){
		if(!this.length) return null;
		return this[0] === window ?
			// use document.documentElement or document.body depending on Quirks vs Standards mode
			document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] || document.body[ "client" + name ] :
			// Get document width or height
			this[0] === document ?
				// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
				Math.max(
					document.documentElement["client" + name],
					document.body["scroll" + name], document.documentElement["scroll" + name],
					document.body["offset" + name], document.documentElement["offset" + name]
				) :
				border ?
					this[0]['offset'+name]:
					this[0]['client'+name];
	},
	
	width: function(val){
		return Karma.isValue(val) ? this.setStyle('width', val) : this.dimension('Width') - (parseInt(this.getStyle('paddingLeft'), 10) || 0) - (parseInt(this.getStyle('paddingRight'), 10) || 0);
	},
	
	height: function(val){
		return Karma.isValue(val) ? this.setStyle('height', val) : this.dimension('Height') - (parseInt(this.getStyle('paddingTop'), 10) || 0) - (parseInt(this.getStyle('paddingBottom'), 10) || 0);
	},
	
	innerWidth: function(){
		return this.dimension('Width');
	},
	
	innerHeight: function(val){
		return this.dimension('Height');
	},
	
	outerWidth: function(val, margin){
		var marginLeft = margin ? parseInt(this.css('marginLeft'), 10) || 0 : 0,
			marginRight = margin ? parseInt(this.css('marginRight'), 10) || 0 : 0;
		return this.dimension('Width', 1) + marginLeft + marginRight;
	},
	
	outerHeight: function(val, margin){
		var marginTop = margin ? parseInt(this.css('marginTop'), 10) || 0 : 0,
			marginBottom = margin ? parseInt(this.css('marginBottom'), 10) || 0 : 0;
		return this.dimension('Height', 1) + marginTop + marginBottom;
	},

	offset: function() {
		if (!this[0]) return null;
		// w3c
		Karma.calculateOffset();
		if (document.documentElement.getBoundingClientRect) {
			if ( this[0] === (this[0].ownerDocument||this[0]).body ) {
				var top = this[0].offsetTop, left = this[0].offsetLeft;
				if ( Karma.support.offsetDoesNotIncludeMarginInBodyOffset )
					top  += parseInt(this.css('marginTop'), 10) || 0,
					left += parseInt(this.css('marginLeft'), 10 ) || 0;
				return { top: top, left: left };
			}
			
			var box  = this[0].getBoundingClientRect(), 
				doc = this[0].ownerDocument || doc, 
				body = doc.body, 
				docElem = doc.documentElement,
				clientTop = docElem.clientTop || body.clientTop || 0, 
				clientLeft = docElem.clientLeft || body.clientLeft || 0,
				top  = box.top  + (self.pageYOffset || Karma.support.boxModel && docElem.scrollTop || body.scrollTop) - clientTop,
				left = box.left + (self.pageXOffset || Karma.support.boxModel && docElem.scrollTop || body.scrollLeft) - clientLeft;
			
			return { top: top, left: left };
		}
		// m$
		else {
			var elem = this[0], 
				offsetParent = elem.offsetParent, 
				prevOffsetParent = elem,
				doc = elem.ownerDocument || elem, 
				computedStyle, 
				docElem = doc.documentElement,
				body = doc.body, 
				defaultView = doc.defaultView,
				prevComputedStyle = defaultView.getComputedStyle(elem, null),
				top = elem.offsetTop, 
				left = elem.offsetLeft;
	
			while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
				computedStyle = defaultView.getComputedStyle(elem, null);
				top -= elem.scrollTop, 
				left -= elem.scrollLeft;
				
				if ( elem === offsetParent ) {
					top += elem.offsetTop, 
					left += elem.offsetLeft;
					if ( Karma.support.offsetDoesNotAddBorder && !(Karma.support.offsetDoesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) )
						top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
						left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
					prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
				}
				
				if ( Karma.support.offsetSubtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" )
					top  += parseInt( computedStyle.borderTopWidth,  10) || 0,
					left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
				prevComputedStyle = computedStyle;
			}
	
			if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" )
				top  += body.offsetTop,
				left += body.offsetLeft;
	
			if ( prevComputedStyle.position === "fixed" )
				top  += Math.max(docElem.scrollTop, body.scrollTop),
				left += Math.max(docElem.scrollLeft, body.scrollLeft);
	
			return { top: top, left: left };			
			
		}
	},
	
	position: function() {
		var left = 0, top = 0, results = null;

		if ( this[0] ) {
			// Get *real* offsetParent
			var offsetParent = this.offsetParent(),
				offsetDoc = offsetParent.ownerDocument || offsetParent,

			// Get correct offsets
			offset       = this.offset(),
			parentOffset = (offsetDoc.documentElement === offsetParent || offsetDoc.body === offsetParent) ? { top: 0, left: 0 } : offsetParent.offset();

			// Subtract element margins
			// note: when an element has margin: auto the offsetLeft and marginLeft 
			// are the same in Safari causing offset.left to incorrectly be 0
			offset.top  -= parseInt( this.css('marginTop'), 10 ) ||  0;
			offset.left -= parseInt( this.css('marginLeft'), 10 ) ||  0;

			// Add offsetParent borders
			parentOffset.top  += parseInt( Karma(offsetParent).css('borderTopWidth'), 10 ) || 0;
			parentOffset.left += parseInt( Karma(offsetParent).css('borderLeftWidth'), 10 ) || 0;

			// Subtract the two offsets
			results = {
				top:  offset.top  - parentOffset.top,
				left: offset.left - parentOffset.left
			};
		}

		return results;
	},
	
	offsetParent: function() {
		var offsetParent = this[0].offsetParent || document.body,
			offsetDoc = offsetParent.ownerDocument || offsetParent;
		while ( offsetParent && offsetParent !== offsetDoc.documentElement && offsetParent !== offsetDoc.body && Karma(offsetParent).css('position') == 'static')
			offsetParent = offsetParent.offsetParent;
		return Karma(offsetParent);
	},
	
	scrollTop: function() {
		return this.css('scrollTop');
	},
	
	scrollLeft: function() {
		return this.css('scrollLeft');
	}	
});

Karma.fn.css = Karma.fn.style;

Karma.extend({
	camelCase: function(property) {
		if (Karma.temp.camelCase[property]) {
			property = Karma.temp.camelCase[property];
		}
		else {
			property = Karma.temp.camelCase[property] = property.replace(/\-(\w)/g, function(all, letter){ return letter.toUpperCase(); });
		}
		
		return property;
	},
	
	rgbToHex: function(array){
		if (array.length < 3) return null;
		if (array.length == 4 && array[3] == 0 && !array) return 'transparent';
		var hex = [];
		for (var i = 0; i < 3; i++){
			var bit = (array[i] - 0).toString(16);
			hex.push((bit.length == 1) ? '0' + bit : bit);
		}
		return '#' + hex.join('');
	},
	
	calculateOffset: function(){
		if (Karma.temp.calculatedOffsets) return;
		
		var offset = new Karma.temp.offsets();
		Karma.extend(Karma.support, {
			offsetDoesNotAddBorder: offset.doesNotAddBorder,
			offsetDoesAddBorderForTableAndCells: offset.doesAddBorderForTableAndCells,
			offsetSubtractsBorderForOverflowNotVisible: offset.subtractsBorderForOverflowNotVisible,
			offsetDoesNotIncludeMarginInBodyOffset: offset.doesNotIncludeMarginInBodyOffset
		});
		
		Karma.temp.calculatedOffsets = true;
	}
});


Karma.fn.extend({
	stop: function(){
		for(var i = 0; i < this.length; i++) {
			var KarmaFX = Karma.data(this[i], 'KarmaFX');
			for(var iter in KarmaFX)
				clearInterval(KarmaFX[iter].timer);
		}
		
		return this.data('KarmaFX', null);
	},
	
	// do not calculate and store upfront, calculate on animating iteration hit
	// reason, css props can change in the middle
	animate: function(attributes, dur, callback, easing, step){
		if (!Karma.isGenericObject(attributes) || !this.length) return this;
		
		// do this for scoping issues with internal functions
		var els = this, duration, queue;
		
		if (Karma.isGenericObject(dur)) {
			duration = parseInt(dur.duration);
			if (!duration && duration !== 0)
				duration = 500;
				
			easing = dur.easing || Karma.easing.global;
			callback = dur.complete || null;
			step = dur.step || null;
			queue = dur.queue || true;
		}
		else {
			// default values
			duration = parseInt(dur, 10);
			if (!duration && duration !== 0)
				duration = 500;
	
			easing = easing || Karma.easing.global;
			callback = callback || null;
			step = step || null;
			queue = true;
		}
		// setup initial KarmaFX data structure
		
		
		for(var i=0; i<els.length; i++) {
			var FX = {
				start: {},
				end: {},
				duration: duration,
				callback: callback,
				attributes: attributes,
				easing: easing,
				step: step,
				queue: queue
			};

			var $cur = Karma(els[i]),
				KarmaFX = $cur.data('KarmaFX', $cur.data('KarmaFX') || []).data('KarmaFX');

			// get starting/ending attributes
			// we need to calculate end cause we are converting values like em, etc to px
			KarmaFX.push(Karma.temp.populateStartEndValues($cur, FX, attributes));
			Karma.temp.animate($cur);
		}

		return this;
	}
});

Karma.temp.populateStartEndValues = function($curEl, FX, attributes) {
	for (var prop in attributes) {
		// get the current unanimated attribute
		FX.start[prop] = $curEl.getStyle(prop);
		FX.start[prop] = +FX.start[prop] || parseInt(FX.start[prop], 10);
		
		var cur_prop = +attributes[prop];

		// get start properties and convert to integer or float
		// set the final attribute if they are in numbers, no calculation
		if (cur_prop || cur_prop === 0) {
			FX.end[prop] = cur_prop;
		}
		
		// else we have to detemine the end attributes, ie 1.6 em = how many px
		else {
			// these are strings
			//var val = Karma.trim(attributes[prop]);
			var val = attributes[prop];
			
			// need to add or substract determined from original value
			if (val.indexOf('+=') >= 0 || val.indexOf('-=') >= 0) {
			
				var cur_val = val.replace('+=','').replace('-=',''),
					temp_val = +cur_val;
				
				// number looks like strings, means all digits /\d/ or has a unit of pixel
				if (temp_val || temp_val === 0 || val.indexOf('px') > 0)
					cur_val = temp_val || parseInt(cur_val, 10);
				
				// other units, opacity, will not hit this so no problem to parseInt
				else {
					cur_val = parseInt($curEl.setStyle(prop, cur_val).getStyle(prop), 10);
					$curEl.setStyle(prop, FX.start[prop]); // revert to start value
				}
				
				FX.end[prop] = (val.indexOf('+=') == 0) ? FX.start[prop] + cur_val : FX.start[prop] - cur_val;
			}
	
			// set the final attribute if they are in pixels, no calculation
			else if (val.indexOf('px') > 0) {
				FX.end[prop] = parseInt(val, 10);
			}
			
			// all other units like em, pt
			// using parseInt cause returned value by browser is px
			else {
				FX.end[prop] = parseInt($curEl.setStyle(prop, val).getStyle(prop), 10);
				$curEl.setStyle(prop, FX.start[prop]); // revert to start value
			}
		}
	}
		
	return FX;
}

Karma.temp.animate = function($cur) {
	var KarmaFX = $cur.data('KarmaFX');
	if (KarmaFX.length == 1) {
		var iter = 0,
			startTimer = new Date().getTime(),
			endTimer = startTimer + (KarmaFX[iter].duration || 0),
			timer;
			
		KarmaFX[iter].timer = timer = setInterval(function FX_first(){
			var curTime = new Date().getTime();
			
			if (!KarmaFX)
				clearInterval(timer);
				
			// a frame value between start and end
			else if(curTime < endTimer)
				currentFrame(curTime - startTimer, KarmaFX[iter].end);
			
			// last frame
			else 
				completeAnimation();

		}, 13); // try to run every 13ms
		
		var currentFrame = function(elapsed, attr){
			for (var prop in attr) {
				var start = KarmaFX[iter].start[prop],
					end = KarmaFX[iter].end[prop],
					duration = KarmaFX[iter].duration,					
					curval = KarmaFX[iter].easing(elapsed, start, end-start, duration);
				
				$cur.setStyle(prop, curval);
				if (KarmaFX && KarmaFX[iter] && KarmaFX[iter].step)	KarmaFX[iter].step(+curval);
			}
			// just executing on every step
			//if (KarmaFX && KarmaFX[iter] && KarmaFX[iter].step)	KarmaFX[iter].step();
		}
		
		var completeAnimation = function(){
			clearInterval(timer);
			
			// set to end values;
			if(KarmaFX && KarmaFX[iter]) {
				if (KarmaFX[iter].callback)
					KarmaFX[iter].callback();
			
				$cur.css(KarmaFX[iter].end);
			}
			
			KarmaFX[iter] = null;
			iter++;
			
			// if there's no next item, do a clean up
			if(KarmaFX.length && !KarmaFX[iter]) {
				$cur.data('KarmaFX', null);
			}
			
			// start the next animation queue in stack
			else {
				var startTimer = new Date().getTime(),
					endTimer = startTimer + KarmaFX[iter].duration;
					
				for (var prop in KarmaFX[iter].end)
					Karma.temp.populateStartEndValues($cur, KarmaFX[iter], KarmaFX[iter].attributes);

				KarmaFX[iter].timer = timer = setInterval(function FX_next(){
					var curTime = new Date().getTime();
					
					if(!KarmaFX)
						clearInterval(timer);

					// a frame value between start and end
					else if(curTime < endTimer){
						currentFrame(curTime - startTimer, KarmaFX[iter].end);
					}
					// last frame
					else { 
						completeAnimation();
					}
				}, 13); // try to run every 13ms
			}
		}
	}
}

Karma.easing = {
	easeIn: function (t, b, c, d) {
    	return c*(t/=d)*t + b;
    }
};

Karma.easing.global = Karma.easing.easeIn;

Karma.extend({
			 
	// method to namespace function, taking a chapter from YUI,
	// Ariel Flesler created this function, during a discussion in jQuery mailing list when I was a n00b using eval
	// http://groups.google.com/group/jquery-en/browse_thread/thread/95d1ceabe4bda4eb/c6fd0c270f91426e?q=#c6fd0c270f91426e
	namespace: function(name, root) {
		if (Karma.isString(name)) {
			// explode namespace with delimiter
		    name = name.split(".");
			// root is defaulted to window obj
		    var ns = root || window;
			// loop through each level of the namespace
		    for (var i =0; i<name.length; i++) {
				// nm is current level name
		    	var nm = name[i];
				// if not exist, add current name as obj to parent level, assign ns (parent) to current
				ns = ns[nm] || ( ns[nm] = {} ); 
				
				if (i == name.length-1) 
					return (typeof ns == 'function' || typeof ns == 'object') ? ns: false;
			}
		}
	},
	
	each: function(o, fn){
		for (var i = 0; i < o.length; i++) {
			fn.call(o[i], i, o[i]);
		}
	},
	
	trim: function(str){
		/* Thanks to Steven Levithan's benchmark on string trimming */
		// unicode friendly string trim for older browsers that don't catch all whitespaces
		// string.trim() is in JS 1.8.1, supported by FF 3.5
		// Using Luca Guidi's string trim for non native trim method
		if(!Karma.isString(str)) return str;
		
		if(str.trim)
		   return str.trim();
		
		var ws = /[\s\xA0]/, _start = 0, end = str.length;
		while(ws.test(str.charAt(_start++)));
		while(ws.test(str.charAt(--end)));
		return str.slice(_start - 1, end + 1);
	},
			 
	grep: function(o, fn) {
		if (o.filter)
			return o.filter(fn);
		
		var ret = new Array(o.length);
		// Go through the array, only saving the items that pass the validator function
		for (var i = 0, j = 0; i < o.length; i++)
			if (fn(o[i], i) !== false)
				ret[j++] = o[i];

		return ret;
	},

	inArray: function(el, o){
		for (var i = 0; i < o.length; i++)
			if (o[i] === el)
				return i;
		return -1;
	},
	
	map: function(o, fn) {
		if (o.map)
			return o.map(fn);

		var array = new Array(o.length);
		for ( var i = 0; i < o.length; i++ ) 
			array[i] = fn(o[i], i);
		return array;

	},
	
	// merge all arrays
	merge: function(){
		return _Array.prototype.concat.apply([], arguments);
	}
});

Karma.Class = function(opts){
	
	opts.construct = opts.construct || function(){};
	
	opts.construct.adds = function(option){
		for (var prop in option)
			if (prop !== 'construct') 
				opts.construct.prototype[prop] = option[prop];
	};
	
	opts.construct.inherits = function(parent){
   		opts.construct.prototype.__proto__ = parent.prototype;
		opts.construct.prototype.parent = parent;
	}
	
	for (var prop in opts)
		if (prop !== 'construct') 
			opts.construct.prototype[prop] = opts[prop];
	
	return opts.construct;
};


/*!
 * Sizzle CSS Selector Engine - v1.0
 *  Copyright 2009, The Dojo Foundation
 *  Released under the MIT, BSD, and GPL Licenses.
 *  More information: http://sizzlejs.com/
 */
(function(){

var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,
	done = 0,
	toString = Object.prototype.toString,
	hasDuplicate = false;

var Sizzle = function(selector, context, results, seed) {
	results = results || [];
	var origContext = context = context || document;

	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
		return [];
	}
	
	if ( !selector || typeof selector !== "string" ) {
		return results;
	}

	var parts = [], m, set, checkSet, check, mode, extra, prune = true, contextXML = isXML(context);
	
	// Reset the position of the chunker regexp (start from head)
	chunker.lastIndex = 0;
	
	while ( (m = chunker.exec(selector)) !== null ) {
		parts.push( m[1] );
		
		if ( m[2] ) {
			extra = RegExp.rightContext;
			break;
		}
	}

	if ( parts.length > 1 && origPOS.exec( selector ) ) {
		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
			set = posProcess( parts[0] + parts[1], context );
		} else {
			set = Expr.relative[ parts[0] ] ?
				[ context ] :
				Sizzle( parts.shift(), context );

			while ( parts.length ) {
				selector = parts.shift();

				if ( Expr.relative[ selector ] )
					selector += parts.shift();

				set = posProcess( selector, set );
			}
		}
	} else {
		// Take a shortcut and set the context if the root selector is an ID
		// (but not if it'll be faster if the inner selector is an ID)
		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
			var ret = Sizzle.find( parts.shift(), context, contextXML );
			context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
		}

		if ( context ) {
			var ret = seed ?
				{ expr: parts.pop(), set: makeArray(seed) } :
				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
			set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;

			if ( parts.length > 0 ) {
				checkSet = makeArray(set);
			} else {
				prune = false;
			}

			while ( parts.length ) {
				var cur = parts.pop(), pop = cur;

				if ( !Expr.relative[ cur ] ) {
					cur = "";
				} else {
					pop = parts.pop();
				}

				if ( pop == null ) {
					pop = context;
				}

				Expr.relative[ cur ]( checkSet, pop, contextXML );
			}
		} else {
			checkSet = parts = [];
		}
	}

	if ( !checkSet ) {
		checkSet = set;
	}

	if ( !checkSet ) {
		throw "Syntax error, unrecognized expression: " + (cur || selector);
	}

	if ( toString.call(checkSet) === "[object Array]" ) {
		if ( !prune ) {
			results.push.apply( results, checkSet );
		} else if ( context && context.nodeType === 1 ) {
			for ( var i = 0; checkSet[i] != null; i++ ) {
				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
					results.push( set[i] );
				}
			}
		} else {
			for ( var i = 0; checkSet[i] != null; i++ ) {
				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
					results.push( set[i] );
				}
			}
		}
	} else {
		makeArray( checkSet, results );
	}

	if ( extra ) {
		Sizzle( extra, origContext, results, seed );
		Sizzle.uniqueSort( results );
	}

	return results;
};

Sizzle.uniqueSort = function(results){
	if ( sortOrder ) {
		hasDuplicate = false;
		results.sort(sortOrder);

		if ( hasDuplicate ) {
			for ( var i = 1; i < results.length; i++ ) {
				if ( results[i] === results[i-1] ) {
					results.splice(i--, 1);
				}
			}
		}
	}
};

Sizzle.matches = function(expr, set){
	return Sizzle(expr, null, null, set);
};

Sizzle.find = function(expr, context, isXML){
	var set, match;

	if ( !expr ) {
		return [];
	}

	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
		var type = Expr.order[i], match;
		
		if ( (match = Expr.match[ type ].exec( expr )) ) {
			var left = RegExp.leftContext;

			if ( left.substr( left.length - 1 ) !== "\\" ) {
				match[1] = (match[1] || "").replace(/\\/g, "");
				set = Expr.find[ type ]( match, context, isXML );
				if ( set != null ) {
					expr = expr.replace( Expr.match[ type ], "" );
					break;
				}
			}
		}
	}

	if ( !set ) {
		set = context.getElementsByTagName("*");
	}

	return {set: set, expr: expr};
};

Sizzle.filter = function(expr, set, inplace, not){
	var old = expr, result = [], curLoop = set, match, anyFound,
		isXMLFilter = set && set[0] && isXML(set[0]);

	while ( expr && set.length ) {
		for ( var type in Expr.filter ) {
			if ( (match = Expr.match[ type ].exec( expr )) != null ) {
				var filter = Expr.filter[ type ], found, item;
				anyFound = false;

				if ( curLoop == result ) {
					result = [];
				}

				if ( Expr.preFilter[ type ] ) {
					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );

					if ( !match ) {
						anyFound = found = true;
					} else if ( match === true ) {
						continue;
					}
				}

				if ( match ) {
					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
						if ( item ) {
							found = filter( item, match, i, curLoop );
							var pass = not ^ !!found;

							if ( inplace && found != null ) {
								if ( pass ) {
									anyFound = true;
								} else {
									curLoop[i] = false;
								}
							} else if ( pass ) {
								result.push( item );
								anyFound = true;
							}
						}
					}
				}

				if ( found !== undefined ) {
					if ( !inplace ) {
						curLoop = result;
					}

					expr = expr.replace( Expr.match[ type ], "" );

					if ( !anyFound ) {
						return [];
					}

					break;
				}
			}
		}

		// Improper expression
		if ( expr == old ) {
			if ( anyFound == null ) {
				throw "Syntax error, unrecognized expression: " + expr;
			} else {
				break;
			}
		}

		old = expr;
	}

	return curLoop;
};

var Expr = Sizzle.selectors = {
	order: [ "ID", "NAME", "TAG" ],
	match: {
		ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
		CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
		TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
		CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
		PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
	},
	attrMap: {
		"class": "className",
		"for": "htmlFor"
	},
	attrHandle: {
		href: function(elem){
			return elem.getAttribute("href");
		}
	},
	relative: {
		"+": function(checkSet, part, isXML){
			var isPartStr = typeof part === "string",
				isTag = isPartStr && !/\W/.test(part),
				isPartStrNotTag = isPartStr && !isTag;

			if ( isTag && !isXML ) {
				part = part.toUpperCase();
			}

			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
				if ( (elem = checkSet[i]) ) {
					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}

					checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
						elem || false :
						elem === part;
				}
			}

			if ( isPartStrNotTag ) {
				Sizzle.filter( part, checkSet, true );
			}
		},
		">": function(checkSet, part, isXML){
			var isPartStr = typeof part === "string";

			if ( isPartStr && !/\W/.test(part) ) {
				part = isXML ? part : part.toUpperCase();

				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
					var elem = checkSet[i];
					if ( elem ) {
						var parent = elem.parentNode;
						checkSet[i] = parent.nodeName === part ? parent : false;
					}
				}
			} else {
				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
					var elem = checkSet[i];
					if ( elem ) {
						checkSet[i] = isPartStr ?
							elem.parentNode :
							elem.parentNode === part;
					}
				}

				if ( isPartStr ) {
					Sizzle.filter( part, checkSet, true );
				}
			}
		},
		"": function(checkSet, part, isXML){
			var doneName = done++, checkFn = dirCheck;

			if ( !/\W/.test(part) ) {
				var nodeCheck = part = isXML ? part : part.toUpperCase();
				checkFn = dirNodeCheck;
			}

			checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
		},
		"~": function(checkSet, part, isXML){
			var doneName = done++, checkFn = dirCheck;

			if ( typeof part === "string" && !/\W/.test(part) ) {
				var nodeCheck = part = isXML ? part : part.toUpperCase();
				checkFn = dirNodeCheck;
			}

			checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
		}
	},
	find: {
		ID: function(match, context, isXML){
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
				var m = context.getElementById(match[1]);
				return m ? [m] : [];
			}
		},
		NAME: function(match, context, isXML){
			if ( typeof context.getElementsByName !== "undefined" ) {
				var ret = [], results = context.getElementsByName(match[1]);

				for ( var i = 0, l = results.length; i < l; i++ ) {
					if ( results[i].getAttribute("name") === match[1] ) {
						ret.push( results[i] );
					}
				}

				return ret.length === 0 ? null : ret;
			}
		},
		TAG: function(match, context){
			return context.getElementsByTagName(match[1]);
		}
	},
	preFilter: {
		CLASS: function(match, curLoop, inplace, result, not, isXML){
			match = " " + match[1].replace(/\\/g, "") + " ";

			if ( isXML ) {
				return match;
			}

			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
				if ( elem ) {
					if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
						if ( !inplace )
							result.push( elem );
					} else if ( inplace ) {
						curLoop[i] = false;
					}
				}
			}

			return false;
		},
		ID: function(match){
			return match[1].replace(/\\/g, "");
		},
		TAG: function(match, curLoop){
			for ( var i = 0; curLoop[i] === false; i++ ){}
			return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
		},
		CHILD: function(match){
			if ( match[1] == "nth" ) {
				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
					match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);

				// calculate the numbers (first)n+(last) including if they are negative
				match[2] = (test[1] + (test[2] || 1)) - 0;
				match[3] = test[3] - 0;
			}

			// TODO: Move to normal caching system
			match[0] = done++;

			return match;
		},
		ATTR: function(match, curLoop, inplace, result, not, isXML){
			var name = match[1].replace(/\\/g, "");
			
			if ( !isXML && Expr.attrMap[name] ) {
				match[1] = Expr.attrMap[name];
			}

			if ( match[2] === "~=" ) {
				match[4] = " " + match[4] + " ";
			}

			return match;
		},
		PSEUDO: function(match, curLoop, inplace, result, not){
			if ( match[1] === "not" ) {
				// If we're dealing with a complex expression, or a simple one
				if ( chunker.exec(match[3]).length > 1 || /^\w/.test(match[3]) ) {
					match[3] = Sizzle(match[3], null, null, curLoop);
				} else {
					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
					if ( !inplace ) {
						result.push.apply( result, ret );
					}
					return false;
				}
			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
				return true;
			}
			
			return match;
		},
		POS: function(match){
			match.unshift( true );
			return match;
		}
	},
	filters: {
		enabled: function(elem){
			return elem.disabled === false && elem.type !== "hidden";
		},
		disabled: function(elem){
			return elem.disabled === true;
		},
		checked: function(elem){
			return elem.checked === true;
		},
		selected: function(elem){
			// Accessing this property makes selected-by-default
			// options in Safari work properly
			elem.parentNode.selectedIndex;
			return elem.selected === true;
		},
		parent: function(elem){
			return !!elem.firstChild;
		},
		empty: function(elem){
			return !elem.firstChild;
		},
		has: function(elem, i, match){
			return !!Sizzle( match[3], elem ).length;
		},
		header: function(elem){
			return /h\d/i.test( elem.nodeName );
		},
		text: function(elem){
			return "text" === elem.type;
		},
		radio: function(elem){
			return "radio" === elem.type;
		},
		checkbox: function(elem){
			return "checkbox" === elem.type;
		},
		file: function(elem){
			return "file" === elem.type;
		},
		password: function(elem){
			return "password" === elem.type;
		},
		submit: function(elem){
			return "submit" === elem.type;
		},
		image: function(elem){
			return "image" === elem.type;
		},
		reset: function(elem){
			return "reset" === elem.type;
		},
		button: function(elem){
			return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
		},
		input: function(elem){
			return /input|select|textarea|button/i.test(elem.nodeName);
		}
	},
	setFilters: {
		first: function(elem, i){
			return i === 0;
		},
		last: function(elem, i, match, array){
			return i === array.length - 1;
		},
		even: function(elem, i){
			return i % 2 === 0;
		},
		odd: function(elem, i){
			return i % 2 === 1;
		},
		lt: function(elem, i, match){
			return i < match[3] - 0;
		},
		gt: function(elem, i, match){
			return i > match[3] - 0;
		},
		nth: function(elem, i, match){
			return match[3] - 0 == i;
		},
		eq: function(elem, i, match){
			return match[3] - 0 == i;
		}
	},
	filter: {
		PSEUDO: function(elem, match, i, array){
			var name = match[1], filter = Expr.filters[ name ];

			if ( filter ) {
				return filter( elem, i, match, array );
			} else if ( name === "contains" ) {
				return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
			} else if ( name === "not" ) {
				var not = match[3];

				for ( var i = 0, l = not.length; i < l; i++ ) {
					if ( not[i] === elem ) {
						return false;
					}
				}

				return true;
			}
		},
		CHILD: function(elem, match){
			var type = match[1], node = elem;
			switch (type) {
				case 'only':
				case 'first':
					while ( (node = node.previousSibling) )  {
						if ( node.nodeType === 1 ) return false;
					}
					if ( type == 'first') return true;
					node = elem;
				case 'last':
					while ( (node = node.nextSibling) )  {
						if ( node.nodeType === 1 ) return false;
					}
					return true;
				case 'nth':
					var first = match[2], last = match[3];

					if ( first == 1 && last == 0 ) {
						return true;
					}
					
					var doneName = match[0],
						parent = elem.parentNode;
	
					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
						var count = 0;
						for ( node = parent.firstChild; node; node = node.nextSibling ) {
							if ( node.nodeType === 1 ) {
								node.nodeIndex = ++count;
							}
						} 
						parent.sizcache = doneName;
					}
					
					var diff = elem.nodeIndex - last;
					if ( first == 0 ) {
						return diff == 0;
					} else {
						return ( diff % first == 0 && diff / first >= 0 );
					}
			}
		},
		ID: function(elem, match){
			return elem.nodeType === 1 && elem.getAttribute("id") === match;
		},
		TAG: function(elem, match){
			return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
		},
		CLASS: function(elem, match){
			return (" " + (elem.className || elem.getAttribute("class")) + " ")
				.indexOf( match ) > -1;
		},
		ATTR: function(elem, match){
			var name = match[1],
				result = Expr.attrHandle[ name ] ?
					Expr.attrHandle[ name ]( elem ) :
					elem[ name ] != null ?
						elem[ name ] :
						elem.getAttribute( name ),
				value = result + "",
				type = match[2],
				check = match[4];

			return result == null ?
				type === "!=" :
				type === "=" ?
				value === check :
				type === "*=" ?
				value.indexOf(check) >= 0 :
				type === "~=" ?
				(" " + value + " ").indexOf(check) >= 0 :
				!check ?
				value && result !== false :
				type === "!=" ?
				value != check :
				type === "^=" ?
				value.indexOf(check) === 0 :
				type === "$=" ?
				value.substr(value.length - check.length) === check :
				type === "|=" ?
				value === check || value.substr(0, check.length + 1) === check + "-" :
				false;
		},
		POS: function(elem, match, i, array){
			var name = match[2], filter = Expr.setFilters[ name ];

			if ( filter ) {
				return filter( elem, i, match, array );
			}
		}
	}
};

var origPOS = Expr.match.POS;

for ( var type in Expr.match ) {
	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
}

var makeArray = function(array, results) {
	array = Array.prototype.slice.call( array, 0 );

	if ( results ) {
		results.push.apply( results, array );
		return results;
	}
	
	return array;
};

// Perform a simple check to determine if the browser is capable of
// converting a NodeList to an array using builtin methods.
try {
	Array.prototype.slice.call( document.documentElement.childNodes, 0 );

// Provide a fallback method if it does not work
} catch(e){
	makeArray = function(array, results) {
		var ret = results || [];

		if ( toString.call(array) === "[object Array]" ) {
			Array.prototype.push.apply( ret, array );
		} else {
			if ( typeof array.length === "number" ) {
				for ( var i = 0, l = array.length; i < l; i++ ) {
					ret.push( array[i] );
				}
			} else {
				for ( var i = 0; array[i]; i++ ) {
					ret.push( array[i] );
				}
			}
		}

		return ret;
	};
}

var sortOrder;

if ( document.documentElement.compareDocumentPosition ) {
	sortOrder = function( a, b ) {
		var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
		if ( ret === 0 ) {
			hasDuplicate = true;
		}
		return ret;
	};
} else if ( "sourceIndex" in document.documentElement ) {
	sortOrder = function( a, b ) {
		var ret = a.sourceIndex - b.sourceIndex;
		if ( ret === 0 ) {
			hasDuplicate = true;
		}
		return ret;
	};
} else if ( document.createRange ) {
	sortOrder = function( a, b ) {
		var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
		aRange.selectNode(a);
		aRange.collapse(true);
		bRange.selectNode(b);
		bRange.collapse(true);
		var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
		if ( ret === 0 ) {
			hasDuplicate = true;
		}
		return ret;
	};
}

// Check to see if the browser returns elements by name when
// querying by getElementById (and provide a workaround)
(function(){
	// We're going to inject a fake input element with a specified name
	var form = document.createElement("div"),
		id = "script" + (new Date).getTime();
	form.innerHTML = "<a name='" + id + "'/>";

	// Inject it into the root element, check its status, and remove it quickly
	var root = document.documentElement;
	root.insertBefore( form, root.firstChild );

	// The workaround has to do additional checks after a getElementById
	// Which slows things down for other browsers (hence the branching)
	if ( !!document.getElementById( id ) ) {
		Expr.find.ID = function(match, context, isXML){
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
				var m = context.getElementById(match[1]);
				return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
			}
		};

		Expr.filter.ID = function(elem, match){
			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
			return elem.nodeType === 1 && node && node.nodeValue === match;
		};
	}

	root.removeChild( form );
	root = form = null; // release memory in IE
})();

(function(){
	// Check to see if the browser returns only elements
	// when doing getElementsByTagName("*")

	// Create a fake element
	var div = document.createElement("div");
	div.appendChild( document.createComment("") );

	// Make sure no comments are found
	if ( div.getElementsByTagName("*").length > 0 ) {
		Expr.find.TAG = function(match, context){
			var results = context.getElementsByTagName(match[1]);

			// Filter out possible comments
			if ( match[1] === "*" ) {
				var tmp = [];

				for ( var i = 0; results[i]; i++ ) {
					if ( results[i].nodeType === 1 ) {
						tmp.push( results[i] );
					}
				}

				results = tmp;
			}

			return results;
		};
	}

	// Check to see if an attribute returns normalized href attributes
	div.innerHTML = "<a href='#'></a>";
	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
			div.firstChild.getAttribute("href") !== "#" ) {
		Expr.attrHandle.href = function(elem){
			return elem.getAttribute("href", 2);
		};
	}

	div = null; // release memory in IE
})();

if ( document.querySelectorAll ) (function(){
	var oldSizzle = Sizzle, div = document.createElement("div");
	div.innerHTML = "<p class='TEST'></p>";

	// Safari can't handle uppercase or unicode characters when
	// in quirks mode.
	if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
		return;
	}
	
	Sizzle = function(query, context, extra, seed){
		context = context || document;

		// Only use querySelectorAll on non-XML documents
		// (ID selectors don't work in non-HTML documents)
		if ( !seed && context.nodeType === 9 && !isXML(context) ) {
			try {
				return makeArray( context.querySelectorAll(query), extra );
			} catch(e){}
		}
		
		return oldSizzle(query, context, extra, seed);
	};

	for ( var prop in oldSizzle ) {
		Sizzle[ prop ] = oldSizzle[ prop ];
	}

	div = null; // release memory in IE
})();

if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
	var div = document.createElement("div");
	div.innerHTML = "<div class='test e'></div><div class='test'></div>";

	// Opera can't find a second classname (in 9.6)
	if ( div.getElementsByClassName("e").length === 0 )
		return;

	// Safari caches class attributes, doesn't catch changes (in 3.2)
	div.lastChild.className = "e";

	if ( div.getElementsByClassName("e").length === 1 )
		return;

	Expr.order.splice(1, 0, "CLASS");
	Expr.find.CLASS = function(match, context, isXML) {
		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
			return context.getElementsByClassName(match[1]);
		}
	};

	div = null; // release memory in IE
})();

function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
	var sibDir = dir == "previousSibling" && !isXML;
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
		var elem = checkSet[i];
		if ( elem ) {
			if ( sibDir && elem.nodeType === 1 ){
				elem.sizcache = doneName;
				elem.sizset = i;
			}
			elem = elem[dir];
			var match = false;

			while ( elem ) {
				if ( elem.sizcache === doneName ) {
					match = checkSet[elem.sizset];
					break;
				}

				if ( elem.nodeType === 1 && !isXML ){
					elem.sizcache = doneName;
					elem.sizset = i;
				}

				if ( elem.nodeName === cur ) {
					match = elem;
					break;
				}

				elem = elem[dir];
			}

			checkSet[i] = match;
		}
	}
}

function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
	var sibDir = dir == "previousSibling" && !isXML;
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
		var elem = checkSet[i];
		if ( elem ) {
			if ( sibDir && elem.nodeType === 1 ) {
				elem.sizcache = doneName;
				elem.sizset = i;
			}
			elem = elem[dir];
			var match = false;

			while ( elem ) {
				if ( elem.sizcache === doneName ) {
					match = checkSet[elem.sizset];
					break;
				}

				if ( elem.nodeType === 1 ) {
					if ( !isXML ) {
						elem.sizcache = doneName;
						elem.sizset = i;
					}
					if ( typeof cur !== "string" ) {
						if ( elem === cur ) {
							match = true;
							break;
						}

					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
						match = elem;
						break;
					}
				}

				elem = elem[dir];
			}

			checkSet[i] = match;
		}
	}
}

var contains = document.compareDocumentPosition ?  function(a, b){
	return a.compareDocumentPosition(b) & 16;
} : function(a, b){
	return a !== b && (a.contains ? a.contains(b) : true);
};

var isXML = function(elem){
	return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
		!!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML";
};

var posProcess = function(selector, context){
	var tmpSet = [], later = "", match,
		root = context.nodeType ? [context] : context;

	// Position selectors must be done after the filter
	// And so must :not(positional) so we move all PSEUDOs to the end
	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
		later += match[0];
		selector = selector.replace( Expr.match.PSEUDO, "" );
	}

	selector = Expr.relative[selector] ? selector + "*" : selector;

	for ( var i = 0, l = root.length; i < l; i++ ) {
		Sizzle( selector, root[i], tmpSet );
	}

	return Sizzle.filter( later, tmpSet );
};

// EXPOSE

Karma.Sizzle = Sizzle;

})();

Karma.each( ("blur,focus,load,resize,scroll,unload,click,dblclick,mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave,change,select,submit,keydown,keypress,keyup,error,hover").split(","), function(i, name){
	// Handle event binding
	Karma.fn[name] = function(fn){
		var args = [name].concat(Karma.makeArray(arguments));
		return arguments.length ? this.bind.apply(this, args) : this.trigger(name);
	};
});

Karma(function first_onload(){ 
	// predetermine boxModel
	if (document.body) {
		var div = document.createElement("div");
		div.style.width = div.style.paddingLeft = "1px";
		document.body.appendChild( div );
		Karma.support.boxModel = div.offsetWidth == 2;
		document.body.removeChild( div ).style.display = 'none';
	}
	
	/*try{
		iframe.src = '';
		document.documentElement.removeChild(iframe); // remove the iframe
	} catch(e){};*/
	
	// cleaning up the mess	
	Karma(window).bind('unload', function(){ 
		Karma.storage = null;
		Karma.event.caller = null;
		window.onunload = null;
	});
});
// Remember Karma.Sizzle = Sizzle;

// 2 filters below from the jQuery project
Karma.Sizzle.selectors.filters.visible = function(el){
	return el.offsetWidth > 0 || el.offsetHeight > 0;
};

Karma.Sizzle.selectors.filters.hidden = function(el){
	return el.offsetWidth === 0 && el.offsetHeight === 0;
};

Karma.Sizzle.selectors.filters.animated = function(el){
	return Karma(el).data('KarmaFX');
};


})(this);