https://evisaindien.de/ScriptResource.axd?d=1egYHS04c-1_Nwpiy08O1-…5CEU7VgHqSlvHG6wTpVxV1fgfAHhydg2&t=51e37521

1// Name:        jQuery.jQuery.debug.js
2// Assembly:    AjaxControlToolkit
3// Version:     4.1.7.1213
4// FileVersion: 4.1.7.1213
5// (c) 2010 CodePlex Foundation
6/*!
7 * jQuery JavaScript Library v1.9.1
8 * http://jquery.com/
9 *
10 * Includes Sizzle.js
11 * http://sizzlejs.com/
12 *
13 * Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors
14 * Released under the MIT license
15 * http://jquery.org/license
16 *
17 * Date: 2013-2-4
18 */
19(function( window, undefined ) {
20
21var
22	readyList,
23
24	rootjQuery,
25
26	core_strundefined = typeof undefined,
27
28	document = window.document,
29	location = window.location,
30
31	_jQuery = window.jQuery,
32
33	_$ = window.$,
34
35	class2type = {},
36
37	core_deletedIds = [],
38
39	core_version = "1.9.1",
40
41	core_concat = core_deletedIds.concat,
42	core_push = core_deletedIds.push,
43	core_slice = core_deletedIds.slice,
44	core_indexOf = core_deletedIds.indexOf,
45	core_toString = class2type.toString,
46	core_hasOwn = class2type.hasOwnProperty,
47	core_trim = core_version.trim,
48
49	jQuery = function( selector, context ) {
50		return new jQuery.fn.init( selector, context, rootjQuery );
51	},
52
53	core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
54
55	core_rnotwhite = /\S+/g,
56
57	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
58
59	rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,
60
61	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
62
63	rvalidchars = /^[\],:{}\s]*$/,
64	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
65	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
66	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
67
68	rmsPrefix = /^-ms-/,
69	rdashAlpha = /-([\da-z])/gi,
70
71	fcamelCase = function( all, letter ) {
72		return letter.toUpperCase();
73	},
74
75	completed = function( event ) {
76
77		if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
78			detach();
79			jQuery.ready();
80		}
81	},
82	detach = function() {
83		if ( document.addEventListener ) {
84			document.removeEventListener( "DOMContentLoaded", completed, false );
85			window.removeEventListener( "load", completed, false );
86
87		} else {
88			document.detachEvent( "onreadystatechange", completed );
89			window.detachEvent( "onload", completed );
90		}
91	};
92
93jQuery.fn = jQuery.prototype = {
94	jquery: core_version,
95
96	constructor: jQuery,
97	init: function( selector, context, rootjQuery ) {
98		var match, elem;
99
100		if ( !selector ) {
101			return this;
102		}
103
104		if ( typeof selector === "string" ) {
105			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
106				match = [ null, selector, null ];
107
108			} else {
109				match = rquickExpr.exec( selector );
110			}
111
112			if ( match && (match[1] || !context) ) {
113
114				if ( match[1] ) {
115					context = context instanceof jQuery ? context[0] : context;
116
117					jQuery.merge( this, jQuery.parseHTML(
118						match[1],
119						context && context.nodeType ? context.ownerDocument || context : document,
120						true
121					) );
122
123					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
124						for ( match in context ) {
125							if ( jQuery.isFunction( this[ match ] ) ) {
126								this[ match ]( context[ match ] );
127
128							} else {
129								this.attr( match, context[ match ] );
130							}
131						}
132					}
133
134					return this;
135
136				} else {
137					elem = document.getElementById( match[2] );
138
139					if ( elem && elem.parentNode ) {
140						if ( elem.id !== match[2] ) {
141							return rootjQuery.find( selector );
142						}
143
144						this.length = 1;
145						this[0] = elem;
146					}
147
148					this.context = document;
149					this.selector = selector;
150					return this;
151				}
152
153			} else if ( !context || context.jquery ) {
154				return ( context || rootjQuery ).find( selector );
155
156			} else {
157				return this.constructor( context ).find( selector );
158			}
159
160		} else if ( selector.nodeType ) {
161			this.context = this[0] = selector;
162			this.length = 1;
163			return this;
164
165		} else if ( jQuery.isFunction( selector ) ) {
166			return rootjQuery.ready( selector );
167		}
168
169		if ( selector.selector !== undefined ) {
170			this.selector = selector.selector;
171			this.context = selector.context;
172		}
173
174		return jQuery.makeArray( selector, this );
175	},
176
177	selector: "",
178
179	length: 0,
180
181	size: function() {
182		return this.length;
183	},
184
185	toArray: function() {
186		return core_slice.call( this );
187	},
188
189	get: function( num ) {
190		return num == null ?
191
192			this.toArray() :
193
194			( num < 0 ? this[ this.length + num ] : this[ num ] );
195	},
196
197	pushStack: function( elems ) {
198
199		var ret = jQuery.merge( this.constructor(), elems );
200

675			context = fn;
676			fn = tmp;
677		}
678
679		if ( !jQuery.isFunction( fn ) ) {
680			return undefined;
681		}
682
683		args = core_slice.call( arguments, 2 );
684		proxy = function() {
685			return fn.apply( context || this, args.concat( core_slice.call( arguments ) ) );
686		};
687
688		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
689
690		return proxy;
691	},
692
693	access: function( elems, fn, key, value, chainable, emptyGet, raw ) {
694		var i = 0,
695			length = elems.length,
696			bulk = key == null;
697
698		if ( jQuery.type( key ) === "object" ) {
699			chainable = true;
700			for ( i in key ) {
701				jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
702			}
703
704		} else if ( value !== undefined ) {
705			chainable = true;
706
707			if ( !jQuery.isFunction( value ) ) {
708				raw = true;
709			}
710
711			if ( bulk ) {
712				if ( raw ) {
713					fn.call( elems, value );
714					fn = null;
715
716				} else {
717					bulk = fn;
718					fn = function( elem, key, value ) {
719						return bulk.call( jQuery( elem ), value );
720					};
721				}
722			}
723
724			if ( fn ) {
725				for ( ; i < length; i++ ) {
726					fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
727				}
728			}
729		}
730
731		return chainable ?
732			elems :
733
734			bulk ?
735				fn.call( elems ) :
736				length ? fn( elems[0], key ) : emptyGet;
737	},
738
739	now: function() {
740		return ( new Date() ).getTime();
741	}
742});
743
744jQuery.ready.promise = function( obj ) {
745	if ( !readyList ) {
746
747		readyList = jQuery.Deferred();
748
749		if ( document.readyState === "complete" ) {
750			setTimeout( jQuery.ready );
751
752		} else if ( document.addEventListener ) {
753			document.addEventListener( "DOMContentLoaded", completed, false );
754
755			window.addEventListener( "load", completed, false );
756
757		} else {
758			document.attachEvent( "onreadystatechange", completed );
759
760			window.attachEvent( "onload", completed );
761
762			var top = false;
763
764			try {
765				top = window.frameElement == null && document.documentElement;
766			} catch(e) {}
767
768			if ( top && top.doScroll ) {
769				(function doScrollCheck() {
770					if ( !jQuery.isReady ) {
771
772						try {
773							top.doScroll("left");
774						} catch(e) {
775							return setTimeout( doScrollCheck, 50 );
776						}
777
778						detach();
779
780						jQuery.ready();
781					}
782				})();
783			}
784		}
785	}
786	return readyList.promise( obj );
787};
788
789jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
790	class2type[ "[object " + name + "]" ] = name.toLowerCase();
791});
792
793function isArraylike( obj ) {
794	var length = obj.length,
795		type = jQuery.type( obj );
796
797	if ( jQuery.isWindow( obj ) ) {
798		return false;
799	}
800
801	if ( obj.nodeType === 1 && length ) {
802		return true;
803	}
804
805	return type === "array" || type !== "function" &&
806		( length === 0 ||
807		typeof length === "number" && length > 0 && ( length - 1 ) in obj );
808}
809
810rootjQuery = jQuery(document);
811var optionsCache = {};
812
813function createOptions( options ) {
814	var object = optionsCache[ options ] = {};
815	jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
816		object[ flag ] = true;
817	});
818	return object;
819}
820
821/*
822 * Create a callback list using the following parameters:
823 *
824 *	options: an optional list of space-separated options that will change how
825 *			the callback list behaves or a more traditional option object
826 *
827 * By default a callback list will act like an event callback list and can be
828 * "fired" multiple times.
829 *
830 * Possible options:
831 *
832 *	once:			will ensure the callback list can only be fired once (like a Deferred)
833 *
834 *	memory:			will keep track of previous values and will call any callback added
835 *					after the list has been fired right away with the latest "memorized"
836 *					values (like a Deferred)
837 *
838 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
839 *
840 *	stopOnFalse:	interrupt callings when a callback returns false
841 *
842 */
843jQuery.Callbacks = function( options ) {
844
845	options = typeof options === "string" ?
846		( optionsCache[ options ] || createOptions( options ) ) :
847		jQuery.extend( {}, options );
848
849	var // Flag to know if list is currently firing
850		firing,
851		memory,
852		fired,
853		firingLength,
854		firingIndex,
855		firingStart,
856		list = [],
857		stack = !options.once && [],
858		fire = function( data ) {
859			memory = options.memory && data;
860			fired = true;
861			firingIndex = firingStart || 0;
862			firingStart = 0;
863			firingLength = list.length;
864			firing = true;
865			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
866				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
867					memory = false; // To prevent further calls using add
868					break;
869				}
870			}
871			firing = false;
872			if ( list ) {
873				if ( stack ) {
874					if ( stack.length ) {
875						fire( stack.shift() );
876					}
877				} else if ( memory ) {
878					list = [];
879				} else {
880					self.disable();
881				}
882			}
883		},
884		self = {
885			add: function() {
886				if ( list ) {
887					var start = list.length;
888					(function add( args ) {
889						jQuery.each( args, function( _, arg ) {
890							var type = jQuery.type( arg );
891							if ( type === "function" ) {
892								if ( !options.unique || !self.has( arg ) ) {
893									list.push( arg );
894								}
895							} else if ( arg && arg.length && type !== "string" ) {
896								add( arg );
897							}
898						});
899					})( arguments );
900					if ( firing ) {
901						firingLength = list.length;
902					} else if ( memory ) {
903						firingStart = start;
904						fire( memory );
905					}
906				}
907				return this;
908			},
909			remove: function() {
910				if ( list ) {
911					jQuery.each( arguments, function( _, arg ) {
912						var index;
913						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
914							list.splice( index, 1 );
915							if ( firing ) {
916								if ( index <= firingLength ) {
917									firingLength--;
918								}
919								if ( index <= firingIndex ) {
920									firingIndex--;
921								}
922							}
923						}
924					});
925				}
926				return this;
927			},
928			has: function( fn ) {
929				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
930			},
931			empty: function() {
932				list = [];
933				return this;
934			},
935			disable: function() {
936				list = stack = memory = undefined;
937				return this;
938			},
939			disabled: function() {
940				return !list;
941			},
942			lock: function() {
943				stack = undefined;
944				if ( !memory ) {
945					self.disable();
946				}
947				return this;
948			},
949			locked: function() {
950				return !stack;
951			},
952			fireWith: function( context, args ) {
953				args = args || [];
954				args = [ context, args.slice ? args.slice() : args ];
955				if ( list && ( !fired || stack ) ) {
956					if ( firing ) {
957						stack.push( args );
958					} else {
959						fire( args );
960					}
961				}
962				return this;
963			},
964			fire: function() {
965				self.fireWith( this, arguments );
966				return this;
967			},
968			fired: function() {
969				return !!fired;
970			}
971		};
972
973	return self;
974};
975jQuery.extend({
976
977	Deferred: function( func ) {
978		var tuples = [
979				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
980				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
981				[ "notify", "progress", jQuery.Callbacks("memory") ]
982			],
983			state = "pending",
984			promise = {
985				state: function() {
986					return state;
987				},
988				always: function() {
989					deferred.done( arguments ).fail( arguments );
990					return this;
991				},
992				then: function( /* fnDone, fnFail, fnProgress */ ) {
993					var fns = arguments;
994					return jQuery.Deferred(function( newDefer ) {
995						jQuery.each( tuples, function( i, tuple ) {
996							var action = tuple[ 0 ],
997								fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
998							deferred[ tuple[1] ](function() {
999								var returned = fn && fn.apply( this, arguments );
1000								if ( returned && jQuery.isFunction( returned.promise ) ) {
1001									returned.promise()
1002										.done( newDefer.resolve )
1003										.fail( newDefer.reject )
1004										.progress( newDefer.notify );
1005								} else {
1006									newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
1007								}
1008							});
1009						});
1010						fns = null;
1011					}).promise();
1012				},
1013				promise: function( obj ) {
1014					return obj != null ? jQuery.extend( obj, promise ) : promise;
1015				}
1016			},
1017			deferred = {};
1018
1019		promise.pipe = promise.then;
1020
1021		jQuery.each( tuples, function( i, tuple ) {
1022			var list = tuple[ 2 ],
1023				stateString = tuple[ 3 ];
1024
1025			promise[ tuple[1] ] = list.add;
1026
1027			if ( stateString ) {
1028				list.add(function() {
1029					state = stateString;
1030
1031				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
1032			}
1033
1034			deferred[ tuple[0] ] = function() {
1035				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
1036				return this;
1037			};
1038			deferred[ tuple[0] + "With" ] = list.fireWith;
1039		});
1040
1041		promise.promise( deferred );
1042
1043		if ( func ) {
1044			func.call( deferred, deferred );
1045		}
1046
1047		return deferred;
1048	},
1049
1050	when: function( subordinate /* , ..., subordinateN */ ) {
1051		var i = 0,
1052			resolveValues = core_slice.call( arguments ),
1053			length = resolveValues.length,
1054
1055			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
1056
1057			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
1058
1059			updateFunc = function( i, contexts, values ) {
1060				return function( value ) {
1061					contexts[ i ] = this;
1062					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
1063					if( values === progressValues ) {
1064						deferred.notifyWith( contexts, values );
1065					} else if ( !( --remaining ) ) {
1066						deferred.resolveWith( contexts, values );
1067					}
1068				};
1069			},
1070
1071			progressValues, progressContexts, resolveContexts;
1072
1073		if ( length > 1 ) {
1074			progressValues = new Array( length );
1075			progressContexts = new Array( length );
1076			resolveContexts = new Array( length );
1077			for ( ; i < length; i++ ) {
1078				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
1079					resolveValues[ i ].promise()
1080						.done( updateFunc( i, resolveContexts, resolveValues ) )
1081						.fail( deferred.reject )
1082						.progress( updateFunc( i, progressContexts, progressValues ) );
1083				} else {
1084					--remaining;
1085				}
1086			}
1087		}
1088
1089		if ( !remaining ) {

1568		type = type || "fx";
1569
1570		var queue = jQuery.queue( elem, type ),
1571			startLength = queue.length,
1572			fn = queue.shift(),
1573			hooks = jQuery._queueHooks( elem, type ),
1574			next = function() {
1575				jQuery.dequeue( elem, type );
1576			};
1577
1578		if ( fn === "inprogress" ) {
1579			fn = queue.shift();
1580			startLength--;
1581		}
1582
1583		hooks.cur = fn;
1584		if ( fn ) {
1585
1586			if ( type === "fx" ) {
1587				queue.unshift( "inprogress" );
1588			}
1589
1590			delete hooks.stop;
1591			fn.call( elem, next, hooks );
1592		}
1593
1594		if ( !startLength && hooks ) {
1595			hooks.empty.fire();
1596		}
1597	},
1598
1599	_queueHooks: function( elem, type ) {
1600		var key = type + "queueHooks";
1601		return jQuery._data( elem, key ) || jQuery._data( elem, key, {
1602			empty: jQuery.Callbacks("once memory").add(function() {
1603				jQuery._removeData( elem, type + "queue" );
1604				jQuery._removeData( elem, key );
1605			})
1606		});
1607	}
1608});
1609
1610jQuery.fn.extend({
1611	queue: function( type, data ) {
1612		var setter = 2;
1613
1614		if ( typeof type !== "string" ) {
1615			data = type;
1616			type = "fx";
1617			setter--;
1618		}
1619
1620		if ( arguments.length < setter ) {
1621			return jQuery.queue( this[0], type );
1622		}
1623
1624		return data === undefined ?
1625			this :
1626			this.each(function() {
1627				var queue = jQuery.queue( this, type, data );
1628
1629				jQuery._queueHooks( this, type );
1630
1631				if ( type === "fx" && queue[0] !== "inprogress" ) {
1632					jQuery.dequeue( this, type );
1633				}
1634			});
1635	},
1636	dequeue: function( type ) {
1637		return this.each(function() {
1638			jQuery.dequeue( this, type );
1639		});
1640	},
1641	delay: function( time, type ) {
1642		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
1643		type = type || "fx";
1644
1645		return this.queue( type, function( next, hooks ) {
1646			var timeout = setTimeout( next, time );
1647			hooks.stop = function() {
1648				clearTimeout( timeout );
1649			};
1650		});
1651	},
1652	clearQueue: function( type ) {
1653		return this.queue( type || "fx", [] );
1654	},
1655	promise: function( type, obj ) {
1656		var tmp,
1657			count = 1,
1658			defer = jQuery.Deferred(),
1659			elements = this,
1660			i = this.length,
1661			resolve = function() {
1662				if ( !( --count ) ) {
1663					defer.resolveWith( elements, [ elements ] );
1664				}
1665			};
1666
1667		if ( typeof type !== "string" ) {
1668			obj = type;
1669			type = undefined;
1670		}
1671		type = type || "fx";
1672
1673		while( i-- ) {
1674			tmp = jQuery._data( elements[ i ], type + "queueHooks" );
1675			if ( tmp && tmp.empty ) {
1676				count++;
1677				tmp.empty.add( resolve );
1678			}
1679		}
1680		resolve();
1681		return defer.promise( obj );
1682	}
1683});
1684var nodeHook, boolHook,
1685	rclass = /[\t\r\n]/g,
1686	rreturn = /\r/g,
1687	rfocusable = /^(?:input|select|textarea|button|object)$/i,
1688	rclickable = /^(?:a|area)$/i,
1689	rboolean = /^(?:checked|selected|autofocus|autoplay|async|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped)$/i,
1690	ruseDefault = /^(?:checked|selected)$/i,
1691	getSetAttribute = jQuery.support.getSetAttribute,
1692	getSetInput = jQuery.support.input;
1693
1694jQuery.fn.extend({
1695	attr: function( name, value ) {
1696		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
1697	},
1698
1699	removeAttr: function( name ) {
1700		return this.each(function() {
1701			jQuery.removeAttr( this, name );
1702		});
1703	},
1704
1705	prop: function( name, value ) {
1706		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
1707	},
1708
1709	removeProp: function( name ) {
1710		name = jQuery.propFix[ name ] || name;
1711		return this.each(function() {
1712			try {
1713				this[ name ] = undefined;
1714				delete this[ name ];
1715			} catch( e ) {}
1716		});
1717	},
1718
1719	addClass: function( value ) {
1720		var classes, elem, cur, clazz, j,
1721			i = 0,
1722			len = this.length,
1723			proceed = typeof value === "string" && value;
1724
1725		if ( jQuery.isFunction( value ) ) {
1726			return this.each(function( j ) {
1727				jQuery( this ).addClass( value.call( this, j, this.className ) );
1728			});
1729		}
1730
1731		if ( proceed ) {
1732			classes = ( value || "" ).match( core_rnotwhite ) || [];
1733
1734			for ( ; i < len; i++ ) {
1735				elem = this[ i ];
1736				cur = elem.nodeType === 1 && ( elem.className ?
1737					( " " + elem.className + " " ).replace( rclass, " " ) :
1738					" "
1739				);
1740
1741				if ( cur ) {
1742					j = 0;
1743					while ( (clazz = classes[j++]) ) {
1744						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
1745							cur += clazz + " ";
1746						}
1747					}
1748					elem.className = jQuery.trim( cur );
1749
1750				}
1751			}
1752		}
1753
1754		return this;
1755	},
1756
1757	removeClass: function( value ) {
1758		var classes, elem, cur, clazz, j,
1759			i = 0,
1760			len = this.length,
1761			proceed = arguments.length === 0 || typeof value === "string" && value;
1762
1763		if ( jQuery.isFunction( value ) ) {
1764			return this.each(function( j ) {
1765				jQuery( this ).removeClass( value.call( this, j, this.className ) );
1766			});
1767		}
1768		if ( proceed ) {
1769			classes = ( value || "" ).match( core_rnotwhite ) || [];
1770
1771			for ( ; i < len; i++ ) {
1772				elem = this[ i ];
1773				cur = elem.nodeType === 1 && ( elem.className ?
1774					( " " + elem.className + " " ).replace( rclass, " " ) :
1775					""
1776				);
1777
1778				if ( cur ) {
1779					j = 0;
1780					while ( (clazz = classes[j++]) ) {
1781						while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
1782							cur = cur.replace( " " + clazz + " ", " " );
1783						}
1784					}
1785					elem.className = value ? jQuery.trim( cur ) : "";
1786				}
1787			}
1788		}
1789
1790		return this;
1791	},
1792
1793	toggleClass: function( value, stateVal ) {
1794		var type = typeof value,
1795			isBool = typeof stateVal === "boolean";
1796
1797		if ( jQuery.isFunction( value ) ) {
1798			return this.each(function( i ) {
1799				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
1800			});
1801		}
1802
1803		return this.each(function() {
1804			if ( type === "string" ) {
1805				var className,
1806					i = 0,
1807					self = jQuery( this ),
1808					state = stateVal,
1809					classNames = value.match( core_rnotwhite ) || [];
1810
1811				while ( (className = classNames[ i++ ]) ) {
1812					state = isBool ? state : !self.hasClass( className );
1813					self[ state ? "addClass" : "removeClass" ]( className );
1814				}
1815
1816			} else if ( type === core_strundefined || type === "boolean" ) {
1817				if ( this.className ) {
1818					jQuery._data( this, "__className__", this.className );
1819				}
1820
1821				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
1822			}
1823		});
1824	},
1825
1826	hasClass: function( selector ) {
1827		var className = " " + selector + " ",
1828			i = 0,
1829			l = this.length;
1830		for ( ; i < l; i++ ) {
1831			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
1832				return true;
1833			}
1834		}
1835
1836		return false;
1837	},
1838
1839	val: function( value ) {
1840		var ret, hooks, isFunction,
1841			elem = this[0];
1842
1843		if ( !arguments.length ) {
1844			if ( elem ) {
1845				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
1846
1847				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
1848					return ret;
1849				}
1850
1851				ret = elem.value;
1852
1853				return typeof ret === "string" ?
1854					ret.replace(rreturn, "") :
1855					ret == null ? "" : ret;
1856			}
1857
1858			return;
1859		}
1860
1861		isFunction = jQuery.isFunction( value );
1862
1863		return this.each(function( i ) {
1864			var val,
1865				self = jQuery(this);
1866
1867			if ( this.nodeType !== 1 ) {
1868				return;
1869			}
1870
1871			if ( isFunction ) {
1872				val = value.call( this, i, self.val() );
1873			} else {
1874				val = value;
1875			}
1876
1877			if ( val == null ) {
1878				val = "";
1879			} else if ( typeof val === "number" ) {
1880				val += "";
1881			} else if ( jQuery.isArray( val ) ) {
1882				val = jQuery.map(val, function ( value ) {
1883					return value == null ? "" : value + "";
1884				});
1885			}
1886
1887			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
1888
1889			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
1890				this.value = val;
1891			}
1892		});
1893	}
1894});
1895
1896jQuery.extend({
1897	valHooks: {
1898		option: {
1899			get: function( elem ) {
1900				var val = elem.attributes.value;
1901				return !val || val.specified ? elem.value : elem.text;
1902			}
1903		},
1904		select: {
1905			get: function( elem ) {
1906				var value, option,
1907					options = elem.options,
1908					index = elem.selectedIndex,
1909					one = elem.type === "select-one" || index < 0,
1910					values = one ? null : [],
1911					max = one ? index + 1 : options.length,
1912					i = index < 0 ?
1913						max :
1914						one ? index : 0;
1915
1916				for ( ; i < max; i++ ) {
1917					option = options[ i ];
1918
1919					if ( ( option.selected || i === index ) &&
1920							( jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) &&
1921							( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
1922
1923						value = jQuery( option ).val();
1924
1925						if ( one ) {
1926							return value;
1927						}
1928
1929						values.push( value );
1930					}
1931				}
1932
1933				return values;
1934			},
1935
1936			set: function( elem, value ) {
1937				var values = jQuery.makeArray( value );
1938
1939				jQuery(elem).find("option").each(function() {
1940					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1941				});
1942
1943				if ( !values.length ) {
1944					elem.selectedIndex = -1;
1945				}
1946				return values;
1947			}
1948		}
1949	},
1950
1951	attr: function( elem, name, value ) {
1952		var hooks, notxml, ret,
1953			nType = elem.nodeType;
1954
1955		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
1956			return;
1957		}
1958
1959		if ( typeof elem.getAttribute === core_strundefined ) {
1960			return jQuery.prop( elem, name, value );
1961		}
1962
1963		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
1964
1965		if ( notxml ) {
1966			name = name.toLowerCase();
1967			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
1968		}
1969
1970		if ( value !== undefined ) {
1971
1972			if ( value === null ) {
1973				jQuery.removeAttr( elem, name );
1974
1975			} else if ( hooks && notxml && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
1976				return ret;
1977
1978			} else {
1979				elem.setAttribute( name, value + "" );
1980				return value;
1981			}
1982
1983		} else if ( hooks && notxml && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
1984			return ret;
1985
1986		} else {
1987
1988			if ( typeof elem.getAttribute !== core_strundefined ) {
1989				ret =  elem.getAttribute( name );
1990			}
1991
1992			return ret == null ?
1993				undefined :
1994				ret;
1995		}
1996	},
1997
1998	removeAttr: function( elem, value ) {
1999		var name, propName,
2000			i = 0,
2001			attrNames = value && value.match( core_rnotwhite );
2002
2003		if ( attrNames && elem.nodeType === 1 ) {
2004			while ( (name = attrNames[i++]) ) {
2005				propName = jQuery.propFix[ name ] || name;
2006
2007				if ( rboolean.test( name ) ) {
2008					if ( !getSetAttribute && ruseDefault.test( name ) ) {
2009						elem[ jQuery.camelCase( "default-" + name ) ] =
2010							elem[ propName ] = false;
2011					} else {
2012						elem[ propName ] = false;
2013					}
2014
2015				} else {
2016					jQuery.attr( elem, name, "" );
2017				}
2018
2019				elem.removeAttribute( getSetAttribute ? name : propName );
2020			}
2021		}
2022	},
2023
2024	attrHooks: {

2469		ontype = type.indexOf(":") < 0 && "on" + type;
2470
2471		event = event[ jQuery.expando ] ?
2472			event :
2473			new jQuery.Event( type, typeof event === "object" && event );
2474
2475		event.isTrigger = true;
2476		event.namespace = namespaces.join(".");
2477		event.namespace_re = event.namespace ?
2478			new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
2479			null;
2480
2481		event.result = undefined;
2482		if ( !event.target ) {
2483			event.target = elem;
2484		}
2485
2486		data = data == null ?
2487			[ event ] :
2488			jQuery.makeArray( data, [ event ] );
2489
2490		special = jQuery.event.special[ type ] || {};
2491		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
2492			return;
2493		}
2494
2495		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
2496
2497			bubbleType = special.delegateType || type;
2498			if ( !rfocusMorph.test( bubbleType + type ) ) {
2499				cur = cur.parentNode;
2500			}
2501			for ( ; cur; cur = cur.parentNode ) {
2502				eventPath.push( cur );
2503				tmp = cur;
2504			}
2505
2506			if ( tmp === (elem.ownerDocument || document) ) {
2507				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
2508			}
2509		}
2510
2511		i = 0;
2512		while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
2513
2514			event.type = i > 1 ?
2515				bubbleType :
2516				special.bindType || type;
2517
2518			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
2519			if ( handle ) {
2520				handle.apply( cur, data );
2521			}
2522
2523			handle = ontype && cur[ ontype ];
2524			if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
2525				event.preventDefault();
2526			}
2527		}
2528		event.type = type;
2529
2530		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
2531
2532			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
2533				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
2534
2535				if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) {
2536
2537					tmp = elem[ ontype ];
2538
2539					if ( tmp ) {
2540						elem[ ontype ] = null;
2541					}
2542
2543					jQuery.event.triggered = type;
2544					try {
2545						elem[ type ]();
2546					} catch ( e ) {
2547					}
2548					jQuery.event.triggered = undefined;
2549
2550					if ( tmp ) {
2551						elem[ ontype ] = tmp;
2552					}
2553				}
2554			}
2555		}
2556
2557		return event.result;
2558	},
2559
2560	dispatch: function( event ) {
2561
2562		event = jQuery.event.fix( event );
2563
2564		var i, ret, handleObj, matched, j,
2565			handlerQueue = [],
2566			args = core_slice.call( arguments ),
2567			handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [],
2568			special = jQuery.event.special[ event.type ] || {};
2569
2570		args[0] = event;
2571		event.delegateTarget = this;
2572
2573		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
2574			return;
2575		}
2576
2577		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
2578
2579		i = 0;
2580		while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
2581			event.currentTarget = matched.elem;
2582
2583			j = 0;
2584			while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
2585
2586				if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
2587
2588					event.handleObj = handleObj;
2589					event.data = handleObj.data;
2590
2591					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
2592							.apply( matched.elem, args );
2593
2594					if ( ret !== undefined ) {
2595						if ( (event.result = ret) === false ) {
2596							event.preventDefault();
2597							event.stopPropagation();
2598						}
2599					}
2600				}
2601			}
2602		}
2603
2604		if ( special.postDispatch ) {
2605			special.postDispatch.call( this, event );
2606		}
2607
2608		return event.result;
2609	},
2610
2611	handlers: function( event, handlers ) {
2612		var sel, handleObj, matches, i,
2613			handlerQueue = [],
2614			delegateCount = handlers.delegateCount,
2615			cur = event.target;
2616
2617		if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
2618
2619			for ( ; cur != this; cur = cur.parentNode || this ) {
2620
2621				if ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click") ) {
2622					matches = [];
2623					for ( i = 0; i < delegateCount; i++ ) {
2624						handleObj = handlers[ i ];
2625
2626						sel = handleObj.selector + " ";
2627
2628						if ( matches[ sel ] === undefined ) {
2629							matches[ sel ] = handleObj.needsContext ?
2630								jQuery( sel, this ).index( cur ) >= 0 :
2631								jQuery.find( sel, this, null, [ cur ] ).length;
2632						}
2633						if ( matches[ sel ] ) {
2634							matches.push( handleObj );
2635						}
2636					}
2637					if ( matches.length ) {
2638						handlerQueue.push({ elem: cur, handlers: matches });
2639					}
2640				}
2641			}
2642		}
2643
2644		if ( delegateCount < handlers.length ) {
2645			handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
2646		}
2647
2648		return handlerQueue;
2649	},
2650
2651	fix: function( event ) {
2652		if ( event[ jQuery.expando ] ) {
2653			return event;
2654		}
2655
2656		var i, prop, copy,
2657			type = event.type,
2658			originalEvent = event,
2659			fixHook = this.fixHooks[ type ];
2660
2661		if ( !fixHook ) {
2662			this.fixHooks[ type ] = fixHook =
2663				rmouseEvent.test( type ) ? this.mouseHooks :
2664				rkeyEvent.test( type ) ? this.keyHooks :
2665				{};
2666		}
2667		copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
2668
2669		event = new jQuery.Event( originalEvent );
2670
2671		i = copy.length;
2672		while ( i-- ) {
2673			prop = copy[ i ];
2674			event[ prop ] = originalEvent[ prop ];
2675		}
2676
2677		if ( !event.target ) {
2678			event.target = originalEvent.srcElement || document;
2679		}
2680
2681		if ( event.target.nodeType === 3 ) {
2682			event.target = event.target.parentNode;
2683		}
2684
2685		event.metaKey = !!event.metaKey;
2686
2687		return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
2688	},
2689
2690	props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
2691
2692	fixHooks: {},
2693
2694	keyHooks: {
2695		props: "char charCode key keyCode".split(" "),
2696		filter: function( event, original ) {
2697
2698			if ( event.which == null ) {
2699				event.which = original.charCode != null ? original.charCode : original.keyCode;
2700			}
2701
2702			return event;
2703		}
2704	},
2705
2706	mouseHooks: {
2707		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
2708		filter: function( event, original ) {
2709			var body, eventDoc, doc,
2710				button = original.button,
2711				fromElement = original.fromElement;
2712
2713			if ( event.pageX == null && original.clientX != null ) {
2714				eventDoc = event.target.ownerDocument || document;
2715				doc = eventDoc.documentElement;
2716				body = eventDoc.body;
2717
2718				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
2719				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
2720			}
2721
2722			if ( !event.relatedTarget && fromElement ) {
2723				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
2724			}
2725
2726			if ( !event.which && button !== undefined ) {
2727				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
2728			}
2729
2730			return event;
2731		}
2732	},
2733
2734	special: {
2735		load: {
2736			noBubble: true
2737		},
2738		click: {
2739			trigger: function() {
2740				if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) {
2741					this.click();
2742					return false;
2743				}
2744			}
2745		},
2746		focus: {
2747			trigger: function() {
2748				if ( this !== document.activeElement && this.focus ) {
2749					try {
2750						this.focus();
2751						return false;
2752					} catch ( e ) {
2753					}
2754				}
2755			},
2756			delegateType: "focusin"
2757		},
2758		blur: {
2759			trigger: function() {
2760				if ( this === document.activeElement && this.blur ) {
2761					this.blur();
2762					return false;
2763				}
2764			},
2765			delegateType: "focusout"
2766		},
2767
2768		beforeunload: {
2769			postDispatch: function( event ) {
2770
2771				if ( event.result !== undefined ) {
2772					event.originalEvent.returnValue = event.result;
2773				}
2774			}
2775		}
2776	},
2777
2778	simulate: function( type, elem, event, bubble ) {
2779		var e = jQuery.extend(
2780			new jQuery.Event(),
2781			event,
2782			{ type: type,
2783				isSimulated: true,
2784				originalEvent: {}
2785			}
2786		);
2787		if ( bubble ) {
2788			jQuery.event.trigger( e, null, elem );
2789		} else {
2790			jQuery.event.dispatch.call( elem, e );
2791		}
2792		if ( e.isDefaultPrevented() ) {
2793			event.preventDefault();
2794		}
2795	}
2796};
2797
2798jQuery.removeEvent = document.removeEventListener ?
2799	function( elem, type, handle ) {
2800		if ( elem.removeEventListener ) {
2801			elem.removeEventListener( type, handle, false );
2802		}
2803	} :
2804	function( elem, type, handle ) {
2805		var name = "on" + type;
2806
2807		if ( elem.detachEvent ) {
2808
2809			if ( typeof elem[ name ] === core_strundefined ) {
2810				elem[ name ] = null;
2811			}
2812
2813			elem.detachEvent( name, handle );
2814		}
2815	};
2816
2817jQuery.Event = function( src, props ) {
2818	if ( !(this instanceof jQuery.Event) ) {
2819		return new jQuery.Event( src, props );
2820	}
2821
2822	if ( src && src.type ) {
2823		this.originalEvent = src;
2824		this.type = src.type;
2825
2826		this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
2827			src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
2828
2829	} else {
2830		this.type = src;
2831	}
2832
2833	if ( props ) {
2834		jQuery.extend( this, props );
2835	}
2836
2837	this.timeStamp = src && src.timeStamp || jQuery.now();
2838
2839	this[ jQuery.expando ] = true;
2840};
2841
2842jQuery.Event.prototype = {
2843	isDefaultPrevented: returnFalse,
2844	isPropagationStopped: returnFalse,
2845	isImmediatePropagationStopped: returnFalse,
2846
2847	preventDefault: function() {
2848		var e = this.originalEvent;
2849
2850		this.isDefaultPrevented = returnTrue;
2851		if ( !e ) {
2852			return;
2853		}
2854
2855		if ( e.preventDefault ) {
2856			e.preventDefault();
2857
2858		} else {
2859			e.returnValue = false;
2860		}
2861	},
2862	stopPropagation: function() {
2863		var e = this.originalEvent;
2864
2865		this.isPropagationStopped = returnTrue;
2866		if ( !e ) {
2867			return;
2868		}
2869		if ( e.stopPropagation ) {
2870			e.stopPropagation();
2871		}
2872
2873		e.cancelBubble = true;
2874	},
2875	stopImmediatePropagation: function() {
2876		this.isImmediatePropagationStopped = returnTrue;
2877		this.stopPropagation();
2878	}
2879};
2880
2881jQuery.each({
2882	mouseenter: "mouseover",
2883	mouseleave: "mouseout"
2884}, function( orig, fix ) {
2885	jQuery.event.special[ orig ] = {
2886		delegateType: fix,
2887		bindType: fix,
2888
2889		handle: function( event ) {
2890			var ret,
2891				target = this,
2892				related = event.relatedTarget,
2893				handleObj = event.handleObj;
2894
2895			if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
2896				event.type = handleObj.origType;
2897				ret = handleObj.handler.apply( this, arguments );
2898				event.type = fix;
2899			}
2900			return ret;
2901		}
2902	};
2903});
2904
2905if ( !jQuery.support.submitBubbles ) {
2906
2907	jQuery.event.special.submit = {
2908		setup: function() {
2909			if ( jQuery.nodeName( this, "form" ) ) {
2910				return false;
2911			}
2912
2913			jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
2914				var elem = e.target,
2915					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
2916				if ( form && !jQuery._data( form, "submitBubbles" ) ) {
2917					jQuery.event.add( form, "submit._submit", function( event ) {
2918						event._submit_bubble = true;
2919					});