https://www.10mileroadrace.org/fend/js/functions_js.asp?article_id=1

32// e.g. var jQuery = require("jquery")(window);
33// See ticket #14549 for more info.
34module.exports = global.document ?
35factory(global, true) :
36function (w) {
37if (!w.document) {
38throw new Error("jQuery requires a window with a document");
39}
40return factory(w);
41};
42} else {
43factory(global);
44}
45
46// Pass this if window is not defined yet
47}(typeof window !== "undefined" ? window : this, function (window, noGlobal) {
48
49// Support: Firefox 18+
50// Can't be in strict mode, several libs including ASP.NET trace
51// the stack via arguments.caller.callee and Firefox dies if
52// you try to trace through "use strict" call chains. (#13335)
53//"use strict";
54var arr = [];
55
56var document = window.document;
57
58var slice = arr.slice;
59
60var concat = arr.concat;
61
62var push = arr.push;
63
64var indexOf = arr.indexOf;
65
66var class2type = {};
67
68var toString = class2type.toString;
69
70var hasOwn = class2type.hasOwnProperty;
71
72var support = {};
73
74
75
76var
77version = "2.2.4",
78
79// Define a local copy of jQuery
80jQuery = function (selector, context) {
81
82// The jQuery object is actually just the init constructor 'enhanced'
83// Need init if jQuery is called (just allow error to be thrown if not included)
84return new jQuery.fn.init(selector, context);
85},
86
87// Support: Android<4.1
88// Make sure we trim BOM and NBSP
89rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
90
91// Matches dashed string for camelizing
92rmsPrefix = /^-ms-/,
93rdashAlpha = /-([\da-z])/gi,
94
95// Used by jQuery.camelCase as callback to replace()
96fcamelCase = function (all, letter) {
97return letter.toUpperCase();
98};
99
100jQuery.fn = jQuery.prototype = {
101
102// The current version of jQuery being used
103jquery: version,
104
105constructor: jQuery,
106
107// Start with an empty selector
108selector: "",
109
110// The default length of a jQuery object is 0
111length: 0,
112
113toArray: function () {
114return slice.call(this);
115},
116
117// Get the Nth element in the matched element set OR
118// Get the whole matched element set as a clean array
119get: function (num) {
120return num != null ?
121
122// Return just the one element from the set
123(num < 0 ? this[num + this.length] : this[num]) :
124
125// Return all the elements in a clean array
126slice.call(this);
127},
128
129// Take an array of elements and push it onto the stack
130// (returning the new matched element set)
131pushStack: function (elems) {
132
133// Build a new jQuery matched element set
134var ret = jQuery.merge(this.constructor(), elems);
135
136// Add the old object onto the stack (as a reference)
137ret.prevObject = this;
138ret.context = this.context;
139
140// Return the newly-formed element set
141return ret;
142},
143
144// Execute a callback for every element in the matched set.
145each: function (callback) {
146return jQuery.each(this, callback);
147},
148
149map: function (callback) {
150return this.pushStack(jQuery.map(this, function (elem, i) {
151return callback.call(elem, i, elem);
152}));
153},
154
155slice: function () {
156return this.pushStack(slice.apply(this, arguments));
157},
158
159first: function () {
160return this.eq(0);
161},
162
163last: function () {
164return this.eq(-1);
165},
166
167eq: function (i) {
168var len = this.length,
169j = +i + (i < 0 ? len : 0);
170return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
171},
172
173end: function () {
174return this.prevObject || this.constructor();
175},
176
177// For internal use only.
178// Behaves like an Array's method, not like a jQuery method.
179push: push,
180sort: arr.sort,
181splice: arr.splice
182};
183
184jQuery.extend = jQuery.fn.extend = function () {
185var options, name, src, copy, copyIsArray, clone,
186target = arguments[0] || {},
187i = 1,
188length = arguments.length,
189deep = false;
190
191// Handle a deep copy situation
192if (typeof target === "boolean") {
193deep = target;
194
195// Skip the boolean and the target
196target = arguments[i] || {};
197i++;
198}
199
200// Handle case when target is a string or something (possible in deep copy)
201if (typeof target !== "object" && !jQuery.isFunction(target)) {
202target = {};
203}
204
205// Extend jQuery itself if only one argument is passed
206if (i === length) {
207target = this;
208i--;
209}
210
211for (; i < length; i++) {
212
213// Only deal with non-null/undefined values
214if ((options = arguments[i]) != null) {
215
216// Extend the base object
217for (name in options) {
218src = target[name];
219copy = options[name];
220
221// Prevent never-ending loop
222if (target === copy) {
223continue;
224}
225
226// Recurse if we're merging plain objects or arrays
227if (deep && copy && (jQuery.isPlainObject(copy) ||
228(copyIsArray = jQuery.isArray(copy)))) {
229
230if (copyIsArray) {
231copyIsArray = false;
232clone = src && jQuery.isArray(src) ? src : [];
233
234} else {
235clone = src && jQuery.isPlainObject(src) ? src : {};
236}
237
238// Never move original objects, clone them
239target[name] = jQuery.extend(deep, clone, copy);
240
241// Don't bring in undefined values
242} else if (copy !== undefined) {
243target[name] = copy;
244}
245}
246}
247}
248
249// Return the modified object
250return target;
251};
252
253jQuery.extend({
254
255// Unique for each copy of jQuery on the page
256expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),
257
258// Assume jQuery is ready without the ready module
259isReady: true,
260
261error: function (msg) {
262throw new Error(msg);
263},
264
265noop: function () { },
266
267isFunction: function (obj) {
268return jQuery.type(obj) === "function";
269},
270
271isArray: Array.isArray,
272
273isWindow: function (obj) {
274return obj != null && obj === obj.window;
275},
276
277isNumeric: function (obj) {
278
279// parseFloat NaNs numeric-cast false positives (null|true|false|"")
280// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
281// subtraction forces infinities to NaN
282// adding 1 corrects loss of precision from parseFloat (#15100)
283var realStringObj = obj && obj.toString();
284return !jQuery.isArray(obj) && (realStringObj - parseFloat(realStringObj) + 1) >= 0;
285},
286
287isPlainObject: function (obj) {
288var key;
289
290// Not plain objects:
291// - Any object or value whose internal [[Class]] property is not "[object Object]"
292// - DOM nodes
293// - window
294if (jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow(obj)) {
295return false;
296}
297
298// Not own constructor property must be Object
299if (obj.constructor &&
300!hasOwn.call(obj, "constructor") &&
301!hasOwn.call(obj.constructor.prototype || {}, "isPrototypeOf")) {
302return false;
303}
304
305// Own properties are enumerated firstly, so to speed up,
306// if last one is own, then all properties are own
307for (key in obj) { }
308
309return key === undefined || hasOwn.call(obj, key);
310},
311
312isEmptyObject: function (obj) {
313var name;
314for (name in obj) {
315return false;
316}
317return true;
318},
319
320type: function (obj) {
321if (obj == null) {
322return obj + "";
323}
324
325// Support: Android<4.0, iOS<6 (functionish RegExp)
326return typeof obj === "object" || typeof obj === "function" ?
327class2type[toString.call(obj)] || "object" :
328typeof obj;
329},
330
331// Evaluates a script in a global context
332globalEval: function (code) {
333var script,
334indirect = eval;
335
336code = jQuery.trim(code);
337
338if (code) {
339
340// If the code includes a valid, prologue position
341// strict mode pragma, execute code by injecting a
342// script tag into the document.
343if (code.indexOf("use strict") === 1) {
344script = document.createElement("script");
345script.text = code;
346document.head.appendChild(script).parentNode.removeChild(script);
347} else {
348
349// Otherwise, avoid the DOM node creation, insertion
350// and removal by using an indirect global eval
351
352indirect(code);
353}
354}
355},
356
357// Convert dashed to camelCase; used by the css and data modules
358// Support: IE9-11+
359// Microsoft forgot to hump their vendor prefix (#9572)
360camelCase: function (string) {
361return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
362},
363
364nodeName: function (elem, name) {
365return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
366},
367
368each: function (obj, callback) {
369var length, i = 0;
370
371if (isArrayLike(obj)) {
372length = obj.length;
373for (; i < length; i++) {
374if (callback.call(obj[i], i, obj[i]) === false) {
375break;
376}
377}
378} else {
379for (i in obj) {
380if (callback.call(obj[i], i, obj[i]) === false) {
381break;
382}
383}
384}
385
386return obj;

387},
388
389// Support: Android<4.1
390trim: function (text) {
391return text == null ?
392"" :
393(text + "").replace(rtrim, "");
394},
395
396// results is for internal usage only
397makeArray: function (arr, results) {
398var ret = results || [];
399
400if (arr != null) {
401if (isArrayLike(Object(arr))) {
402jQuery.merge(ret,
403typeof arr === "string" ?
404[arr] : arr
405);
406} else {
407push.call(ret, arr);
408}
409}
410
411return ret;
412},
413
414inArray: function (elem, arr, i) {
415return arr == null ? -1 : indexOf.call(arr, elem, i);
416},
417
418merge: function (first, second) {
419var len = +second.length,
420j = 0,
421i = first.length;
422
423for (; j < len; j++) {
424first[i++] = second[j];
425}
426
427first.length = i;
428
429return first;
430},
431
432grep: function (elems, callback, invert) {
433var callbackInverse,
434matches = [],
435i = 0,
436length = elems.length,
437callbackExpect = !invert;
438
439// Go through the array, only saving the items
440// that pass the validator function
441for (; i < length; i++) {
442callbackInverse = !callback(elems[i], i);
443if (callbackInverse !== callbackExpect) {
444matches.push(elems[i]);
445}
446}
447
448return matches;
449},
450
451// arg is for internal usage only
452map: function (elems, callback, arg) {
453var length, value,
454i = 0,
455ret = [];
456
457// Go through the array, translating each of the items to their new values
458if (isArrayLike(elems)) {
459length = elems.length;
460for (; i < length; i++) {
461value = callback(elems[i], i, arg);
462
463if (value != null) {
464ret.push(value);
465}
466}
467
468// Go through every key on the object,
469} else {
470for (i in elems) {
471value = callback(elems[i], i, arg);
472
473if (value != null) {
474ret.push(value);
475}
476}
477}
478
479// Flatten any nested arrays
480return concat.apply([], ret);
481},
482
483// A global GUID counter for objects
484guid: 1,
485
486// Bind a function to a context, optionally partially applying any
487// arguments.
488proxy: function (fn, context) {
489var tmp, args, proxy;
490
491if (typeof context === "string") {
492tmp = fn[context];
493context = fn;
494fn = tmp;
495}
496
497// Quick check to determine if target is callable, in the spec
498// this throws a TypeError, but we will just return undefined.
499if (!jQuery.isFunction(fn)) {
500return undefined;
501}
502
503// Simulated bind
504args = slice.call(arguments, 2);
505proxy = function () {
506return fn.apply(context || this, args.concat(slice.call(arguments)));
507};
508
509// Set the guid of unique handler to the same of original handler, so it can be removed
510proxy.guid = fn.guid = fn.guid || jQuery.guid++;
511
512return proxy;
513},
514
515now: Date.now,
516
517// jQuery.support is not used in Core but other projects attach their
518// properties to it so it needs to exist.
519support: support
520});
521
522// JSHint would error on this code due to the Symbol not being defined in ES5.
523// Defining this global in .jshintrc would create a danger of using the global
524// unguarded in another place, it seems safer to just disable JSHint for these
525// three lines.
526/* jshint ignore: start */
527if (typeof Symbol === "function") {
528jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
529}
530/* jshint ignore: end */
531
532// Populate the class2type map
533jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "),
534function (i, name) {
535class2type["[object " + name + "]"] = name.toLowerCase();
536});
537
538function isArrayLike(obj) {
539
540// Support: iOS 8.2 (not reproducible in simulator)
541// `in` check used to prevent JIT error (gh-2145)
542// hasOwn isn't used here due to false negatives
543// regarding Nodelist length in IE
544var length = !!obj && "length" in obj && obj.length,
545type = jQuery.type(obj);
546
547if (type === "function" || jQuery.isWindow(obj)) {
548return false;
549}
550
551return type === "array" || length === 0 ||
552typeof length === "number" && length > 0 && (length - 1) in obj;
553}
554var Sizzle =
555/*!
556 * Sizzle CSS Selector Engine v2.2.1
557 * http://sizzlejs.com/
558 *
559 * Copyright jQuery Foundation and other contributors
560 * Released under the MIT license
561 * http://jquery.org/license
562 *
563 * Date: 2015-10-17
564 */
565(function (window) {
566
567var i,
568support,
569Expr,
570getText,
571isXML,
572tokenize,
573compile,
574select,
575outermostContext,
576sortInput,
577hasDuplicate,
578
579// Local document vars
580setDocument,
581document,
582docElem,
583documentIsHTML,
584rbuggyQSA,
585rbuggyMatches,
586matches,
587contains,
588
589// Instance-specific data
590expando = "sizzle" + 1 * new Date(),
591preferredDoc = window.document,
592dirruns = 0,
593done = 0,
594classCache = createCache(),
595tokenCache = createCache(),
596compilerCache = createCache(),
597sortOrder = function (a, b) {
598if (a === b) {

599hasDuplicate = true;
600}
601return 0;
602},
603
604// General-purpose constants
605MAX_NEGATIVE = 1 << 31,
606
607// Instance methods
608hasOwn = ({}).hasOwnProperty,
609arr = [],
610pop = arr.pop,
611push_native = arr.push,
612push = arr.push,
613slice = arr.slice,
614// Use a stripped-down indexOf as it's faster than native
615// http://jsperf.com/thor-indexof-vs-for/5
616indexOf = function (list, elem) {
617var i = 0,
618len = list.length;
619for (; i < len; i++) {
620if (list[i] === elem) {
621return i;
622}
623}
624return -1;
625},
626
627booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
628
629// Regular expressions
630
631// http://www.w3.org/TR/css3-selectors/#whitespace
632whitespace = "[\\x20\\t\\r\\n\\f]",
633
634// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
635identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
636
637// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
638attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
639// Operator (capture 2)
640"*([*^$|!~]?=)" + whitespace +
641// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
642"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
643"*\\]",
644
645pseudos = ":(" + identifier + ")(?:\\((" +
646// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
647// 1. quoted (capture 3; capture 4 or capture 5)
648"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
649// 2. simple (capture 6)
650"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
651// 3. anything else (capture 2)
652".*" +
653")\\)|)",
654
655// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
656rwhitespace = new RegExp(whitespace + "+", "g"),
657rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),
658
659rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
660rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
661
662rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"),
663
664rpseudo = new RegExp(pseudos),
665ridentifier = new RegExp("^" + identifier + "$"),
666
667matchExpr = {
668"ID": new RegExp("^#(" + identifier + ")"),
669"CLASS": new RegExp("^\\.(" + identifier + ")"),
670"TAG": new RegExp("^(" + identifier + "|[*])"),
671"ATTR": new RegExp("^" + attributes),
672"PSEUDO": new RegExp("^" + pseudos),
673"CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
674"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
675"*(\\d+)|))" + whitespace + "*\\)|)", "i"),
676"bool": new RegExp("^(?:" + booleans + ")$", "i"),
677// For use in libraries implementing .is()
678// We use this for POS matching in `select`
679"needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
680whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
681},
682
683rinputs = /^(?:input|select|textarea|button)$/i,
684rheader = /^h\d$/i,
685
686rnative = /^[^{]+\{\s*\[native \w/,
687
688// Easily-parseable/retrievable ID or TAG or CLASS selectors
689rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
690
691rsibling = /[+~]/,
692rescape = /'|\\/g,
693
694// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
695runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"),
696funescape = function (_, escaped, escapedWhitespace) {
697var high = "0x" + escaped - 0x10000;
698// NaN means non-codepoint
699// Support: Firefox<24
700// Workaround erroneous numeric interpretation of +"0x"
701return high !== high || escapedWhitespace ?
702escaped :
703high < 0 ?
704// BMP codepoint
705String.fromCharCode(high + 0x10000) :
706// Supplemental Plane codepoint (surrogate pair)
707String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
708},
709
710// Used for iframes
711// See setDocument()
712// Removing the function wrapper causes a "Permission Denied"
713// error in IE
714unloadHandler = function () {
715setDocument();
716};
717
718// Optimize for push.apply( _, NodeList )
719try {
720push.apply(
721(arr = slice.call(preferredDoc.childNodes)),
722preferredDoc.childNodes
723);
724// Support: Android<4.0
725// Detect silently failing push.apply
726arr[preferredDoc.childNodes.length].nodeType;
727} catch (e) {
728push = {
729apply: arr.length ?
730
731// Leverage slice if possible
732function (target, els) {
733push_native.apply(target, slice.call(els));
734} :
735
736// Support: IE<9
737// Otherwise append directly
738function (target, els) {
739var j = target.length,
740i = 0;
741// Can't trust NodeList.length
742while ((target[j++] = els[i++])) { }
743target.length = j - 1;
744}
745};
746}
747
748function Sizzle(selector, context, results, seed) {
749var m, i, elem, nid, nidselect, match, groups, newSelector,
750newContext = context && context.ownerDocument,
751
752// nodeType defaults to 9, since context defaults to document
753nodeType = context ? context.nodeType : 9;
754
755results = results || [];
756
757// Return early from calls with invalid selector or context
758if (typeof selector !== "string" || !selector ||
759nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {
760
761return results;
762}
763
764// Try to shortcut find operations (as opposed to filters) in HTML documents
765if (!seed) {
766
767if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
768setDocument(context);
769}
770context = context || document;
771
772if (documentIsHTML) {
773
774// If the selector is sufficiently simple, try using a "get*By*" DOM method
775// (excepting DocumentFragment context, where the methods don't exist)
776if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
777
778// ID selector
779if ((m = match[1])) {
780
781// Document context
782if (nodeType === 9) {
783if ((elem = context.getElementById(m))) {
784
785// Support: IE, Opera, Webkit
786// TODO: identify versions
787// getElementById can match elements by name instead of ID
788if (elem.id === m) {
789results.push(elem);
790return results;
791}
792} else {
793return results;
794}
795
796// Element context
797} else {
798
799// Support: IE, Opera, Webkit
800// TODO: identify versions
801// getElementById can match elements by name instead of ID
802if (newContext && (elem = newContext.getElementById(m)) &&
803contains(context, elem) &&
804elem.id === m) {
805
806results.push(elem);
807return results;
808}
809}
810
811// Type selector
812} else if (match[2]) {
813push.apply(results, context.getElementsByTagName(selector));
814return results;
815
816// Class selector
817} else if ((m = match[3]) && support.getElementsByClassName &&
818context.getElementsByClassName) {
819
820push.apply(results, context.getElementsByClassName(m));
821return results;
822}
823}
824
825// Take advantage of querySelectorAll
826if (support.qsa &&
827!compilerCache[selector + " "] &&
828(!rbuggyQSA || !rbuggyQSA.test(selector))) {
829
830if (nodeType !== 1) {
831newContext = context;
832newSelector = selector;
833
834// qSA looks outside Element context, which is not what we want
835// Thanks to Andrew Dupont for this workaround technique
836// Support: IE <=8
837// Exclude object elements
838} else if (context.nodeName.toLowerCase() !== "object") {
839
840// Capture the context ID, setting it first if necessary
841if ((nid = context.getAttribute("id"))) {
842nid = nid.replace(rescape, "\\$&");
843} else {
844context.setAttribute("id", (nid = expando));
845}
846
847// Prefix every selector in the list
848groups = tokenize(selector);
849i = groups.length;
850nidselect = ridentifier.test(nid) ? "#" + nid : "[id='" + nid + "']";
851while (i--) {
852groups[i] = nidselect + " " + toSelector(groups[i]);
853}
854newSelector = groups.join(",");
855
856// Expand context for sibling selectors
857newContext = rsibling.test(selector) && testContext(context.parentNode) ||
858context;
859}
860
861if (newSelector) {
862try {
863push.apply(results,
864newContext.querySelectorAll(newSelector)
865);
866return results;
867} catch (qsaError) {
868} finally {
869if (nid === expando) {
870context.removeAttribute("id");
871}
872}
873}
874}
875}
876}
877
878// All others
879return select(selector.replace(rtrim, "$1"), context, results, seed);
880}
881
882/**
883 * Create key-value caches of limited size
884 * @returns {function(string, object)} Returns the Object data after storing it on itself with
885 *property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
886 *deleting the oldest entry
887 */
888function createCache() {
889var keys = [];
890
891function cache(key, value) {
892// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
893if (keys.push(key + " ") > Expr.cacheLength) {
894// Only keep the most recent entries
895delete cache[keys.shift()];
896}
897return (cache[key + " "] = value);
898}
899return cache;
900}
901
902/**
903 * Mark a function for special use by Sizzle
904 * @param {Function} fn The function to mark
905 */
906function markFunction(fn) {
907fn[expando] = true;
908return fn;
909}
910
911/**
912 * Support testing using an element
913 * @param {Function} fn Passed the created div and expects a boolean result
914 */
915function assert(fn) {
916var div = document.createElement("div");
917
918try {
919return !!fn(div);
920} catch (e) {
921return false;
922} finally {
923// Remove from its parent by default
924if (div.parentNode) {
925div.parentNode.removeChild(div);
926}
927// release memory in IE
928div = null;
929}
930}
931
932/**
933 * Adds the same handler for all of the specified attrs
934 * @param {String} attrs Pipe-separated list of attributes
935 * @param {Function} handler The method that will be applied
936 */
937function addHandle(attrs, handler) {
938var arr = attrs.split("|"),
939i = arr.length;
940
941while (i--) {
942Expr.attrHandle[arr[i]] = handler;
943}
944}
945
946/**
947 * Checks document order of two siblings
948 * @param {Element} a
949 * @param {Element} b
950 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
951 */
952function siblingCheck(a, b) {
953var cur = b && a,
954diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
955(~b.sourceIndex || MAX_NEGATIVE) -
956(~a.sourceIndex || MAX_NEGATIVE);
957
958// Use IE sourceIndex if available on both nodes
959if (diff) {
960return diff;
961}
962
963// Check if b follows a
964if (cur) {
965while ((cur = cur.nextSibling)) {
966if (cur === b) {
967return -1;
968}
969}
970}
971
972return a ? 1 : -1;
973}
974
975/**
976 * Returns a function to use in pseudos for input types
977 * @param {String} type
978 */
979function createInputPseudo(type) {
980return function (elem) {
981var name = elem.nodeName.toLowerCase();
982return name === "input" && elem.type === type;
983};
984}
985
986/**
987 * Returns a function to use in pseudos for buttons
988 * @param {String} type
989 */
990function createButtonPseudo(type) {
991return function (elem) {
992var name = elem.nodeName.toLowerCase();
993return (name === "input" || name === "button") && elem.type === type;
994};
995}
996
997/**
998 * Returns a function to use in pseudos for positionals
999 * @param {Function} fn
1000 */
1001function createPositionalPseudo(fn) {
1002return markFunction(function (argument) {
1003argument = +argument;
1004return markFunction(function (seed, matches) {
1005var j,
1006matchIndexes = fn([], seed.length, argument),
1007i = matchIndexes.length;
1008
1009// Match elements found at the specified indexes
1010while (i--) {
1011if (seed[(j = matchIndexes[i])]) {
1012seed[j] = !(matches[j] = seed[j]);
1013}
1014}
1015});
1016});
1017}
1018
1019/**
1020 * Checks a node for validity as a Sizzle context
1021 * @param {Element|Object=} context
1022 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1023 */
1024function testContext(context) {
1025return context && typeof context.getElementsByTagName !== "undefined" && context;
1026}
1027
1028// Expose support vars for convenience
1029support = Sizzle.support = {};
1030
1031/**
1032 * Detects XML nodes
1033 * @param {Element|Object} elem An element or a document
1034 * @returns {Boolean} True iff elem is a non-HTML XML node
1035 */
1036isXML = Sizzle.isXML = function (elem) {
1037// documentElement is verified for cases where it doesn't yet exist
1038// (such as loading iframes in IE - #4833)
1039var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1040return documentElement ? documentElement.nodeName !== "HTML" : false;
1041};
1042
1043/**
1044 * Sets document-related variables once based on the current document
1045 * @param {Element|Object} [doc] An element or document object to use to set the document
1046 * @returns {Object} Returns the current document
1047 */
1048setDocument = Sizzle.setDocument = function (node) {
1049var hasCompare, parent,
1050doc = node ? node.ownerDocument || node : preferredDoc;
1051
1052// Return early if doc is invalid or already selected
1053if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
1054return document;
1055}
1056
1057// Update global variables
1058document = doc;
1059docElem = document.documentElement;
1060documentIsHTML = !isXML(document);
1061
1062// Support: IE 9-11, Edge
1063// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1064if ((parent = document.defaultView) && parent.top !== parent) {
1065// Support: IE 11
1066if (parent.addEventListener) {
1067parent.addEventListener("unload", unloadHandler, false);
1068
1069// Support: IE 9 - 10 only
1070} else if (parent.attachEvent) {
1071parent.attachEvent("onunload", unloadHandler);
1072}
1073}
1074
1075/* Attributes
1076---------------------------------------------------------------------- */
1077
1078// Support: IE<8
1079// Verify that getAttribute really returns attributes and not properties
1080// (excepting IE8 booleans)
1081support.attributes = assert(function (div) {
1082div.className = "i";
1083return !div.getAttribute("className");
1084});
1085
1086/* getElement(s)By*
1087---------------------------------------------------------------------- */
1088
1089// Check if getElementsByTagName("*") returns only elements
1090support.getElementsByTagName = assert(function (div) {
1091div.appendChild(document.createComment(""));
1092return !div.getElementsByTagName("*").length;
1093});
1094
1095// Support: IE<9
1096support.getElementsByClassName = rnative.test(document.getElementsByClassName);
1097
1098// Support: IE<10
1099// Check if getElementById returns elements by name
1100// The broken getElementById methods don't pick up programatically-set names,
1101// so use a roundabout getElementsByName test
1102support.getById = assert(function (div) {
1103docElem.appendChild(div).id = expando;
1104return !document.getElementsByName || !document.getElementsByName(expando).length;
1105});
1106
1107// ID find and filter
1108if (support.getById) {
1109Expr.find["ID"] = function (id, context) {
1110if (typeof context.getElementById !== "undefined" && documentIsHTML) {
1111var m = context.getElementById(id);
1112return m ? [m] : [];
1113}
1114};
1115Expr.filter["ID"] = function (id) {
1116var attrId = id.replace(runescape, funescape);
1117return function (elem) {
1118return elem.getAttribute("id") === attrId;
1119};
1120};
1121} else {
1122// Support: IE6/7
1123// getElementById is not reliable as a find shortcut
1124delete Expr.find["ID"];
1125
1126Expr.filter["ID"] = function (id) {
1127var attrId = id.replace(runescape, funescape);
1128return function (elem) {
1129var node = typeof elem.getAttributeNode !== "undefined" &&
1130elem.getAttributeNode("id");
1131return node && node.value === attrId;
1132};
1133};
1134}
1135
1136// Tag
1137Expr.find["TAG"] = support.getElementsByTagName ?
1138function (tag, context) {
1139if (typeof context.getElementsByTagName !== "undefined") {
1140return context.getElementsByTagName(tag);
1141
1142// DocumentFragment nodes don't have gEBTN
1143} else if (support.qsa) {
1144return context.querySelectorAll(tag);
1145}
1146} :
1147
1148function (tag, context) {
1149var elem,
1150tmp = [],
1151i = 0,
1152// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1153results = context.getElementsByTagName(tag);
1154
1155// Filter out possible comments
1156if (tag === "*") {
1157while ((elem = results[i++])) {
1158if (elem.nodeType === 1) {
1159tmp.push(elem);
1160}
1161}
1162
1163return tmp;
1164}
1165return results;
1166};
1167
1168// Class
1169Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) {
1170if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
1171return context.getElementsByClassName(className);
1172}
1173};
1174
1175/* QSA/matchesSelector
1176---------------------------------------------------------------------- */
1177
1178// QSA and matchesSelector support
1179
1180// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1181rbuggyMatches = [];
1182
1183// qSa(:focus) reports false when true (Chrome 21)
1184// We allow this because of a bug in IE8/9 that throws an error
1185// whenever `document.activeElement` is accessed on an iframe
1186// So, we allow :focus to pass through QSA all the time to avoid the IE error
1187// See http://bugs.jquery.com/ticket/13378
1188rbuggyQSA = [];
1189
1190if ((support.qsa = rnative.test(document.querySelectorAll))) {
1191// Build QSA regex
1192// Regex strategy adopted from Diego Perini
1193assert(function (div) {
1194// Select is set to empty string on purpose
1195// This is to test IE's treatment of not explicitly
1196// setting a boolean content attribute,
1197// since its presence should be enough
1198// http://bugs.jquery.com/ticket/12359
1199docElem.appendChild(div).innerHTML = "<a id='" + expando + "'></a>" +
1200"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1201"<option selected=''></option></select>";
1202
1203// Support: IE8, Opera 11-12.16
1204// Nothing should be selected when empty strings follow ^= or $= or *=
1205// The test attribute must be unknown in Opera but "safe" for WinRT

1206// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1207if (div.querySelectorAll("[msallowcapture^='']").length) {
1208rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
1209}
1210
1211// Support: IE8
1212// Boolean attributes and "value" are not treated correctly
1213if (!div.querySelectorAll("[selected]").length) {
1214rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
1215}
1216
1217// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1218if (!div.querySelectorAll("[id~=" + expando + "-]").length) {
1219rbuggyQSA.push("~=");
1220}
1221
1222// Webkit/Opera - :checked should return selected option elements
1223// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1224// IE8 throws error here and will not see later tests
1225if (!div.querySelectorAll(":checked").length) {
1226rbuggyQSA.push(":checked");
1227}
1228
1229// Support: Safari 8+, iOS 8+
1230// https://bugs.webkit.org/show_bug.cgi?id=136851
1231// In-page `selector#id sibing-combinator selector` fails
1232if (!div.querySelectorAll("a#" + expando + "+*").length) {
1233rbuggyQSA.push(".#.+[+~]");
1234}
1235});
1236
1237assert(function (div) {
1238// Support: Windows 8 Native Apps
1239// The type and name attributes are restricted during .innerHTML assignment
1240var input = document.createElement("input");
1241input.setAttribute("type", "hidden");
1242div.appendChild(input).setAttribute("name", "D");
1243
1244// Support: IE8
1245// Enforce case-sensitivity of name attribute
1246if (div.querySelectorAll("[name=d]").length) {
1247rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?=");
1248}
1249
1250// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1251// IE8 throws error here and will not see later tests
1252if (!div.querySelectorAll(":enabled").length) {
1253rbuggyQSA.push(":enabled", ":disabled");
1254}
1255
1256// Opera 10-11 does not throw on post-comma invalid pseudos
1257div.querySelectorAll("*,:x");
1258rbuggyQSA.push(",.*:");
1259});
1260}
1261
1262if ((support.matchesSelector = rnative.test((matches = docElem.matches ||
1263docElem.webkitMatchesSelector ||
1264docElem.mozMatchesSelector ||
1265docElem.oMatchesSelector ||
1266docElem.msMatchesSelector)))) {
1267
1268assert(function (div) {
1269// Check to see if it's possible to do matchesSelector
1270// on a disconnected node (IE 9)
1271support.disconnectedMatch = matches.call(div, "div");
1272
1273// This should fail with an exception
1274// Gecko does not error, returns false instead
1275matches.call(div, "[s!='']:x");
1276rbuggyMatches.push("!=", pseudos);
1277});
1278}
1279
1280rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
1281rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));
1282
1283/* Contains
1284---------------------------------------------------------------------- */
1285hasCompare = rnative.test(docElem.compareDocumentPosition);
1286
1287// Element contains another
1288// Purposefully self-exclusive
1289// As in, an element does not contain itself
1290contains = hasCompare || rnative.test(docElem.contains) ?
1291function (a, b) {
1292var adown = a.nodeType === 9 ? a.documentElement : a,
1293bup = b && b.parentNode;
1294return a === bup || !!(bup && bup.nodeType === 1 && (
1295adown.contains ?
1296adown.contains(bup) :
1297a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16
1298));
1299} :
1300function (a, b) {
1301if (b) {
1302while ((b = b.parentNode)) {
1303if (b === a) {
1304return true;
1305}
1306}
1307}
1308return false;
1309};
1310
1311/* Sorting
1312---------------------------------------------------------------------- */
1313
1314// Document order sorting
1315sortOrder = hasCompare ?
1316function (a, b) {
1317
1318// Flag for duplicate removal
1319if (a === b) {
1320hasDuplicate = true;
1321return 0;
1322}
1323
1324// Sort on method existence if only one input has compareDocumentPosition
1325var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1326if (compare) {
1327return compare;
1328}
1329
1330// Calculate position if both inputs belong to the same document
1331compare = (a.ownerDocument || a) === (b.ownerDocument || b) ?
1332a.compareDocumentPosition(b) :
1333
1334// Otherwise we know they are disconnected
13351;
1336
1337// Disconnected nodes
1338if (compare & 1 ||
1339(!support.sortDetached && b.compareDocumentPosition(a) === compare)) {
1340
1341// Choose the first element that is related to our preferred document
1342if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
1343return -1;
1344}
1345if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
1346return 1;
1347}
1348
1349// Maintain original order
1350return sortInput ?
1351(indexOf(sortInput, a) - indexOf(sortInput, b)) :
13520;
1353}
1354
1355return compare & 4 ? -1 : 1;
1356} :
1357function (a, b) {
1358// Exit early if the nodes are identical
1359if (a === b) {

1360hasDuplicate = true;
1361return 0;
1362}
1363
1364var cur,
1365i = 0,
1366aup = a.parentNode,
1367bup = b.parentNode,
1368ap = [a],
1369bp = [b];
1370
1371// Parentless nodes are either documents or disconnected
1372if (!aup || !bup) {
1373return a === document ? -1 :
1374b === document ? 1 :
1375aup ? -1 :
1376bup ? 1 :
1377sortInput ?
1378(indexOf(sortInput, a) - indexOf(sortInput, b)) :
13790;
1380
1381// If the nodes are siblings, we can do a quick check
1382} else if (aup === bup) {
1383return siblingCheck(a, b);
1384}
1385
1386// Otherwise we need full lists of their ancestors for comparison
1387cur = a;
1388while ((cur = cur.parentNode)) {
1389ap.unshift(cur);
1390}
1391cur = b;
1392while ((cur = cur.parentNode)) {
1393bp.unshift(cur);
1394}
1395
1396// Walk down the tree looking for a discrepancy
1397while (ap[i] === bp[i]) {
1398i++;
1399}
1400
1401return i ?
1402// Do a sibling check if the nodes have a common ancestor
1403siblingCheck(ap[i], bp[i]) :
1404
1405// Otherwise nodes in our document sort first
1406ap[i] === preferredDoc ? -1 :
1407bp[i] === preferredDoc ? 1 :
14080;
1409};
1410
1411return document;
1412};
1413
1414Sizzle.matches = function (expr, elements) {
1415return Sizzle(expr, null, null, elements);
1416};
1417
1418Sizzle.matchesSelector = function (elem, expr) {
1419// Set document vars if needed
1420if ((elem.ownerDocument || elem) !== document) {
1421setDocument(elem);
1422}
1423
1424// Make sure that attribute selectors are quoted
1425expr = expr.replace(rattributeQuotes, "='$1']");
1426
1427if (support.matchesSelector && documentIsHTML &&
1428!compilerCache[expr + " "] &&
1429(!rbuggyMatches || !rbuggyMatches.test(expr)) &&
1430(!rbuggyQSA || !rbuggyQSA.test(expr))) {
1431
1432try {
1433var ret = matches.call(elem, expr);
1434
1435// IE 9's matchesSelector returns false on disconnected nodes
1436if (ret || support.disconnectedMatch ||
1437// As well, disconnected nodes are said to be in a document
1438// fragment in IE 9
1439elem.document && elem.document.nodeType !== 11) {
1440return ret;
1441}
1442} catch (e) { }
1443}
1444
1445return Sizzle(expr, document, null, [elem]).length > 0;
1446};
1447
1448Sizzle.contains = function (context, elem) {
1449// Set document vars if needed
1450if ((context.ownerDocument || context) !== document) {
1451setDocument(context);
1452}
1453return contains(context, elem);
1454};
1455
1456Sizzle.attr = function (elem, name) {
1457// Set document vars if needed
1458if ((elem.ownerDocument || elem) !== document) {
1459setDocument(elem);
1460}
1461
1462var fn = Expr.attrHandle[name.toLowerCase()],
1463// Don't get fooled by Object.prototype properties (jQuery #13807)
1464val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ?
1465fn(elem, name, !documentIsHTML) :
1466undefined;
1467
1468return val !== undefined ?
1469val :
1470support.attributes || !documentIsHTML ?
1471elem.getAttribute(name) :
1472(val = elem.getAttributeNode(name)) && val.specified ?
1473val.value :
1474null;
1475};
1476
1477Sizzle.error = function (msg) {
1478throw new Error("Syntax error, unrecognized expression: " + msg);
1479};
1480
1481/**
1482 * Document sorting and removing duplicates
1483 * @param {ArrayLike} results
1484 */
1485Sizzle.uniqueSort = function (results) {
1486var elem,
1487duplicates = [],
1488j = 0,
1489i = 0;
1490
1491// Unless we *know* we can detect duplicates, assume their presence
1492hasDuplicate = !support.detectDuplicates;
1493sortInput = !support.sortStable && results.slice(0);
1494results.sort(sortOrder);
1495
1496if (hasDuplicate) {
1497while ((elem = results[i++])) {
1498if (elem === results[i]) {
1499j = duplicates.push(i);
1500}
1501}
1502while (j--) {
1503results.splice(duplicates[j], 1);
1504}
1505}
1506
1507// Clear input after sorting to release objects
1508// See https://github.com/jquery/sizzle/pull/225
1509sortInput = null;
1510
1511return results;
1512};
1513
1514/**
1515 * Utility function for retrieving the text value of an array of DOM nodes
1516 * @param {Array|Element} elem
1517 */
1518getText = Sizzle.getText = function (elem) {
1519var node,
1520ret = "",
1521i = 0,
1522nodeType = elem.nodeType;
1523
1524if (!nodeType) {
1525// If no nodeType, this is expected to be an array
1526while ((node = elem[i++])) {
1527// Do not traverse comment nodes
1528ret += getText(node);
1529}
1530} else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
1531// Use textContent for elements
1532// innerText usage removed for consistency of new lines (jQuery #11153)
1533if (typeof elem.textContent === "string") {
1534return elem.textContent;
1535} else {
1536// Traverse its children
1537for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
1538ret += getText(elem);
1539}
1540}
1541} else if (nodeType === 3 || nodeType === 4) {
1542return elem.nodeValue;
1543}
1544// Do not include comment or processing instruction nodes
1545
1546return ret;
1547};
1548
1549Expr = Sizzle.selectors = {
1550
1551// Can be adjusted by the user
1552cacheLength: 50,
1553
1554createPseudo: markFunction,
1555
1556match: matchExpr,
1557
1558attrHandle: {},
1559
1560find: {},
1561
1562relative: {
1563">": { dir: "parentNode", first: true },
1564" ": { dir: "parentNode" },
1565"+": { dir: "previousSibling", first: true },
1566"~": { dir: "previousSibling" }
1567},
1568
1569preFilter: {
1570"ATTR": function (match) {
1571match[1] = match[1].replace(runescape, funescape);
1572
1573// Move the given value to match[3] whether quoted or unquoted
1574match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
1575
1576if (match[2] === "~=") {
1577match[3] = " " + match[3] + " ";
1578}
1579
1580return match.slice(0, 4);
1581},
1582
1583"CHILD": function (match) {
1584/* matches from matchExpr["CHILD"]
15851 type (only|nth|...)
15862 what (child|of-type)
15873 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
15884 xn-component of xn+y argument ([+-]?\d*n|)
15895 sign of xn-component
15906 x of xn-component
15917 sign of y-component
15928 y of y-component
1593*/
1594match[1] = match[1].toLowerCase();
1595
1596if (match[1].slice(0, 3) === "nth") {
1597// nth-* requires argument
1598if (!match[3]) {
1599Sizzle.error(match[0]);
1600}
1601
1602// numeric x and y parameters for Expr.filter.CHILD
1603// remember that false/true cast respectively to 0/1
1604match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
1605match[5] = +((match[7] + match[8]) || match[3] === "odd");
1606
1607// other types prohibit arguments
1608} else if (match[3]) {
1609Sizzle.error(match[0]);
1610}
1611
1612return match;
1613},
1614
1615"PSEUDO": function (match) {
1616var excess,
1617unquoted = !match[6] && match[2];
1618
1619if (matchExpr["CHILD"].test(match[0])) {
1620return null;
1621}
1622
1623// Accept quoted arguments as-is
1624if (match[3]) {
1625match[2] = match[4] || match[5] || "";
1626
1627// Strip excess characters from unquoted arguments
1628} else if (unquoted && rpseudo.test(unquoted) &&
1629// Get excess from tokenize (recursively)
1630(excess = tokenize(unquoted, true)) &&
1631// advance to the next closing parenthesis
1632(excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
1633
1634// excess is a negative index
1635match[0] = match[0].slice(0, excess);
1636match[2] = unquoted.slice(0, excess);
1637}
1638
1639// Return only captures needed by the pseudo filter method (type and argument)
1640return match.slice(0, 3);
1641}
1642},
1643
1644filter: {
1645
1646"TAG": function (nodeNameSelector) {
1647var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
1648return nodeNameSelector === "*" ?
1649function () { return true; } :
1650function (elem) {
1651return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1652};
1653},
1654
1655"CLASS": function (className) {
1656var pattern = classCache[className + " "];
1657
1658return pattern ||
1659(pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) &&
1660classCache(className, function (elem) {
1661return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
1662});
1663},
1664
1665"ATTR": function (name, operator, check) {
1666return function (elem) {
1667var result = Sizzle.attr(elem, name);
1668
1669if (result == null) {
1670return operator === "!=";
1671}
1672if (!operator) {
1673return true;
1674}
1675
1676result += "";
1677
1678return operator === "=" ? result === check :
1679operator === "!=" ? result !== check :
1680operator === "^=" ? check && result.indexOf(check) === 0 :
1681operator === "*=" ? check && result.indexOf(check) > -1 :
1682operator === "$=" ? check && result.slice(-check.length) === check :
1683operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 :
1684operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" :
1685false;
1686};
1687},
1688
1689"CHILD": function (type, what, argument, first, last) {
1690var simple = type.slice(0, 3) !== "nth",
1691forward = type.slice(-4) !== "last",
1692ofType = what === "of-type";
1693
1694return first === 1 && last === 0 ?
1695
1696// Shortcut for :nth-*(n)
1697function (elem) {
1698return !!elem.parentNode;
1699} :
1700
1701function (elem, context, xml) {
1702var cache, uniqueCache, outerCache, node, nodeIndex, start,
1703dir = simple !== forward ? "nextSibling" : "previousSibling",
1704parent = elem.parentNode,
1705name = ofType && elem.nodeName.toLowerCase(),
1706useCache = !xml && !ofType,
1707diff = false;
1708
1709if (parent) {
1710
1711// :(first|last|only)-(child|of-type)
1712if (simple) {
1713while (dir) {
1714node = elem;
1715while ((node = node[dir])) {
1716if (ofType ?
1717node.nodeName.toLowerCase() === name :
1718node.nodeType === 1) {
1719
1720return false;
1721}
1722}
1723// Reverse direction for :only-* (if we haven't yet done so)
1724start = dir = type === "only" && !start && "nextSibling";
1725}
1726return true;
1727}
1728
1729start = [forward ? parent.firstChild : parent.lastChild];
1730
1731// non-xml :nth-child(...) stores cache data on `parent`
1732if (forward && useCache) {
1733
1734// Seek `elem` from a previously-cached index
1735
1736// ...in a gzip-friendly way
1737node = parent;
1738outerCache = node[expando] || (node[expando] = {});
1739
1740// Support: IE <9 only
1741// Defend against cloned attroperties (jQuery gh-1709)
1742uniqueCache = outerCache[node.uniqueID] ||
1743(outerCache[node.uniqueID] = {});
1744
1745cache = uniqueCache[type] || [];

1746nodeIndex = cache[0] === dirruns && cache[1];
1747diff = nodeIndex && cache[2];
1748node = nodeIndex && parent.childNodes[nodeIndex];
1749
1750while ((node = ++nodeIndex && node && node[dir] ||
1751
1752// Fallback to seeking `elem` from the start
1753(diff = nodeIndex = 0) || start.pop())) {
1754
1755// When found, cache indexes on `parent` and break
1756if (node.nodeType === 1 && ++diff && node === elem) {
1757uniqueCache[type] = [dirruns, nodeIndex, diff];
1758break;
1759}
1760}
1761
1762} else {
1763// Use previously-cached element index if available
1764if (useCache) {
1765// ...in a gzip-friendly way
1766node = elem;
1767outerCache = node[expando] || (node[expando] = {});
1768
1769// Support: IE <9 only
1770// Defend against cloned attroperties (jQuery gh-1709)
1771uniqueCache = outerCache[node.uniqueID] ||
1772(outerCache[node.uniqueID] = {});
1773
1774cache = uniqueCache[type] || [];
1775nodeIndex = cache[0] === dirruns && cache[1];
1776diff = nodeIndex;
1777}
1778
1779// xml :nth-child(...)
1780// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1781if (diff === false) {
1782// Use the same loop as above to seek `elem` from the start
1783while ((node = ++nodeIndex && node && node[dir] ||
1784(diff = nodeIndex = 0) || start.pop())) {
1785
1786if ((ofType ?
1787node.nodeName.toLowerCase() === name :
1788node.nodeType === 1) &&
1789++diff) {
1790
1791// Cache the index of each encountered element
1792if (useCache) {
1793outerCache = node[expando] || (node[expando] = {});
1794
1795// Support: IE <9 only
1796// Defend against cloned attroperties (jQuery gh-1709)
1797uniqueCache = outerCache[node.uniqueID] ||
1798(outerCache[node.uniqueID] = {});
1799
1800uniqueCache[type] = [dirruns, diff];
1801}
1802
1803if (node === elem) {
1804break;
1805}
1806}
1807}
1808}
1809}
1810
1811// Incorporate the offset, then check against cycle size
1812diff -= last;
1813return diff === first || (diff % first === 0 && diff / first >= 0);
1814}
1815};
1816},
1817
1818"PSEUDO": function (pseudo, argument) {
1819// pseudo-class names are case-insensitive
1820// http://www.w3.org/TR/selectors/#pseudo-classes
1821// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1822// Remember that setFilters inherits from pseudos
1823var args,
1824fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] ||
1825Sizzle.error("unsupported pseudo: " + pseudo);
1826
1827// The user may use createPseudo to indicate that
1828// arguments are needed to create the filter function
1829// just as Sizzle does
1830if (fn[expando]) {
1831return fn(argument);
1832}
1833
1834// But maintain support for old signatures
1835if (fn.length > 1) {
1836args = [pseudo, pseudo, "", argument];
1837return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ?
1838markFunction(function (seed, matches) {
1839var idx,
1840matched = fn(seed, argument),
1841i = matched.length;
1842while (i--) {
1843idx = indexOf(seed, matched[i]);
1844seed[idx] = !(matches[idx] = matched[i]);
1845}
1846}) :
1847function (elem) {
1848return fn(elem, 0, args);
1849};
1850}
1851
1852return fn;
1853}
1854},
1855
1856pseudos: {
1857// Potentially complex pseudos
1858"not": markFunction(function (selector) {
1859// Trim the selector passed to compile
1860// to avoid treating leading and trailing
1861// spaces as combinators
1862var input = [],
1863results = [],
1864matcher = compile(selector.replace(rtrim, "$1"));
1865
1866return matcher[expando] ?
1867markFunction(function (seed, matches, context, xml) {
1868var elem,
1869unmatched = matcher(seed, null, xml, []),
1870i = seed.length;
1871
1872// Match elements unmatched by `matcher`
1873while (i--) {
1874if ((elem = unmatched[i])) {
1875seed[i] = !(matches[i] = elem);
1876}
1877}
1878}) :
1879function (elem, context, xml) {
1880input[0] = elem;
1881matcher(input, null, xml, results);
1882// Don't keep the element (issue #299)
1883input[0] = null;
1884return !results.pop();
1885};
1886}),
1887
1888"has": markFunction(function (selector) {
1889return function (elem) {
1890return Sizzle(selector, elem).length > 0;
1891};
1892}),
1893
1894"contains": markFunction(function (text) {
1895text = text.replace(runescape, funescape);
1896return function (elem) {
1897return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
1898};
1899}),
1900
1901// "Whether an element is represented by a :lang() selector
1902// is based solely on the element's language value
1903// being equal to the identifier C,
1904// or beginning with the identifier C immediately followed by "-".
1905// The matching of C against the element's language value is performed case-insensitively.
1906// The identifier C does not have to be a valid language name."
1907// http://www.w3.org/TR/selectors/#lang-pseudo
1908"lang": markFunction(function (lang) {
1909// lang value must be a valid identifier
1910if (!ridentifier.test(lang || "")) {
1911Sizzle.error("unsupported lang: " + lang);
1912}
1913lang = lang.replace(runescape, funescape).toLowerCase();
1914return function (elem) {
1915var elemLang;
1916do {
1917if ((elemLang = documentIsHTML ?
1918elem.lang :
1919elem.getAttribute("xml:lang") || elem.getAttribute("lang"))) {
1920
1921elemLang = elemLang.toLowerCase();
1922return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
1923}
1924} while ((elem = elem.parentNode) && elem.nodeType === 1);
1925return false;
1926};
1927}),
1928
1929// Miscellaneous
1930"target": function (elem) {
1931var hash = window.location && window.location.hash;
1932return hash && hash.slice(1) === elem.id;
1933},
1934
1935"root": function (elem) {
1936return elem === docElem;
1937},
1938
1939"focus": function (elem) {
1940return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
1941},
1942
1943// Boolean properties
1944"enabled": function (elem) {
1945return elem.disabled === false;
1946},
1947
1948"disabled": function (elem) {
1949return elem.disabled === true;
1950},
1951
1952"checked": function (elem) {
1953// In CSS3, :checked should return both checked and selected elements
1954// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1955var nodeName = elem.nodeName.toLowerCase();
1956return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
1957},
1958
1959"selected": function (elem) {
1960// Accessing this property makes selected-by-default
1961// options in Safari work properly
1962if (elem.parentNode) {
1963elem.parentNode.selectedIndex;
1964}
1965
1966return elem.selected === true;
1967},
1968
1969// Contents
1970"empty": function (elem) {
1971// http://www.w3.org/TR/selectors/#empty-pseudo
1972// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1973//   but not by others (comment: 8; processing instruction: 7; etc.)
1974// nodeType < 6 works because attributes (2) do not appear as children
1975for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
1976if (elem.nodeType < 6) {
1977return false;
1978}
1979}
1980return true;
1981},
1982
1983"parent": function (elem) {
1984return !Expr.pseudos["empty"](elem);
1985},
1986
1987// Element/input types
1988"header": function (elem) {
1989return rheader.test(elem.nodeName);
1990},
1991
1992"input": function (elem) {
1993return rinputs.test(elem.nodeName);
1994},
1995
1996"button": function (elem) {
1997var name = elem.nodeName.toLowerCase();
1998return name === "input" && elem.type === "button" || name === "button";
1999},
2000
2001"text": function (elem) {
2002var attr;
2003return elem.nodeName.toLowerCase() === "input" &&
2004elem.type === "text" &&
2005
2006// Support: IE<8
2007// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2008((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
2009},
2010
2011// Position-in-collection
2012"first": createPositionalPseudo(function () {
2013return [0];
2014}),
2015
2016"last": createPositionalPseudo(function (matchIndexes, length) {
2017return [length - 1];
2018}),
2019
2020"eq": createPositionalPseudo(function (matchIndexes, length, argument) {
2021return [argument < 0 ? argument + length : argument];
2022}),
2023
2024"even": createPositionalPseudo(function (matchIndexes, length) {
2025var i = 0;
2026for (; i < length; i += 2) {
2027matchIndexes.push(i);
2028}
2029return matchIndexes;
2030}),
2031
2032"odd": createPositionalPseudo(function (matchIndexes, length) {
2033var i = 1;
2034for (; i < length; i += 2) {
2035matchIndexes.push(i);
2036}
2037return matchIndexes;
2038}),
2039
2040"lt": createPositionalPseudo(function (matchIndexes, length, argument) {
2041var i = argument < 0 ? argument + length : argument;
2042for (; --i >= 0;) {
2043matchIndexes.push(i);
2044}
2045return matchIndexes;
2046}),
2047
2048"gt": createPositionalPseudo(function (matchIndexes, length, argument) {
2049var i = argument < 0 ? argument + length : argument;
2050for (; ++i < length;) {
2051matchIndexes.push(i);
2052}
2053return matchIndexes;
2054})
2055}
2056};
2057
2058Expr.pseudos["nth"] = Expr.pseudos["eq"];
2059
2060// Add button/input type pseudos
2061for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) {
2062Expr.pseudos[i] = createInputPseudo(i);
2063}
2064for (i in { submit: true, reset: true }) {
2065Expr.pseudos[i] = createButtonPseudo(i);
2066}
2067
2068// Easy API for creating new setFilters
2069function setFilters() { }
2070setFilters.prototype = Expr.filters = Expr.pseudos;
2071Expr.setFilters = new setFilters();
2072
2073tokenize = Sizzle.tokenize = function (selector, parseOnly) {
2074var matched, match, tokens, type,
2075soFar, groups, preFilters,
2076cached = tokenCache[selector + " "];
2077
2078if (cached) {
2079return parseOnly ? 0 : cached.slice(0);
2080}
2081
2082soFar = selector;
2083groups = [];
2084preFilters = Expr.preFilter;
2085
2086while (soFar) {
2087
2088// Comma and first run
2089if (!matched || (match = rcomma.exec(soFar))) {
2090if (match) {
2091// Don't consume trailing commas as valid
2092soFar = soFar.slice(match[0].length) || soFar;
2093}
2094groups.push((tokens = []));
2095}
2096
2097matched = false;
2098
2099// Combinators
2100if ((match = rcombinators.exec(soFar))) {
2101matched = match.shift();
2102tokens.push({
2103value: matched,
2104// Cast descendant combinators to space
2105type: match[0].replace(rtrim, " ")
2106});
2107soFar = soFar.slice(matched.length);
2108}
2109
2110// Filters
2111for (type in Expr.filter) {
2112if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] ||
2113(match = preFilters[type](match)))) {
2114matched = match.shift();
2115tokens.push({
2116value: matched,
2117type: type,
2118matches: match
2119});
2120soFar = soFar.slice(matched.length);
2121}
2122}
2123
2124if (!matched) {
2125break;
2126}
2127}
2128
2129// Return the length of the invalid excess
2130// if we're just parsing
2131// Otherwise, throw an error or return tokens
2132return parseOnly ?
2133soFar.length :
2134soFar ?
2135Sizzle.error(selector) :
2136// Cache the tokens
2137tokenCache(selector, groups).slice(0);
2138};
2139
2140function toSelector(tokens) {
2141var i = 0,
2142len = tokens.length,
2143selector = "";
2144for (; i < len; i++) {
2145selector += tokens[i].value;
2146}
2147return selector;
2148}
2149
2150function addCombinator(matcher, combinator, base) {
2151var dir = combinator.dir,
2152checkNonElements = base && dir === "parentNode",
2153doneName = done++;
2154
2155return combinator.first ?
2156// Check against closest ancestor/preceding element
2157function (elem, context, xml) {
2158while ((elem = elem[dir])) {
2159if (elem.nodeType === 1 || checkNonElements) {
2160return matcher(elem, context, xml);
2161}
2162}
2163} :
2164
2165// Check against all ancestor/preceding elements
2166function (elem, context, xml) {
2167var oldCache, uniqueCache, outerCache,
2168newCache = [dirruns, doneName];
2169
2170// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2171if (xml) {
2172while ((elem = elem[dir])) {
2173if (elem.nodeType === 1 || checkNonElements) {
2174if (matcher(elem, context, xml)) {
2175return true;
2176}
2177}
2178}
2179} else {
2180while ((elem = elem[dir])) {
2181if (elem.nodeType === 1 || checkNonElements) {
2182outerCache = elem[expando] || (elem[expando] = {});
2183
2184// Support: IE <9 only
2185// Defend against cloned attroperties (jQuery gh-1709)
2186uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});
2187
2188if ((oldCache = uniqueCache[dir]) &&
2189oldCache[0] === dirruns && oldCache[1] === doneName) {
2190
2191// Assign to newCache so results back-propagate to previous elements
2192return (newCache[2] = oldCache[2]);
2193} else {
2194// Reuse newcache so results back-propagate to previous elements
2195uniqueCache[dir] = newCache;
2196
2197// A match means we're done; a fail means we have to keep checking
2198if ((newCache[2] = matcher(elem, context, xml))) {
2199return true;
2200}
2201}
2202}
2203}
2204}
2205};
2206}
2207
2208function elementMatcher(matchers) {
2209return matchers.length > 1 ?
2210function (elem, context, xml) {
2211var i = matchers.length;
2212while (i--) {
2213if (!matchers[i](elem, context, xml)) {
2214return false;
2215}
2216}
2217return true;
2218} :
2219matchers[0];
2220}
2221
2222function multipleContexts(selector, contexts, results) {
2223var i = 0,
2224len = contexts.length;
2225for (; i < len; i++) {
2226Sizzle(selector, contexts[i], results);
2227}
2228return results;
2229}
2230
2231function condense(unmatched, map, filter, context, xml) {
2232var elem,
2233newUnmatched = [],
2234i = 0,
2235len = unmatched.length,
2236mapped = map != null;
2237
2238for (; i < len; i++) {
2239if ((elem = unmatched[i])) {
2240if (!filter || filter(elem, context, xml)) {
2241newUnmatched.push(elem);
2242if (mapped) {
2243map.push(i);
2244}
2245}
2246}
2247}
2248
2249return newUnmatched;
2250}
2251
2252function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
2253if (postFilter && !postFilter[expando]) {
2254postFilter = setMatcher(postFilter);
2255}
2256if (postFinder && !postFinder[expando]) {
2257postFinder = setMatcher(postFinder, postSelector);
2258}
2259return markFunction(function (seed, results, context, xml) {
2260var temp, i, elem,
2261preMap = [],
2262postMap = [],
2263preexisting = results.length,
2264
2265// Get initial elements from seed or context
2266elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),
2267
2268// Prefilter to get matcher input, preserving a map for seed-results synchronization
2269matcherIn = preFilter && (seed || !selector) ?
2270condense(elems, preMap, preFilter, context, xml) :
2271elems,
2272
2273matcherOut = matcher ?
2274// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2275postFinder || (seed ? preFilter : preexisting || postFilter) ?
2276
2277// ...intermediate processing is necessary
2278[] :
2279
2280// ...otherwise use results directly
2281results :
2282matcherIn;
2283
2284// Find primary matches
2285if (matcher) {
2286matcher(matcherIn, matcherOut, context, xml);
2287}
2288
2289// Apply postFilter
2290if (postFilter) {
2291temp = condense(matcherOut, postMap);
2292postFilter(temp, [], context, xml);
2293
2294// Un-match failing elements by moving them back to matcherIn
2295i = temp.length;
2296while (i--) {
2297if ((elem = temp[i])) {
2298matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
2299}
2300}
2301}
2302
2303if (seed) {
2304if (postFinder || preFilter) {
2305if (postFinder) {
2306// Get the final matcherOut by condensing this intermediate into postFinder contexts
2307temp = [];
2308i = matcherOut.length;
2309while (i--) {
2310if ((elem = matcherOut[i])) {
2311// Restore matcherIn since elem is not yet a final match
2312temp.push((matcherIn[i] = elem));
2313}
2314}
2315postFinder(null, (matcherOut = []), temp, xml);
2316}
2317
2318// Move matched elements from seed to results to keep them synchronized
2319i = matcherOut.length;
2320while (i--) {
2321if ((elem = matcherOut[i]) &&
2322(temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {
2323
2324seed[temp] = !(results[temp] = elem);
2325}
2326}
2327}
2328
2329// Add elements to results, through postFinder if defined
2330} else {
2331matcherOut = condense(
2332matcherOut === results ?
2333matcherOut.splice(preexisting, matcherOut.length) :
2334matcherOut
2335);
2336if (postFinder) {
2337postFinder(null, results, matcherOut, xml);
2338} else {
2339push.apply(results, matcherOut);
2340}
2341}
2342});
2343}
2344
2345function matcherFromTokens(tokens) {
2346var checkContext, matcher, j,
2347len = tokens.length,
2348leadingRelative = Expr.relative[tokens[0].type],
2349implicitRelative = leadingRelative || Expr.relative[" "],
2350i = leadingRelative ? 1 : 0,
2351
2352// The foundational matcher ensures that elements are reachable from top-level context(s)
2353matchContext = addCombinator(function (elem) {
2354return elem === checkContext;
2355}, implicitRelative, true),
2356matchAnyContext = addCombinator(function (elem) {
2357return indexOf(checkContext, elem) > -1;
2358}, implicitRelative, true),
2359matchers = [function (elem, context, xml) {
2360var ret = (!leadingRelative && (xml || context !== outermostContext)) || (
2361(checkContext = context).nodeType ?
2362matchContext(elem, context, xml) :
2363matchAnyContext(elem, context, xml));
2364// Avoid hanging onto element (issue #299)
2365checkContext = null;
2366return ret;
2367}];
2368
2369for (; i < len; i++) {
2370if ((matcher = Expr.relative[tokens[i].type])) {
2371matchers = [addCombinator(elementMatcher(matchers), matcher)];
2372} else {
2373matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
2374
2375// Return special upon seeing a positional matcher
2376if (matcher[expando]) {
2377// Find the next relative operator (if any) for proper handling
2378j = ++i;
2379for (; j < len; j++) {
2380if (Expr.relative[tokens[j].type]) {
2381break;
2382}
2383}
2384return setMatcher(
2385i > 1 && elementMatcher(matchers),
2386i > 1 && toSelector(
2387// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2388tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === " " ? "*" : "" })
2389).replace(rtrim, "$1"),
2390matcher,
2391i < j && matcherFromTokens(tokens.slice(i, j)),
2392j < len && matcherFromTokens((tokens = tokens.slice(j))),
2393j < len && toSelector(tokens)
2394);
2395}
2396matchers.push(matcher);
2397}
2398}
2399
2400return elementMatcher(matchers);
2401}
2402
2403function matcherFromGroupMatchers(elementMatchers, setMatchers) {
2404var bySet = setMatchers.length > 0,
2405byElement = elementMatchers.length > 0,
2406superMatcher = function (seed, context, xml, results, outermost) {
2407var elem, j, matcher,
2408matchedCount = 0,
2409i = "0",
2410unmatched = seed && [],
2411setMatched = [],
2412contextBackup = outermostContext,
2413// We must always have either seed elements or outermost context
2414elems = seed || byElement && Expr.find["TAG"]("*", outermost),
2415// Use integer dirruns iff this is the outermost matcher
2416dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2417len = elems.length;
2418
2419if (outermost) {
2420outermostContext = context === document || context || outermost;
2421}
2422
2423// Add elements passing elementMatchers directly to results
2424// Support: IE<9, Safari
2425// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2426for (; i !== len && (elem = elems[i]) != null; i++) {
2427if (byElement && elem) {
2428j = 0;
2429if (!context && elem.ownerDocument !== document) {
2430setDocument(elem);
2431xml = !documentIsHTML;
2432}
2433while ((matcher = elementMatchers[j++])) {
2434if (matcher(elem, context || document, xml)) {
2435results.push(elem);
2436break;
2437}
2438}
2439if (outermost) {
2440dirruns = dirrunsUnique;
2441}
2442}
2443
2444// Track unmatched elements for set filters
2445if (bySet) {
2446// They will have gone through all possible matchers
2447if ((elem = !matcher && elem)) {
2448matchedCount--;
2449}
2450
2451// Lengthen the array for every element, matched or not
2452if (seed) {
2453unmatched.push(elem);
2454}
2455}
2456}
2457
2458// `i` is now the count of elements visited above, and adding it to `matchedCount`
2459// makes the latter nonnegative.
2460matchedCount += i;
2461
2462// Apply set filters to unmatched elements
2463// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2464// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2465// no element matchers and no seed.
2466// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2467// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2468// numerically zero.
2469if (bySet && i !== matchedCount) {
2470j = 0;
2471while ((matcher = setMatchers[j++])) {
2472matcher(unmatched, setMatched, context, xml);
2473}
2474
2475if (seed) {
2476// Reintegrate element matches to eliminate the need for sorting
2477if (matchedCount > 0) {
2478while (i--) {
2479if (!(unmatched[i] || setMatched[i])) {
2480setMatched[i] = pop.call(results);
2481}
2482}
2483}
2484
2485// Discard index placeholder values to get only actual matches
2486setMatched = condense(setMatched);
2487}
2488
2489// Add matches to results
2490push.apply(results, setMatched);
2491
2492// Seedless set matches succeeding multiple successful matchers stipulate sorting
2493if (outermost && !seed && setMatched.length > 0 &&
2494(matchedCount + setMatchers.length) > 1) {
2495
2496Sizzle.uniqueSort(results);
2497}
2498}
2499
2500// Override manipulation of globals by nested matchers
2501if (outermost) {
2502dirruns = dirrunsUnique;
2503outermostContext = contextBackup;
2504}
2505
2506return unmatched;
2507};

2508
2509return bySet ?
2510markFunction(superMatcher) :
2511superMatcher;
2512}
2513
2514compile = Sizzle.compile = function (selector, match /* Internal Use Only */) {
2515var i,
2516setMatchers = [],
2517elementMatchers = [],
2518cached = compilerCache[selector + " "];
2519
2520if (!cached) {
2521// Generate a function of recursive functions that can be used to check each element
2522if (!match) {
2523match = tokenize(selector);
2524}
2525i = match.length;
2526while (i--) {
2527cached = matcherFromTokens(match[i]);
2528if (cached[expando]) {
2529setMatchers.push(cached);
2530} else {
2531elementMatchers.push(cached);
2532}
2533}
2534
2535// Cache the compiled function
2536cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
2537
2538// Save selector and tokenization
2539cached.selector = selector;
2540}
2541return cached;
2542};
2543
2544/**
2545 * A low-level selection function that works with Sizzle's compiled
2546 *  selector functions
2547 * @param {String|Function} selector A selector or a pre-compiled
2548 *  selector function built with Sizzle.compile
2549 * @param {Element} context
2550 * @param {Array} [results]
2551 * @param {Array} [seed] A set of elements to match against
2552 */
2553select = Sizzle.select = function (selector, context, results, seed) {
2554var i, tokens, token, type, find,
2555compiled = typeof selector === "function" && selector,
2556match = !seed && tokenize((selector = compiled.selector || selector));
2557
2558results = results || [];
2559
2560// Try to minimize operations if there is only one selector in the list and no seed
2561// (the latter of which guarantees us context)
2562if (match.length === 1) {
2563
2564// Reduce context if the leading compound selector is an ID
2565tokens = match[0] = match[0].slice(0);
2566if (tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2567support.getById && context.nodeType === 9 && documentIsHTML &&
2568Expr.relative[tokens[1].type]) {
2569
2570context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
2571if (!context) {
2572return results;
2573
2574// Precompiled matchers will still verify ancestry, so step up a level
2575} else if (compiled) {
2576context = context.parentNode;
2577}
2578
2579selector = selector.slice(tokens.shift().value.length);
2580}
2581
2582// Fetch a seed set for right-to-left matching
2583i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
2584while (i--) {
2585token = tokens[i];
2586
2587// Abort if we hit a combinator
2588if (Expr.relative[(type = token.type)]) {
2589break;
2590}
2591if ((find = Expr.find[type])) {
2592// Search, expanding context for leading sibling combinators
2593if ((seed = find(
2594token.matches[0].replace(runescape, funescape),
2595rsibling.test(tokens[0].type) && testContext(context.parentNode) || context
2596))) {
2597
2598// If seed is empty or no tokens remain, we can return early
2599tokens.splice(i, 1);
2600selector = seed.length && toSelector(tokens);
2601if (!selector) {
2602push.apply(results, seed);
2603return results;
2604}
2605
2606break;
2607}
2608}
2609}
2610}
2611
2612// Compile and execute a filtering function if one is not provided
2613// Provide `match` to avoid retokenization if we modified the selector above
2614(compiled || compile(selector, match))(
2615seed,
2616context,
2617!documentIsHTML,
2618results,
2619!context || rsibling.test(selector) && testContext(context.parentNode) || context
2620);
2621return results;
2622};
2623
2624// One-time assignments
2625
2626// Sort stability
2627support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
2628
2629// Support: Chrome 14-35+
2630// Always assume duplicates if they aren't passed to the comparison function
2631support.detectDuplicates = !!hasDuplicate;
2632
2633// Initialize against the default document
2634setDocument();
2635
2636// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2637// Detached nodes confoundingly follow *each other*
2638support.sortDetached = assert(function (div1) {
2639// Should return 1, but returns 4 (following)
2640return div1.compareDocumentPosition(document.createElement("div")) & 1;
2641});
2642
2643// Support: IE<8
2644// Prevent attribute/property "interpolation"
2645// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2646if (!assert(function (div) {
2647div.innerHTML = "<a href='#'></a>";
2648return div.firstChild.getAttribute("href") === "#";
2649})) {
2650addHandle("type|href|height|width", function (elem, name, isXML) {
2651if (!isXML) {
2652return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
2653}
2654});
2655}
2656
2657// Support: IE<9