https://spark.parkpark.dk/build/assets/js/jquery-Bw33iOZF.js

1import { t as __commonJSMin } from "./chunk-CPYxVWes.js";
2//#region node_modules/jquery/dist/jquery.js
3var require_jquery = /* @__PURE__ */ __commonJSMin(((exports, module) => {
4	/*!
5	* jQuery JavaScript Library v3.7.1
6	* https://jquery.com/
7	*
8	* Copyright OpenJS Foundation and other contributors
9	* Released under the MIT license
10	* https://jquery.org/license
11	*
12	* Date: 2023-08-28T13:37Z
13	*/
14	(function(global, factory) {
15		"use strict";
16		if (typeof module === "object" && typeof module.exports === "object") module.exports = global.document ? factory(global, true) : function(w) {
17			if (!w.document) throw new Error("jQuery requires a window with a document");
18			return factory(w);
19		};
20		else factory(global);
21	})(typeof window !== "undefined" ? window : exports, function(window, noGlobal) {
22		"use strict";
23		var arr = [];
24		var getProto = Object.getPrototypeOf;
25		var slice = arr.slice;
26		var flat = arr.flat ? function(array) {
27			return arr.flat.call(array);
28		} : function(array) {
29			return arr.concat.apply([], array);
30		};
31		var push = arr.push;
32		var indexOf = arr.indexOf;
33		var class2type = {};
34		var toString = class2type.toString;
35		var hasOwn = class2type.hasOwnProperty;
36		var fnToString = hasOwn.toString;
37		var ObjectFunctionString = fnToString.call(Object);
38		var support = {};
39		var isFunction = function isFunction(obj) {
40			return typeof obj === "function" && typeof obj.nodeType !== "number" && typeof obj.item !== "function";
41		};
42		var isWindow = function isWindow(obj) {
43			return obj != null && obj === obj.window;
44		};
45		var document = window.document;
46		var preservedScriptAttributes = {
47			type: true,
48			src: true,
49			nonce: true,
50			noModule: true
51		};
52		function DOMEval(code, node, doc) {
53			doc = doc || document;
54			var i, val, script = doc.createElement("script");
55			script.text = code;
56			if (node) for (i in preservedScriptAttributes) {
57				val = node[i] || node.getAttribute && node.getAttribute(i);
58				if (val) script.setAttribute(i, val);
59			}
60			doc.head.appendChild(script).parentNode.removeChild(script);
61		}
62		function toType(obj) {
63			if (obj == null) return obj + "";
64			return typeof obj === "object" || typeof obj === "function" ? class2type[toString.call(obj)] || "object" : typeof obj;
65		}
66		var version = "3.7.1", rhtmlSuffix = /HTML$/i, jQuery = function(selector, context) {
67			return new jQuery.fn.init(selector, context);
68		};
69		jQuery.fn = jQuery.prototype = {
70			jquery: version,
71			constructor: jQuery,
72			length: 0,
73			toArray: function() {
74				return slice.call(this);
75			},
76			get: function(num) {
77				if (num == null) return slice.call(this);
78				return num < 0 ? this[num + this.length] : this[num];
79			},
80			pushStack: function(elems) {
81				var ret = jQuery.merge(this.constructor(), elems);
82				ret.prevObject = this;
83				return ret;
84			},
85			each: function(callback) {
86				return jQuery.each(this, callback);
87			},
88			map: function(callback) {
89				return this.pushStack(jQuery.map(this, function(elem, i) {
90					return callback.call(elem, i, elem);
91				}));
92			},
93			slice: function() {
94				return this.pushStack(slice.apply(this, arguments));
95			},
96			first: function() {
97				return this.eq(0);
98			},
99			last: function() {
100				return this.eq(-1);
101			},
102			even: function() {
103				return this.pushStack(jQuery.grep(this, function(_elem, i) {
104					return (i + 1) % 2;
105				}));
106			},
107			odd: function() {
108				return this.pushStack(jQuery.grep(this, function(_elem, i) {
109					return i % 2;
110				}));
111			},
112			eq: function(i) {
113				var len = this.length, j = +i + (i < 0 ? len : 0);
114				return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
115			},
116			end: function() {
117				return this.prevObject || this.constructor();
118			},
119			push,
120			sort: arr.sort,
121			splice: arr.splice
122		};
123		jQuery.extend = jQuery.fn.extend = function() {
124			var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false;
125			if (typeof target === "boolean") {
126				deep = target;
127				target = arguments[i] || {};
128				i++;
129			}
130			if (typeof target !== "object" && !isFunction(target)) target = {};
131			if (i === length) {
132				target = this;
133				i--;
134			}
135			for (; i < length; i++) if ((options = arguments[i]) != null) for (name in options) {
136				copy = options[name];
137				if (name === "__proto__" || target === copy) continue;
138				if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))) {
139					src = target[name];
140					if (copyIsArray && !Array.isArray(src)) clone = [];
141					else if (!copyIsArray && !jQuery.isPlainObject(src)) clone = {};
142					else clone = src;
143					copyIsArray = false;

144					target[name] = jQuery.extend(deep, clone, copy);
145				} else if (copy !== void 0) target[name] = copy;
146			}
147			return target;
148		};
149		jQuery.extend({
150			expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),
151			isReady: true,
152			error: function(msg) {
153				throw new Error(msg);
154			},
155			noop: function() {},
156			isPlainObject: function(obj) {
157				var proto, Ctor;
158				if (!obj || toString.call(obj) !== "[object Object]") return false;
159				proto = getProto(obj);
160				if (!proto) return true;
161				Ctor = hasOwn.call(proto, "constructor") && proto.constructor;
162				return typeof Ctor === "function" && fnToString.call(Ctor) === ObjectFunctionString;
163			},
164			isEmptyObject: function(obj) {
165				var name;
166				for (name in obj) return false;
167				return true;
168			},
169			globalEval: function(code, options, doc) {
170				DOMEval(code, { nonce: options && options.nonce }, doc);
171			},
172			each: function(obj, callback) {
173				var length, i = 0;
174				if (isArrayLike(obj)) {
175					length = obj.length;
176					for (; i < length; i++) if (callback.call(obj[i], i, obj[i]) === false) break;
177				} else for (i in obj) if (callback.call(obj[i], i, obj[i]) === false) break;
178				return obj;
179			},
180			text: function(elem) {
181				var node, ret = "", i = 0, nodeType = elem.nodeType;
182				if (!nodeType) while (node = elem[i++]) ret += jQuery.text(node);
183				if (nodeType === 1 || nodeType === 11) return elem.textContent;
184				if (nodeType === 9) return elem.documentElement.textContent;
185				if (nodeType === 3 || nodeType === 4) return elem.nodeValue;
186				return ret;
187			},
188			makeArray: function(arr, results) {
189				var ret = results || [];
190				if (arr != null) if (isArrayLike(Object(arr))) jQuery.merge(ret, typeof arr === "string" ? [arr] : arr);
191				else push.call(ret, arr);
192				return ret;
193			},
194			inArray: function(elem, arr, i) {
195				return arr == null ? -1 : indexOf.call(arr, elem, i);
196			},
197			isXMLDoc: function(elem) {
198				var namespace = elem && elem.namespaceURI, docElem = elem && (elem.ownerDocument || elem).documentElement;
199				return !rhtmlSuffix.test(namespace || docElem && docElem.nodeName || "HTML");
200			},
201			merge: function(first, second) {
202				var len = +second.length, j = 0, i = first.length;
203				for (; j < len; j++) first[i++] = second[j];
204				first.length = i;
205				return first;
206			},
207			grep: function(elems, callback, invert) {
208				var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert;
209				for (; i < length; i++) {
210					callbackInverse = !callback(elems[i], i);
211					if (callbackInverse !== callbackExpect) matches.push(elems[i]);
212				}
213				return matches;
214			},
215			map: function(elems, callback, arg) {
216				var length, value, i = 0, ret = [];
217				if (isArrayLike(elems)) {
218					length = elems.length;
219					for (; i < length; i++) {
220						value = callback(elems[i], i, arg);
221						if (value != null) ret.push(value);
222					}
223				} else for (i in elems) {
224					value = callback(elems[i], i, arg);
225					if (value != null) ret.push(value);
226				}
227				return flat(ret);
228			},
229			guid: 1,
230			support
231		});
232		if (typeof Symbol === "function") jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
233		jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function(_i, name) {
234			class2type["[object " + name + "]"] = name.toLowerCase();
235		});
236		function isArrayLike(obj) {
237			var length = !!obj && "length" in obj && obj.length, type = toType(obj);
238			if (isFunction(obj) || isWindow(obj)) return false;
239			return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj;
240		}
241		function nodeName(elem, name) {
242			return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
243		}
244		var pop = arr.pop;
245		var sort = arr.sort;
246		var splice = arr.splice;
247		var whitespace = "[\\x20\\t\\r\\n\\f]";
248		var rtrimCSS = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g");
249		jQuery.contains = function(a, b) {
250			var bup = b && b.parentNode;
251			return a === bup || !!(bup && bup.nodeType === 1 && (a.contains ? a.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
252		};
253		var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
254		function fcssescape(ch, asCodePoint) {
255			if (asCodePoint) {
256				if (ch === "\0") return "�";

257				return ch.slice(0, -1) + "\\" + ch.charCodeAt(ch.length - 1).toString(16) + " ";
258			}
259			return "\\" + ch;
260		}
261		jQuery.escapeSelector = function(sel) {
262			return (sel + "").replace(rcssescape, fcssescape);
263		};
264		var preferredDoc = document, pushNative = push;
265		(function() {
266			var i, Expr, outermostContext, sortInput, hasDuplicate, push = pushNative, document, documentElement, documentIsHTML, rbuggyQSA, matches, expando = jQuery.expando, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), nonnativeSelectorCache = createCache(), sortOrder = function(a, b) {
267				if (a === b) hasDuplicate = true;
268				return 0;
269			}, booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + "*([*^$|!~]?=)" + whitespace + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]", pseudos = ":(" + identifier + ")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|.*)\\)|)", rwhitespace = new RegExp(whitespace + "+", "g"), rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"), rleadingCombinator = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"), rdescend = new RegExp(whitespace + "|>"), rpseudo = new RegExp(pseudos), ridentifier = new RegExp("^" + identifier + "$"), matchExpr = {
270				ID: new RegExp("^#(" + identifier + ")"),
271				CLASS: new RegExp("^\\.(" + identifier + ")"),
272				TAG: new RegExp("^(" + identifier + "|[*])"),
273				ATTR: new RegExp("^" + attributes),
274				PSEUDO: new RegExp("^" + pseudos),
275				CHILD: new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
276				bool: new RegExp("^(?:" + booleans + ")$", "i"),
277				needsContext: new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
278			}, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, runescape = new RegExp("\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g"), funescape = function(escape, nonHex) {
279				var high = "0x" + escape.slice(1) - 65536;
280				if (nonHex) return nonHex;
281				return high < 0 ? String.fromCharCode(high + 65536) : String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320);
282			}, unloadHandler = function() {
283				setDocument();
284			}, inDisabledFieldset = addCombinator(function(elem) {
285				return elem.disabled === true && nodeName(elem, "fieldset");
286			}, {
287				dir: "parentNode",
288				next: "legend"
289			});
290			function safeActiveElement() {
291				try {
292					return document.activeElement;
293				} catch (err) {}
294			}
295			try {
296				push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes);
297				arr[preferredDoc.childNodes.length].nodeType;
298			} catch (e) {
299				push = {
300					apply: function(target, els) {
301						pushNative.apply(target, slice.call(els));
302					},
303					call: function(target) {
304						pushNative.apply(target, slice.call(arguments, 1));
305					}
306				};
307			}
308			function find(selector, context, results, seed) {
309				var m, i, elem, nid, match, groups, newSelector, newContext = context && context.ownerDocument, nodeType = context ? context.nodeType : 9;
310				results = results || [];
311				if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) return results;
312				if (!seed) {
313					setDocument(context);
314					context = context || document;
315					if (documentIsHTML) {
316						if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
317							if (m = match[1]) {
318								if (nodeType === 9) if (elem = context.getElementById(m)) {
319									if (elem.id === m) {
320										push.call(results, elem);
321										return results;
322									}
323								} else return results;
324								else if (newContext && (elem = newContext.getElementById(m)) && find.contains(context, elem) && elem.id === m) {
325									push.call(results, elem);
326									return results;
327								}
328							} else if (match[2]) {
329								push.apply(results, context.getElementsByTagName(selector));
330								return results;
331							} else if ((m = match[3]) && context.getElementsByClassName) {
332								push.apply(results, context.getElementsByClassName(m));
333								return results;
334							}
335						}
336						if (!nonnativeSelectorCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
337							newSelector = selector;
338							newContext = context;
339							if (nodeType === 1 && (rdescend.test(selector) || rleadingCombinator.test(selector))) {

340								newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
341								if (newContext != context || !support.scope) if (nid = context.getAttribute("id")) nid = jQuery.escapeSelector(nid);
342								else context.setAttribute("id", nid = expando);
343								groups = tokenize(selector);
344								i = groups.length;
345								while (i--) groups[i] = (nid ? "#" + nid : ":scope") + " " + toSelector(groups[i]);
346								newSelector = groups.join(",");
347							}
348							try {
349								push.apply(results, newContext.querySelectorAll(newSelector));
350								return results;
351							} catch (qsaError) {
352								nonnativeSelectorCache(selector, true);
353							} finally {
354								if (nid === expando) context.removeAttribute("id");
355							}
356						}
357					}
358				}
359				return select(selector.replace(rtrimCSS, "$1"), context, results, seed);
360			}
361			/**
362			* Create key-value caches of limited size
363			* @returns {function(string, object)} Returns the Object data after storing it on itself with
364			*	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
365			*	deleting the oldest entry
366			*/
367			function createCache() {
368				var keys = [];
369				function cache(key, value) {
370					if (keys.push(key + " ") > Expr.cacheLength) delete cache[keys.shift()];
371					return cache[key + " "] = value;
372				}
373				return cache;
374			}
375			/**
376			* Mark a function for special use by jQuery selector module
377			* @param {Function} fn The function to mark
378			*/
379			function markFunction(fn) {
380				fn[expando] = true;
381				return fn;
382			}
383			/**
384			* Support testing using an element
385			* @param {Function} fn Passed the created element and returns a boolean result
386			*/
387			function assert(fn) {
388				var el = document.createElement("fieldset");
389				try {
390					return !!fn(el);
391				} catch (e) {
392					return false;
393				} finally {
394					if (el.parentNode) el.parentNode.removeChild(el);
395					el = null;
396				}
397			}
398			/**
399			* Returns a function to use in pseudos for input types
400			* @param {String} type
401			*/
402			function createInputPseudo(type) {
403				return function(elem) {
404					return nodeName(elem, "input") && elem.type === type;
405				};
406			}
407			/**
408			* Returns a function to use in pseudos for buttons
409			* @param {String} type
410			*/
411			function createButtonPseudo(type) {
412				return function(elem) {
413					return (nodeName(elem, "input") || nodeName(elem, "button")) && elem.type === type;
414				};
415			}
416			/**
417			* Returns a function to use in pseudos for :enabled/:disabled
418			* @param {Boolean} disabled true for :disabled; false for :enabled
419			*/
420			function createDisabledPseudo(disabled) {
421				return function(elem) {
422					if ("form" in elem) {
423						if (elem.parentNode && elem.disabled === false) {
424							if ("label" in elem) if ("label" in elem.parentNode) return elem.parentNode.disabled === disabled;
425							else return elem.disabled === disabled;
426							return elem.isDisabled === disabled || elem.isDisabled !== !disabled && inDisabledFieldset(elem) === disabled;
427						}
428						return elem.disabled === disabled;
429					} else if ("label" in elem) return elem.disabled === disabled;
430					return false;
431				};
432			}
433			/**
434			* Returns a function to use in pseudos for positionals
435			* @param {Function} fn
436			*/
437			function createPositionalPseudo(fn) {
438				return markFunction(function(argument) {
439					argument = +argument;
440					return markFunction(function(seed, matches) {
441						var j, matchIndexes = fn([], seed.length, argument), i = matchIndexes.length;
442						while (i--) if (seed[j = matchIndexes[i]]) seed[j] = !(matches[j] = seed[j]);
443					});
444				});
445			}
446			/**
447			* Checks a node for validity as a jQuery selector context
448			* @param {Element|Object=} context
449			* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
450			*/
451			function testContext(context) {
452				return context && typeof context.getElementsByTagName !== "undefined" && context;
453			}
454			/**
455			* Sets document-related variables once based on the current document
456			* @param {Element|Object} [node] An element or document object to use to set the document
457			* @returns {Object} Returns the current document
458			*/
459			function setDocument(node) {
460				var subWindow, doc = node ? node.ownerDocument || node : preferredDoc;
461				if (doc == document || doc.nodeType !== 9 || !doc.documentElement) return document;
462				document = doc;
463				documentElement = document.documentElement;
464				documentIsHTML = !jQuery.isXMLDoc(document);
465				matches = documentElement.matches || documentElement.webkitMatchesSelector || documentElement.msMat

465chesSelector;
466				if (documentElement.msMatchesSelector && preferredDoc != document && (subWindow = document.defaultView) && subWindow.top !== subWindow) subWindow.addEventListener("unload", unloadHandler);
467				support.getById = assert(function(el) {
468					documentElement.appendChild(el).id = jQuery.expando;
469					return !document.getElementsByName || !document.getElementsByName(jQuery.expando).length;
470				});
471				support.disconnectedMatch = assert(function(el) {
472					return matches.call(el, "*");
473				});
474				support.scope = assert(function() {
475					return document.querySelectorAll(":scope");
476				});
477				support.cssHas = assert(function() {
478					try {
479						document.querySelector(":has(*,:jqfake)");
480						return false;
481					} catch (e) {
482						return true;
483					}
484				});
485				if (support.getById) {
486					Expr.filter.ID = function(id) {
487						var attrId = id.replace(runescape, funescape);
488						return function(elem) {
489							return elem.getAttribute("id") === attrId;
490						};
491					};
492					Expr.find.ID = function(id, context) {
493						if (typeof context.getElementById !== "undefined" && documentIsHTML) {
494							var elem = context.getElementById(id);
495							return elem ? [elem] : [];
496						}
497					};
498				} else {
499					Expr.filter.ID = function(id) {
500						var attrId = id.replace(runescape, funescape);
501						return function(elem) {
502							var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
503							return node && node.value === attrId;
504						};
505					};
506					Expr.find.ID = function(id, context) {
507						if (typeof context.getElementById !== "undefined" && documentIsHTML) {
508							var node, i, elems, elem = context.getElementById(id);
509							if (elem) {
510								node = elem.getAttributeNode("id");
511								if (node && node.value === id) return [elem];
512								elems = context.getElementsByName(id);
513								i = 0;
514								while (elem = elems[i++]) {
515									node = elem.getAttributeNode("id");
516									if (node && node.value === id) return [elem];
517								}
518							}
519							return [];
520						}
521					};
522				}
523				Expr.find.TAG = function(tag, context) {
524					if (typeof context.getElementsByTagName !== "undefined") return context.getElementsByTagName(tag);
525					else return context.querySelectorAll(tag);
526				};
527				Expr.find.CLASS = function(className, context) {
528					if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) return context.getElementsByClassName(className);
529				};
530				rbuggyQSA = [];
531				assert(function(el) {
532					var input;
533					documentElement.appendChild(el).innerHTML = "<a id='" + expando + "' href='' disabled='disabled'></a><select id='" + expando + "-\r\\' disabled='disabled'><option selected=''></option></select>";
534					if (!el.querySelectorAll("[selected]").length) rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
535					if (!el.querySelectorAll("[id~=" + expando + "-]").length) rbuggyQSA.push("~=");
536					if (!el.querySelectorAll("a#" + expando + "+*").length) rbuggyQSA.push(".#.+[+~]");
537					if (!el.querySelectorAll(":checked").length) rbuggyQSA.push(":checked");
538					input = document.createElement("input");
539					input.setAttribute("type", "hidden");
540					el.appendChild(input).setAttribute("name", "D");
541					documentElement.appendChild(el).disabled = true;
542					if (el.querySelectorAll(":disabled").length !== 2) rbuggyQSA.push(":enabled", ":disabled");
543					input = document.createElement("input");
544					input.setAttribute("name", "");
545					el.appendChild(input);
546					if (!el.querySelectorAll("[name='']").length) rbuggyQSA.push("\\[" + whitespace + "*name" + whitespace + "*=" + whitespace + "*(?:''|\"\")");
547				});
548				if (!support.cssHas) rbuggyQSA.push(":has");
549				rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
550				sortOrder = function(a, b) {
551					if (a === b) {
552						hasDuplicate = true;
553						return 0;
554					}
555					var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
556					if (compare) return compare;
557					compare = (a.ownerDocument || a) == (b.ownerDocument || b) ? a.compareDocumentPosition(b) : 1;
558					if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {
559						if (a === document || a.ownerDocument == preferredDoc && find.contains(preferredDoc, a)) return -1;
560						if (b === document || b.ownerDocument == preferredDoc && find.contains(preferredDoc, b)) return 1;
561						return sortInput ? indexOf.call(sortInput, a) - indexOf.call(sortInput, b) : 0;
562					}
563					return compare & 4 ? -1 : 1;
564				};
565				return document;
566			}
567			find.matches = function(expr, elements) {
568				return find(expr, null, null, elements);
569			};
570			find.matchesSelector = function(elem, expr) {
571				setDocument(elem);
572				if (documentIsHTML && !nonnativeSelectorCache[expr + " "] && (!rbuggyQSA || !rbuggyQSA.test(expr))) try {
573					var ret = matches.call(elem, expr);
574					if (ret || support.disconnectedMatch || elem.document && elem.document.nodeType !== 11) return ret;
575				} catch (e) {
576					nonnativeSelectorCache(expr, true);
577				}
578				return find(expr, document, null, [elem]).length > 0;
579			};
580			find.contains = function(context, elem) {
581				if ((context.ownerDocument || context) != document) setDocument(context);
582				return jQuery.contains(context, elem);
583			};
584			find.attr = function(elem, name) {
585				if ((elem.ownerDocument || elem) != document) setDocument(elem);
586				var fn = Expr.attrHandle[name.toLowerCase()], val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : void 0;
587				if (val !== void 0) return val;
588				return elem.getAttribute(name);
589			};
590			find.error = function(msg) {
591				throw new Error("Syntax error, unrecognized expression: " + msg);
592			};
593			/**
594			* Document sorting and removing duplicates
595			* @param {ArrayLike} results
596			*/
597			jQuery.uniqueSort = function(results) {
598				var elem, duplicates = [], j = 0, i = 0;
599				hasDuplicate = !support.sortStable;
600				sortInput = !support.sortStable && slice.call(results, 0);
601				sort.call(results, sortOrder);

602				if (hasDuplicate) {
603					while (elem = results[i++]) if (elem === results[i]) j = duplicates.push(i);
604					while (j--) splice.call(results, duplicates[j], 1);
605				}
606				sortInput = null;
607				return results;
608			};
609			jQuery.fn.uniqueSort = function() {
610				return this.pushStack(jQuery.uniqueSort(slice.apply(this)));
611			};
612			Expr = jQuery.expr = {
613				cacheLength: 50,
614				createPseudo: markFunction,
615				match: matchExpr,
616				attrHandle: {},
617				find: {},
618				relative: {
619					">": {
620						dir: "parentNode",
621						first: true
622					},
623					" ": { dir: "parentNode" },
624					"+": {
625						dir: "previousSibling",
626						first: true
627					},
628					"~": { dir: "previousSibling" }
629				},
630				preFilter: {
631					ATTR: function(match) {
632						match[1] = match[1].replace(runescape, funescape);
633						match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
634						if (match[2] === "~=") match[3] = " " + match[3] + " ";
635						return match.slice(0, 4);
636					},
637					CHILD: function(match) {
638						match[1] = match[1].toLowerCase();
639						if (match[1].slice(0, 3) === "nth") {
640							if (!match[3]) find.error(match[0]);
641							match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
642							match[5] = +(match[7] + match[8] || match[3] === "odd");
643						} else if (match[3]) find.error(match[0]);
644						return match;
645					},
646					PSEUDO: function(match) {
647						var excess, unquoted = !match[6] && match[2];
648						if (matchExpr.CHILD.test(match[0])) return null;
649						if (match[3]) match[2] = match[4] || match[5] || "";
650						else if (unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, true)) && (excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
651							match[0] = match[0].slice(0, excess);
652							match[2] = unquoted.slice(0, excess);
653						}
654						return match.slice(0, 3);
655					}
656				},
657				filter: {
658					TAG: function(nodeNameSelector) {
659						var expectedNodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
660						return nodeNameSelector === "*" ? function() {
661							return true;
662						} : function(elem) {
663							return nodeName(elem, expectedNodeName);
664						};
665					},
666					CLASS: function(className) {
667						var pattern = classCache[className + " "];
668						return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function(elem) {
669							return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
670						});
671					},
672					ATTR: function(name, operator, check) {
673						return function(elem) {
674							var result = find.attr(elem, name);
675							if (result == null) return operator === "!=";
676							if (!operator) return true;
677							result += "";
678							if (operator === "=") return result === check;
679							if (operator === "!=") return result !== check;
680							if (operator === "^=") return check && result.indexOf(check) === 0;
681							if (operator === "*=") return check && result.indexOf(check) > -1;
682							if (operator === "$=") return check && result.slice(-check.length) === check;
683							if (operator === "~=") return (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1;
684							if (operator === "|=") return result === check || result.slice(0, check.length + 1) === check + "-";
685							return false;
686						};
687					},
688					CHILD: function(type, what, _argument, first, last) {
689						var simple = type.slice(0, 3) !== "nth", forward = type.slice(-4) !== "last", ofType = what === "of-type";
690						return first === 1 && last === 0 ? function(elem) {
691							return !!elem.parentNode;
692						} : function(elem, _context, xml) {
693							var cache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false;

694							if (parent) {
695								if (simple) {
696									while (dir) {
697										node = elem;
698										while (node = node[dir]) if (ofType ? nodeName(node, name) : node.nodeType === 1) return false;
699										start = dir = type === "only" && !start && "nextSibling";
700									}
701									return true;
702								}
703								start = [forward ? parent.firstChild : parent.lastChild];
704								if (forward && useCache) {
705									outerCache = parent[expando] || (parent[expando] = {});
706									cache = outerCache[type] || [];
707									nodeIndex = cache[0] === dirruns && cache[1];
708									diff = nodeIndex && cache[2];
709									node = nodeIndex && parent.childNodes[nodeIndex];
710									while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) if (node.nodeType === 1 && ++diff && node === elem) {
711										outerCache[type] = [
712											dirruns,
713											nodeIndex,
714											diff
715										];
716										break;
717									}
718								} else {
719									if (useCache) {
720										outerCache = elem[expando] || (elem[expando] = {});
721										cache = outerCache[type] || [];
722										nodeIndex = cache[0] === dirruns && cache[1];
723										diff = nodeIndex;
724									}
725									if (diff === false) {
726										while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) if ((ofType ? nodeName(node, name) : node.nodeType === 1) && ++diff) {
727											if (useCache) {
728												outerCache = node[expando] || (node[expando] = {});
729												outerCache[type] = [dirruns, diff];
730											}
731											if (node === elem) break;
732										}
733									}
734								}
735								diff -= last;
736								return diff === first || diff % first === 0 && diff / first >= 0;
737							}
738						};
739					},
740					PSEUDO: function(pseudo, argument) {
741						var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || find.error("unsupported pseudo: " + pseudo);
742						if (fn[expando]) return fn(argument);
743						if (fn.length > 1) {
744							args = [
745								pseudo,
746								pseudo,
747								"",
748								argument
749							];
750							return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function(seed, matches) {
751								var idx, matched = fn(seed, argument), i = matched.length;
752								while (i--) {
753									idx = indexOf.call(seed, matched[i]);
754									seed[idx] = !(matches[idx] = matched[i]);
755								}
756							}) : function(elem) {
757								return fn(elem, 0, args);
758							};
759						}
760						return fn;
761					}
762				},
763				pseudos: {
764					not: markFunction(function(selector) {
765						var input = [], results = [], matcher = compile(selector.replace(rtrimCSS, "$1"));
766						return matcher[expando] ? markFunction(function(seed, matches, _context, xml) {
767							var elem, unmatched = matcher(seed, null, xml, []), i = seed.length;
768							while (i--) if (elem = unmatched[i]) seed[i] = !(matches[i] = elem);
769						}) : function(elem, _context, xml) {
770							input[0] = elem;
771							matcher(input, null, xml, results);
772							input[0] = null;
773							return !results.pop();
774						};
775					}),
776					has: markFunction(function(selector) {
777						return function(elem) {
778							return find(selector, elem).length > 0;
779						};
780					}),
781					contains: markFunction(function(text) {
782						text = text.replace(runescape, funescape);
783						return function(elem) {
784							return (elem.textContent || jQuery.text(elem)).indexOf(text) > -1;
785						};
786					}),
787					lang: markFunction(function(lang) {
788						if (!ridentifier.test(lang || "")) find.error("unsupported lang: " + lang);
789						lang = lang.replace(runescape, funescape).toLowerCase();
790						return function(elem) {
791							var elemLang;
792							do
793								if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
794									elemLang = elemLang.toLowerCase();
795									return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
796								}
797							while ((elem = elem.parentNode) && elem.nodeType === 1);
798							return false;
799						};
800					}),
801					target: function(elem) {
802						var hash = window.location && window.location.hash;
803						return hash && hash.slice(1) === elem.id;
804					},
805					root: function(elem) {
806						return elem === documentElement;
807					},
808					focus: function(elem) {
809						return elem === safeActiveElement() && document.hasFocus() && !!(elem.type || elem.href || ~elem.tabIndex);
810					},
811					enabled: createDisabledPseudo(false),
812					disabled: createDisabledPseudo(true),

813					checked: function(elem) {
814						return nodeName(elem, "input") && !!elem.checked || nodeName(elem, "option") && !!elem.selected;
815					},
816					selected: function(elem) {
817						if (elem.parentNode) elem.parentNode.selectedIndex;
818						return elem.selected === true;
819					},
820					empty: function(elem) {
821						for (elem = elem.firstChild; elem; elem = elem.nextSibling) if (elem.nodeType < 6) return false;
822						return true;
823					},
824					parent: function(elem) {
825						return !Expr.pseudos.empty(elem);
826					},
827					header: function(elem) {
828						return rheader.test(elem.nodeName);
829					},
830					input: function(elem) {
831						return rinputs.test(elem.nodeName);
832					},
833					button: function(elem) {
834						return nodeName(elem, "input") && elem.type === "button" || nodeName(elem, "button");
835					},
836					text: function(elem) {
837						var attr;
838						return nodeName(elem, "input") && elem.type === "text" && ((attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
839					},
840					first: createPositionalPseudo(function() {
841						return [0];
842					}),
843					last: createPositionalPseudo(function(_matchIndexes, length) {
844						return [length - 1];
845					}),
846					eq: createPositionalPseudo(function(_matchIndexes, length, argument) {
847						return [argument < 0 ? argument + length : argument];
848					}),
849					even: createPositionalPseudo(function(matchIndexes, length) {
850						var i = 0;
851						for (; i < length; i += 2) matchIndexes.push(i);
852						return matchIndexes;
853					}),
854					odd: createPositionalPseudo(function(matchIndexes, length) {
855						var i = 1;
856						for (; i < length; i += 2) matchIndexes.push(i);
857						return matchIndexes;
858					}),
859					lt: createPositionalPseudo(function(matchIndexes, length, argument) {
860						var i;
861						if (argument < 0) i = argument + length;
862						else if (argument > length) i = length;
863						else i = argument;
864						for (; --i >= 0;) matchIndexes.push(i);
865						return matchIndexes;
866					}),
867					gt: createPositionalPseudo(function(matchIndexes, length, argument) {
868						var i = argument < 0 ? argument + length : argument;
869						for (; ++i < length;) matchIndexes.push(i);
870						return matchIndexes;
871					})
872				}
873			};
874			Expr.pseudos.nth = Expr.pseudos.eq;
875			for (i in {
876				radio: true,
877				checkbox: true,
878				file: true,
879				password: true,
880				image: true
881			}) Expr.pseudos[i] = createInputPseudo(i);
882			for (i in {
883				submit: true,
884				reset: true
885			}) Expr.pseudos[i] = createButtonPseudo(i);
886			function setFilters() {}
887			setFilters.prototype = Expr.filters = Expr.pseudos;
888			Expr.setFilters = new setFilters();
889			function tokenize(selector, parseOnly) {
890				var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + " "];
891				if (cached) return parseOnly ? 0 : cached.slice(0);
892				soFar = selector;
893				groups = [];
894				preFilters = Expr.preFilter;
895				while (soFar) {
896					if (!matched || (match = rcomma.exec(soFar))) {
897						if (match) soFar = soFar.slice(match[0].length) || soFar;
898						groups.push(tokens = []);
899					}
900					matched = false;
901					if (match = rleadingCombinator.exec(soFar)) {
902						matched = match.shift();
903						tokens.push({
904							value: matched,
905							type: match[0].replace(rtrimCSS, " ")
906						});
907						soFar = soFar.slice(matched.length);
908					}
909					for (type in Expr.filter) if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
910						matched = match.shift();
911						tokens.push({
912							value: matched,
913							type,
914							matches: match
915						});
916						soFar = soFar.slice(matched.length);
917					}
918					if (!matched) break;
919				}
920				if (parseOnly) return soFar.length;
921				return soFar ? find.error(selector) : tokenCache(selector, groups).slice(0);
922			}
923			function toSelector(tokens) {
924				var i = 0, len = tokens.length, selector = "";
925				for (; i < len; i++) selector += tokens[i].value;
926				return selector;
927			}
928			function addCombinator(matcher, combinator, base) {
929				var dir = combinator.dir, skip = combinator.next, key = skip || dir, checkNonElements = base && key === "parentNode", doneName = done++;
930				return combinator.first ? function(elem, context, xml) {
931					while (elem = elem[dir]) if (elem.nodeType === 1 || checkNonElements) return matcher(elem, context, xml);
932					return false;

933				} : function(elem, context, xml) {
934					var oldCache, outerCache, newCache = [dirruns, doneName];
935					if (xml) {
936						while (elem = elem[dir]) if (elem.nodeType === 1 || checkNonElements) {
937							if (matcher(elem, context, xml)) return true;
938						}
939					} else while (elem = elem[dir]) if (elem.nodeType === 1 || checkNonElements) {
940						outerCache = elem[expando] || (elem[expando] = {});
941						if (skip && nodeName(elem, skip)) elem = elem[dir] || elem;
942						else if ((oldCache = outerCache[key]) && oldCache[0] === dirruns && oldCache[1] === doneName) return newCache[2] = oldCache[2];
943						else {
944							outerCache[key] = newCache;
945							if (newCache[2] = matcher(elem, context, xml)) return true;
946						}
947					}
948					return false;
949				};
950			}
951			function elementMatcher(matchers) {
952				return matchers.length > 1 ? function(elem, context, xml) {
953					var i = matchers.length;
954					while (i--) if (!matchers[i](elem, context, xml)) return false;
955					return true;
956				} : matchers[0];
957			}
958			function multipleContexts(selector, contexts, results) {
959				var i = 0, len = contexts.length;
960				for (; i < len; i++) find(selector, contexts[i], results);
961				return results;
962			}
963			function condense(unmatched, map, filter, context, xml) {
964				var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null;
965				for (; i < len; i++) if (elem = unmatched[i]) {
966					if (!filter || filter(elem, context, xml)) {
967						newUnmatched.push(elem);
968						if (mapped) map.push(i);
969					}
970				}
971				return newUnmatched;
972			}
973			function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
974				if (postFilter && !postFilter[expando]) postFilter = setMatcher(postFilter);
975				if (postFinder && !postFinder[expando]) postFinder = setMatcher(postFinder, postSelector);
976				return markFunction(function(seed, results, context, xml) {
977					var temp, i, elem, matcherOut, preMap = [], postMap = [], preexisting = results.length, elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []), matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems;
978					if (matcher) {
979						matcherOut = postFinder || (seed ? preFilter : preexisting || postFilter) ? [] : results;
980						matcher(matcherIn, matcherOut, context, xml);
981					} else matcherOut = matcherIn;
982					if (postFilter) {
983						temp = condense(matcherOut, postMap);
984						postFilter(temp, [], context, xml);
985						i = temp.length;
986						while (i--) if (elem = temp[i]) matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
987					}
988					if (seed) {
989						if (postFinder || preFilter) {
990							if (postFinder) {
991								temp = [];
992								i = matcherOut.length;
993								while (i--) if (elem = matcherOut[i]) temp.push(matcherIn[i] = elem);
994								postFinder(null, matcherOut = [], temp, xml);
995							}
996							i = matcherOut.length;
997							while (i--) if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf.call(seed, elem) : preMap[i]) > -1) seed[temp] = !(results[temp] = elem);
998						}
999					} else {
1000						matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
1001						if (postFinder) postFinder(null, results, matcherOut, xml);
1002						else push.apply(results, matcherOut);
1003					}
1004				});
1005			}
1006			function matcherFromTokens(tokens) {
1007				var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative || Expr.relative[" "], i = leadingRelative ? 1 : 0, matchContext = addCombinator(function(elem) {
1008					return elem === checkContext;
1009				}, implicitRelative, true), matchAnyContext = addCombinator(function(elem) {
1010					return indexOf.call(checkContext, elem) > -1;
1011				}, implicitRelative, true), matchers = [function(elem, context, xml) {
1012					var ret = !leadingRelative && (xml || context != outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
1013					checkContext = null;
1014					return ret;
1015				}];
1016				for (; i < len; i++) if (matcher = Expr.relative[tokens[i].type]) matchers = [addCombinator(elementMatcher(matchers), matcher)];
1017				else {
1018					matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
1019					if (matcher[expando]) {
1020						j = ++i;
1021						for (; j < len; j++) if (Expr.relative[tokens[j].type]) break;
1022						return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === " " ? "*" : "" })).replace(rtrimCSS, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
1023					}
1024					matchers.push(matcher);
1025				}
1026				return elementMatcher(matchers);
1027			}
1028			function matcherFromGroupMatchers(elementMatchers, setMatchers) {
1029				var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function(seed, context, xml, results, outermost) {
1030					var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, elems = seed || byElement && Expr.find.TAG("*", outermost), dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || .1, len = elems.length;
1031					if (outermost) outermostContext = context == document || context || outermost;
1032					for (; i !== len && (elem = elems[i]) != null; i++) {
1033						if (byElement && elem) {
1034							j = 0;
1035							if (!context && elem.ownerDocument != document) {
1036								setDocument(elem);
1037								xml = !documentIsHTML;
1038							}
1039							while (matcher = elementMatchers[j++]) if (matcher(elem, context || document, xml)) {
1040								push.call(results, elem);
1041								break;
1042							}
1043							if (outermost) dirruns = dirrunsUnique;
1044						}
1045						if (bySet) {
1046							if (elem = !matcher && elem) matchedCount--;
1047							if (seed) unmatched.push(elem);
1048						}
1049					}
1050					matchedCount += i;
1051					if (bySet && i !== matchedCount) {
1052						j = 0;
1053						while (matcher = setMatchers[j++]) matcher(unmatched, setMatched, context, xml);
1054						if (seed) {
1055							if (matchedCount > 0) {

1056								while (i--) if (!(unmatched[i] || setMatched[i])) setMatched[i] = pop.call(results);
1057							}
1058							setMatched = condense(setMatched);
1059						}
1060						push.apply(results, setMatched);
1061						if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) jQuery.uniqueSort(results);
1062					}
1063					if (outermost) {
1064						dirruns = dirrunsUnique;
1065						outermostContext = contextBackup;
1066					}
1067					return unmatched;
1068				};
1069				return bySet ? markFunction(superMatcher) : superMatcher;
1070			}
1071			function compile(selector, match) {
1072				var i, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + " "];
1073				if (!cached) {
1074					if (!match) match = tokenize(selector);
1075					i = match.length;
1076					while (i--) {
1077						cached = matcherFromTokens(match[i]);
1078						if (cached[expando]) setMatchers.push(cached);
1079						else elementMatchers.push(cached);
1080					}
1081					cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
1082					cached.selector = selector;
1083				}
1084				return cached;
1085			}
1086			/**
1087			* A low-level selection function that works with jQuery's compiled
1088			*  selector functions
1089			* @param {String|Function} selector A selector or a pre-compiled
1090			*  selector function built with jQuery selector compile
1091			* @param {Element} context
1092			* @param {Array} [results]
1093			* @param {Array} [seed] A set of elements to match against
1094			*/
1095			function select(selector, context, results, seed) {
1096				var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed && tokenize(selector = compiled.selector || selector);
1097				results = results || [];
1098				if (match.length === 1) {
1099					tokens = match[0] = match[0].slice(0);
1100					if (tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
1101						context = (Expr.find.ID(token.matches[0].replace(runescape, funescape), context) || [])[0];
1102						if (!context) return results;
1103						else if (compiled) context = context.parentNode;
1104						selector = selector.slice(tokens.shift().value.length);
1105					}
1106					i = matchExpr.needsContext.test(selector) ? 0 : tokens.length;
1107					while (i--) {
1108						token = tokens[i];
1109						if (Expr.relative[type = token.type]) break;
1110						if (find = Expr.find[type]) {
1111							if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {
1112								tokens.splice(i, 1);
1113								selector = seed.length && toSelector(tokens);
1114								if (!selector) {
1115									push.apply(results, seed);
1116									return results;
1117								}
1118								break;
1119							}
1120						}
1121					}
1122				}
1123				(compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
1124				return results;
1125			}
1126			support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
1127			setDocument();
1128			support.sortDetached = assert(function(el) {
1129				return el.compareDocumentPosition(document.createElement("fieldset")) & 1;
1130			});
1131			jQuery.find = find;
1132			jQuery.expr[":"] = jQuery.expr.pseudos;
1133			jQuery.unique = jQuery.uniqueSort;
1134			find.compile = compile;
1135			find.select = select;
1136			find.setDocument = setDocument;
1137			find.tokenize = tokenize;
1138			find.escape = jQuery.escapeSelector;
1139			find.getText = jQuery.text;
1140			find.isXML = jQuery.isXMLDoc;
1141			find.selectors = jQuery.expr;
1142			find.support = jQuery.support;
1143			find.uniqueSort = jQuery.uniqueSort;
1144		})();
1145		var dir = function(elem, dir, until) {
1146			var matched = [], truncate = until !== void 0;
1147			while ((elem = elem[dir]) && elem.nodeType !== 9) if (elem.nodeType === 1) {
1148				if (truncate && jQuery(elem).is(until)) break;
1149				matched.push(elem);
1150			}
1151			return matched;
1152		};
1153		var siblings = function(n, elem) {
1154			var matched = [];
1155			for (; n; n = n.nextSibling) if (n.nodeType === 1 && n !== elem) matched.push(n);
1156			return matched;
1157		};
1158		var rneedsContext = jQuery.expr.match.needsContext;
1159		var rsingleTag = /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;
1160		function winnow(elements, qualifier, not) {
1161			if (isFunction(qualifier)) return jQuery.grep(elements, function(elem, i) {
1162				return !!qualifier.call(elem, i, elem) !== not;
1163			});
1164			if (qualifier.nodeType) return jQuery.grep(elements, function(elem) {
1165				return elem === qualifier !== not;
1166			});
1167			if (typeof qualifier !== "string") return jQuery.grep(elements, function(elem) {
1168				return indexOf.call(qualifier, elem) > -1 !== not;
1169			});
1170			return jQuery.filter(qualifier, elements, not);
1171		}
1172		jQuery.filter = function(expr, elems, not) {
1173			var elem = elems[0];
1174			if (not) expr = ":not(" + expr + ")";
1175			if (elems.length === 1 && elem.nodeType === 1) return jQuery.find.matchesSelector(elem, expr) ? [elem] : [];
1176			return jQuery.find.matches(expr, jQuery.grep(elems, function(elem) {
1177				return elem.nodeType === 1;
1178			}));
1179		};
1180		jQuery.fn.extend({
1181			find: function(selector) {
1182				var i, ret, len = this.length, self = this;
1183				if (typeof selector !== "string") return this.pushStack(jQuery(selector).filter(function() {
1184					for (i = 0; i < len;

1184 i++) if (jQuery.contains(self[i], this)) return true;
1185				}));
1186				ret = this.pushStack([]);
1187				for (i = 0; i < len; i++) jQuery.find(selector, self[i], ret);
1188				return len > 1 ? jQuery.uniqueSort(ret) : ret;
1189			},
1190			filter: function(selector) {
1191				return this.pushStack(winnow(this, selector || [], false));
1192			},
1193			not: function(selector) {
1194				return this.pushStack(winnow(this, selector || [], true));
1195			},
1196			is: function(selector) {
1197				return !!winnow(this, typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;
1198			}
1199		});
1200		var rootjQuery, rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, init = jQuery.fn.init = function(selector, context, root) {
1201			var match, elem;
1202			if (!selector) return this;
1203			root = root || rootjQuery;
1204			if (typeof selector === "string") {
1205				if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) match = [
1206					null,
1207					selector,
1208					null
1209				];
1210				else match = rquickExpr.exec(selector);
1211				if (match && (match[1] || !context)) if (match[1]) {
1212					context = context instanceof jQuery ? context[0] : context;
1213					jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true));
1214					if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) for (match in context) if (isFunction(this[match])) this[match](context[match]);
1215					else this.attr(match, context[match]);
1216					return this;
1217				} else {
1218					elem = document.getElementById(match[2]);
1219					if (elem) {
1220						this[0] = elem;
1221						this.length = 1;
1222					}
1223					return this;
1224				}
1225				else if (!context || context.jquery) return (context || root).find(selector);
1226				else return this.constructor(context).find(selector);
1227			} else if (selector.nodeType) {
1228				this[0] = selector;
1229				this.length = 1;
1230				return this;
1231			} else if (isFunction(selector)) return root.ready !== void 0 ? root.ready(selector) : selector(jQuery);
1232			return jQuery.makeArray(selector, this);
1233		};
1234		init.prototype = jQuery.fn;
1235		rootjQuery = jQuery(document);
1236		var rparentsprev = /^(?:parents|prev(?:Until|All))/, guaranteedUnique = {
1237			children: true,
1238			contents: true,
1239			next: true,
1240			prev: true
1241		};
1242		jQuery.fn.extend({
1243			has: function(target) {
1244				var targets = jQuery(target, this), l = targets.length;
1245				return this.filter(function() {
1246					var i = 0;
1247					for (; i < l; i++) if (jQuery.contains(this, targets[i])) return true;
1248				});
1249			},
1250			closest: function(selectors, context) {
1251				var cur, i = 0, l = this.length, matched = [], targets = typeof selectors !== "string" && jQuery(selectors);
1252				if (!rneedsContext.test(selectors)) {
1253					for (; i < l; i++) for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) if (cur.nodeType < 11 && (targets ? targets.index(cur) > -1 : cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) {
1254						matched.push(cur);
1255						break;
1256					}
1257				}
1258				return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched);
1259			},
1260			index: function(elem) {
1261				if (!elem) return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
1262				if (typeof elem === "string") return indexOf.call(jQuery(elem), this[0]);
1263				return indexOf.call(this, elem.jquery ? elem[0] : elem);
1264			},
1265			add: function(selector, context) {
1266				return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(selector, context))));
1267			},
1268			addBack: function(selector) {
1269				return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector));
1270			}
1271		});
1272		function sibling(cur, dir) {
1273			while ((cur = cur[dir]) && cur.nodeType !== 1);
1274			return cur;
1275		}
1276		jQuery.each({
1277			parent: function(elem) {
1278				var parent = elem.parentNode;
1279				return parent && parent.nodeType !== 11 ? parent : null;
1280			},
1281			parents: function(elem) {
1282				return dir(elem, "parentNode");
1283			},
1284			parentsUntil: function(elem, _i, until) {
1285				return dir(elem, "parentNode", until);
1286			},
1287			next: function(elem) {
1288				return sibling(elem, "nextSibling");
1289			},
1290			prev: function(elem) {
1291				return sibling(elem, "previousSibling");
1292			},
1293			nextAll: function(elem) {
1294				return dir(elem, "nextSibling");
1295			},
1296			prevAll: function(elem) {
1297				return dir(elem, "previousSibling");
1298			},
1299			nextUntil: function(elem, _i, until) {
1300				return dir(elem, "nextSibling", until);
1301			},
1302			prevUntil: function(elem, _i, until) {
1303				return dir(elem, "previousSibling", until);
1304			},
1305			siblings: function(elem) {
1306				return siblings((elem.parentNode || {}).firstChild, elem);
1307			},
1308			children: function(elem) {
1309				return siblings(elem.firstChild);
1310			},

1311			contents: function(elem) {
1312				if (elem.contentDocument != null && getProto(elem.contentDocument)) return elem.contentDocument;
1313				if (nodeName(elem, "template")) elem = elem.content || elem;
1314				return jQuery.merge([], elem.childNodes);
1315			}
1316		}, function(name, fn) {
1317			jQuery.fn[name] = function(until, selector) {
1318				var matched = jQuery.map(this, fn, until);
1319				if (name.slice(-5) !== "Until") selector = until;
1320				if (selector && typeof selector === "string") matched = jQuery.filter(selector, matched);
1321				if (this.length > 1) {
1322					if (!guaranteedUnique[name]) jQuery.uniqueSort(matched);
1323					if (rparentsprev.test(name)) matched.reverse();
1324				}
1325				return this.pushStack(matched);
1326			};
1327		});
1328		var rnothtmlwhite = /[^\x20\t\r\n\f]+/g;
1329		function createOptions(options) {
1330			var object = {};
1331			jQuery.each(options.match(rnothtmlwhite) || [], function(_, flag) {
1332				object[flag] = true;
1333			});
1334			return object;
1335		}
1336		jQuery.Callbacks = function(options) {
1337			options = typeof options === "string" ? createOptions(options) : jQuery.extend({}, options);
1338			var firing, memory, fired, locked, list = [], queue = [], firingIndex = -1, fire = function() {
1339				locked = locked || options.once;
1340				fired = firing = true;
1341				for (; queue.length; firingIndex = -1) {
1342					memory = queue.shift();
1343					while (++firingIndex < list.length) if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {
1344						firingIndex = list.length;
1345						memory = false;
1346					}
1347				}
1348				if (!options.memory) memory = false;
1349				firing = false;
1350				if (locked) if (memory) list = [];
1351				else list = "";
1352			}, self = {
1353				add: function() {
1354					if (list) {
1355						if (memory && !firing) {
1356							firingIndex = list.length - 1;
1357							queue.push(memory);
1358						}
1359						(function add(args) {
1360							jQuery.each(args, function(_, arg) {
1361								if (isFunction(arg)) {
1362									if (!options.unique || !self.has(arg)) list.push(arg);
1363								} else if (arg && arg.length && toType(arg) !== "string") add(arg);
1364							});
1365						})(arguments);
1366						if (memory && !firing) fire();
1367					}
1368					return this;
1369				},
1370				remove: function() {
1371					jQuery.each(arguments, function(_, arg) {
1372						var index;
1373						while ((index = jQuery.inArray(arg, list, index)) > -1) {
1374							list.splice(index, 1);
1375							if (index <= firingIndex) firingIndex--;
1376						}
1377					});
1378					return this;
1379				},
1380				has: function(fn) {
1381					return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0;
1382				},
1383				empty: function() {
1384					if (list) list = [];
1385					return this;
1386				},
1387				disable: function() {
1388					locked = queue = [];
1389					list = memory = "";
1390					return this;
1391				},
1392				disabled: function() {
1393					return !list;
1394				},
1395				lock: function() {
1396					locked = queue = [];
1397					if (!memory && !firing) list = memory = "";
1398					return this;
1399				},
1400				locked: function() {
1401					return !!locked;
1402				},
1403				fireWith: function(context, args) {
1404					if (!locked) {
1405						args = args || [];
1406						args = [context, args.slice ? args.slice() : args];
1407						queue.push(args);
1408						if (!firing) fire();
1409					}
1410					return this;
1411				},
1412				fire: function() {
1413					self.fireWith(this, arguments);
1414					return this;
1415				},
1416				fired: function() {
1417					return !!fired;
1418				}
1419			};
1420			return self;
1421		};
1422		function Identity(v) {
1423			return v;
1424		}
1425		function Thrower(ex) {
1426			throw ex;
1427		}
1428		function adoptValue(value, resolve, reject, noValue) {
1429			var method;
1430			try {
1431				if (value && isFunction(method = value.promise)) method.call(value).done(resolve).fail(reject);
1432				else if (value && isFunction(method = value.then)) method.call(value, resolve, reject);
1433				else resolve.apply(void 0, [value].slice(noValue));
1434			} catch (value) {
1435				reject.apply(void 0, [value]);
1436			}
1437		}
1438		jQuery.extend({
1439			Deferred: function(func) {
1440				var tuples = [
1441					[
1442						"notify",
1443						"progress",
1444						jQuery.Callbacks("memory"),
1445						jQuery.Callbacks("memory"),
1446						2
1447					],
1448					[
1449						"resolve",
1450						"done",
1451						jQuery.Callbacks("once memory"),
1452						jQuery.Callbacks("once memory"),
1453						0,
1454						"resolved"
1455					],
1456					[
1457						"reject",
1458						"fail",
1459						jQuery.Callbacks("once memory"),
1460						jQuery.Callbacks("once memory"),
1461						1,
1462						"rejected"
1463					]
1464				], state = "pending", promise = {
1465					state: function() {
1466						return state;
1467					},
1468					always: function() {
1469						deferred.done(arguments).fail(arguments);
1470						return this;
1471					},
1472					"catch": function(fn) {
1473						return promise.then(null, fn);
1474					},
1475					pipe: function() {
1476						var fns = arguments;
1477						return jQuery.Deferred(function(newDefer) {
1478							jQuery.each(tuples, function(_i, tuple) {
1479								var fn = isFunction(fns[tuple[4]]) && fns[tuple[4]];
1480								deferred[tuple[1]](function() {
1481									var returned = fn && fn.apply(this, arguments);
1482									if (returned && isFunction(returned.promise)) returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
1483									else newDefer[tuple[0] + "With"](this, fn ? [returned] : arguments);
1484								});
1485							});
1486							fns = null;
1487						}).promise();
1488					},
1489					then: function(onFulfilled, onRejected, onProgress) {
1490						var maxDepth = 0;
1491						function resolve(depth, deferred, handler, special) {
1492							return function() {
1493								var that = this, args = arguments, mightThrow = function() {
1494									var returned, then;
1495									if (depth < maxDepth) return;
1496									returned = handler.apply(that, args);
1497									if (returned === deferred.promise()) throw new TypeError("Thenable self

1497-resolution");
1498									then = returned && (typeof returned === "object" || typeof returned === "function") && returned.then;
1499									if (isFunction(then)) if (special) then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special));
1500									else {
1501										maxDepth++;
1502										then.call(returned, resolve(maxDepth, deferred, Identity, special), resolve(maxDepth, deferred, Thrower, special), resolve(maxDepth, deferred, Identity, deferred.notifyWith));
1503									}
1504									else {
1505										if (handler !== Identity) {
1506											that = void 0;
1507											args = [returned];
1508										}
1509										(special || deferred.resolveWith)(that, args);
1510									}
1511								}, process = special ? mightThrow : function() {
1512									try {
1513										mightThrow();
1514									} catch (e) {
1515										if (jQuery.Deferred.exceptionHook) jQuery.Deferred.exceptionHook(e, process.error);
1516										if (depth + 1 >= maxDepth) {
1517											if (handler !== Thrower) {
1518												that = void 0;
1519												args = [e];
1520											}
1521											deferred.rejectWith(that, args);
1522										}
1523									}
1524								};
1525								if (depth) process();
1526								else {
1527									if (jQuery.Deferred.getErrorHook) process.error = jQuery.Deferred.getErrorHook();
1528									else if (jQuery.Deferred.getStackHook) process.error = jQuery.Deferred.getStackHook();
1529									window.setTimeout(process);
1530								}
1531							};
1532						}
1533						return jQuery.Deferred(function(newDefer) {
1534							tuples[0][3].add(resolve(0, newDefer, isFunction(onProgress) ? onProgress : Identity, newDefer.notifyWith));
1535							tuples[1][3].add(resolve(0, newDefer, isFunction(onFulfilled) ? onFulfilled : Identity));
1536							tuples[2][3].add(resolve(0, newDefer, isFunction(onRejected) ? onRejected : Thrower));
1537						}).promise();
1538					},
1539					promise: function(obj) {
1540						return obj != null ? jQuery.extend(obj, promise) : promise;
1541					}
1542				}, deferred = {};
1543				jQuery.each(tuples, function(i, tuple) {
1544					var list = tuple[2], stateString = tuple[5];
1545					promise[tuple[1]] = list.add;
1546					if (stateString) list.add(function() {
1547						state = stateString;
1548					}, tuples[3 - i][2].disable, tuples[3 - i][3].disable, tuples[0][2].lock, tuples[0][3].lock);
1549					list.add(tuple[3].fire);
1550					deferred[tuple[0]] = function() {
1551						deferred[tuple[0] + "With"](this === deferred ? void 0 : this, arguments);
1552						return this;
1553					};
1554					deferred[tuple[0] + "With"] = list.fireWith;
1555				});
1556				promise.promise(deferred);
1557				if (func) func.call(deferred, deferred);
1558				return deferred;
1559			},
1560			when: function(singleValue) {
1561				var remaining = arguments.length, i = remaining, resolveContexts = Array(i), resolveValues = slice.call(arguments), primary = jQuery.Deferred(), updateFunc = function(i) {
1562					return function(value) {
1563						resolveContexts[i] = this;
1564						resolveValues[i] = arguments.length > 1 ? slice.call(arguments) : value;
1565						if (!--remaining) primary.resolveWith(resolveContexts, resolveValues);
1566					};
1567				};
1568				if (remaining <= 1) {
1569					adoptValue(singleValue, primary.done(updateFunc(i)).resolve, primary.reject, !remaining);
1570					if (primary.state() === "pending" || isFunction(resolveValues[i] && resolveValues[i].then)) return primary.then();
1571				}
1572				while (i--) adoptValue(resolveValues[i], updateFunc(i), primary.reject);
1573				return primary.promise();
1574			}
1575		});
1576		var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
1577		jQuery.Deferred.exceptionHook = function(error, asyncError) {
1578			if (window.console && window.console.warn && error && rerrorNames.test(error.name)) window.console.warn("jQuery.Deferred exception: " + error.message, error.stack, asyncError);
1579		};
1580		jQuery.readyException = function(error) {
1581			window.setTimeout(function() {
1582				throw error;
1583			});
1584		};
1585		var readyList = jQuery.Deferred();
1586		jQuery.fn.ready = function(fn) {
1587			readyList.then(fn).catch(function(error) {
1588				jQuery.readyException(error);
1589			});
1590			return this;
1591		};
1592		jQuery.extend({
1593			isReady: false,
1594			readyWait: 1,
1595			ready: function(wait) {
1596				if (wait === true ? --jQuery.readyWait : jQuery.isReady) return;
1597				jQuery.isReady = true;
1598				if (wait !== true && --jQuery.readyWait > 0) return;
1599				readyList.resolveWith(document, [jQuery]);
1600			}
1601		});
1602		jQuery.ready.then = readyList.then;
1603		function completed() {
1604			document.removeEventListener("DOMContentLoaded", completed);
1605			window.removeEventListener("load", completed);
1606			jQuery.ready();
1607		}
1608		if (document.readyState === "complete" || document.readyState !== "loading" && !document.documentElement.doScroll) window.setTimeout(jQuery.ready);
1609		else {
1610			document.addEventListener("DOMContentLoaded", completed);
1611			window.addEventListener("load", completed);
1612		}
1613		var access = function(elems, fn, key, value, chainable, emptyGet, raw) {
1614			var i = 0, len = elems.length, bulk = key == null;
1615			if (toType(key) === "object") {
1616				chainable = true;
1617				for (i in key) access(elems, fn, i, key[i], true, emptyGet, raw);
1618			} else if (value !== void 0) {
1619				chainable = true;
1620				if (!isFunction(value)) raw = true;
1621				if (bulk) if (raw) {
1622					fn.call(elems, value);
1623					fn = null;
1624				} else {
1625					bulk = fn;
1626					fn = function(elem, _key, value) {

1627						return bulk.call(jQuery(elem), value);
1628					};
1629				}
1630				if (fn) for (; i < len; i++) fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
1631			}
1632			if (chainable) return elems;
1633			if (bulk) return fn.call(elems);
1634			return len ? fn(elems[0], key) : emptyGet;
1635		};
1636		var rmsPrefix = /^-ms-/, rdashAlpha = /-([a-z])/g;
1637		function fcamelCase(_all, letter) {
1638			return letter.toUpperCase();
1639		}
1640		function camelCase(string) {
1641			return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
1642		}
1643		var acceptData = function(owner) {
1644			return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType;
1645		};
1646		function Data() {
1647			this.expando = jQuery.expando + Data.uid++;
1648		}
1649		Data.uid = 1;
1650		Data.prototype = {
1651			cache: function(owner) {
1652				var value = owner[this.expando];
1653				if (!value) {
1654					value = {};
1655					if (acceptData(owner)) if (owner.nodeType) owner[this.expando] = value;
1656					else Object.defineProperty(owner, this.expando, {
1657						value,
1658						configurable: true
1659					});
1660				}
1661				return value;
1662			},
1663			set: function(owner, data, value) {
1664				var prop, cache = this.cache(owner);
1665				if (typeof data === "string") cache[camelCase(data)] = value;
1666				else for (prop in data) cache[camelCase(prop)] = data[prop];
1667				return cache;
1668			},
1669			get: function(owner, key) {
1670				return key === void 0 ? this.cache(owner) : owner[this.expando] && owner[this.expando][camelCase(key)];
1671			},
1672			access: function(owner, key, value) {
1673				if (key === void 0 || key && typeof key === "string" && value === void 0) return this.get(owner, key);
1674				this.set(owner, key, value);
1675				return value !== void 0 ? value : key;
1676			},
1677			remove: function(owner, key) {
1678				var i, cache = owner[this.expando];
1679				if (cache === void 0) return;
1680				if (key !== void 0) {
1681					if (Array.isArray(key)) key = key.map(camelCase);
1682					else {
1683						key = camelCase(key);
1684						key = key in cache ? [key] : key.match(rnothtmlwhite) || [];
1685					}
1686					i = key.length;
1687					while (i--) delete cache[key[i]];
1688				}
1689				if (key === void 0 || jQuery.isEmptyObject(cache)) if (owner.nodeType) owner[this.expando] = void 0;
1690				else delete owner[this.expando];
1691			},
1692			hasData: function(owner) {
1693				var cache = owner[this.expando];
1694				return cache !== void 0 && !jQuery.isEmptyObject(cache);
1695			}
1696		};
1697		var dataPriv = new Data();
1698		var dataUser = new Data();
1699		var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /[A-Z]/g;
1700		function getData(data) {
1701			if (data === "true") return true;
1702			if (data === "false") return false;
1703			if (data === "null") return null;
1704			if (data === +data + "") return +data;
1705			if (rbrace.test(data)) return JSON.parse(data);
1706			return data;
1707		}
1708		function dataAttr(elem, key, data) {
1709			var name;
1710			if (data === void 0 && elem.nodeType === 1) {
1711				name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase();
1712				data = elem.getAttribute(name);
1713				if (typeof data === "string") {
1714					try {
1715						data = getData(data);
1716					} catch (e) {}
1717					dataUser.set(elem, key, data);
1718				} else data = void 0;
1719			}
1720			return data;
1721		}
1722		jQuery.extend({
1723			hasData: function(elem) {
1724				return dataUser.hasData(elem) || dataPriv.hasData(elem);
1725			},
1726			data: function(elem, name, data) {
1727				return dataUser.access(elem, name, data);
1728			},
1729			removeData: function(elem, name) {
1730				dataUser.remove(elem, name);
1731			},
1732			_data: function(elem, name, data) {
1733				return dataPriv.access(elem, name, data);
1734			},
1735			_removeData: function(elem, name) {
1736				dataPriv.remove(elem, name);
1737			}
1738		});
1739		jQuery.fn.extend({
1740			data: function(key, value) {
1741				var i, name, data, elem = this[0], attrs = elem && elem.attributes;
1742				if (key === void 0) {
1743					if (this.length) {
1744						data = dataUser.get(elem);
1745						if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) {
1746							i = attrs.length;
1747							while (i--) if (attrs[i]) {
1748								name = attrs[i].name;
1749								if (name.indexOf("data-") === 0) {
1750									name = camelCase(name.slice(5));
1751									dataAttr(elem, name, data[name]);
1752								}
1753							}
1754							dataPriv.set(elem, "hasDataAttrs", true);
1755						}
1756					}
1757					return data;
1758				}
1759				if (typeof key === "object") return this.each(function() {
1760					dataUser.set(this, key);
1761				});
1762				return access(this, function(value) {
1763					var data;
1764					if (elem && value === void 0) {
1765						data = dataUser.get(elem, key);
1766						if (data !== void 0) return data;
1767						data = dataAttr(elem, key);
1768						if (data !== void 0) return data;
1769						return;
1770					}
1771					this.each(function() {
1772						dataUser.set(this, key, value);
1773					});
1774				}, null, value, arguments.length > 1, null, true);
1775			},
1776			removeData: function(key) {
1777				return this.each(function() {
1778					dataUser.remove(this, key);
1779				});
1780			}
1781		});
1782		jQuery.extend({
1783			queue: function(elem, type, data) {
1784				var queue;
1785				if (elem) {
1786					type = (type || "fx") + "queue";
1787					queue = dataPriv.get(elem, type);
1788					if (data) if (!queue || Array.isArray(data)) queue = dataPriv.access(elem, type, jQuery.makeArray(data));
1789					else queue.push(data);
1790					return queue || [];
1791				}
1792			},
1793			dequeue: function(elem, type) {
1794				type = type || "fx";
1795				var queue = jQuery.queue(elem, type), startLength = queue.length, fn = queue.shift(), hooks = jQuery._queueHooks(elem, type), next = function() {
1796					jQuery.dequeue(elem, type);
1797				};
1798				if (fn === "inprogress") {
1799					fn = queue.shift();
1800					startLength--;
1801				}
1802				if (fn) {
1803					if (type === "fx") queue.unshift("inprogress");
1804					delete hooks.stop;
1805					fn.call(elem, next, hooks);
1806				}
1807				if (!startLength && hooks) hooks.empty.fire();
1808			},
1809			_queueHooks: function(elem, type) {
1810				var key = type + "queueHooks";
1811				return dataPriv.get(elem, key) || dataPriv.access(elem, key, { empty: jQuery.Callbacks("once memory").add(function() {
1812					dataPriv.remove(elem, [type + "queue", key]);
1813				}) });
1814			}
1815		});
1816		jQuery.fn.extend({
1817			queue: function(type, data) {
1818				var setter = 2;
1819				if (typeof type !== "string") {
1820					data = type;
1821					type = "fx";
1822					setter--;
1823				}
1824				if (arguments.length < setter) return jQuery.queue(this[0], type);

1825				return data === void 0 ? this : this.each(function() {
1826					var queue = jQuery.queue(this, type, data);
1827					jQuery._queueHooks(this, type);
1828					if (type === "fx" && queue[0] !== "inprogress") jQuery.dequeue(this, type);
1829				});
1830			},
1831			dequeue: function(type) {
1832				return this.each(function() {
1833					jQuery.dequeue(this, type);
1834				});
1835			},
1836			clearQueue: function(type) {
1837				return this.queue(type || "fx", []);
1838			},
1839			promise: function(type, obj) {
1840				var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() {
1841					if (!--count) defer.resolveWith(elements, [elements]);
1842				};
1843				if (typeof type !== "string") {
1844					obj = type;
1845					type = void 0;
1846				}
1847				type = type || "fx";
1848				while (i--) {
1849					tmp = dataPriv.get(elements[i], type + "queueHooks");
1850					if (tmp && tmp.empty) {
1851						count++;
1852						tmp.empty.add(resolve);
1853					}
1854				}
1855				resolve();
1856				return defer.promise(obj);
1857			}
1858		});
1859		var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
1860		var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i");
1861		var cssExpand = [
1862			"Top",
1863			"Right",
1864			"Bottom",
1865			"Left"
1866		];
1867		var documentElement = document.documentElement;
1868		var isAttached = function(elem) {
1869			return jQuery.contains(elem.ownerDocument, elem);
1870		}, composed = { composed: true };
1871		if (documentElement.getRootNode) isAttached = function(elem) {
1872			return jQuery.contains(elem.ownerDocument, elem) || elem.getRootNode(composed) === elem.ownerDocument;
1873		};
1874		var isHiddenWithinTree = function(elem, el) {
1875			elem = el || elem;
1876			return elem.style.display === "none" || elem.style.display === "" && isAttached(elem) && jQuery.css(elem, "display") === "none";
1877		};
1878		function adjustCSS(elem, prop, valueParts, tween) {
1879			var adjusted, scale, maxIterations = 20, currentValue = tween ? function() {
1880				return tween.cur();
1881			} : function() {
1882				return jQuery.css(elem, prop, "");
1883			}, initial = currentValue(), unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px"), initialInUnit = elem.nodeType && (jQuery.cssNumber[prop] || unit !== "px" && +initial) && rcssNum.exec(jQuery.css(elem, prop));
1884			if (initialInUnit && initialInUnit[3] !== unit) {
1885				initial = initial / 2;
1886				unit = unit || initialInUnit[3];
1887				initialInUnit = +initial || 1;
1888				while (maxIterations--) {
1889					jQuery.style(elem, prop, initialInUnit + unit);
1890					if ((1 - scale) * (1 - (scale = currentValue() / initial || .5)) <= 0) maxIterations = 0;
1891					initialInUnit = initialInUnit / scale;
1892				}
1893				initialInUnit = initialInUnit * 2;
1894				jQuery.style(elem, prop, initialInUnit + unit);
1895				valueParts = valueParts || [];
1896			}
1897			if (valueParts) {
1898				initialInUnit = +initialInUnit || +initial || 0;
1899				adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];
1900				if (tween) {
1901					tween.unit = unit;
1902					tween.start = initialInUnit;
1903					tween.end = adjusted;
1904				}
1905			}
1906			return adjusted;
1907		}
1908		var defaultDisplayMap = {};
1909		function getDefaultDisplay(elem) {
1910			var temp, doc = elem.ownerDocument, nodeName = elem.nodeName, display = defaultDisplayMap[nodeName];
1911			if (display) return display;
1912			temp = doc.body.appendChild(doc.createElement(nodeName));
1913			display = jQuery.css(temp, "display");
1914			temp.parentNode.removeChild(temp);
1915			if (display === "none") display = "block";
1916			defaultDisplayMap[nodeName] = display;
1917			return display;
1918		}
1919		function showHide(elements, show) {
1920			var display, elem, values = [], index = 0, length = elements.length;
1921			for (; index < length; index++) {
1922				elem = elements[index];
1923				if (!elem.style) continue;
1924				display = elem.style.display;
1925				if (show) {
1926					if (display === "none") {
1927						values[index] = dataPriv.get(elem, "display") || null;
1928						if (!values[index]) elem.style.display = "";
1929					}
1930					if (elem.style.display === "" && isHiddenWithinTree(elem)) values[index] = getDefaultDisplay(elem);
1931				} else if (display !== "none") {
1932					values[index] = "none";
1933					dataPriv.set(elem, "display", display);
1934				}
1935			}
1936			for (index = 0; index < length; index++) if (values[index] != null) elements[index].style.display = values[index];
1937			return elements;
1938		}
1939		jQuery.fn.extend({
1940			show: function() {
1941				return showHide(this, true);
1942			},
1943			hide: function() {
1944				return showHide(this);
1945			},
1946			toggle: function(state) {
1947				if (typeof state === "boolean") return state ? this.show() : this.hide();
1948				return this.each(function() {
1949					if (isHiddenWithinTree(this)) jQuery(this).show();
1950					else jQuery(this).hide();
1951				});
1952			}
1953		});
1954		var rcheckableType = /^(?:checkbox|radio)$/i;
1955		var rtagName = /<([a-z][^\/\0>\x20\t\r\n\f]*)/i;
1956		var rscriptType = /^$|^module$|\/(?:java|ecma)script/i;
1957		(function() {
1958			var div = document.createDocumentFragment().appendChild(document.createElement("div")), input = document.createElement("input");
1959			input.setAttribute("type", "radio");
1960			input.setAttribute("checked", "checked");
1961			input.setAttribute("name", "t");
1962			div.appendChild(input);
1963			support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;
1964			div.innerHTML = "<textarea>x</textarea>";
1965			support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;
1966			div.innerHTML = "<option></option>";
1967			support.option = !!div.lastChild;
1968		})();
1969		var wrapMap = {
1970			thead: [
1971				1,
1972				"<table>",
1973				"</table>"
1974			],

1975			col: [
1976				2,
1977				"<table><colgroup>",
1978				"</colgroup></table>"
1979			],
1980			tr: [
1981				2,
1982				"<table><tbody>",
1983				"</tbody></table>"
1984			],
1985			td: [
1986				3,
1987				"<table><tbody><tr>",
1988				"</tr></tbody></table>"
1989			],
1990			_default: [
1991				0,
1992				"",
1993				""
1994			]
1995		};
1996		wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
1997		wrapMap.th = wrapMap.td;
1998		if (!support.option) wrapMap.optgroup = wrapMap.option = [
1999			1,
2000			"<select multiple='multiple'>",
2001			"</select>"
2002		];
2003		function getAll(context, tag) {
2004			var ret;
2005			if (typeof context.getElementsByTagName !== "undefined") ret = context.getElementsByTagName(tag || "*");
2006			else if (typeof context.querySelectorAll !== "undefined") ret = context.querySelectorAll(tag || "*");
2007			else ret = [];
2008			if (tag === void 0 || tag && nodeName(context, tag)) return jQuery.merge([context], ret);
2009			return ret;
2010		}
2011		function setGlobalEval(elems, refElements) {
2012			var i = 0, l = elems.length;
2013			for (; i < l; i++) dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval"));
2014		}
2015		var rhtml = /<|&#?\w+;/;
2016		function buildFragment(elems, context, scripts, selection, ignored) {
2017			var elem, tmp, tag, wrap, attached, j, fragment = context.createDocumentFragment(), nodes = [], i = 0, l = elems.length;
2018			for (; i < l; i++) {
2019				elem = elems[i];
2020				if (elem || elem === 0) if (toType(elem) === "object") jQuery.merge(nodes, elem.nodeType ? [elem] : elem);
2021				else if (!rhtml.test(elem)) nodes.push(context.createTextNode(elem));
2022				else {
2023					tmp = tmp || fragment.appendChild(context.createElement("div"));
2024					tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
2025					wrap = wrapMap[tag] || wrapMap._default;
2026					tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2];
2027					j = wrap[0];
2028					while (j--) tmp = tmp.lastChild;
2029					jQuery.merge(nodes, tmp.childNodes);
2030					tmp = fragment.firstChild;
2031					tmp.textContent = "";
2032				}
2033			}
2034			fragment.textContent = "";
2035			i = 0;
2036			while (elem = nodes[i++]) {
2037				if (selection && jQuery.inArray(elem, selection) > -1) {
2038					if (ignored) ignored.push(elem);
2039					continue;
2040				}
2041				attached = isAttached(elem);
2042				tmp = getAll(fragment.appendChild(elem), "script");
2043				if (attached) setGlobalEval(tmp);
2044				if (scripts) {
2045					j = 0;
2046					while (elem = tmp[j++]) if (rscriptType.test(elem.type || "")) scripts.push(elem);
2047				}
2048			}
2049			return fragment;
2050		}
2051		var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
2052		function returnTrue() {
2053			return true;
2054		}
2055		function returnFalse() {
2056			return false;
2057		}
2058		function on(elem, types, selector, data, fn, one) {
2059			var origFn, type;
2060			if (typeof types === "object") {
2061				if (typeof selector !== "string") {
2062					data = data || selector;
2063					selector = void 0;
2064				}
2065				for (type in types) on(elem, type, selector, data, types[type], one);
2066				return elem;
2067			}
2068			if (data == null && fn == null) {
2069				fn = selector;
2070				data = selector = void 0;
2071			} else if (fn == null) if (typeof selector === "string") {
2072				fn = data;
2073				data = void 0;
2074			} else {
2075				fn = data;
2076				data = selector;
2077				selector = void 0;
2078			}
2079			if (fn === false) fn = returnFalse;
2080			else if (!fn) return elem;
2081			if (one === 1) {
2082				origFn = fn;
2083				fn = function(event) {
2084					jQuery().off(event);
2085					return origFn.apply(this, arguments);
2086				};
2087				fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);
2088			}
2089			return elem.each(function() {
2090				jQuery.event.add(this, types, fn, data, selector);
2091			});
2092		}
2093		jQuery.event = {
2094			global: {},
2095			add: function(elem, types, handler, data, selector) {
2096				var handleObjIn, eventHandle, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.get(elem);
2097				if (!acceptData(elem)) return;
2098				if (handler.handler) {
2099					handleObjIn = handler;
2100					handler = handleObjIn.handler;
2101					selector = handleObjIn.selector;
2102				}
2103				if (selector) jQuery.find.matchesSelector(documentElement, selector);
2104				if (!handler.guid) handler.guid = jQuery.guid++;
2105				if (!(events = elemData.events)) events = elemData.events = Object.create(null);
2106				if (!(eventHandle = elemData.handle)) eventHandle = elemData.handle = function(e) {
2107					return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : void 0;
2108				};
2109				types = (types || "").match(rnothtmlwhite) || [""];
2110				t = types.length;
2111				while (t--) {
2112					tmp = rtypenamespace.exec(types[t]) || [];
2113					type = origType = tmp[1];
2114					namespaces = (tmp[2] || "").split(".").sort();
2115					if (!type) continue;
2116					special = jQuery.event.special[type] || {};
2117					type = (selector ? special.delegateType : special.bindType) || type;
2118					special = jQuery.event.special[type] || {};
2119					handleObj = jQuery.extend({
2120						type,
2121						origType,
2122						data,
2123						handler,
2124						guid: handler.guid,
2125						selector,
2126						needsContext: selector && jQuery.expr.match.needsContext.test(selector),
2127						namespace: namespaces.join(".")
2128					}, handleObjIn);
2129					if (!(handlers = events[type])) {
2130						handlers = events[type] = [];
2131						handlers.delegateCount = 0;
2132						if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
2133							if (elem.addEventListener) elem.addEventListener(type, eventHandle);
2134						}
2135					}
2136					if (special.add) {
2137						special.add.call(elem, handleObj);
2138						if (!handleObj.handler.guid) handleObj.handler.guid = handler.guid;
2139					}
2140					if (selector) handlers.splice(handlers.delegateCount++, 0, handleObj);
2141					else handlers.push(handleObj);
2142					jQuery.event.global[type] = true;
2143				}
2144			},
2145			remove: function(elem, types, handler, selector, mappedTypes) {
2146				var j, origCount, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
2147				if (!elemData || !(events = elemData.events)) return;
2148				types = (types || "").match(rnothtmlwhite) || [""];
2149				t = types.length;
2150				while (t--) {
2151					tmp = rtypenamespace.exec(types[t]) || [];
2152					type = origType = tmp[1];
2153					namespaces = (tmp[2] || "").split(".").sort();
2154					if (!type) {
2155						for (type in events) jQuery.event.remove(elem, type + types[t], handler, selector, true);
2156						continue;
2157					}
2158					special = jQuery.event.special[type] || {};
2159					type = (selector ? special.delegateType : special.bindType) || type;
2160					handlers = events[type] || [];
2161					tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");
2162					origCount = j = handlers.length;
2163					while (j--) {
2164						handleObj = handlers[j];
2165						if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) {
2166							handlers.splice(j, 1);
2167							if (handleObj.selector) handlers.delegateCount--;
2168							if (special.remove) special.remove.call(elem, handleObj);
2169						}
2170					}
2171					if (origCount && !handlers.length) {
2172						if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) jQuery.removeEvent(elem, type, elemData.handle);
2173						delete events[type];
2174					}
2175				}
2176				if (jQuery.isEmptyObject(events)) dataPriv.remove(elem, "handle events");
2177			},
2178			dispatch: function(nativeEvent) {
2179				var i, j, ret, matched, handleObj, handlerQueue, args = new Array(arguments.length), event = jQuery.event.fix(nativeEvent), handlers = (d

2179ataPriv.get(this, "events") || Object.create(null))[event.type] || [], special = jQuery.event.special[event.type] || {};
2180				args[0] = event;
2181				for (i = 1; i < arguments.length; i++) args[i] = arguments[i];
2182				event.delegateTarget = this;
2183				if (special.preDispatch && special.preDispatch.call(this, event) === false) return;
2184				handlerQueue = jQuery.event.handlers.call(this, event, handlers);
2185				i = 0;
2186				while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
2187					event.currentTarget = matched.elem;
2188					j = 0;
2189					while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) if (!event.rnamespace || handleObj.namespace === false || event.rnamespace.test(handleObj.namespace)) {
2190						event.handleObj = handleObj;
2191						event.data = handleObj.data;
2192						ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
2193						if (ret !== void 0) {
2194							if ((event.result = ret) === false) {
2195								event.preventDefault();
2196								event.stopPropagation();
2197							}
2198						}
2199					}
2200				}
2201				if (special.postDispatch) special.postDispatch.call(this, event);
2202				return event.result;
2203			},
2204			handlers: function(event, handlers) {
2205				var i, handleObj, sel, matchedHandlers, matchedSelectors, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target;
2206				if (delegateCount && cur.nodeType && !(event.type === "click" && event.button >= 1)) {
2207					for (; cur !== this; cur = cur.parentNode || this) if (cur.nodeType === 1 && !(event.type === "click" && cur.disabled === true)) {
2208						matchedHandlers = [];
2209						matchedSelectors = {};
2210						for (i = 0; i < delegateCount; i++) {
2211							handleObj = handlers[i];
2212							sel = handleObj.selector + " ";
2213							if (matchedSelectors[sel] === void 0) matchedSelectors[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 : jQuery.find(sel, this, null, [cur]).length;
2214							if (matchedSelectors[sel]) matchedHandlers.push(handleObj);
2215						}
2216						if (matchedHandlers.length) handlerQueue.push({
2217							elem: cur,
2218							handlers: matchedHandlers
2219						});
2220					}
2221				}
2222				cur = this;
2223				if (delegateCount < handlers.length) handlerQueue.push({
2224					elem: cur,
2225					handlers: handlers.slice(delegateCount)
2226				});
2227				return handlerQueue;
2228			},
2229			addProp: function(name, hook) {
2230				Object.defineProperty(jQuery.Event.prototype, name, {
2231					enumerable: true,
2232					configurable: true,
2233					get: isFunction(hook) ? function() {
2234						if (this.originalEvent) return hook(this.originalEvent);
2235					} : function() {
2236						if (this.originalEvent) return this.originalEvent[name];
2237					},
2238					set: function(value) {
2239						Object.defineProperty(this, name, {
2240							enumerable: true,
2241							configurable: true,
2242							writable: true,
2243							value
2244						});
2245					}
2246				});
2247			},
2248			fix: function(originalEvent) {
2249				return originalEvent[jQuery.expando] ? originalEvent : new jQuery.Event(originalEvent);
2250			},
2251			special: {
2252				load: { noBubble: true },
2253				click: {
2254					setup: function(data) {
2255						var el = this || data;
2256						if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) leverageNative(el, "click", true);
2257						return false;
2258					},
2259					trigger: function(data) {
2260						var el = this || data;
2261						if (rcheckableType.test(el.type) && el.click && nodeName(el, "input")) leverageNative(el, "click");
2262						return true;
2263					},
2264					_default: function(event) {
2265						var target = event.target;
2266						return rcheckableType.test(target.type) && target.click && nodeName(target, "input") && dataPriv.get(target, "click") || nodeName(target, "a");
2267					}
2268				},
2269				beforeunload: { postDispatch: function(event) {
2270					if (event.result !== void 0 && event.originalEvent) event.originalEvent.returnValue = event.result;
2271				} }
2272			}
2273		};
2274		function leverageNative(el, type, isSetup) {
2275			if (!isSetup) {
2276				if (dataPriv.get(el, type) === void 0) jQuery.event.add(el, type, returnTrue);
2277				return;
2278			}
2279			dataPriv.set(el, type, false);
2280			jQuery.event.add(el, type, {
2281				namespace: false,
2282				handler: function(event) {
2283					var result, saved = dataPriv.get(this, type);
2284					if (event.isTrigger & 1 && this[type]) {
2285						if (!saved) {
2286							saved = slice.call(arguments);
2287							dataPriv.set(this, type, saved);
2288							this[type]();
2289							result = dataPriv.get(this, type);
2290							dataPriv.set(this, type, false);
2291							if (saved !== result) {
2292								event.stopImmediatePropagation();
2293								event.preventDefault();
2294								return result;
2295							}
2296						} else if ((jQuery.event.special[type] || {}).delegateType) event.stopPropagation();
2297					} else if (saved) {
2298						dataPriv.set(this, type, jQuery.event.trigger(saved[0], saved.slice(1), this));
2299						event.stopPropagation();
2300						event.isImmediatePropagationStopped = returnTrue;
2301					}
2302				}
2303			});
2304		}
2305		jQuery.removeEvent = function(elem, type, handle) {
2306			if (elem.removeEventListener) elem.removeEventListener(type, handle);
2307		};
2308		jQuery.Event = function(src, props) {
2309			if (!(this instanceof jQuery.Event)) return new jQuery.Event(src, props);
2310			if (src && src.type) {
2311				this.originalEvent = src;
2312				this.type = src.type;
2313				this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === void 0 && src.returnValue === false ? returnTrue : returnFalse;
2314				this.target = src.target && src.target.nodeType === 3 ? src.target.parentNode : src.target;
2315				this.currentTarget = src.currentTarget;
2316				this.relatedTarget = src.relatedTarget;
2317			} else this.type = src;
2318			if (props) jQuery.extend(this, props);
2319			this.timeStamp = src && src.timeStamp || Date.now();
2320			this[jQuery.expando] = true;
2321		};
2322		jQuery.Event.prototype = {
2323			constructor: jQuery.Event,
2324			isDefaultPrevented: returnFalse,
2325			isPropagationStopped: returnFalse,
2326			isImmediatePropagationStopped: returnFalse,
2327			isSimulated: false,
2328			preventDefault: function() {
2329				var e = this.originalEvent;
2330				this.isDefaultPrevented = returnTrue;
2331				if (e && !this.isSimulated) e.preventDefault();
2332			},
2333			stopPropagation: function() {
2334				var e = this.originalEvent;
2335				this.isPropagationStopped = returnTrue;
2336				if (e && !this.isSimulated) e.stopPropagation();
2337			},
2338			stopImmediatePropagation: function() {
2339				var e = this.originalEvent;
2340				this.isImmediatePropagationStopped = returnTrue;
2341				if (e && !this.isSimulated) e.stopImmediatePropagation();
2342				this.stopPropagation();
2343			}
2344		};
2345		jQuery.each({
2346			altKey: true,
2347			bubbles: true,
2348			cancelable: true,
2349			changedTouches: true,
2350			ctrlKey: true,
2351			detail: true,
2352			eventPhase: true,
2353			metaKey: true,
2354			pageX: true,
2355			pageY: true,
2356			shiftKey: true,
2357			view: true,
2358			"char": true,
2359			code: true,

2360			charCode: true,
2361			key: true,
2362			keyCode: true,
2363			button: true,
2364			buttons: true,
2365			clientX: true,
2366			clientY: true,
2367			offsetX: true,
2368			offsetY: true,
2369			pointerId: true,
2370			pointerType: true,
2371			screenX: true,
2372			screenY: true,
2373			targetTouches: true,
2374			toElement: true,
2375			touches: true,
2376			which: true
2377		}, jQuery.event.addProp);
2378		jQuery.each({
2379			focus: "focusin",
2380			blur: "focusout"
2381		}, function(type, delegateType) {
2382			function focusMappedHandler(nativeEvent) {
2383				if (document.documentMode) {
2384					var handle = dataPriv.get(this, "handle"), event = jQuery.event.fix(nativeEvent);
2385					event.type = nativeEvent.type === "focusin" ? "focus" : "blur";
2386					event.isSimulated = true;
2387					handle(nativeEvent);
2388					if (event.target === event.currentTarget) handle(event);
2389				} else jQuery.event.simulate(delegateType, nativeEvent.target, jQuery.event.fix(nativeEvent));
2390			}
2391			jQuery.event.special[type] = {
2392				setup: function() {
2393					var attaches;
2394					leverageNative(this, type, true);
2395					if (document.documentMode) {
2396						attaches = dataPriv.get(this, delegateType);
2397						if (!attaches) this.addEventListener(delegateType, focusMappedHandler);
2398						dataPriv.set(this, delegateType, (attaches || 0) + 1);
2399					} else return false;
2400				},
2401				trigger: function() {
2402					leverageNative(this, type);
2403					return true;
2404				},
2405				teardown: function() {
2406					var attaches;
2407					if (document.documentMode) {
2408						attaches = dataPriv.get(this, delegateType) - 1;
2409						if (!attaches) {
2410							this.removeEventListener(delegateType, focusMappedHandler);
2411							dataPriv.remove(this, delegateType);
2412						} else dataPriv.set(this, delegateType, attaches);
2413					} else return false;
2414				},
2415				_default: function(event) {
2416					return dataPriv.get(event.target, type);
2417				},
2418				delegateType
2419			};
2420			jQuery.event.special[delegateType] = {
2421				setup: function() {
2422					var doc = this.ownerDocument || this.document || this, dataHolder = document.documentMode ? this : doc, attaches = dataPriv.get(dataHolder, delegateType);
2423					if (!attaches) if (document.documentMode) this.addEventListener(delegateType, focusMappedHandler);
2424					else doc.addEventListener(type, focusMappedHandler, true);
2425					dataPriv.set(dataHolder, delegateType, (attaches || 0) + 1);
2426				},
2427				teardown: function() {
2428					var doc = this.ownerDocument || this.document || this, dataHolder = document.documentMode ? this : doc, attaches = dataPriv.get(dataHolder, delegateType) - 1;
2429					if (!attaches) {
2430						if (document.documentMode) this.removeEventListener(delegateType, focusMappedHandler);
2431						else doc.removeEventListener(type, focusMappedHandler, true);
2432						dataPriv.remove(dataHolder, delegateType);
2433					} else dataPriv.set(dataHolder, delegateType, attaches);
2434				}
2435			};
2436		});
2437		jQuery.each({
2438			mouseenter: "mouseover",
2439			mouseleave: "mouseout",
2440			pointerenter: "pointerover",
2441			pointerleave: "pointerout"
2442		}, function(orig, fix) {
2443			jQuery.event.special[orig] = {
2444				delegateType: fix,
2445				bindType: fix,
2446				handle: function(event) {
2447					var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj;
2448					if (!related || related !== target && !jQuery.contains(target, related)) {
2449						event.type = handleObj.origType;
2450						ret = handleObj.handler.apply(this, arguments);
2451						event.type = fix;
2452					}
2453					return ret;
2454				}
2455			};
2456		});
2457		jQuery.fn.extend({
2458			on: function(types, selector, data, fn) {
2459				return on(this, types, selector, data, fn);
2460			},
2461			one: function(types, selector, data, fn) {
2462				return on(this, types, selector, data, fn, 1);
2463			},
2464			off: function(types, selector, fn) {
2465				var handleObj, type;
2466				if (types && types.preventDefault && types.handleObj) {
2467					handleObj = types.handleObj;
2468					jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler);
2469					return this;
2470				}
2471				if (typeof types === "object") {
2472					for (type in types) this.off(type, selector, types[type]);
2473					return this;
2474				}
2475				if (selector === false || typeof selector === "function") {
2476					fn = selector;
2477					selector = void 0;
2478				}
2479				if (fn === false) fn = returnFalse;
2480				return this.each(function() {
2481					jQuery.event.remove(this, types, fn, selector);
2482				});
2483			}
2484		});
2485		var rnoInnerhtml = /<script|<style|<link/i, rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g;
2486		function manipulationTarget(elem, content) {
2487			if (nodeName(elem, "table") && nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr")) return jQuery(elem).children("tbody")[0] || elem;
2488			return elem;
2489		}
2490		function disableScript(elem) {
2491			elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
2492			return elem;
2493		}
2494		function restoreScript(elem) {
2495			if ((elem.type || "").slice(0, 5) === "true/") elem.type = elem.type.slice(5);
2496			else elem.removeAttribute("type");
2497			return elem;
2498		}
2499		function cloneCopyEvent(src, dest) {
2500			var i, l, type, pdataOld, udataOld, udataCur, events;
2501			if (dest.nodeType !== 1) return;
2502			if (dataPriv.hasData(src)) {
2503				pdataOld = dataPriv.get(src);
2504				events = pdataOld.events;
2505				if (events) {
2506					dataPriv.remove(dest, "handle events");
2507					for (type in events) for (i = 0, l = events[type].length; i < l; i++) jQuery.event.add(dest, type, events[type][i]);
2508				}
2509			}
2510			if (dataUser.hasData(src)) {
2511				udataOld = dataUser.access(src);
2512				udataCur = jQuery.extend({}, udataOld);
2513				dataUser.set(dest, udataCur);
2514			}
2515		}

2516		function fixInput(src, dest) {
2517			var nodeName = dest.nodeName.toLowerCase();
2518			if (nodeName === "input" && rcheckableType.test(src.type)) dest.checked = src.checked;
2519			else if (nodeName === "input" || nodeName === "textarea") dest.defaultValue = src.defaultValue;
2520		}
2521		function domManip(collection, args, callback, ignored) {
2522			args = flat(args);
2523			var fragment, first, scripts, hasScripts, node, doc, i = 0, l = collection.length, iNoClone = l - 1, value = args[0], valueIsFunction = isFunction(value);
2524			if (valueIsFunction || l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value)) return collection.each(function(index) {
2525				var self = collection.eq(index);
2526				if (valueIsFunction) args[0] = value.call(this, index, self.html());
2527				domManip(self, args, callback, ignored);
2528			});
2529			if (l) {
2530				fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
2531				first = fragment.firstChild;
2532				if (fragment.childNodes.length === 1) fragment = first;
2533				if (first || ignored) {
2534					scripts = jQuery.map(getAll(fragment, "script"), disableScript);
2535					hasScripts = scripts.length;
2536					for (; i < l; i++) {
2537						node = fragment;
2538						if (i !== iNoClone) {
2539							node = jQuery.clone(node, true, true);
2540							if (hasScripts) jQuery.merge(scripts, getAll(node, "script"));
2541						}
2542						callback.call(collection[i], node, i);
2543					}
2544					if (hasScripts) {
2545						doc = scripts[scripts.length - 1].ownerDocument;
2546						jQuery.map(scripts, restoreScript);
2547						for (i = 0; i < hasScripts; i++) {
2548							node = scripts[i];
2549							if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(doc, node)) if (node.src && (node.type || "").toLowerCase() !== "module") {
2550								if (jQuery._evalUrl && !node.noModule) jQuery._evalUrl(node.src, { nonce: node.nonce || node.getAttribute("nonce") }, doc);
2551							} else DOMEval(node.textContent.replace(rcleanScript, ""), node, doc);
2552						}
2553					}
2554				}
2555			}
2556			return collection;
2557		}
2558		function remove(elem, selector, keepData) {
2559			var node, nodes = selector ? jQuery.filter(selector, elem) : elem, i = 0;
2560			for (; (node = nodes[i]) != null; i++) {
2561				if (!keepData && node.nodeType === 1) jQuery.cleanData(getAll(node));
2562				if (node.parentNode) {
2563					if (keepData && isAttached(node)) setGlobalEval(getAll(node, "script"));
2564					node.parentNode.removeChild(node);
2565				}
2566			}
2567			return elem;
2568		}
2569		jQuery.extend({
2570			htmlPrefilter: function(html) {
2571				return html;
2572			},
2573			clone: function(elem, dataAndEvents, deepDataAndEvents) {
2574				var i, l, srcElements, destElements, clone = elem.cloneNode(true), inPage = isAttached(elem);
2575				if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {
2576					destElements = getAll(clone);
2577					srcElements = getAll(elem);
2578					for (i = 0, l = srcElements.length; i < l; i++) fixInput(srcElements[i], destElements[i]);
2579				}
2580				if (dataAndEvents) if (deepDataAndEvents) {
2581					srcElements = srcElements || getAll(elem);
2582					destElements = destElements || getAll(clone);
2583					for (i = 0, l = srcElements.length; i < l; i++) cloneCopyEvent(srcElements[i], destElements[i]);
2584				} else cloneCopyEvent(elem, clone);
2585				destElements = getAll(clone, "script");
2586				if (destElements.length > 0) setGlobalEval(destElements, !inPage && getAll(elem, "script"));
2587				return clone;
2588			},
2589			cleanData: function(elems) {
2590				var data, elem, type, special = jQuery.event.special, i = 0;
2591				for (; (elem = elems[i]) !== void 0; i++) if (acceptData(elem)) {
2592					if (data = elem[dataPriv.expando]) {
2593						if (data.events) for (type in data.events) if (special[type]) jQuery.event.remove(elem, type);
2594						else jQuery.removeEvent(elem, type, data.handle);
2595						elem[dataPriv.expando] = void 0;
2596					}
2597					if (elem[dataUser.expando]) elem[dataUser.expando] = void 0;
2598				}
2599			}
2600		});
2601		jQuery.fn.extend({
2602			detach: function(selector) {
2603				return remove(this, selector, true);
2604			},
2605			remove: function(selector) {
2606				return remove(this, selector);
2607			},
2608			text: function(value) {
2609				return access(this, function(value) {
2610					return value === void 0 ? jQuery.text(this) : this.empty().each(function() {
2611						if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) this.textContent = value;
2612					});
2613				}, null, value, arguments.length);
2614			},
2615			append: function() {
2616				return domManip(this, arguments, function(elem) {
2617					if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) manipulationTarget(this, elem).appendChild(elem);
2618				});
2619			},
2620			prepend: function() {
2621				return domManip(this, arguments, function(elem) {
2622					if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
2623						var target = manipulationTarget(this, elem);
2624						target.insertBefore(elem, target.firstChild);
2625					}
2626				});
2627			},
2628			before: function() {
2629				return domManip(this, arguments, function(elem) {
2630					if (this.parentNode) this.parentNode.insertBefore(elem, this);
2631				});
2632			},
2633			after: function() {
2634				return domManip(this, arguments, function(elem) {
2635					if (this.parentNode) this.parentNode.insertBefore(elem, this.nextSibling);
2636				});
2637			},
2638			empty: function() {
2639				var elem, i = 0;
2640				for (; (elem = this[i]) != null; i++) if (elem.nodeType === 1) {
2641					jQuery.cleanData(getAll(elem, false));
2642					elem.textContent = "";
2643				}
2644				return this;
2645			},
2646			clone: function(dataAndEvents, deepDataAndEvents) {
2647				dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
2648				deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
2649				return this.map(function() {
2650					return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
2651				});
2652			},
2653			html: function(value) {
2654				return access(this, function(value) {
2655					var elem = this[0] || {}, i = 0, l = this.length;
2656					if (value === void 0 && elem.nodeType === 1) return elem.innerHTML;
2657					if (typeof value === "string" && !rnoInnerhtml.test(value) && !wrapMap[