Subversion Repositories SmartDukaan

/*!

 * Sizzle CSS Selector Engine v2.2.0-pre

 * http://sizzlejs.com/

 *

 * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors

 * Released under the MIT license

 * http://jquery.org/license

 *

 * Date: 2014-12-16

 */

(function( window ) {

var i,

	support,

	Expr,

	getText,

	isXML,

	tokenize,

	compile,

	select,

	outermostContext,

	sortInput,

	hasDuplicate,

	// Local document vars

	setDocument,

	document,

	docElem,

	documentIsHTML,

	rbuggyQSA,

	rbuggyMatches,

	matches,

	contains,

	// Instance-specific data

	expando = "sizzle" + 1 * new Date(),

	preferredDoc = window.document,

	dirruns = 0,

	done = 0,

	classCache = createCache(),

	tokenCache = createCache(),

	compilerCache = createCache(),

	sortOrder = function( a, b ) {

		if ( a === b ) {

			hasDuplicate = true;

		}

		return 0;

	},

	// General-purpose constants

	MAX_NEGATIVE = 1 << 31,

	// Instance methods

	hasOwn = ({}).hasOwnProperty,

	arr = [],

	pop = arr.pop,

	push_native = arr.push,

	push = arr.push,

	slice = arr.slice,

	// Use a stripped-down indexOf as it's faster than native

	// http://jsperf.com/thor-indexof-vs-for/5

	indexOf = function( list, elem ) {

		var i = 0,

			len = list.length;

		for ( ; i < len; i++ ) {

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

				return i;

			}

		}

		return -1;

	},

	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",

	// Regular expressions

	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace

	whitespace = "[\\x20\\t\\r\\n\\f]",

	// http://www.w3.org/TR/css3-syntax/#characters

	characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",

	// Loosely modeled on CSS identifier characters

	// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors

	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier

	identifier = characterEncoding.replace( "w", "w#" ),

	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors

	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +

		// Operator (capture 2)

		"*([*^$|!~]?=)" + whitespace +

		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"

		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +

		"*\\]",

	pseudos = ":(" + characterEncoding + ")(?:\\((" +

		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:

		// 1. quoted (capture 3; capture 4 or capture 5)

		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +

		// 2. simple (capture 6)

		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +

		// 3. anything else (capture 2)

		".*" +

		")\\)|)",

	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter

	rwhitespace = new RegExp( whitespace + "+", "g" ),

	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),

	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),

	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),

	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),

	rpseudo = new RegExp( pseudos ),

	ridentifier = new RegExp( "^" + identifier + "$" ),

	matchExpr = {

		"ID": new RegExp( "^#(" + characterEncoding + ")" ),

		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),

		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),

		"ATTR": new RegExp( "^" + attributes ),

		"PSEUDO": new RegExp( "^" + pseudos ),

		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +

			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +

			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),

		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),

		// For use in libraries implementing .is()

		// We use this for POS matching in `select`

		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +

			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )

	},

	rinputs = /^(?:input|select|textarea|button)$/i,

	rheader = /^h\d$/i,

	rnative = /^[^{]+\{\s*\[native \w/,

	// Easily-parseable/retrievable ID or TAG or CLASS selectors

	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,

	rsibling = /[+~]/,

	rescape = /'|\\/g,

	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters

	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),

	funescape = function( _, escaped, escapedWhitespace ) {

		var high = "0x" + escaped - 0x10000;

		// NaN means non-codepoint

		// Support: Firefox<24

		// Workaround erroneous numeric interpretation of +"0x"

		return high !== high || escapedWhitespace ?

			escaped :

			high < 0 ?

				// BMP codepoint

				String.fromCharCode( high + 0x10000 ) :

				// Supplemental Plane codepoint (surrogate pair)

				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );

	},

	// Used for iframes

	// See setDocument()

	// Removing the function wrapper causes a "Permission Denied"

	// error in IE

	unloadHandler = function() {

		setDocument();

	};

// Optimize for push.apply( _, NodeList )

try {

	push.apply(

		(arr = slice.call( preferredDoc.childNodes )),

		preferredDoc.childNodes

	);

	// Support: Android<4.0

	// Detect silently failing push.apply

	arr[ preferredDoc.childNodes.length ].nodeType;

} catch ( e ) {

	push = { apply: arr.length ?

		// Leverage slice if possible

		function( target, els ) {

			push_native.apply( target, slice.call(els) );

		} :

		// Support: IE<9

		// Otherwise append directly

		function( target, els ) {

			var j = target.length,

				i = 0;

			// Can't trust NodeList.length

			while ( (target[j++] = els[i++]) ) {}

			target.length = j - 1;

		}

	};

}

function Sizzle( selector, context, results, seed ) {

	var match, elem, m, nodeType,

		// QSA vars

		i, groups, old, nid, newContext, newSelector;

	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {

		setDocument( context );

	}

	context = context || document;

	results = results || [];

	nodeType = context.nodeType;

	if ( typeof selector !== "string" || !selector ||

		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {

		return results;

	}

	if ( !seed && documentIsHTML ) {

		// Try to shortcut find operations when possible (e.g., not under DocumentFragment)

		if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {

			// Speed-up: Sizzle("#ID")

			if ( (m = match[1]) ) {

				if ( nodeType === 9 ) {

					elem = context.getElementById( m );

					// Check parentNode to catch when Blackberry 4.6 returns

					// nodes that are no longer in the document (jQuery #6963)

					if ( elem && elem.parentNode ) {

						// Handle the case where IE, Opera, and Webkit return items

						// by name instead of ID

						if ( elem.id === m ) {

							results.push( elem );

							return results;

						}

					} else {

						return results;

					}

				} else {

					// Context is not a document

					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&

						contains( context, elem ) && elem.id === m ) {

						results.push( elem );

						return results;

					}

				}

			// Speed-up: Sizzle("TAG")

			} else if ( match[2] ) {

				push.apply( results, context.getElementsByTagName( selector ) );

				return results;

			// Speed-up: Sizzle(".CLASS")

			} else if ( (m = match[3]) && support.getElementsByClassName ) {

				push.apply( results, context.getElementsByClassName( m ) );

				return results;

			}

		}

		// QSA path

		if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {

			nid = old = expando;

			newContext = context;

			newSelector = nodeType !== 1 && selector;

			// qSA works strangely on Element-rooted queries

			// We can work around this by specifying an extra ID on the root

			// and working up from there (Thanks to Andrew Dupont for the technique)

			// IE 8 doesn't work on object elements

			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {

				groups = tokenize( selector );

				if ( (old = context.getAttribute("id")) ) {

					nid = old.replace( rescape, "\\$&" );

				} else {

					context.setAttribute( "id", nid );

				}

				nid = "[id='" + nid + "'] ";

				i = groups.length;

				while ( i-- ) {

					groups[i] = nid + toSelector( groups[i] );

				}

				newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;

				newSelector = groups.join(",");

			}

			if ( newSelector ) {

				try {

					push.apply( results,

						newContext.querySelectorAll( newSelector )

					);

					return results;

				} catch(qsaError) {

				} finally {

					if ( !old ) {

						context.removeAttribute("id");

					}

				}

			}

		}

	}

	// All others

	return select( selector.replace( rtrim, "$1" ), context, results, seed );

}

/**

 * Create key-value caches of limited size

 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with

 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)

 *	deleting the oldest entry

 */

function createCache() {

	var keys = [];

	function cache( key, value ) {

		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)

		if ( keys.push( key + " " ) > Expr.cacheLength ) {

			// Only keep the most recent entries

			delete cache[ keys.shift() ];

		}

		return (cache[ key + " " ] = value);

	}

	return cache;

}

/**

 * Mark a function for special use by Sizzle

 * @param {Function} fn The function to mark

 */

function markFunction( fn ) {

	fn[ expando ] = true;

	return fn;

}

/**

 * Support testing using an element

 * @param {Function} fn Passed the created div and expects a boolean result

 */

function assert( fn ) {

	var div = document.createElement("div");

	try {

		return !!fn( div );

	} catch (e) {

		return false;

	} finally {

		// Remove from its parent by default

		if ( div.parentNode ) {

			div.parentNode.removeChild( div );

		}

		// release memory in IE

		div = null;

	}

}

/**

 * Adds the same handler for all of the specified attrs

 * @param {String} attrs Pipe-separated list of attributes

 * @param {Function} handler The method that will be applied

 */

function addHandle( attrs, handler ) {

	var arr = attrs.split("|"),

		i = attrs.length;

	while ( i-- ) {

		Expr.attrHandle[ arr[i] ] = handler;

	}

}

/**

 * Checks document order of two siblings

 * @param {Element} a

 * @param {Element} b

 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b

 */

function siblingCheck( a, b ) {

	var cur = b && a,

		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&

			( ~b.sourceIndex || MAX_NEGATIVE ) -

			( ~a.sourceIndex || MAX_NEGATIVE );

	// Use IE sourceIndex if available on both nodes

	if ( diff ) {

		return diff;

	}

	// Check if b follows a

	if ( cur ) {

		while ( (cur = cur.nextSibling) ) {

			if ( cur === b ) {

				return -1;

			}

		}

	}

	return a ? 1 : -1;

}

/**

 * Returns a function to use in pseudos for input types

 * @param {String} type

 */

function createInputPseudo( type ) {

	return function( elem ) {

		var name = elem.nodeName.toLowerCase();

		return name === "input" && elem.type === type;

	};

}

/**

 * Returns a function to use in pseudos for buttons

 * @param {String} type

 */

function createButtonPseudo( type ) {

	return function( elem ) {

		var name = elem.nodeName.toLowerCase();

		return (name === "input" || name === "button") && elem.type === type;

	};

}

/**

 * Returns a function to use in pseudos for positionals

 * @param {Function} fn

 */

function createPositionalPseudo( fn ) {

	return markFunction(function( argument ) {

		argument = +argument;

		return markFunction(function( seed, matches ) {

			var j,

				matchIndexes = fn( [], seed.length, argument ),

				i = matchIndexes.length;

			// Match elements found at the specified indexes

			while ( i-- ) {

				if ( seed[ (j = matchIndexes[i]) ] ) {

					seed[j] = !(matches[j] = seed[j]);

				}

			}

		});

	});

}

/**

 * Checks a node for validity as a Sizzle context

 * @param {Element|Object=} context

 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value

 */

function testContext( context ) {

	return context && typeof context.getElementsByTagName !== "undefined" && context;

}

// Expose support vars for convenience

support = Sizzle.support = {};

/**

 * Detects XML nodes

 * @param {Element|Object} elem An element or a document

 * @returns {Boolean} True iff elem is a non-HTML XML node

 */

isXML = Sizzle.isXML = function( elem ) {

	// documentElement is verified for cases where it doesn't yet exist

	// (such as loading iframes in IE - #4833)

	var documentElement = elem && (elem.ownerDocument || elem).documentElement;

	return documentElement ? documentElement.nodeName !== "HTML" : false;

};

/**

 * Sets document-related variables once based on the current document

 * @param {Element|Object} [doc] An element or document object to use to set the document

 * @returns {Object} Returns the current document

 */

setDocument = Sizzle.setDocument = function( node ) {

	var hasCompare, parent,

		doc = node ? node.ownerDocument || node : preferredDoc;

	// If no document and documentElement is available, return

	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {

		return document;

	}

	// Set our document

	document = doc;

	docElem = doc.documentElement;

	parent = doc.defaultView;

	// Support: IE>8

	// If iframe document is assigned to "document" variable and if iframe has been reloaded,

	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936

	// IE6-8 do not support the defaultView property so parent will be undefined

	if ( parent && parent !== parent.top ) {

		// IE11 does not have attachEvent, so all must suffer

		if ( parent.addEventListener ) {

			parent.addEventListener( "unload", unloadHandler, false );

		} else if ( parent.attachEvent ) {

			parent.attachEvent( "onunload", unloadHandler );

		}

	}

	/* Support tests

	---------------------------------------------------------------------- */

	documentIsHTML = !isXML( doc );

	/* Attributes

	---------------------------------------------------------------------- */

	// Support: IE<8

	// Verify that getAttribute really returns attributes and not properties

	// (excepting IE8 booleans)

	support.attributes = assert(function( div ) {

		div.className = "i";

		return !div.getAttribute("className");

	});

	/* getElement(s)By*

	---------------------------------------------------------------------- */

	// Check if getElementsByTagName("*") returns only elements

	support.getElementsByTagName = assert(function( div ) {

		div.appendChild( doc.createComment("") );

		return !div.getElementsByTagName("*").length;

	});

	// Support: IE<9

	support.getElementsByClassName = rnative.test( doc.getElementsByClassName );

	// Support: IE<10

	// Check if getElementById returns elements by name

	// The broken getElementById methods don't pick up programatically-set names,

	// so use a roundabout getElementsByName test

	support.getById = assert(function( div ) {

		docElem.appendChild( div ).id = expando;

		return !doc.getElementsByName || !doc.getElementsByName( expando ).length;

	});

	// ID find and filter

	if ( support.getById ) {

		Expr.find["ID"] = function( id, context ) {

			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {

				var m = context.getElementById( id );

				// Check parentNode to catch when Blackberry 4.6 returns

				// nodes that are no longer in the document #6963

				return m && m.parentNode ? [ m ] : [];

			}

		};

		Expr.filter["ID"] = function( id ) {

			var attrId = id.replace( runescape, funescape );

			return function( elem ) {

				return elem.getAttribute("id") === attrId;

			};

		};

	} else {

		// Support: IE6/7

		// getElementById is not reliable as a find shortcut

		delete Expr.find["ID"];

		Expr.filter["ID"] =  function( id ) {

			var attrId = id.replace( runescape, funescape );

			return function( elem ) {

				var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");

				return node && node.value === attrId;

			};

		};

	}

	// Tag

	Expr.find["TAG"] = support.getElementsByTagName ?

		function( tag, context ) {

			if ( typeof context.getElementsByTagName !== "undefined" ) {

				return context.getElementsByTagName( tag );

			// DocumentFragment nodes don't have gEBTN

			} else if ( support.qsa ) {

				return context.querySelectorAll( tag );

			}

		} :

		function( tag, context ) {

			var elem,

				tmp = [],

				i = 0,

				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too

				results = context.getElementsByTagName( tag );

			// Filter out possible comments

			if ( tag === "*" ) {

				while ( (elem = results[i++]) ) {

					if ( elem.nodeType === 1 ) {

						tmp.push( elem );

					}

				}

				return tmp;

			}

			return results;

		};

	// Class

	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {

		if ( documentIsHTML ) {

			return context.getElementsByClassName( className );

		}

	};

	/* QSA/matchesSelector

	---------------------------------------------------------------------- */

	// QSA and matchesSelector support

	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)

	rbuggyMatches = [];

	// qSa(:focus) reports false when true (Chrome 21)

	// We allow this because of a bug in IE8/9 that throws an error

	// whenever `document.activeElement` is accessed on an iframe

	// So, we allow :focus to pass through QSA all the time to avoid the IE error

	// See http://bugs.jquery.com/ticket/13378

	rbuggyQSA = [];

	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {

		// Build QSA regex

		// Regex strategy adopted from Diego Perini

		assert(function( div ) {

			// Select is set to empty string on purpose

			// This is to test IE's treatment of not explicitly

			// setting a boolean content attribute,

			// since its presence should be enough

			// http://bugs.jquery.com/ticket/12359

			docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +

				"<select id='" + expando + "-\f]' msallowcapture=''>" +

				"<option selected=''></option></select>";

			// Support: IE8, Opera 11-12.16

			// Nothing should be selected when empty strings follow ^= or $= or *=

			// The test attribute must be unknown in Opera but "safe" for WinRT

			// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section

			if ( div.querySelectorAll("[msallowcapture^='']").length ) {

				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );

			}

			// Support: IE8

			// Boolean attributes and "value" are not treated correctly

			if ( !div.querySelectorAll("[selected]").length ) {

				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );

			}

			// Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+

			if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {

				rbuggyQSA.push("~=");

			}

			// Webkit/Opera - :checked should return selected option elements

			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked

			// IE8 throws error here and will not see later tests

			if ( !div.querySelectorAll(":checked").length ) {

				rbuggyQSA.push(":checked");

			}

			// Support: Safari 8+, iOS 8+

			// https://bugs.webkit.org/show_bug.cgi?id=136851

			// In-page `selector#id sibing-combinator selector` fails

			if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {

				rbuggyQSA.push(".#.+[+~]");

			}

		});

		assert(function( div ) {

			// Support: Windows 8 Native Apps

			// The type and name attributes are restricted during .innerHTML assignment

			var input = doc.createElement("input");

			input.setAttribute( "type", "hidden" );

			div.appendChild( input ).setAttribute( "name", "D" );

			// Support: IE8

			// Enforce case-sensitivity of name attribute

			if ( div.querySelectorAll("[name=d]").length ) {

				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );

			}

			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)

			// IE8 throws error here and will not see later tests

			if ( !div.querySelectorAll(":enabled").length ) {

				rbuggyQSA.push( ":enabled", ":disabled" );

			}

			// Opera 10-11 does not throw on post-comma invalid pseudos

			div.querySelectorAll("*,:x");

			rbuggyQSA.push(",.*:");

		});

	}

	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||

		docElem.webkitMatchesSelector ||

		docElem.mozMatchesSelector ||

		docElem.oMatchesSelector ||

		docElem.msMatchesSelector) )) ) {

		assert(function( div ) {

			// Check to see if it's possible to do matchesSelector

			// on a disconnected node (IE 9)

			support.disconnectedMatch = matches.call( div, "div" );

			// This should fail with an exception

			// Gecko does not error, returns false instead

			matches.call( div, "[s!='']:x" );

			rbuggyMatches.push( "!=", pseudos );

		});

	}

	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );

	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );

	/* Contains

	---------------------------------------------------------------------- */

	hasCompare = rnative.test( docElem.compareDocumentPosition );

	// Element contains another

	// Purposefully does not implement inclusive descendent

	// As in, an element does not contain itself

	contains = hasCompare || rnative.test( docElem.contains ) ?

		function( a, b ) {

			var adown = a.nodeType === 9 ? a.documentElement : a,

				bup = b && b.parentNode;

			return a === bup || !!( bup && bup.nodeType === 1 && (

				adown.contains ?

					adown.contains( bup ) :

					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16

			));

		} :

		function( a, b ) {

			if ( b ) {

				while ( (b = b.parentNode) ) {

					if ( b === a ) {

						return true;

					}

				}

			}

			return false;

		};

	/* Sorting

	---------------------------------------------------------------------- */

	// Document order sorting

	sortOrder = hasCompare ?

	function( a, b ) {

		// Flag for duplicate removal

		if ( a === b ) {

			hasDuplicate = true;

			return 0;

		}

		// Sort on method existence if only one input has compareDocumentPosition

		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;

		if ( compare ) {

			return compare;

		}

		// Calculate position if both inputs belong to the same document

		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?

			a.compareDocumentPosition( b ) :

			// Otherwise we know they are disconnected

			1;

		// Disconnected nodes

		if ( compare & 1 ||

			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {

			// Choose the first element that is related to our preferred document

			if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {

				return -1;

			}

			if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {

				return 1;

			}

			// Maintain original order

			return sortInput ?

				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :

				0;

		}

		return compare & 4 ? -1 : 1;

	} :

	function( a, b ) {

		// Exit early if the nodes are identical

		if ( a === b ) {

			hasDuplicate = true;

			return 0;

		}

		var cur,

			i = 0,

			aup = a.parentNode,

			bup = b.parentNode,

			ap = [ a ],

			bp = [ b ];

		// Parentless nodes are either documents or disconnected

		if ( !aup || !bup ) {

			return a === doc ? -1 :

				b === doc ? 1 :

				aup ? -1 :

				bup ? 1 :

				sortInput ?

				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :

				0;

		// If the nodes are siblings, we can do a quick check

		} else if ( aup === bup ) {

			return siblingCheck( a, b );

		}

		// Otherwise we need full lists of their ancestors for comparison

		cur = a;

		while ( (cur = cur.parentNode) ) {

			ap.unshift( cur );

		}

		cur = b;

		while ( (cur = cur.parentNode) ) {

			bp.unshift( cur );

		}

		// Walk down the tree looking for a discrepancy

		while ( ap[i] === bp[i] ) {

			i++;

		}

		return i ?

			// Do a sibling check if the nodes have a common ancestor

			siblingCheck( ap[i], bp[i] ) :

			// Otherwise nodes in our document sort first

			ap[i] === preferredDoc ? -1 :

			bp[i] === preferredDoc ? 1 :

			0;

	};

	return doc;

};

Sizzle.matches = function( expr, elements ) {

	return Sizzle( expr, null, null, elements );

};

Sizzle.matchesSelector = function( elem, expr ) {

	// Set document vars if needed

	if ( ( elem.ownerDocument || elem ) !== document ) {

		setDocument( elem );

	}

	// Make sure that attribute selectors are quoted

	expr = expr.replace( rattributeQuotes, "='$1']" );

	if ( support.matchesSelector && documentIsHTML &&

		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&

		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {

		try {

			var ret = matches.call( elem, expr );

			// IE 9's matchesSelector returns false on disconnected nodes

			if ( ret || support.disconnectedMatch ||

					// As well, disconnected nodes are said to be in a document

					// fragment in IE 9

					elem.document && elem.document.nodeType !== 11 ) {

				return ret;

			}

		} catch (e) {}

	}

	return Sizzle( expr, document, null, [ elem ] ).length > 0;

};

Sizzle.contains = function( context, elem ) {

	// Set document vars if needed

	if ( ( context.ownerDocument || context ) !== document ) {

		setDocument( context );

	}

	return contains( context, elem );

};

Sizzle.attr = function( elem, name ) {

	// Set document vars if needed

	if ( ( elem.ownerDocument || elem ) !== document ) {

		setDocument( elem );

	}

	var fn = Expr.attrHandle[ name.toLowerCase() ],

		// Don't get fooled by Object.prototype properties (jQuery #13807)

		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?

			fn( elem, name, !documentIsHTML ) :

			undefined;

	return val !== undefined ?

		val :

		support.attributes || !documentIsHTML ?

			elem.getAttribute( name ) :

			(val = elem.getAttributeNode(name)) && val.specified ?

				val.value :

				null;

};

Sizzle.error = function( msg ) {

	throw new Error( "Syntax error, unrecognized expression: " + msg );

};

/**

 * Document sorting and removing duplicates

 * @param {ArrayLike} results

 */

Sizzle.uniqueSort = function( results ) {

	var elem,

		duplicates = [],

		j = 0,

		i = 0;

	// Unless we *know* we can detect duplicates, assume their presence

	hasDuplicate = !support.detectDuplicates;

	sortInput = !support.sortStable && results.slice( 0 );

	results.sort( sortOrder );

	if ( hasDuplicate ) {

		while ( (elem = results[i++]) ) {

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

				j = duplicates.push( i );

			}

		}

		while ( j-- ) {

			results.splice( duplicates[ j ], 1 );

		}

	}

	// Clear input after sorting to release objects

	// See https://github.com/jquery/sizzle/pull/225

	sortInput = null;

	return results;

};

/**

 * Utility function for retrieving the text value of an array of DOM nodes

 * @param {Array|Element} elem

 */

getText = Sizzle.getText = function( elem ) {

	var node,

		ret = "",

		i = 0,

		nodeType = elem.nodeType;

	if ( !nodeType ) {

		// If no nodeType, this is expected to be an array

		while ( (node = elem[i++]) ) {

			// Do not traverse comment nodes

			ret += getText( node );

		}

	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {

		// Use textContent for elements

		// innerText usage removed for consistency of new lines (jQuery #11153)

		if ( typeof elem.textContent === "string" ) {

			return elem.textContent;

		} else {

			// Traverse its children

			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {

				ret += getText( elem );

			}

		}

	} else if ( nodeType === 3 || nodeType === 4 ) {

		return elem.nodeValue;

	}

	// Do not include comment or processing instruction nodes

	return ret;

};

Expr = Sizzle.selectors = {

	// Can be adjusted by the user

	cacheLength: 50,

	createPseudo: markFunction,

	match: matchExpr,

	attrHandle: {},

	find: {},

	relative: {

		">": { dir: "parentNode", first: true },

		" ": { dir: "parentNode" },

		"+": { dir: "previousSibling", first: true },

		"~": { dir: "previousSibling" }

	},

	preFilter: {

		"ATTR": function( match ) {

			match[1] = match[1].replace( runescape, funescape );

			// Move the given value to match[3] whether quoted or unquoted

			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );

			if ( match[2] === "~=" ) {

				match[3] = " " + match[3] + " ";

			}