https://anebquebec.com/app/themes/wp-aneb-corpo/public/javascripts/common.js

1(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
2var $ = require("jquery");
3var breakpoint = require('./app-breakpoints');
4require('./app-accordion');
5var slick = require("slick");
6var _ = require('underscore');
7var _gridSize = breakpoint().match(/(\d+)/g);
8var _winSize = $(window).width();
9var	_gridLabel = breakpoint().replace(/\d+/g, '').replace(" ", "").replace(/\"/g, "");
10
11var sticky = $('.c-navigation').offset().top;
12
13require('./app-map');
14
15$(function() {
16	$('.carousel').slick({
17		autoplay: true,
18		responsive: false,
19		fade: true,
20		dots: false,
21		autoplaySpeed: 8500,
22		arrows: false
23	});
24
25	$('.carousel-element').slick({
26		autoplay: true,
27		responsive: [
28		{
29		 breakpoint: 767,
30	      settings: {
31	        slidesToShow: 1,
32	        slidesToScroll: 1
33	      }
34		}],
35		//fade: true,
36		dots: true,
37		slidesToShow: 2,
38 		slidesToScroll: 2,
39		arrows: false
40	});
41
42
43	$(".post .item .item-media").click(function() {
44		if( $(this).find("a").attr("href") ) {
45	 		 window.location = $(this).find("a").attr("href");
46		}
47	  return false;
48	});
49
50	$(window).scroll(function() {
51		console.log(_gridLabel);
52
53		if(_gridLabel != "smartphone") {
54			if ($(this).scrollTop() > sticky){
55		   	 $('.c-navigation').addClass("sticky");
56			  } else {
57			    $('.c-navigation').removeClass("sticky");
58			  }
59		}
60	});
61
62	$(document).on('click', '.nav-trigger', function(e) {
63		$(this).toggleClass('is-active');
64		$('#menu-mobile').slideToggle();
65		return false;
66	});
67
68	$(document).on("click", ".new-window", function () {
69
70		var w = 500;
71		var h = 500;
72
73		var dualScreenLeft = window.screenLeft != undefined ? window.screenLeft : screen.left;
74		var dualScreenTop = window.screenTop != undefined ? window.screenTop : screen.top;
75
76		var width = window.innerWidth ? window.innerWidth : document.documentElement.clientWidth ? document.documentElement.clientWidth : screen.width;
77   		var height = window.innerHeight ? window.innerHeight : document.documentElement.clientHeight ? document.documentElement.clientHeight : screen.height;
78
79   		var title = $(this).attr('data-title');
80   		var url = $(this).attr('href');
81
82		var left = ((width / 2) - (w / 2)) + dualScreenLeft;
83		var top = ((height / 2) - (h / 2)) + dualScreenTop;
84		var newWindow = window.open(url, title, 'scrollbars=yes, width=' + w + ', height=' + h + ', top=' + top + ', left=' + left);
85
86		if (window.focus) {
87	       newWindow.focus();
88	    }
89
90   		return false;
91    });
92
93    $(window).resize(function(){
94		_gridSize = breakpoint().match(/(\d+)/g);
95		_winSize = $(window).width();
96		_margin = (_winSize - _gridSize) / 2;
97
98		_gridLabel = breakpoint().replace(/\d+/g, '').replace(' ','');
99
100		if(_gridLabel == "smartphone") {
101			$('.c-navigation').removeClass("sticky");
102		}
103
104	}).resize();
105
106
107	
108	$(".c-alimentaire .list a").click(function () {
109		$(".c-alimentaire .list li").removeClass("active"),
110		$(this).parent().addClass("active"),
111		$(".c-alimentaire .contentBox").hide(),
112		$(".c-alimentaire .contentBox[data-id=" + $(this).attr("data-id") + "]").fadeIn();
113	});
114	$(".c-alimentaire .list li:eq(0) a").trigger("click");
115	$(".carousel").slick({ autoplay: !0, responsive: !1, fade: !0, dots: !1, autoplaySpeed: 8500, arrows: !1 });
116	$(".carousel-element").slick({ autoplay: !0, responsive: [{ breakpoint: 767, settings: { slidesToShow: 1, slidesToScroll: 1 } }], dots: !0, slidesToShow: 2, slidesToScroll: 2, arrows: !1 });
117	$(".post .item .item-media").click(function () {
118		return $(this).find("a").attr("href") && (window.location = $(this).find("a").attr("href")), !1;
119	});
120	// $(window).scroll(function () {
121	// 	"smartphone" != a && ($(this).scrollTop() > l ? $(".c-navigation").addClass("sticky") : $(".c-navigation").removeClass("sticky"));
122	// });
123	// $(document).on("click", ".nav-trigger", function (e) {
124	// 	return $(this).toggleClass("is-active"), $("#menu-mobile").slideToggle(), !1;
125	// });
126	$(document).on("click", ".new-window", function () {
127		var e = 500,
128			t = 500,
129			n = void 0 != window.screenLeft ? window.screenLeft : screen.left,
130			o = void 0 != window.screenTop ? window.screenTop : screen.top,
131			r = window.innerWidth ? window.innerWidth : document.documentElement.clientWidth ? document.documentElement.clientWidth : screen.width,
132			s = window.innerHeight ? window.innerHeight : document.documentElement.clientHeight ? document.documentElement.clientHeight : screen.height,
133			a = $(this).attr("data-title"),
134			l = $(this).attr("href"),
135			c = r / 2 - e / 2 + n,
136			u = s / 2 - t / 2 + o,

137			d = window.open(l, a, "scrollbars=yes, width=" + e + ", height=" + t + ", top=" + u + ", left=" + c);
138		return window.focus && d.focus(), !1;
139	});
140	// $(window).resize(function () {
141	// 		(r = o().match(/(\d+)/g)), (s = i(window).width()), (_margin = (s - r) / 2), (a = o().replace(/\d+/g, "").replace(" ", "")), "smartphone" == a && i(".c-navigation").removeClass("sticky");
142	// }).resize();
143		
144	/*
145	function PopupCenter(url, title, w, h) {
146    // Fixes dual-screen position                         Most browsers      Firefox
147
148    // Puts focus on the newWindow
149    if (window.focus) {
150        newWindow.focus();
151    }
152}
153	 */
154});
155
156/*var $ = require("jquery");
157var stick_in_parent = require("sticky-kit");
158var slick = require("slick");
159var breakpoint = require('./app-breakpoints');
160var sameheight = require('./app-sameheight');
161var TweenMax = require('TweenMax');
162var _ = require('underscore');
163
164var _gridSize = breakpoint().match(/(\d+)/g);
165var _winSize = $(window).width();
166var current = 0;
167var next = 0;
168var prev = 0;
169var	_gridLabel = breakpoint().replace(/\d+/g, '').replace(" ", "").replace(/\"/g, "");
170var debouncedLayout = _.debounce(_resize, 300);
171
172var slickVar = {
173	centerMode: true,
174	autoplay: ((_gridSize > 768) ? true : false),
175	variableWidth: true,
176	slidesToShow: ((_gridSize > 768) ? 3 : 1),
177	infinite: false,
178	initialSlide: 1,
179	centerPadding: '0',
180	draggable: false
181};
182
183$(function() {
184	_gridSize = breakpoint().match(/(\d+)/g);
185	_winSize = $(window).width();
186	var _margin = (_winSize - _gridSize) / 2;
187	_gridLabel = breakpoint().replace(/\d+/g, '').replace(" ", "").replace(/\"/g, "");
188
189	$('.fb-share').click(function(e) {
190		e.preventDefault();
191		window.open($(this).attr('href'), 'fbShareWindow',
192			'height=450, width=550, top=' + ($(window).height() / 2 - 275) +
193			', left=' + ($(window).width() / 2 - 225) +
194			', toolbar=0, location=0, menubar=0, directories=0, scrollbars=0');
195		return false;
196	});
197
198console.log(_gridLabel);
199
200	if (_gridLabel !== "smartphone" && _gridLabel !== "tablet" ) {
201		$("#stick-in-parent").stick_in_parent({
202			parent: '.source-_product_cat',
203			sticky_class: 'is-stuck',
204		});
205	}
206
207	$(window).resize(debouncedLayout);
208	_resize();
209
210	$(document).on('click', '.nav-trigger', function(e) {
211
212		$(this).toggleClass('is-active');
213		$('#menu-mobile').slideToggle();
214
215		return false;
216	});
217
218	$(document).on('mouseenter', '.menu-item', function() {
219		if (_gridSize > 768) {
220			var height = $('.sub-menu ul', this).outerHeight(true);
221
222			if (height) {
223				TweenMax.set(['.menu-depth-1', '.menu-depth-2'], {
224					height: height
225				});
226			}
227		}
228	});
229
230	$(document).on('mouseenter', '.menu-item-has-children', function() {
231		if (_gridSize > 768) {
232			var padding = $(this).offset().left;
233			var grid = $('#menu-menu-primaire').outerWidth();
234
235			$(this).children('div.menu-depth-1').css({
236				paddingLeft: padding
237			});
238
239			$('.menu-item-depth-1').css({
240				width: grid * 0.3
241			});
242
243			$('.menu-depth-2').css({
244				left: grid * 0.3
245			}).children('ul').css({
246				width: grid * 0.7
247			});
248		}
249	});
250
251
252	$('.slider').slick({
253		autoplay: true,
254		fade: true,
255		dots: true,
256		arrows: false
257	});
258
259	$('.product-formats-slider').slick({
260		slidesToShow: 1,
261		slidesToScroll: 1,
262		fade: true,
263		centerMode: true,
264		asNavFor: '.product-formats-nav',
265	});
266
267	$('.product-formats-nav').slick({
268		slidesToShow: 4,
269		slidesToScroll: 4,
270		centerPadding: 0,
271		asNavFor: '.product-formats-slider',
272		focusOnSelect: true,
273		variableWidth: true,
274		useTransform: false,
275	});
276
277	$('.related-products-slider').slick({
278		adaptiveHeight: true,
279		dots: true,
280	});
281
282	$('.related-products-slider').on('setPosition', function(event, slick,
283		direction) {
284		_resize();
285	});
286
287});
288
289var runSlick = function() {
290	current = 0;
291	next = 0;
292	prev = 0;
293
294	if ($('.carousel').find('.c-list-item-carousel').length >= 3) {
295		var carousel = $('.carousel');
296		if ($(carousel).hasClass('slick-slider')) carousel.slick('unslick');
297
298		carousel.on('init', function(slick) {
299			if (_gridSize > 768) {
300				current = carousel.find('.slick-current');
301				prev = current.prev();
302				next = current.next();
303				TweenMax.set([prev, next], {
304					autoAlpha: 1,
305					scale: 0.7
306				});
307				TweenMax.set(current, {
308					scale: 1,
309					autoAlpha: 1
310				});
311			}
312		});
313
314		carousel.slick(slickVar).on('beforeChange', function(event, slick,
315			currentSlide, nextSlide) {
316			if (_gridSize > 768) {
317
318				if (Math.abs(nextSlide - currentSlide) == 1) {
319					direction = (nextSlide - currentSlide > 0) ? "right" : "left";
320				} else {
321					direction = (nextSlide - currentSlide > 0) ? "left" : "right";
322				}
323				TweenMax.to(slick.$slides.eq(currentSlide), 0.1, {
324					scale: 0.7,
325					autoAlpha: 1
326				});
327				TweenMax.to(slick.$slides.eq(nextSlide), 0.1, {
328					autoAlpha: 1,
329					scale: 1
330				});
331
332				if (direction === "right") {
333					//edge
334					TweenMax.to(slick.$slides.eq(currentSlide - 1), 0.1, {
335						autoAlpha: 0
336					});
337					TweenMax.to(slick.$slides.eq(nextSlide + 1), 0.1, {
338						autoAlpha: 1,
339						scale: 0.7
340					});
341				} else {
342					TweenMax.to(slick.$slides.eq(currentSlide + 1), 0.1, {
343						autoAlpha: 0
344					});
345					TweenMax.to(slick.$slides.eq(nextSlide - 1), 0.1, {
346						autoAlpha: 1,
347						scale: 0.7
348					});
349				}
350			}
351		});
352
353	} else if ($('.c-section.has-source .c-listing .c-list-item').length >= 3) {
354
355		var carousel = $('.c-section.has-source .c-listing__wrapper');
356		if ($(carousel).hasClass('slick-slider')) carousel.slick('unslick');
357

358		// if( $(carousel).find('.c-list-item-carousel').length > 3) {
359		carousel.on('init', function(slick) {
360			if (_gridSize > 768) {
361				current = carousel.find('.slick-current');
362				prev = current.prev();
363				next = current.next();
364
365				TweenMax.set([prev, next], {
366					autoAlpha: 1
367				});
368				TweenMax.set(current, {
369					autoAlpha: 1
370				});
371			}
372		});
373
374		carousel.slick(slickVar).on('beforeChange', function(event, slick,
375			currentSlide, nextSlide) {
376			if (_gridSize > 768) {
377				if (Math.abs(nextSlide - currentSlide) == 1) {
378					direction = (nextSlide - currentSlide > 0) ? "right" : "left";
379				} else {
380					direction = (nextSlide - currentSlide > 0) ? "left" : "right";
381				}
382				TweenMax.to(slick.$slides.eq(currentSlide), 0.1, {
383					autoAlpha: 1
384				});
385				TweenMax.to(slick.$slides.eq(nextSlide), 0.1, {
386					autoAlpha: 1
387				});
388
389				if (direction === "right") {
390					//edge
391					TweenMax.to(slick.$slides.eq(currentSlide - 1), 0.1, {
392						autoAlpha: 0
393					});
394					TweenMax.to(slick.$slides.eq(nextSlide + 1), 0.1, {
395						autoAlpha: 1
396					});
397				} else {
398					TweenMax.to(slick.$slides.eq(currentSlide + 1), 0.1, {
399						autoAlpha: 0
400					});
401					TweenMax.to(slick.$slides.eq(nextSlide - 1), 0.1, {
402						autoAlpha: 1
403					});
404				}
405			}
406		});
407	}
408	// }
409}
410
411$(window).resize(function(){
412	_gridSize = breakpoint().match(/(\d+)/g);
413	_gridLabel = breakpoint().replace(/\d+/g, '').replace(" ", "").replace(/\"/g, "");
414	_winSize = $(window).width();
415	_margin = (_winSize - _gridSize) / 2;
416	maxHeight = -1;
417
418	if (_gridSize > 1200) {
419		$('.c-section--header.has-thumbnail .c-section__wrapper').css({
420			paddingLeft: _margin
421		});
422	}
423})
424
425function _resize() {
426	console.log("resize once");
427	_gridSize = breakpoint().match(/(\d+)/g);
428	_gridLabel = breakpoint().replace(/\d+/g, '').replace(" ", "").replace(/\"/g, "");
429	_winSize = $(window).width();
430	_margin = (_winSize - _gridSize) / 2;
431	maxHeight = -1;
432
433	//Reset
434	$('.c-section--header.has-thumbnail .c-section__wrapper').css('paddingLeft',
435		'');
436
437	$('.menu-depth-1, .menu-depth-2').css({
438		minHeight: $('.menu-depth-1').find('ul').eq(0).outerHeight(true)
439	});
440
441	if (_gridSize > 1200) {
442		$('.c-section--header.has-thumbnail .c-section__wrapper').css({
443			paddingLeft: _margin
444		});
445	}
446
447	if ($('.same-height').length && _gridLabel !== "smartphone") {
448		$('.same-height').equalRowHeights();
449	}
450
451	runSlick();
452}
453*/
454},{"./app-accordion":5,"./app-breakpoints":6,"./app-map":7,"jquery":2,"slick":3,"underscore":4}],2:[function(require,module,exports){
455(function (global){
456; var __browserify_shim_require__=require;(function browserifyShim(module, exports, require, define, browserify_shim__define__module__export__) {
457/*!
458 * jQuery JavaScript Library v2.1.4
459 * http://jquery.com/
460 *
461 * Includes Sizzle.js
462 * http://sizzlejs.com/
463 *
464 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
465 * Released under the MIT license
466 * http://jquery.org/license
467 *
468 * Date: 2015-04-28T16:01Z
469 */
470
471(function( global, factory ) {
472
473	if ( typeof module === "object" && typeof module.exports === "object" ) {
474		// For CommonJS and CommonJS-like environments where a proper `window`
475		// is present, execute the factory and get jQuery.
476		// For environments that do not have a `window` with a `document`
477		// (such as Node.js), expose a factory as module.exports.
478		// This accentuates the need for the creation of a real `window`.
479		// e.g. var jQuery = require("jquery")(window);
480		// See ticket #14549 for more info.
481		module.exports = global.document ?
482			factory( global, true ) :
483			function( w ) {
484				if ( !w.document ) {
485					throw new Error( "jQuery requires a window with a document" );
486				}
487				return factory( w );
488			};
489	} else {
490		factory( global );
491	}
492
493// Pass this if window is not defined yet
494}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
495
496// Support: Firefox 18+
497// Can't be in strict mode, several libs including ASP.NET trace
498// the stack via arguments.caller.callee and Firefox dies if
499// you try to trace through "use strict" call chains. (#13335)
500//
501
502var arr = [];
503
504var slice = arr.slice;
505
506var concat = arr.concat;
507
508var push = arr.push;
509
510var indexOf = arr.indexOf;
511
512var class2type = {};
513
514var toString = class2type.toString;
515
516var hasOwn = class2type.hasOwnProperty;
517
518var support = {};
519
520
521
522var
523	// Use the correct document accordingly with window argument (sandbox)
524	document = window.document,
525
526	version = "2.1.4",
527
528	// Define a local copy of jQuery
529	jQuery = function( selector, context ) {
530		// The jQuery object is actually just the init constructor 'enhanced'
531		// Need init if jQuery is called (just allow error to be thrown if not included)
532		return new jQuery.fn.init( selector, context );
533	},
534
535	// Support: Android<4.1
536	// Make sure we trim BOM and NBSP
537	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
538
539	// Matches dashed string for camelizing
540	rmsPrefix = /^-ms-/,
541	rdashAlpha = /-([\da-z])/gi,
542
543	// Used by jQuery.camelCase as callback to replace()
544	fcamelCase = function( all, letter ) {
545		return letter.toUpperCase();
546	};
547
548jQuery.fn = jQuery.prototype = {
549	// The current version of jQuery being used
550	jquery: version,
551
552	constructor: jQuery,
553
554	// Start with an empty selector
555	selector: "",
556
557	// The default length of a jQuery object is 0
558	length: 0,
559
560	toArray: function() {
561		return slice.call( this );
562	},
563
564	// Get the Nth element in the matched element set OR
565	// Get the whole matched element set as a clean array
566	get: function( num ) {
567		return num != null ?
568
569			// Return just the one element from the set
570			( num < 0 ? this[ num + this.length ] : this[ num ] ) :
571
572			// Return all the elements in a clean array
573			slice.call( this );
574	},
575
576	// Take an array of elements and push it onto the stack
577	// (returning the new matched element set)
578	pushStack: function( elems ) {
579
580		// Build a new jQuery matched element set
581		var ret = jQuery.merge( this.constructor(), elems );
582
583		// Add the old object onto the stack (as a reference)

584		ret.prevObject = this;
585		ret.context = this.context;
586
587		// Return the newly-formed element set
588		return ret;
589	},
590
591	// Execute a callback for every element in the matched set.
592	// (You can seed the arguments with an array of args, but this is
593	// only used internally.)
594	each: function( callback, args ) {
595		return jQuery.each( this, callback, args );
596	},
597
598	map: function( callback ) {
599		return this.pushStack( jQuery.map(this, function( elem, i ) {
600			return callback.call( elem, i, elem );
601		}));
602	},
603
604	slice: function() {
605		return this.pushStack( slice.apply( this, arguments ) );
606	},
607
608	first: function() {
609		return this.eq( 0 );
610	},
611
612	last: function() {
613		return this.eq( -1 );
614	},
615
616	eq: function( i ) {
617		var len = this.length,
618			j = +i + ( i < 0 ? len : 0 );
619		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
620	},
621
622	end: function() {
623		return this.prevObject || this.constructor(null);
624	},
625
626	// For internal use only.
627	// Behaves like an Array's method, not like a jQuery method.
628	push: push,
629	sort: arr.sort,
630	splice: arr.splice
631};
632
633jQuery.extend = jQuery.fn.extend = function() {
634	var options, name, src, copy, copyIsArray, clone,
635		target = arguments[0] || {},
636		i = 1,
637		length = arguments.length,
638		deep = false;
639
640	// Handle a deep copy situation
641	if ( typeof target === "boolean" ) {
642		deep = target;
643
644		// Skip the boolean and the target
645		target = arguments[ i ] || {};
646		i++;
647	}
648
649	// Handle case when target is a string or something (possible in deep copy)
650	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
651		target = {};
652	}
653
654	// Extend jQuery itself if only one argument is passed
655	if ( i === length ) {
656		target = this;
657		i--;
658	}
659
660	for ( ; i < length; i++ ) {
661		// Only deal with non-null/undefined values
662		if ( (options = arguments[ i ]) != null ) {
663			// Extend the base object
664			for ( name in options ) {
665				src = target[ name ];
666				copy = options[ name ];
667
668				// Prevent never-ending loop
669				if ( target === copy ) {
670					continue;
671				}
672
673				// Recurse if we're merging plain objects or arrays
674				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
675					if ( copyIsArray ) {
676						copyIsArray = false;
677						clone = src && jQuery.isArray(src) ? src : [];
678
679					} else {
680						clone = src && jQuery.isPlainObject(src) ? src : {};
681					}
682
683					// Never move original objects, clone them
684					target[ name ] = jQuery.extend( deep, clone, copy );
685
686				// Don't bring in undefined values
687				} else if ( copy !== undefined ) {
688					target[ name ] = copy;
689				}
690			}
691		}
692	}
693
694	// Return the modified object
695	return target;
696};
697
698jQuery.extend({
699	// Unique for each copy of jQuery on the page
700	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
701
702	// Assume jQuery is ready without the ready module
703	isReady: true,
704
705	error: function( msg ) {
706		throw new Error( msg );
707	},
708
709	noop: function() {},
710
711	isFunction: function( obj ) {
712		return jQuery.type(obj) === "function";
713	},
714
715	isArray: Array.isArray,
716
717	isWindow: function( obj ) {
718		return obj != null && obj === obj.window;
719	},
720
721	isNumeric: function( obj ) {
722		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
723		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
724		// subtraction forces infinities to NaN
725		// adding 1 corrects loss of precision from parseFloat (#15100)
726		return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;
727	},
728
729	isPlainObject: function( obj ) {
730		// Not plain objects:
731		// - Any object or value whose internal [[Class]] property is not "[object Object]"
732		// - DOM nodes
733		// - window
734		if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
735			return false;
736		}
737
738		if ( obj.constructor &&
739				!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
740			return false;
741		}
742
743		// If the function hasn't returned already, we're confident that
744		// |obj| is a plain object, created by {} or constructed with new Object
745		return true;
746	},
747
748	isEmptyObject: function( obj ) {
749		var name;
750		for ( name in obj ) {
751			return false;

752		}
753		return true;
754	},
755
756	type: function( obj ) {
757		if ( obj == null ) {
758			return obj + "";
759		}
760		// Support: Android<4.0, iOS<6 (functionish RegExp)
761		return typeof obj === "object" || typeof obj === "function" ?
762			class2type[ toString.call(obj) ] || "object" :
763			typeof obj;
764	},
765
766	// Evaluates a script in a global context
767	globalEval: function( code ) {
768		var script,
769			indirect = eval;
770
771		code = jQuery.trim( code );
772
773		if ( code ) {
774			// If the code includes a valid, prologue position
775			// strict mode pragma, execute code by injecting a
776			// script tag into the document.
777			if ( code.indexOf("use strict") === 1 ) {
778				script = document.createElement("script");
779				script.text = code;
780				document.head.appendChild( script ).parentNode.removeChild( script );
781			} else {
782			// Otherwise, avoid the DOM node creation, insertion
783			// and removal by using an indirect global eval
784				indirect( code );
785			}
786		}
787	},
788
789	// Convert dashed to camelCase; used by the css and data modules
790	// Support: IE9-11+
791	// Microsoft forgot to hump their vendor prefix (#9572)
792	camelCase: function( string ) {
793		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
794	},
795

796	nodeName: function( elem, name ) {
797		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
798	},
799
800	// args is for internal usage only
801	each: function( obj, callback, args ) {
802		var value,
803			i = 0,
804			length = obj.length,
805			isArray = isArraylike( obj );
806
807		if ( args ) {
808			if ( isArray ) {
809				for ( ; i < length; i++ ) {
810					value = callback.apply( obj[ i ], args );
811
812					if ( value === false ) {
813						break;
814					}
815				}
816			} else {
817				for ( i in obj ) {
818					value = callback.apply( obj[ i ], args );
819
820					if ( value === false ) {
821						break;
822					}
823				}
824			}
825
826		// A special, fast, case for the most common use of each
827		} else {
828			if ( isArray ) {
829				for ( ; i < length; i++ ) {
830					value = callback.call( obj[ i ], i, obj[ i ] );
831
832					if ( value === false ) {
833						break;
834					}
835				}
836			} else {
837				for ( i in obj ) {
838					value = callback.call( obj[ i ], i, obj[ i ] );
839
840					if ( value === false ) {
841						break;
842					}
843				}
844			}
845		}
846
847		return obj;
848	},
849
850	// Support: Android<4.1
851	trim: function( text ) {
852		return text == null ?
853			"" :
854			( text + "" ).replace( rtrim, "" );
855	},
856
857	// results is for internal usage only
858	makeArray: function( arr, results ) {
859		var ret = results || [];
860
861		if ( arr != null ) {
862			if ( isArraylike( Object(arr) ) ) {
863				jQuery.merge( ret,
864					typeof arr === "string" ?
865					[ arr ] : arr
866				);
867			} else {
868				push.call( ret, arr );
869			}
870		}
871
872		return ret;
873	},
874
875	inArray: function( elem, arr, i ) {
876		return arr == null ? -1 : indexOf.call( arr, elem, i );
877	},
878
879	merge: function( first, second ) {
880		var len = +second.length,
881			j = 0,
882			i = first.length;
883
884		for ( ; j < len; j++ ) {
885			first[ i++ ] = second[ j ];
886		}
887
888		first.length = i;
889
890		return first;
891	},
892
893	grep: function( elems, callback, invert ) {
894		var callbackInverse,
895			matches = [],
896			i = 0,
897			length = elems.length,
898			callbackExpect = !invert;
899
900		// Go through the array, only saving the items
901		// that pass the validator function
902		for ( ; i < length; i++ ) {
903			callbackInverse = !callback( elems[ i ], i );
904			if ( callbackInverse !== callbackExpect ) {
905				matches.push( elems[ i ] );
906			}
907		}
908
909		return matches;
910	},
911
912	// arg is for internal usage only
913	map: function( elems, callback, arg ) {
914		var value,
915			i = 0,
916			length = elems.length,
917			isArray = isArraylike( elems ),
918			ret = [];
919
920		// Go through the array, translating each of the items to their new values
921		if ( isArray ) {
922			for ( ; i < length; i++ ) {
923				value = callback( elems[ i ], i, arg );
924
925				if ( value != null ) {
926					ret.push( value );
927				}
928			}
929
930		// Go through every key on the object,
931		} else {
932			for ( i in elems ) {
933				value = callback( elems[ i ], i, arg );
934
935				if ( value != null ) {
936					ret.push( value );
937				}
938			}
939		}
940
941		// Flatten any nested arrays
942		return concat.apply( [], ret );
943	},
944
945	// A global GUID counter for objects
946	guid: 1,
947
948	// Bind a function to a context, optionally partially applying any
949	// arguments.
950	proxy: function( fn, context ) {
951		var tmp, args, proxy;
952
953		if ( typeof context === "string" ) {
954			tmp = fn[ context ];
955			context = fn;
956			fn = tmp;
957		}
958
959		// Quick check to determine if target is callable, in the spec
960		// this throws a TypeError, but we will just return undefined.
961		if ( !jQuery.isFunction( fn ) ) {
962			return undefined;
963		}
964
965		// Simulated bind
966		args = slice.call( arguments, 2 );
967		proxy = function() {
968			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
969		};
970
971		// Set the guid of unique handler to the same of original handler, so it can be removed
972		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
973
974		return proxy;
975	},
976
977	now: Date.now,
978
979	// jQuery.support is not used in Core but other projects attach their
980	// properties to it so it needs to exist.
981	support: support
982});
983
984// Populate the class2type map
985jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
986	class2type[ "[object " + name + "]" ] = name.toLowerCase();
987});
988
989function isArraylike( obj ) {
990
991	// Support: iOS 8.2 (not reproducible in simulator)
992	// `in` check used to prevent JIT error (gh-2145)
993	// hasOwn isn't used here due to false negatives
994	// regarding Nodelist length in IE
995	var length = "length" in obj && obj.length,
996		type = jQuery.type( obj );
997
998	if ( type === "function" || jQuery.isWindow( obj ) ) {
999		return false;

1000	}
1001
1002	if ( obj.nodeType === 1 && length ) {
1003		return true;
1004	}
1005
1006	return type === "array" || length === 0 ||
1007		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
1008}
1009var Sizzle =
1010/*!
1011 * Sizzle CSS Selector Engine v2.2.0-pre
1012 * http://sizzlejs.com/
1013 *
1014 * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors
1015 * Released under the MIT license
1016 * http://jquery.org/license
1017 *
1018 * Date: 2014-12-16
1019 */
1020(function( window ) {
1021
1022var i,
1023	support,
1024	Expr,
1025	getText,
1026	isXML,
1027	tokenize,
1028	compile,
1029	select,
1030	outermostContext,
1031	sortInput,
1032	hasDuplicate,
1033
1034	// Local document vars
1035	setDocument,
1036	document,
1037	docElem,
1038	documentIsHTML,
1039	rbuggyQSA,
1040	rbuggyMatches,
1041	matches,
1042	contains,
1043
1044	// Instance-specific data
1045	expando = "sizzle" + 1 * new Date(),
1046	preferredDoc = window.document,
1047	dirruns = 0,
1048	done = 0,
1049	classCache = createCache(),
1050	tokenCache = createCache(),
1051	compilerCache = createCache(),
1052	sortOrder = function( a, b ) {
1053		if ( a === b ) {
1054			hasDuplicate = true;
1055		}
1056		return 0;
1057	},
1058
1059	// General-purpose constants
1060	MAX_NEGATIVE = 1 << 31,
1061
1062	// Instance methods
1063	hasOwn = ({}).hasOwnProperty,
1064	arr = [],
1065	pop = arr.pop,
1066	push_native = arr.push,
1067	push = arr.push,
1068	slice = arr.slice,
1069	// Use a stripped-down indexOf as it's faster than native
1070	// http://jsperf.com/thor-indexof-vs-for/5
1071	indexOf = function( list, elem ) {
1072		var i = 0,
1073			len = list.length;
1074		for ( ; i < len; i++ ) {
1075			if ( list[i] === elem ) {
1076				return i;
1077			}
1078		}
1079		return -1;
1080	},
1081
1082	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
1083
1084	// Regular expressions
1085
1086	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
1087	whitespace = "[\\x20\\t\\r\\n\\f]",
1088	// http://www.w3.org/TR/css3-syntax/#characters
1089	characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
1090
1091	// Loosely modeled on CSS identifier characters
1092	// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
1093	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
1094	identifier = characterEncoding.replace( "w", "w#" ),
1095
1096	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
1097	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +
1098		// Operator (capture 2)
1099		"*([*^$|!~]?=)" + whitespace +
1100		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
1101		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
1102		"*\\]",
1103
1104	pseudos = ":(" + characterEncoding + ")(?:\\((" +
1105		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
1106		// 1. quoted (capture 3; capture 4 or capture 5)
1107		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
1108		// 2. simple (capture 6)
1109		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
1110		// 3. anything else (capture 2)
1111		".*" +
1112		")\\)|)",
1113
1114	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
1115	rwhitespace = new RegExp( whitespace + "+", "g" ),
1116	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
1117
1118	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
1119	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
1120
1121	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
1122
1123	rpseudo = new RegExp( pseudos ),
1124	ridentifier = new RegExp( "^" + identifier + "$" ),
1125
1126	matchExpr = {
1127		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
1128		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
1129		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
1130		"ATTR": new RegExp( "^" + attributes ),
1131		"PSEUDO": new RegExp( "^" + pseudos ),
1132		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
1133			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
1134			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
1135		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
1136		// For use in libraries implementing .is()
1137		// We use this for POS matching in `select`
1138		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
1139			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
1140	},
1141

1142	rinputs = /^(?:input|select|textarea|button)$/i,
1143	rheader = /^h\d$/i,
1144
1145	rnative = /^[^{]+\{\s*\[native \w/,
1146
1147	// Easily-parseable/retrievable ID or TAG or CLASS selectors
1148	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
1149
1150	rsibling = /[+~]/,
1151	rescape = /'|\\/g,
1152
1153	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
1154	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
1155	funescape = function( _, escaped, escapedWhitespace ) {
1156		var high = "0x" + escaped - 0x10000;
1157		// NaN means non-codepoint
1158		// Support: Firefox<24
1159		// Workaround erroneous numeric interpretation of +"0x"
1160		return high !== high || escapedWhitespace ?
1161			escaped :
1162			high < 0 ?
1163				// BMP codepoint
1164				String.fromCharCode( high + 0x10000 ) :
1165				// Supplemental Plane codepoint (surrogate pair)
1166				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
1167	},
1168
1169	// Used for iframes
1170	// See setDocument()
1171	// Removing the function wrapper causes a "Permission Denied"
1172	// error in IE
1173	unloadHandler = function() {
1174		setDocument();
1175	};
1176
1177// Optimize for push.apply( _, NodeList )
1178try {
1179	push.apply(
1180		(arr = slice.call( preferredDoc.childNodes )),
1181		preferredDoc.childNodes
1182	);
1183	// Support: Android<4.0
1184	// Detect silently failing push.apply
1185	arr[ preferredDoc.childNodes.length ].nodeType;
1186} catch ( e ) {
1187	push = { apply: arr.length ?
1188
1189		// Leverage slice if possible
1190		function( target, els ) {
1191			push_native.apply( target, slice.call(els) );
1192		} :
1193
1194		// Support: IE<9
1195		// Otherwise append directly
1196		function( target, els ) {
1197			var j = target.length,
1198				i = 0;
1199			// Can't trust NodeList.length
1200			while ( (target[j++] = els[i++]) ) {}
1201			target.length = j - 1;
1202		}
1203	};
1204}
1205
1206function Sizzle( selector, context, results, seed ) {
1207	var match, elem, m, nodeType,
1208		// QSA vars
1209		i, groups, old, nid, newContext, newSelector;
1210
1211	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
1212		setDocument( context );
1213	}
1214
1215	context = context || document;
1216	results = results || [];
1217	nodeType = context.nodeType;
1218
1219	if ( typeof selector !== "string" || !selector ||
1220		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
1221
1222		return results;
1223	}
1224
1225	if ( !seed && documentIsHTML ) {
1226
1227		// Try to shortcut find operations when possible (e.g., not under DocumentFragment)
1228		if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
1229			// Speed-up: Sizzle("#ID")
1230			if ( (m = match[1]) ) {
1231				if ( nodeType === 9 ) {
1232					elem = context.getElementById( m );
1233					// Check parentNode to catch when Blackberry 4.6 returns
1234					// nodes that are no longer in the document (jQuery #6963)
1235					if ( elem && elem.parentNode ) {
1236						// Handle the case where IE, Opera, and Webkit return items
1237						// by name instead of ID
1238						if ( elem.id === m ) {
1239							results.push( elem );
1240							return results;
1241						}
1242					} else {
1243						return results;
1244					}
1245				} else {
1246					// Context is not a document
1247					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
1248						contains( context, elem ) && elem.id === m ) {
1249						results.push( elem );
1250						return results;
1251					}
1252				}
1253
1254			// Speed-up: Sizzle("TAG")
1255			} else if ( match[2] ) {
1256				push.apply( results, context.getElementsByTagName( selector ) );
1257				return results;
1258
1259			// Speed-up: Sizzle(".CLASS")
1260			} else if ( (m = match[3]) && support.getElementsByClassName ) {
1261				push.apply( results, context.getElementsByClassName( m ) );
1262				return results;
1263			}
1264		}
1265
1266		// QSA path
1267		if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
1268			nid = old = expando;
1269			newContext = context;
1270			newSelector = nodeType !== 1 && selector;
1271
1272			// qSA works strangely on Element-rooted queries
1273			// We can work around this by specifying an extra ID on the root
1274			// and working up from there (Thanks to Andrew Dupont for the technique)
1275			// IE 8 doesn't work on object elements
1276			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
1277				groups = tokenize( selector );
1278
1279				if ( (old = context.getAttribute("id")) ) {
1280					nid = old.replace( rescape, "\\$&" );
1281				} else {
1282					context.setAttribute( "id", nid );
1283				}
1284				nid = "[id='" + nid + "'] ";
1285
1286				i = groups.length;
1287				while ( i-- ) {
1288					groups[i] = nid + toSelector( groups[i] );
1289				}

1290				newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
1291				newSelector = groups.join(",");
1292			}
1293
1294			if ( newSelector ) {
1295				try {
1296					push.apply( results,
1297						newContext.querySelectorAll( newSelector )
1298					);
1299					return results;
1300				} catch(qsaError) {
1301				} finally {
1302					if ( !old ) {
1303						context.removeAttribute("id");
1304					}
1305				}
1306			}
1307		}
1308	}
1309
1310	// All others
1311	return select( selector.replace( rtrim, "$1" ), context, results, seed );
1312}
1313
1314/**
1315 * Create key-value caches of limited size
1316 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
1317 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1318 *	deleting the oldest entry
1319 */
1320function createCache() {
1321	var keys = [];
1322
1323	function cache( key, value ) {
1324		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
1325		if ( keys.push( key + " " ) > Expr.cacheLength ) {
1326			// Only keep the most recent entries
1327			delete cache[ keys.shift() ];
1328		}
1329		return (cache[ key + " " ] = value);
1330	}
1331	return cache;
1332}
1333
1334/**
1335 * Mark a function for special use by Sizzle
1336 * @param {Function} fn The function to mark
1337 */
1338function markFunction( fn ) {
1339	fn[ expando ] = true;
1340	return fn;
1341}
1342
1343/**
1344 * Support testing using an element
1345 * @param {Function} fn Passed the created div and expects a boolean result
1346 */
1347function assert( fn ) {
1348	var div = document.createElement("div");
1349
1350	try {
1351		return !!fn( div );
1352	} catch (e) {
1353		return false;
1354	} finally {
1355		// Remove from its parent by default
1356		if ( div.parentNode ) {
1357			div.parentNode.removeChild( div );
1358		}
1359		// release memory in IE
1360		div = null;
1361	}
1362}
1363
1364/**
1365 * Adds the same handler for all of the specified attrs
1366 * @param {String} attrs Pipe-separated list of attributes
1367 * @param {Function} handler The method that will be applied
1368 */
1369function addHandle( attrs, handler ) {
1370	var arr = attrs.split("|"),
1371		i = attrs.length;
1372
1373	while ( i-- ) {
1374		Expr.attrHandle[ arr[i] ] = handler;
1375	}
1376}
1377
1378/**
1379 * Checks document order of two siblings
1380 * @param {Element} a
1381 * @param {Element} b
1382 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1383 */
1384function siblingCheck( a, b ) {
1385	var cur = b && a,
1386		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
1387			( ~b.sourceIndex || MAX_NEGATIVE ) -
1388			( ~a.sourceIndex || MAX_NEGATIVE );
1389
1390	// Use IE sourceIndex if available on both nodes
1391	if ( diff ) {
1392		return diff;
1393	}
1394
1395	// Check if b follows a
1396	if ( cur ) {
1397		while ( (cur = cur.nextSibling) ) {
1398			if ( cur === b ) {
1399				return -1;
1400			}
1401		}
1402	}
1403
1404	return a ? 1 : -1;
1405}
1406
1407/**
1408 * Returns a function to use in pseudos for input types
1409 * @param {String} type
1410 */
1411function createInputPseudo( type ) {
1412	return function( elem ) {
1413		var name = elem.nodeName.toLowerCase();
1414		return name === "input" && elem.type === type;
1415	};
1416}
1417
1418/**
1419 * Returns a function to use in pseudos for buttons
1420 * @param {String} type
1421 */
1422function createButtonPseudo( type ) {
1423	return function( elem ) {
1424		var name = elem.nodeName.toLowerCase();
1425		return (name === "input" || name === "button") && elem.type === type;
1426	};
1427}
1428
1429/**
1430 * Returns a function to use in pseudos for positionals
1431 * @param {Function} fn
1432 */
1433function createPositionalPseudo( fn ) {
1434	return markFunction(function( argument ) {
1435		argument = +argument;
1436		return markFunction(function( seed, matches ) {
1437			var j,
1438				matchIndexes = fn( [], seed.length, argument ),
1439				i = matchIndexes.length;
1440
1441			// Match elements found at the specified indexes
1442			while ( i-- ) {
1443				if ( seed[ (j = matchIndexes[i]) ] ) {
1444					seed[j] = !(matches[j] = seed[j]);
1445				}
1446			}
1447		});
1448	});
1449}
1450
1451/**
1452 * Checks a node for validity as a Sizzle context
1453 * @param {Element|Object=} context
1454 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1455 */
1456function testContext( context ) {
1457	return context && typeof context.getElementsByTagName !== "undefined" && context;
1458}
1459
1460// Expose support vars for convenience
1461support = Sizzle.support = {};
1462
1463/**
1464 * Detects XML nodes
1465 * @param {Element|Object} elem An element or a document
1466 * @returns {Boolean} True iff elem is a non-HTML XML node
1467 */
1468isXML = Sizzle.isXML = function( elem ) {
1469	// documentElement is verified for cases where it doesn't yet exist
1470	// (such as loading iframes in IE - #4833)
1471	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1472	return documentElement ? documentElement.nodeName !== "HTML" : false;

1473};
1474
1475/**
1476 * Sets document-related variables once based on the current document
1477 * @param {Element|Object} [doc] An element or document object to use to set the document
1478 * @returns {Object} Returns the current document
1479 */
1480setDocument = Sizzle.setDocument = function( node ) {
1481	var hasCompare, parent,
1482		doc = node ? node.ownerDocument || node : preferredDoc;
1483
1484	// If no document and documentElement is available, return
1485	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1486		return document;
1487	}
1488
1489	// Set our document
1490	document = doc;
1491	docElem = doc.documentElement;
1492	parent = doc.defaultView;
1493
1494	// Support: IE>8
1495	// If iframe document is assigned to "document" variable and if iframe has been reloaded,
1496	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
1497	// IE6-8 do not support the defaultView property so parent will be undefined
1498	if ( parent && parent !== parent.top ) {
1499		// IE11 does not have attachEvent, so all must suffer
1500		if ( parent.addEventListener ) {
1501			parent.addEventListener( "unload", unloadHandler, false );
1502		} else if ( parent.attachEvent ) {
1503			parent.attachEvent( "onunload", unloadHandler );
1504		}
1505	}
1506
1507	/* Support tests
1508	---------------------------------------------------------------------- */
1509	documentIsHTML = !isXML( doc );
1510
1511	/* Attributes
1512	---------------------------------------------------------------------- */
1513
1514	// Support: IE<8
1515	// Verify that getAttribute really returns attributes and not properties
1516	// (excepting IE8 booleans)
1517	support.attributes = assert(function( div ) {
1518		div.className = "i";
1519		return !div.getAttribute("className");
1520	});
1521
1522	/* getElement(s)By*
1523	---------------------------------------------------------------------- */
1524
1525	// Check if getElementsByTagName("*") returns only elements
1526	support.getElementsByTagName = assert(function( div ) {
1527		div.appendChild( doc.createComment("") );
1528		return !div.getElementsByTagName("*").length;
1529	});
1530
1531	// Support: IE<9
1532	support.getElementsByClassName = rnative.test( doc.getElementsByClassName );
1533
1534	// Support: IE<10
1535	// Check if getElementById returns elements by name
1536	// The broken getElementById methods don't pick up programatically-set names,
1537	// so use a roundabout getElementsByName test
1538	support.getById = assert(function( div ) {
1539		docElem.appendChild( div ).id = expando;
1540		return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
1541	});
1542
1543	// ID find and filter
1544	if ( support.getById ) {
1545		Expr.find["ID"] = function( id, context ) {
1546			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1547				var m = context.getElementById( id );
1548				// Check parentNode to catch when Blackberry 4.6 returns
1549				// nodes that are no longer in the document #6963
1550				return m && m.parentNode ? [ m ] : [];
1551			}
1552		};
1553		Expr.filter["ID"] = function( id ) {
1554			var attrId = id.replace( runescape, funescape );
1555			return function( elem ) {
1556				return elem.getAttribute("id") === attrId;
1557			};
1558		};
1559	} else {

1560		// Support: IE6/7
1561		// getElementById is not reliable as a find shortcut
1562		delete Expr.find["ID"];
1563
1564		Expr.filter["ID"] =  function( id ) {
1565			var attrId = id.replace( runescape, funescape );
1566			return function( elem ) {
1567				var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
1568				return node && node.value === attrId;
1569			};
1570		};
1571	}
1572
1573	// Tag
1574	Expr.find["TAG"] = support.getElementsByTagName ?
1575		function( tag, context ) {
1576			if ( typeof context.getElementsByTagName !== "undefined" ) {
1577				return context.getElementsByTagName( tag );
1578
1579			// DocumentFragment nodes don't have gEBTN
1580			} else if ( support.qsa ) {
1581				return context.querySelectorAll( tag );
1582			}
1583		} :
1584
1585		function( tag, context ) {
1586			var elem,
1587				tmp = [],
1588				i = 0,
1589				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1590				results = context.getElementsByTagName( tag );
1591
1592			// Filter out possible comments
1593			if ( tag === "*" ) {
1594				while ( (elem = results[i++]) ) {
1595					if ( elem.nodeType === 1 ) {
1596						tmp.push( elem );
1597					}
1598				}
1599
1600				return tmp;
1601			}
1602			return results;
1603		};
1604
1605	// Class
1606	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1607		if ( documentIsHTML ) {
1608			return context.getElementsByClassName( className );
1609		}
1610	};
1611
1612	/* QSA/matchesSelector
1613	---------------------------------------------------------------------- */
1614
1615	// QSA and matchesSelector support
1616
1617	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1618	rbuggyMatches = [];
1619
1620	// qSa(:focus) reports false when true (Chrome 21)
1621	// We allow this because of a bug in IE8/9 that throws an error
1622	// whenever `document.activeElement` is accessed on an iframe
1623	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1624	// See http://bugs.jquery.com/ticket/13378
1625	rbuggyQSA = [];
1626
1627	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1628		// Build QSA regex
1629		// Regex strategy adopted from Diego Perini
1630		assert(function( div ) {
1631			// Select is set to empty string on purpose
1632			// This is to test IE's treatment of not explicitly
1633			// setting a boolean content attribute,
1634			// since its presence should be enough
1635			// http://bugs.jquery.com/ticket/12359
1636			docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +
1637				"<select id='" + expando + "-\f]' msallowcapture=''>" +
1638				"<option selected=''></option></select>";
1639
1640			// Support: IE8, Opera 11-12.16
1641			// Nothing should be selected when empty strings follow ^= or $= or *=
1642			// The test attribute must be unknown in Opera but "safe" for WinRT
1643			// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1644			if ( div.querySelectorAll("[msallowcapture^='']").length ) {
1645				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1646			}
1647
1648			// Support: IE8
1649			// Boolean attributes and "value" are not treated correctly
1650			if ( !div.querySelectorAll("[selected]").length ) {
1651				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1652			}
1653
1654			// Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+
1655			if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1656				rbuggyQSA.push("~=");
1657			}
1658
1659			// Webkit/Opera - :checked should return selected option elements
1660			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1661			// IE8 throws error here and will not see later tests
1662			if ( !div.querySelectorAll(":checked").length ) {
1663				rbuggyQSA.push(":checked");
1664			}
1665
1666			// Support: Safari 8+, iOS 8+
1667			// https://bugs.webkit.org/show_bug.cgi?id=136851
1668			// In-page `selector#id sibing-combinator selector` fails
1669			if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
1670				rbuggyQSA.push(".#.+[+~]");
1671			}
1672		});
1673
1674		assert(function( div ) {
1675			// Support: Windows 8 Native Apps
1676			// The type and name attributes are restricted during .innerHTML assignment
1677			var input = doc.createElement("input");
1678			input.setAttribute( "type", "hidden" );
1679			div.appendChild( input ).setAttribute( "name", "D" );
1680
1681			// Support: IE8
1682			// Enforce case-sensitivity of name attribute
1683			if ( div.querySelectorAll("[name=d]").length ) {
1684				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1685			}
1686
1687			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1688			// IE8 throws error here and will not see later tests
1689			if ( !div.querySelectorAll(":enabled").length ) {
1690				rbuggyQSA.push( ":enabled", ":disabled" );
1691			}
1692

1693			// Opera 10-11 does not throw on post-comma invalid pseudos
1694			div.querySelectorAll("*,:x");
1695			rbuggyQSA.push(",.*:");
1696		});
1697	}
1698
1699	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1700		docElem.webkitMatchesSelector ||
1701		docElem.mozMatchesSelector ||
1702		docElem.oMatchesSelector ||
1703		docElem.msMatchesSelector) )) ) {
1704
1705		assert(function( div ) {
1706			// Check to see if it's possible to do matchesSelector
1707			// on a disconnected node (IE 9)
1708			support.disconnectedMatch = matches.call( div, "div" );
1709
1710			// This should fail with an exception
1711			// Gecko does not error, returns false instead
1712			matches.call( div, "[s!='']:x" );
1713			rbuggyMatches.push( "!=", pseudos );
1714		});
1715	}
1716
1717	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1718	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1719
1720	/* Contains
1721	---------------------------------------------------------------------- */
1722	hasCompare = rnative.test( docElem.compareDocumentPosition );
1723
1724	// Element contains another
1725	// Purposefully does not implement inclusive descendent
1726	// As in, an element does not contain itself
1727	contains = hasCompare || rnative.test( docElem.contains ) ?
1728		function( a, b ) {
1729			var adown = a.nodeType === 9 ? a.documentElement : a,
1730				bup = b && b.parentNode;
1731			return a === bup || !!( bup && bup.nodeType === 1 && (
1732				adown.contains ?
1733					adown.contains( bup ) :
1734					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1735			));
1736		} :
1737		function( a, b ) {
1738			if ( b ) {
1739				while ( (b = b.parentNode) ) {
1740					if ( b === a ) {
1741						return true;
1742					}
1743				}
1744			}
1745			return false;
1746		};
1747
1748	/* Sorting
1749	---------------------------------------------------------------------- */
1750
1751	// Document order sorting
1752	sortOrder = hasCompare ?
1753	function( a, b ) {
1754
1755		// Flag for duplicate removal
1756		if ( a === b ) {
1757			hasDuplicate = true;
1758			return 0;
1759		}
1760
1761		// Sort on method existence if only one input has compareDocumentPosition
1762		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1763		if ( compare ) {
1764			return compare;
1765		}
1766
1767		// Calculate position if both inputs belong to the same document
1768		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1769			a.compareDocumentPosition( b ) :
1770
1771			// Otherwise we know they are disconnected
1772			1;
1773
1774		// Disconnected nodes
1775		if ( compare & 1 ||
1776			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1777
1778			// Choose the first element that is related to our preferred document
1779			if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1780				return -1;
1781			}
1782			if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1783				return 1;
1784			}
1785
1786			// Maintain original order
1787			return sortInput ?
1788				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1789				0;
1790		}
1791
1792		return compare & 4 ? -1 : 1;
1793	} :
1794	function( a, b ) {
1795		// Exit early if the nodes are identical
1796		if ( a === b ) {
1797			hasDuplicate = true;
1798			return 0;
1799		}
1800
1801		var cur,
1802			i = 0,
1803			aup = a.parentNode,
1804			bup = b.parentNode,
1805			ap = [ a ],
1806			bp = [ b ];
1807
1808		// Parentless nodes are either documents or disconnected
1809		if ( !aup || !bup ) {
1810			return a === doc ? -1 :
1811				b === doc ? 1 :
1812				aup ? -1 :
1813				bup ? 1 :
1814				sortInput ?
1815				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1816				0;
1817
1818		// If the nodes are siblings, we can do a quick check
1819		} else if ( aup === bup ) {
1820			return siblingCheck( a, b );
1821		}
1822
1823		// Otherwise we need full lists of their ancestors for comparison
1824		cur = a;
1825		while ( (cur = cur.parentNode) ) {
1826			ap.unshift( cur );
1827		}
1828		cur = b;
1829		while ( (cur = cur.parentNode) ) {
1830			bp.unshift( cur );
1831		}
1832
1833		// Walk down the tree looking for a discrepancy
1834		while ( ap[i] === bp[i] ) {
1835			i++;
1836		}
1837
1838		return i ?
1839			// Do a sibling check if the nodes have a common ancestor
1840			siblingCheck( ap[i], bp[i] ) :
1841
1842			// Otherwise nodes in our document sort first
1843			ap[i] === preferredDoc ? -1 :
1844			bp[i] === preferredDoc ? 1 :
1845			0;
1846	};
1847
1848	return doc;
1849};
1850
1851Sizzle.matches = function( expr, elements ) {
1852	return Sizzle( expr, null, null, elements );
1853};
1854
1855Sizzle.matchesSelector = function( elem, expr ) {
1856	// Set document vars if needed
1857	if ( ( elem.ownerDocument || elem ) !== document ) {
1858		setDocument( elem );
1859	}
1860
1861	// Make sure that attribute selectors are quoted
1862	expr = expr.replace( rattributeQuotes, "='$1']" );
1863
1864	if ( support.matchesSelector && documentIsHTML &&
1865		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1866		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1867
1868		try {
1869			var ret = matches.call( elem, expr );
1870
1871			// IE 9's matchesSelector returns false on disconnected nodes
1872			if ( ret || support.disconnectedMatch ||
1873					// As well, disconnected nodes are said to be in a document
1874					// fragment in IE 9
1875					elem.document && elem.document.nodeType !== 11 ) {
1876				return ret;
1877			}
1878		} catch (e) {}
1879	}
1880
1881	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1882};
1883
1884Sizzle.contains = function( context, elem ) {
1885	// Set document vars if needed
1886	if ( ( context.ownerDocument || context ) !== document ) {
1887		setDocument( context );
1888	}
1889	return contains( context, elem );
1890};
1891
1892Sizzle.attr = function( elem, name ) {
1893	// Set document vars if needed
1894	if ( ( elem.ownerDocument || elem ) !== document ) {
1895		setDocument( elem );
1896	}
1897
1898	var fn = Expr.attrHandle[ name.toLowerCase() ],
1899		// Don't get fooled by Object.prototype properties (jQuery #13807)
1900		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1901			fn( elem, name, !documentIsHTML ) :
1902			undefined;
1903
1904	return val !== undefined ?
1905		val :
1906		support.attributes || !documentIsHTML ?
1907			elem.getAttribute( name ) :
1908			(val = elem.getAttributeNode(name)) && val.specified ?
1909				val.value :
1910				null;
1911};
1912
1913Sizzle.error = function( msg ) {
1914	throw new Error( "Syntax error, unrecognized expression: " + msg );
1915};
1916
1917/**
1918 * Document sorting and removing duplicates
1919 * @param {ArrayLike} results
1920 */
1921Sizzle.uniqueSort = function( results ) {
1922	var elem,
1923		duplicates = [],
1924		j = 0,
1925		i = 0;
1926
1927	// Unless we *know* we can detect duplicates, assume their presence
1928	hasDuplicate = !support.detectDuplicates;
1929	sortInput = !support.sortStable && results.slice( 0 );
1930	results.sort( sortOrder );
1931
1932	if ( hasDuplicate ) {
1933		while ( (elem = results[i++]) ) {
1934			if ( elem === results[ i ] ) {
1935				j = duplicates.push( i );
1936			}
1937		}
1938		while ( j-- ) {
1939			results.splice( duplicates[ j ], 1 );
1940		}
1941	}
1942
1943	// Clear input after sorting to release objects
1944	// See https://github.com/jquery/sizzle/pull/225
1945	sortInput = null;
1946
1947	return results;
1948};
1949
1950/**
1951 * Utility function for retrieving the text value of an array of DOM nodes
1952 * @param {Array|Element} elem
1953 */
1954getText = Sizzle.getText = function( elem ) {
1955	var node,
1956		ret = "",
1957		i = 0,
1958		nodeType = elem.nodeType;
1959
1960	if ( !nodeType ) {
1961		// If no nodeType, this is expected to be an array
1962		while ( (node = elem[i++]) ) {

1963			// Do not traverse comment nodes
1964			ret += getText( node );
1965		}
1966	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1967		// Use textContent for elements
1968		// innerText usage removed for consistency of new lines (jQuery #11153)
1969		if ( typeof elem.textContent === "string" ) {
1970			return elem.textContent;
1971		} else {
1972			// Traverse its children
1973			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1974				ret += getText( elem );
1975			}
1976		}
1977	} else if ( nodeType === 3 || nodeType === 4 ) {
1978		return elem.nodeValue;
1979	}
1980	// Do not include comment or processing instruction nodes
1981
1982	return ret;
1983};
1984
1985Expr = Sizzle.selectors = {
1986
1987	// Can be adjusted by the user
1988	cacheLength: 50,
1989
1990	createPseudo: markFunction,
1991
1992	match: matchExpr,
1993
1994	attrHandle: {},
1995
1996	find: {},
1997
1998	relative: {
1999		">": { dir: "parentNode", first: true },
2000		" ": { dir: "parentNode" },
2001		"+": { dir: "previousSibling", first: true },
2002		"~": { dir: "previousSibling" }
2003	},
2004
2005	preFilter: {
2006		"ATTR": function( match ) {
2007			match[1] = match[1].replace( runescape, funescape );
2008
2009			// Move the given value to match[3] whether quoted or unquoted
2010			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
2011
2012			if ( match[2] === "~=" ) {
2013				match[3] = " " + match[3] + " ";
2014			}
2015
2016			return match.slice( 0, 4 );
2017		},
2018
2019		"CHILD": function( match ) {
2020			/* matches from matchExpr["CHILD"]
2021				1 type (only|nth|...)
2022				2 what (child|of-type)
2023				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
2024				4 xn-component of xn+y argument ([+-]?\d*n|)
2025				5 sign of xn-component
2026				6 x of xn-component
2027				7 sign of y-component
2028				8 y of y-component
2029			*/
2030			match[1] = match[1].toLowerCase();
2031
2032			if ( match[1].slice( 0, 3 ) === "nth" ) {
2033				// nth-* requires argument
2034				if ( !match[3] ) {
2035					Sizzle.error( match[0] );
2036				}
2037
2038				// numeric x and y parameters for Expr.filter.CHILD
2039				// remember that false/true cast respectively to 0/1
2040				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
2041				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
2042
2043			// other types prohibit arguments
2044			} else if ( match[3] ) {
2045				Sizzle.error( match[0] );
2046			}
2047
2048			return match;
2049		},
2050
2051		"PSEUDO": function( match ) {
2052			var excess,
2053				unquoted = !match[6] && match[2];
2054
2055			if ( matchExpr["CHILD"].test( match[0] ) ) {
2056				return null;
2057			}
2058
2059			// Accept quoted arguments as-is
2060			if ( match[3] ) {
2061				match[2] = match[4] || match[5] || "";
2062
2063			// Strip excess characters from unquoted arguments
2064			} else if ( unquoted && rpseudo.test( unquoted ) &&
2065				// Get excess from tokenize (recursively)
2066				(excess = tokenize( unquoted, true )) &&
2067				// advance to the next closing parenthesis
2068				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
2069
2070				// excess is a negative index
2071				match[0] = match[0].slice( 0, excess );
2072				match[2] = unquoted.slice( 0, excess );
2073			}
2074
2075			// Return only captures needed by the pseudo filter method (type and argument)
2076			return match.slice( 0, 3 );
2077		}
2078	},
2079
2080	filter: {
2081
2082		"TAG": function( nodeNameSelector ) {
2083			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
2084			return nodeNameSelector === "*" ?
2085				function() { return true; } :
2086				function( elem ) {
2087					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
2088				};
2089		},
2090
2091		"CLASS": function( className ) {
2092			var pattern = classCache[ className + " " ];
2093
2094			return pattern ||
2095				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
2096				classCache( className, function( elem ) {
2097					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
2098				});
2099		},
2100
2101		"ATTR": function( name, operator, check ) {
2102			return function( elem ) {
2103				var result = Sizzle.attr( elem, name );
2104
2105				if ( result == null ) {
2106					return operator === "!=";
2107				}
2108				if ( !operator ) {
2109					return true;
2110				}
2111
2112				result += "";
2113
2114				return operator === "=" ? result === check :
2115					operator === "!=" ? result !== check :

2116					operator === "^=" ? check && result.indexOf( check ) === 0 :
2117					operator === "*=" ? check && result.indexOf( check ) > -1 :
2118					operator === "$=" ? check && result.slice( -check.length ) === check :
2119					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
2120					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
2121					false;
2122			};
2123		},
2124
2125		"CHILD": function( type, what, argument, first, last ) {
2126			var simple = type.slice( 0, 3 ) !== "nth",
2127				forward = type.slice( -4 ) !== "last",
2128				ofType = what === "of-type";
2129
2130			return first === 1 && last === 0 ?
2131
2132				// Shortcut for :nth-*(n)
2133				function( elem ) {
2134					return !!elem.parentNode;
2135				} :
2136
2137				function( elem, context, xml ) {
2138					var cache, outerCache, node, diff, nodeIndex, start,
2139						dir = simple !== forward ? "nextSibling" : "previousSibling",
2140						parent = elem.parentNode,
2141						name = ofType && elem.nodeName.toLowerCase(),
2142						useCache = !xml && !ofType;
2143
2144					if ( parent ) {
2145
2146						// :(first|last|only)-(child|of-type)
2147						if ( simple ) {
2148							while ( dir ) {
2149								node = elem;
2150								while ( (node = node[ dir ]) ) {
2151									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
2152										return false;
2153									}
2154								}
2155								// Reverse direction for :only-* (if we haven't yet done so)
2156								start = dir = type === "only" && !start && "nextSibling";
2157							}
2158							return true;
2159						}
2160
2161						start = [ forward ? parent.firstChild : parent.lastChild ];
2162
2163						// non-xml :nth-child(...) stores cache data on `parent`
2164						if ( forward && useCache ) {
2165							// Seek `elem` from a previously-cached index
2166							outerCache = parent[ expando ] || (parent[ expando ] = {});
2167							cache = outerCache[ type ] || [];
2168							nodeIndex = cache[0] === dirruns && cache[1];
2169							diff = cache[0] === dirruns && cache[2];
2170							node = nodeIndex && parent.childNodes[ nodeIndex ];
2171
2172							while ( (node = ++nodeIndex && node && node[ dir ] ||
2173
2174								// Fallback to seeking `elem` from the start
2175								(diff = nodeIndex = 0) || start.pop()) ) {
2176
2177								// When found, cache indexes on `parent` and break
2178								if ( node.nodeType === 1 && ++diff && node === elem ) {
2179									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
2180									break;
2181								}
2182							}
2183
2184						// Use previously-cached element index if available
2185						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
2186							diff = cache[1];
2187
2188						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
2189						} else {
2190							// Use the same loop as above to seek `elem` from the start
2191							while ( (node = ++nodeIndex && node && node[ dir ] ||
2192								(diff = nodeIndex = 0) || start.pop()) ) {
2193
2194								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
2195									// Cache the index of each encountered element
2196									if ( useCache ) {
2197										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
2198									}
2199
2200									if ( node === elem ) {
2201										break;
2202									}
2203								}
2204							}
2205						}
2206
2207						// Incorporate the offset, then check against cycle size
2208						diff -= last;
2209						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2210					}
2211				};
2212		},
2213
2214		"PSEUDO": function( pseudo, argument ) {
2215			// pseudo-class names are case-insensitive
2216			// http://www.w3.org/TR/selectors/#pseudo-classes
2217			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2218			// Remember that setFilters inherits from pseudos
2219			var args,
2220				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2221					Sizzle.error( "unsupported pseudo: " + pseudo );
2222
2223			// The user may use createPseudo to indicate that
2224			// arguments are needed to create the filter function
2225			// just as Sizzle does
2226			if ( fn[ expando ] ) {
2227				return fn( argument );
2228			}
2229
2230			// But maintain support for old signatures
2231			if ( fn.length > 1 ) {
2232				args = [ pseudo, pseudo, "", argument ];
2233				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2234					markFunction(function( seed, matches ) {
2235						var idx,
2236							matched = fn( seed, argument ),
2237							i = matched.length;
2238						while ( i-- ) {
2239							idx = indexOf( seed, matched[i] );
2240							seed[ idx ] = !( matches[ idx ] = matched[i] );
2241						}
2242					}) :
2243					function( elem ) {
2244						return fn( elem, 0, args );
2245					};
2246			}
2247
2248			return fn;
2249		}
2250	},
2251
2252	pseudos: {
2253		// Potentially complex pseudos
2254		"not": markFunction(function( selector ) {
2255			// Trim the selector passed to compile
2256			// to avoid treating leading and trailing
2257			// spaces as combinators
2258			var input = [],
2259				results = [],
2260				matcher = compile( selector.replace( rtrim, "$1" ) );
2261
2262			return matcher[ expando ] ?
2263				markFunction(function( seed, matches, context, xml ) {
2264					var elem,
2265						unmatched = matcher( seed, null, xml, [] ),
2266						i = seed.length;
2267
2268					// Match elements unmatched by `matcher`
2269					while ( i-- ) {
2270						if ( (elem = unmatched[i]) ) {
2271							seed[i] = !(matches[i] = elem);
2272						}
2273					}
2274				}) :
2275				function( elem, context, xml ) {
2276					input[0] = elem;
2277					matcher( input, null, xml, results );
2278					// Don't keep the element (issue #299)
2279					input[0] = null;
2280					return !results.pop();
2281				};
2282		}),
2283
2284		"has": markFunction(function( selector ) {
2285			return function( elem ) {
2286				return Sizzle( selector, elem ).length > 0;
2287			};
2288		}),
2289
2290		"contains": markFunction(function( text ) {
2291			text = text.replace( runescape, funescape );
2292			return function( elem ) {
2293				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2294			};
2295		}),
2296
2297		// "Whether an element is represented by a :lang() selector
2298		// is based solely on the element's language value
2299		// being equal to the identifier C,
2300		// or beginning with the identifier C immediately followed by "-".
2301		// The matching of C against the element's language value is performed case-insensitively.
2302		// The identifier C does not have to be a valid language name."
2303		// http://www.w3.org/TR/selectors/#lang-pseudo
2304		"lang": markFunction( function( lang ) {
2305			// lang value must be a valid identifier
2306			if ( !ridentifier.test(lang || "") ) {
2307				Sizzle.error( "unsupported lang: " + lang );
2308			}
2309			lang = lang.replace( runescape, funescape ).toLowerCase();
2310			return function( elem ) {
2311				var elemLang;
2312				do {
2313					if ( (elemLang = documentIsHTML ?
2314						elem.lang :
2315						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2316
2317						elemLang = elemLang.toLowerCase();
2318						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2319					}
2320				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2321				return false;

2322			};
2323		}),
2324
2325		// Miscellaneous
2326		"target": function( elem ) {
2327			var hash = window.location && window.location.hash;
2328			return hash && hash.slice( 1 ) === elem.id;
2329		},
2330
2331		"root": function( elem ) {
2332			return elem === docElem;
2333		},
2334
2335		"focus": function( elem ) {
2336			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2337		},
2338
2339		// Boolean properties
2340		"enabled": function( elem ) {
2341			return elem.disabled === false;
2342		},
2343
2344		"disabled": function( elem ) {
2345			return elem.disabled === true;
2346		},
2347
2348		"checked": function( elem ) {
2349			// In CSS3, :checked should return both checked and selected elements
2350			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2351			var nodeName = elem.nodeName.toLowerCase();
2352			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2353		},
2354
2355		"selected": function( elem ) {
2356			// Accessing this property makes selected-by-default
2357			// options in Safari work properly
2358			if ( elem.parentNode ) {
2359				elem.parentNode.selectedIndex;
2360			}
2361
2362			return elem.selected === true;
2363		},
2364
2365		// Contents
2366		"empty": function( elem ) {
2367			// http://www.w3.org/TR/selectors/#empty-pseudo
2368			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2369			//   but not by others (comment: 8; processing instruction: 7; etc.)
2370			// nodeType < 6 works because attributes (2) do not appear as children
2371			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2372				if ( elem.nodeType < 6 ) {
2373					return false;
2374				}
2375			}
2376			return true;
2377		},
2378
2379		"parent": function( elem ) {
2380			return !Expr.pseudos["empty"]( elem );
2381		},
2382
2383		// Element/input types
2384		"header": function( elem ) {
2385			return rheader.test( elem.nodeName );
2386		},
2387
2388		"input": function( elem ) {
2389			return rinputs.test( elem.nodeName );
2390		},
2391
2392		"button": function( elem ) {
2393			var name = elem.nodeName.toLowerCase();
2394			return name === "input" && elem.type === "button" || name === "button";
2395		},
2396
2397		"text": function( elem ) {
2398			var attr;
2399			return elem.nodeName.toLowerCase() === "input" &&
2400				elem.type === "text" &&
2401
2402				// Support: IE<8
2403				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2404				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
2405		},
2406
2407		// Position-in-collection
2408		"first": createPositionalPseudo(function() {
2409			return [ 0 ];
2410		}),
2411
2412		"last": createPositionalPseudo(function( matchIndexes, length ) {
2413			return [ length - 1 ];
2414		}),
2415
2416		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2417			return [ argument < 0 ? argument + length : argument ];
2418		}),
2419
2420		"even": createPositionalPseudo(function( matchIndexes, length ) {
2421			var i = 0;
2422			for ( ; i < length; i += 2 ) {
2423				matchIndexes.push( i );
2424			}
2425			return matchIndexes;
2426		}),
2427
2428		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2429			var i = 1;
2430			for ( ; i < length; i += 2 ) {
2431				matchIndexes.push( i );
2432			}
2433			return matchIndexes;
2434		}),
2435
2436		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2437			var i = argument < 0 ? argument + length : argument;
2438			for ( ; --i >= 0; ) {
2439				matchIndexes.push( i );
2440			}
2441			return matchIndexes;
2442		}),
2443
2444		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2445			var i = argument < 0 ? argument + length : argument;
2446			for ( ; ++i < length; ) {
2447				matchIndexes.push( i );
2448			}
2449			return matchIndexes;
2450		})
2451	}
2452};
2453
2454Expr.pseudos["nth"] = Expr.pseudos["eq"];
2455
2456// Add button/input type pseudos
2457for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2458	Expr.pseudos[ i ] = createInputPseudo( i );
2459}
2460for ( i in { submit: true, reset: true } ) {
2461	Expr.pseudos[ i ] = createButtonPseudo( i );
2462}
2463
2464// Easy API for creating new setFilters
2465function setFilters() {}
2466setFilters.prototype = Expr.filters = Expr.pseudos;
2467Expr.setFilters = new setFilters();
2468
2469tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2470	var matched, match, tokens, type,
2471		soFar, groups, preFilters,
2472		cached = tokenCache[ selector + " " ];
2473
2474	if ( cached ) {
2475		return parseOnly ? 0 : cached.slice( 0 );
2476	}
2477
2478	soFar = selector;
2479	groups = [];
2480	preFilters = Expr.preFilter;
2481
2482	while ( soFar ) {
2483
2484		// Comma and first run
2485		if ( !matched || (match = rcomma.exec( soFar )) ) {
2486			if ( match ) {
2487				// Don't consume trailing commas as valid
2488				soFar = soFar.slice( match[0].length ) || soFar;
2489			}
2490			groups.push( (tokens = []) );
2491		}
2492
2493		matched = false;

2494
2495		// Combinators
2496		if ( (match = rcombinators.exec( soFar )) ) {
2497			matched = match.shift();
2498			tokens.push({
2499				value: matched,
2500				// Cast descendant combinators to space
2501				type: match[0].replace( rtrim, " " )
2502			});
2503			soFar = soFar.slice( matched.length );
2504		}
2505
2506		// Filters
2507		for ( type in Expr.filter ) {
2508			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2509				(match = preFilters[ type ]( match ))) ) {
2510				matched = match.shift();
2511				tokens.push({
2512					value: matched,
2513					type: type,
2514					matches: match
2515				});
2516				soFar = soFar.slice( matched.length );
2517			}
2518		}
2519
2520		if ( !matched ) {
2521			break;
2522		}
2523	}
2524
2525	// Return the length of the invalid excess
2526	// if we're just parsing
2527	// Otherwise, throw an error or return tokens
2528	return parseOnly ?
2529		soFar.length :
2530		soFar ?
2531			Sizzle.error( selector ) :
2532			// Cache the tokens
2533			tokenCache( selector, groups ).slice( 0 );
2534};
2535
2536function toSelector( tokens ) {
2537	var i = 0,
2538		len = tokens.length,
2539		selector = "";
2540	for ( ; i < len; i++ ) {
2541		selector += tokens[i].value;
2542	}
2543	return selector;
2544}
2545
2546function addCombinator( matcher, combinator, base ) {
2547	var dir = combinator.dir,
2548		checkNonElements = base && dir === "parentNode",
2549		doneName = done++;
2550
2551	return combinator.first ?
2552		// Check against closest ancestor/preceding element
2553		function( elem, context, xml ) {
2554			while ( (elem = elem[ dir ]) ) {
2555				if ( elem.nodeType === 1 || checkNonElements ) {
2556					return matcher( elem, context, xml );
2557				}
2558			}
2559		} :
2560
2561		// Check against all ancestor/preceding elements
2562		function( elem, context, xml ) {
2563			var oldCache, outerCache,
2564				newCache = [ dirruns, doneName ];
2565
2566			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2567			if ( xml ) {
2568				while ( (elem = elem[ dir ]) ) {
2569					if ( elem.nodeType === 1 || checkNonElements ) {
2570						if ( matcher( elem, context, xml ) ) {
2571							return true;
2572						}
2573					}
2574				}
2575			} else {
2576				while ( (elem = elem[ dir ]) ) {
2577					if ( elem.nodeType === 1 || checkNonElements ) {
2578						outerCache = elem[ expando ] || (elem[ expando ] = {});
2579						if ( (oldCache = outerCache[ dir ]) &&
2580							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2581
2582							// Assign to newCache so results back-propagate to previous elements
2583							return (newCache[ 2 ] = oldCache[ 2 ]);
2584						} else {
2585							// Reuse newcache so results back-propagate to previous elements
2586							outerCache[ dir ] = newCache;
2587
2588							// A match means we're done; a fail means we have to keep checking
2589							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2590								return true;
2591							}
2592						}
2593					}
2594				}
2595			}
2596		};
2597}
2598
2599function elementMatcher( matchers ) {
2600	return matchers.length > 1 ?
2601		function( elem, context, xml ) {
2602			var i = matchers.length;
2603			while ( i-- ) {
2604				if ( !matchers[i]( elem, context, xml ) ) {
2605					return false;
2606				}
2607			}
2608			return true;
2609		} :
2610		matchers[0];
2611}
2612
2613function multipleContexts( selector, contexts, results ) {
2614	var i = 0,
2615		len = contexts.length;
2616	for ( ; i < len; i++ ) {
2617		Sizzle( selector, contexts[i], results );
2618	}
2619	return results;
2620}
2621
2622function condense( unmatched, map, filter, context, xml ) {
2623	var elem,
2624		newUnmatched = [],
2625		i = 0,
2626		len = unmatched.length,
2627		mapped = map != null;
2628
2629	for ( ; i < len; i++ ) {
2630		if ( (elem = unmatched[i]) ) {
2631			if ( !filter || filter( elem, context, xml ) ) {
2632				newUnmatched.push( elem );
2633				if ( mapped ) {
2634					map.push( i );
2635				}
2636			}
2637		}
2638	}
2639
2640	return newUnmatched;
2641}
2642
2643function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2644	if ( postFilter && !postFilter[ expando ] ) {
2645		postFilter = setMatcher( postFilter );
2646	}
2647	if ( postFinder && !postFinder[ expando ] ) {
2648		postFinder = setMatcher( postFinder, postSelector );
2649	}
2650	return markFunction(function( seed, results, context, xml ) {
2651		var temp, i, elem,
2652			preMap = [],
2653			postMap = [],
2654			preexisting = results.length,
2655
2656			// Get initial elements from seed or context
2657			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2658
2659			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2660			matcherIn = preFilter && ( seed || !selector ) ?
2661				condense( elems, preMap, preFilter, context, xml ) :
2662				elems,
2663
2664			matcherOut = matcher ?
2665				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2666				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2667
2668					// ...intermediate processing is necessary
2669					[] :
2670
2671					// ...otherwise use results directly
2672					results :
2673				matcherIn;
2674
2675		// Find primary matches
2676		if ( matcher ) {
2677			matcher( matcherIn, matcherOut, context, xml );
2678		}
2679
2680		// Apply postFilter
2681		if ( postFilter ) {
2682			temp = condense( matcherOut, postMap );
2683			postFilter( temp, [], context, xml );
2684
2685			// Un-match failing elements by moving them back to matcherIn
2686			i = temp.length;
2687			while ( i-- ) {
2688				if ( (elem = temp[i]) ) {
2689					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2690				}
2691			}
2692		}
2693
2694		if ( seed ) {
2695			if ( postFinder || preFilter ) {
2696				if ( postFinder ) {
2697					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2698					temp = [];
2699					i = matcherOut.length;
2700					while ( i-- ) {
2701						if ( (elem = matcherOut[i]) ) {
2702							// Restore matcherIn since elem is not yet a final match
2703							temp.push( (matcherIn[i] = elem) );
2704						}
2705					}
2706					postFinder( null, (matcherOut = []), temp, xml );
2707				}
2708
2709				// Move matched elements from seed to results to keep them synchronized
2710				i = matcherOut.length;
2711				while ( i-- ) {
2712					if ( (elem = matcherOut[i]) &&
2713						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2714
2715						seed[temp] = !(results[temp] = elem);
2716					}
2717				}
2718			}
2719
2720		// Add elements to results, through postFinder if defined
2721		} else {
2722			matcherOut = condense(
2723				matcherOut === results ?
2724					matcherOut.splice( preexisting, matcherOut.length ) :
2725					matcherOut
2726			);
2727			if ( postFinder ) {
2728				postFinder( null, results, matcherOut, xml );
2729			} else {
2730				push.apply( results, matcherOut );
2731			}
2732		}
2733	});
2734}
2735
2736function matcherFromTokens( tokens ) {
2737	var checkContext, matcher, j,
2738		len = tokens.length,
2739		leadingRelative = Expr.relative[ tokens[0].type ],
2740		implicitRelative = leadingRelative || Expr.relative[" "],
2741		i = leadingRelative ? 1 : 0,
2742
2743		// The foundational matcher ensures that elements are reachable from top-level context(s)
2744		matchContext = addCombinator( function( elem ) {
2745			return elem === checkContext;
2746		}, implicitRelative, true ),
2747		matchAnyContext = addCombinator( function( elem ) {
2748			return indexOf( checkContext, elem ) > -1;
2749		}, implicitRelative, true ),
2750		matchers = [ function( elem, context, xml ) {
2751			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2752				(checkContext = context).nodeType ?
2753					matchContext( elem, context, xml ) :
2754					matchAnyContext( elem, context, xml ) );
2755			// Avoid hanging onto element (issue #299)
2756			checkContext = null;
2757			return ret;
2758		} ];
2759
2760	for ( ; i < len; i++ ) {
2761		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2762			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2763		} else {
2764			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2765
2766			// Return special upon seeing a positional matcher
2767			if ( matcher[ expando ] ) {
2768				// Find the next relative operator (if any) for proper handling
2769				j = ++i;
2770				for ( ; j < len; j++ ) {
2771					if ( Expr.relative[ tokens[j].type ] ) {
2772						break;
2773					}
2774				}
2775				return setMatcher(
2776					i > 1 && elementMatcher( matchers ),
2777					i > 1 && toSelector(
2778						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2779						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2780					).replace( rtrim, "$1" ),
2781					matcher,
2782					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2783					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2784					j < len && toSelector( tokens )
2785				);
2786			}
2787			matchers.push( matcher );
2788		}
2789	}
2790
2791	return elementMatcher( matchers );
2792}
2793
2794function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2795	var bySet = setMatchers.length > 0,
2796		byElement = elementMatchers.length > 0,
2797		superMatcher = function( seed, context, xml, results, outermost ) {
2798			var elem, j, matcher,
2799				matchedCount = 0,
2800				i = "0",
2801				unmatched = seed && [],
2802				setMatched = [],
2803				contextBackup = outermostContext,
2804				// We must always have either seed elements or outermost context
2805				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2806				// Use integer dirruns iff this is the outermost matcher
2807				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2808				len = elems.length;
2809
2810			if ( outermost ) {
2811				outermostContext = context !== document && context;
2812			}
2813
2814			// Add elements passing elementMatchers directly to results
2815			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2816			// Support: IE<9, Safari
2817			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2818			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2819				if ( byElement && elem ) {
2820					j = 0;
2821					while ( (matcher = elementMatchers[j++]) ) {
2822						if ( matcher( elem, context, xml ) ) {
2823							results.push( elem );
2824							break;
2825						}
2826					}
2827					if ( outermost ) {
2828						dirruns = dirrunsUnique;
2829					}
2830				}
2831
2832				// Track unmatched elements for set filters
2833				if ( bySet ) {
2834					// They will have gone through all possible matchers
2835					if ( (elem = !matcher && elem) ) {
2836						matchedCount--;
2837					}
2838
2839					// Lengthen the array for every element, matched or not
2840					if ( seed ) {
2841						unmatched.push( elem );
2842					}
2843				}
2844			}
2845
2846			// Apply set filters to unmatched elements
2847			matchedCount += i;
2848			if ( bySet && i !== matchedCount ) {
2849				j = 0;
2850				while ( (matcher = setMatchers[j++]) ) {
2851					matcher( unmatched, setMatched, context, xml );
2852				}
2853
2854				if ( seed ) {
2855					// Reintegrate element matches to eliminate the need for sorting
2856					if ( matchedCount > 0 ) {
2857						while ( i-- ) {
2858							if ( !(unmatched[i] || setMatched[i]) ) {
2859								setMatched[i] = pop.call( results );
2860							}
2861						}
2862					}
2863
2864					// Discard index placeholder values to get only actual matches
2865					setMatched = condense( setMatched );
2866				}
2867
2868				// Add matches to results
2869				push.apply( results, setMatched );
2870
2871				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2872				if ( outermost && !seed && setMatched.length > 0 &&
2873					( matchedCount + setMatchers.length ) > 1 ) {
2874
2875					Sizzle.uniqueSort( results );
2876				}
2877			}
2878
2879			// Override manipulation of globals by nested matchers
2880			if ( outermost ) {
2881				dirruns = dirrunsUnique;
2882				outermostContext = contextBackup;
2883			}
2884
2885			return unmatched;
2886		};
2887
2888	return bySet ?
2889		markFunction( superMatcher ) :
2890		superMatcher;
2891}
2892
2893compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2894	var i,
2895		setMatchers = [],
2896		elementMatchers = [],
2897		cached = compilerCache[ selector + " " ];
2898
2899	if ( !cached ) {
2900		// Generate a function of recursive functions that can be used to check each element
2901		if ( !match ) {
2902			match = tokenize( selector );
2903		}
2904		i = match.length;
2905		while ( i-- ) {
2906			cached = matcherFromTokens( match[i] );
2907			if ( cached[ expando ] ) {
2908				setMatchers.push( cached );
2909			} else {
2910				elementMatchers.push( cached );
2911			}
2912		}
2913
2914		// Cache the compiled function
2915		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2916
2917		// Save selector and tokenization
2918		cached.selector = selector;
2919	}
2920	return cached;
2921};
2922
2923/**
2924 * A low-level selection function that works with Sizzle's compiled
2925 *  selector functions
2926 * @param {String|Function} selector A selector or a pre-compiled
2927 *  selector function built with Sizzle.compile
2928 * @param {Element} context
2929 * @param {Array} [results]
2930 * @param {Array} [seed] A set of elements to match against
2931 */
2932select = Sizzle.select = function( selector, context, results, seed ) {
2933	var i, tokens, token, type, find,
2934		compiled = typeof selector === "function" && selector,
2935		match = !seed && tokenize( (selector = compiled.selector || selector) );
2936
2937	results = results || [];
2938
2939	// Try to minimize operations if there is no seed and only one group
2940	if ( match.length === 1 ) {
2941
2942		// Take a shortcut and set the context if the root selector is an ID
2943		tokens = match[0] = match[0].slice( 0 );
2944		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2945				support.getById && context.nodeType === 9 && documentIsHTML &&
2946				Expr.relative[ tokens[1].type ] ) {
2947
2948			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2949			if ( !context ) {
2950				return results;
2951
2952			// Precompiled matchers will still verify ancestry, so step up a level
2953			} else if ( compiled ) {
2954				context = context.parentNode;
2955			}
2956
2957			selector = selector.slice( tokens.shift().value.length );
2958		}
2959
2960		// Fetch a seed set for right-to-left matching
2961		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2962		while ( i-- ) {
2963			token = tokens[i];
2964
2965			// Abort if we hit a combinator
2966			if ( Expr.relative[ (type = token.type) ] ) {
2967				break;
2968			}
2969			if ( (find = Expr.find[ type ]) ) {
2970				// Search, expanding context for leading sibling combinators
2971				if ( (seed = find(
2972					token.matches[0].replace( runescape, funescape ),