Хранилища Subversion ant

/*!

 * jQuery JavaScript Library v1.3.3pre

 * http://jquery.com/

 *

 * Copyright (c) 2009 John Resig

 * Dual licensed under the MIT and GPL licenses.

 * http://docs.jquery.com/License

 *

 * Date: 2009-04-01 00:35:20 +0700 (Срд, 01 Апр 2009)

 * Revision: 6303

 */

(function(){

// Will speed up references to window, and allows munging its name.

var window = this,

	// Will speed up references to undefined, and allows munging its name.

	undefined,

	// Map over jQuery in case of overwrite

	_jQuery = window.jQuery,

	// Map over the $ in case of overwrite

	_$ = window.$,

	// Define a local copy of jQuery

	jQuery,

	// A central reference to the root jQuery(document)

	rootjQuery,

	jQuery = window.jQuery = window.$ = function( selector, context ) {

		// The jQuery object is actually just the init constructor 'enhanced'

		return selector === undefined ?

			rootjQuery :

			new jQuery.fn.init( selector, context );

	},

	// A simple way to check for HTML strings or ID strings

	// (both of which we optimize for)

	quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,

	// Is it a simple selector

	isSimple = /^.[^:#\[\.,]*$/,

	// Keep a UserAgent string for use with jQuery.browser

	userAgent = navigator.userAgent.toLowerCase(),

	// Save a reference to the core toString method

	toString = Object.prototype.toString;

// Define the main jQuery method

jQuery = window.jQuery = window.$ = function( selector, context ) {

	// The jQuery object is actually just the init constructor 'enhanced'

	return new jQuery.fn.init( selector, context );

};

jQuery.fn = jQuery.prototype = {

	init: function( selector, context ) {

		var match, elem, ret;

		// Handle $(""), $(null), or $(undefined)

		if ( !selector ) {

			this.length = 0;

			return this;

		}

		// Handle $(DOMElement)

		if ( selector.nodeType ) {

			this[0] = selector;

			this.length = 1;

			this.context = selector;

			return this;

		}

		// Handle HTML strings

		if ( typeof selector === "string" ) {

			// Are we dealing with HTML string or an ID?

			match = quickExpr.exec( selector );

			// Verify a match, and that no context was specified for #id

			if ( match && (match[1] || !context) ) {

				// HANDLE: $(html) -> $(array)

				if ( match[1] ) {

					selector = jQuery.clean( [ match[1] ], context );

				// HANDLE: $("#id")

				} else {

					elem = document.getElementById( match[3] );

					// Handle the case where IE and Opera return items

					// by name instead of ID

					if ( elem && elem.id !== match[3] ) {

						return rootjQuery.find( selector );

					}

					// Otherwise, we inject the element directly into the jQuery object

					ret = jQuery( elem || null );

					ret.context = document;

					ret.selector = selector;

					return ret;

				}

			// HANDLE: $(expr, $(...))

			} else if ( !context || context.jquery ) {

				return (context || rootjQuery).find( selector );

			// HANDLE: $(expr, context)

			// (which is just equivalent to: $(context).find(expr)

			} else {

				return jQuery( context ).find( selector );

			}

		// HANDLE: $(function)

		// Shortcut for document ready

		} else if ( jQuery.isFunction( selector ) ) {

			return rootjQuery.ready( selector );

		}

		// Make sure that old selector state is passed along

		if ( selector.selector && selector.context ) {

			this.selector = selector.selector;

			this.context = selector.context;

		}

		return this.setArray(jQuery.isArray( selector ) ?

			selector :

			jQuery.makeArray(selector));

	},

	// Start with an empty selector

	selector: "",

	// The current version of jQuery being used

	jquery: "1.3.3pre",

	// The number of elements contained in the matched element set

	size: function() {

		return this.length;

	},

	// Get the Nth element in the matched element set OR

	// Get the whole matched element set as a clean array

	get: function( num ) {

		return num == null ?

			// Return a 'clean' array

			Array.prototype.slice.call( this ) :

			// Return just the object

			this[ num ];

	},

	// Take an array of elements and push it onto the stack

	// (returning the new matched element set)

	pushStack: function( elems, name, selector ) {

		// Build a new jQuery matched element set

		var ret = jQuery( elems || null );

		// Add the old object onto the stack (as a reference)

		ret.prevObject = this;

		ret.context = this.context;

		if ( name === "find" ) {

			ret.selector = this.selector + (this.selector ? " " : "") + selector;

		} else if ( name ) {

			ret.selector = this.selector + "." + name + "(" + selector + ")";

		}

		// Return the newly-formed element set

		return ret;

	},

	// Force the current matched set of elements to become

	// the specified array of elements (destroying the stack in the process)

	// You should use pushStack() in order to do this, but maintain the stack

	setArray: function( elems ) {

		// Resetting the length to 0, then using the native Array push

		// is a super-fast way to populate an object with array-like properties

		this.length = 0;

		Array.prototype.push.apply( this, elems );

		return this;

	},

	// Execute a callback for every element in the matched set.

	// (You can seed the arguments with an array of args, but this is

	// only used internally.)

	each: function( callback, args ) {

		return jQuery.each( this, callback, args );

	},

	// Determine the position of an element within

	// the matched set of elements

	index: function( elem ) {

		// Locate the position of the desired element

		return jQuery.inArray(

			// If it receives a jQuery object, the first element is used

			elem && elem.jquery ? elem[0] : elem, this );

	},

	is: function( selector ) {

		return !!selector && jQuery.multiFilter( selector, this ).length > 0;

	},

	// For internal use only.

	// Behaves like an Array's method, not like a jQuery method.

	push: [].push,

	sort: [].sort,

	splice: [].splice

};

// Give the init function the jQuery prototype for later instantiation

jQuery.fn.init.prototype = jQuery.fn;

jQuery.extend = jQuery.fn.extend = function() {

	// copy reference to target object

	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;

	// 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" && !jQuery.isFunction(target) ) {

		target = {};

	}

	// extend jQuery 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 ( name in options ) {

				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 ] = jQuery.extend( deep,

						// Never move original objects, clone them

						src || ( copy.length != null ? [ ] : { } ), copy );

				// Don't bring in undefined values

				} else if ( copy !== undefined ) {

					target[ name ] = copy;

				}

			}

		}

	}

	// Return the modified object

	return target;

};

jQuery.extend({

	noConflict: function( deep ) {

		window.$ = _$;

		if ( deep ) {

			window.jQuery = _jQuery;

		}

		return jQuery;

	},

	// See test/unit/core.js for details concerning isFunction.

	// Since version 1.3, DOM methods and functions like alert

	// aren't supported. They return false on IE (#2968).

	isFunction: function( obj ) {

		return toString.call(obj) === "[object Function]";

	},

	isArray: function( obj ) {

		return toString.call(obj) === "[object Array]";

	},

	// check if an element is in a (or is an) XML document

	isXMLDoc: function( elem ) {

		return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||

			!!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML";

	},

	// Evalulates a script in a global context

	globalEval: function( data ) {

		if ( data && /\S/.test(data) ) {

			// Inspired by code by Andrea Giammarchi

			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html

			var head = document.getElementsByTagName("head")[0] || document.documentElement,

				script = document.createElement("script");

			script.type = "text/javascript";

			if ( jQuery.support.scriptEval ) {

				script.appendChild( document.createTextNode( data ) );

			} else {

				script.text = data;

			}

			// Use insertBefore instead of appendChild  to circumvent an IE6 bug.

			// This arises when a base node is used (#2709).

			head.insertBefore( script, head.firstChild );

			head.removeChild( script );

		}

	},

	nodeName: function( elem, name ) {

		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();

	},

	// args is for internal usage only

	each: function( object, callback, args ) {

		var name, i = 0, length = object.length;

		if ( args ) {

			if ( length === undefined ) {

				for ( name in object ) {

					if ( callback.apply( object[ name ], args ) === false ) {

						break;

					}

				}

			} else {

				for ( ; i < length; ) {

					if ( callback.apply( object[ i++ ], args ) === false ) {

						break;

					}

				}

			}

		// A special, fast, case for the most common use of each

		} else {

			if ( length === undefined ) {

				for ( name in object ) {

					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {

						break;

					}

				}

			} else {

				for ( var value = object[0];

					i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}

			}

		}

		return object;

	},

	trim: function( text ) {

		return (text || "").replace( /^\s+|\s+$/g, "" );

	},

	makeArray: function( array ) {

		var ret = [], i;

		if ( array != null ) {

			i = array.length;

			// The window, strings (and functions) also have 'length'

			if ( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval ) {

				ret[0] = array;

			} else {

				while ( i ) {

					ret[--i] = array[i];

				}

			}

		}

		return ret;

	},

	inArray: function( elem, array ) {

		for ( var i = 0, length = array.length; i < length; i++ ) {

			if ( array[ i ] === elem ) {

				return i;

			}

		}

		return -1;

	},

	merge: function( first, second ) {

		// We have to loop this way because IE & Opera overwrite the length

		// expando of getElementsByTagName

		var i = 0, elem, pos = first.length;

		// Also, we need to make sure that the correct elements are being returned

		// (IE returns comment nodes in a '*' query)

		if ( !jQuery.support.getAll ) {

			while ( (elem = second[ i++ ]) != null ) {

				if ( elem.nodeType !== 8 ) {

					first[ pos++ ] = elem;

				}

			}

		} else {

			while ( (elem = second[ i++ ]) != null ) {

				first[ pos++ ] = elem;

			}

		}

		return first;

	},

	unique: function( array ) {

		var ret = [], done = {}, id;

		try {

			for ( var i = 0, length = array.length; i < length; i++ ) {

				id = jQuery.data( array[ i ] );

				if ( !done[ id ] ) {

					done[ id ] = true;

					ret.push( array[ i ] );

				}

			}

		} catch( e ) {

			ret = array;

		}

		return ret;

	},

	grep: function( elems, callback, inv ) {

		var ret = [];

		// Go through the array, only saving the items

		// that pass the validator function

		for ( var i = 0, length = elems.length; i < length; i++ ) {

			if ( !inv !== !callback( elems[ i ], i ) ) {

				ret.push( elems[ i ] );

			}

		}

		return ret;

	},

	map: function( elems, callback ) {

		var ret = [], value;

		// Go through the array, translating each of the items to their

		// new value (or values).

		for ( var i = 0, length = elems.length; i < length; i++ ) {

			value = callback( elems[ i ], i );

			if ( value != null ) {

				ret[ ret.length ] = value;

			}

		}

		return ret.concat.apply( [], ret );

	},

	// Use of jQuery.browser is deprecated.

	// It's included for backwards compatibility and plugins,

	// although they should work to migrate away.

	browser: {

		version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],

		safari: /webkit/.test( userAgent ),

		opera: /opera/.test( userAgent ),

		msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),

		mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )

	}

});

// All jQuery objects should point back to these

rootjQuery = jQuery(document);

function evalScript( i, elem ) {

	if ( elem.src ) {

		jQuery.ajax({

			url: elem.src,

			async: false,

			dataType: "script"

		});

	} else {

		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );

	}

	if ( elem.parentNode ) {

		elem.parentNode.removeChild( elem );

	}

}

function now() {

	return (new Date).getTime();

}

var expando = "jQuery" + now(), uuid = 0, windowData = {};

jQuery.extend({

	cache: {},

	data: function( elem, name, data ) {

		elem = elem == window ?

			windowData :

			elem;

		var id = elem[ expando ];

		// Compute a unique ID for the element

		if ( !id )

			id = elem[ expando ] = ++uuid;

		// Only generate the data cache if we're

		// trying to access or manipulate it

		if ( name && !jQuery.cache[ id ] )

			jQuery.cache[ id ] = {};

		// Prevent overriding the named cache with undefined values

		if ( data !== undefined )

			jQuery.cache[ id ][ name ] = data;

		// Return the named cache data, or the ID for the element

		return name ?

			jQuery.cache[ id ][ name ] :

			id;

	},

	removeData: function( elem, name ) {

		elem = elem == window ?

			windowData :

			elem;

		var id = elem[ expando ];

		// If we want to remove a specific section of the element's data

		if ( name ) {

			if ( jQuery.cache[ id ] ) {

				// Remove the section of cache data

				delete jQuery.cache[ id ][ name ];

				// If we've removed all the data, remove the element's cache

				name = "";

				for ( name in jQuery.cache[ id ] )

					break;

				if ( !name )

					jQuery.removeData( elem );

			}

		// Otherwise, we want to remove all of the element's data

		} else {

			// Clean up the element expando

			try {

				delete elem[ expando ];

			} catch(e){

				// IE has trouble directly removing the expando

				// but it's ok with using removeAttribute

				if ( elem.removeAttribute )

					elem.removeAttribute( expando );

			}

			// Completely remove the data cache

			delete jQuery.cache[ id ];

		}

	},

	queue: function( elem, type, data ) {

		if ( elem ){

			type = (type || "fx") + "queue";

			var q = jQuery.data( elem, type );

			if ( !q || jQuery.isArray(data) )

				q = jQuery.data( elem, type, jQuery.makeArray(data) );

			else if( data )

				q.push( data );

		}

		return q;

	},

	dequeue: function( elem, type ){

		var queue = jQuery.queue( elem, type ),

			fn = queue.shift();

		if( !type || type === "fx" )

			fn = queue[0];

		if( fn !== undefined )

			fn.call(elem);

	}

});

jQuery.fn.extend({

	data: function( key, value ){

		var parts = key.split(".");

		parts[1] = parts[1] ? "." + parts[1] : "";

		if ( value === undefined ) {

			var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);

			if ( data === undefined && this.length )

				data = jQuery.data( this[0], key );

			return data === undefined && parts[1] ?

				this.data( parts[0] ) :

				data;

		} else

			return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){

				jQuery.data( this, key, value );

			});

	},

	removeData: function( key ){

		return this.each(function(){

			jQuery.removeData( this, key );

		});

	},

	queue: function(type, data){

		if ( typeof type !== "string" ) {

			data = type;

			type = "fx";

		}

		if ( data === undefined )

			return jQuery.queue( this[0], type );

		return this.each(function(){

			var queue = jQuery.queue( this, type, data );

			 if( type == "fx" && queue.length == 1 )

				queue[0].call(this);

		});

	},

	dequeue: function(type){

		return this.each(function(){

			jQuery.dequeue( this, type );

		});

	}

});/*!

 * 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;

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 ( !part.match(/\W/) ) {

				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" && !part.match(/\W/) ) {

				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 ( match[3].match(chunker).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){