f3201aacb6fb01b361b93bb21e35fe03bc6636ea
[ikiwiki.git] / underlays / jquery / ikiwiki / jquery.full.js
1 /*!
2  * jQuery JavaScript Library v1.6.2
3  * http://jquery.com/
4  *
5  * Copyright 2011, John Resig
6  * Dual licensed under the MIT or GPL Version 2 licenses.
7  * http://jquery.org/license
8  *
9  * Includes Sizzle.js
10  * http://sizzlejs.com/
11  * Copyright 2011, The Dojo Foundation
12  * Released under the MIT, BSD, and GPL Licenses.
13  *
14  * Date: Thu Jun 30 14:16:56 2011 -0400
15  */
16 (function( window, undefined ) {
17
18 // Use the correct document accordingly with window argument (sandbox)
19 var document = window.document,
20         navigator = window.navigator,
21         location = window.location;
22 var jQuery = (function() {
23
24 // Define a local copy of jQuery
25 var jQuery = function( selector, context ) {
26                 // The jQuery object is actually just the init constructor 'enhanced'
27                 return new jQuery.fn.init( selector, context, rootjQuery );
28         },
29
30         // Map over jQuery in case of overwrite
31         _jQuery = window.jQuery,
32
33         // Map over the $ in case of overwrite
34         _$ = window.$,
35
36         // A central reference to the root jQuery(document)
37         rootjQuery,
38
39         // A simple way to check for HTML strings or ID strings
40         // (both of which we optimize for)
41         quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
42
43         // Check if a string has a non-whitespace character in it
44         rnotwhite = /\S/,
45
46         // Used for trimming whitespace
47         trimLeft = /^\s+/,
48         trimRight = /\s+$/,
49
50         // Check for digits
51         rdigit = /\d/,
52
53         // Match a standalone tag
54         rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
55
56         // JSON RegExp
57         rvalidchars = /^[\],:{}\s]*$/,
58         rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
59         rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
60         rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
61
62         // Useragent RegExp
63         rwebkit = /(webkit)[ \/]([\w.]+)/,
64         ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
65         rmsie = /(msie) ([\w.]+)/,
66         rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
67
68         // Matches dashed string for camelizing
69         rdashAlpha = /-([a-z])/ig,
70
71         // Used by jQuery.camelCase as callback to replace()
72         fcamelCase = function( all, letter ) {
73                 return letter.toUpperCase();
74         },
75
76         // Keep a UserAgent string for use with jQuery.browser
77         userAgent = navigator.userAgent,
78
79         // For matching the engine and version of the browser
80         browserMatch,
81
82         // The deferred used on DOM ready
83         readyList,
84
85         // The ready event handler
86         DOMContentLoaded,
87
88         // Save a reference to some core methods
89         toString = Object.prototype.toString,
90         hasOwn = Object.prototype.hasOwnProperty,
91         push = Array.prototype.push,
92         slice = Array.prototype.slice,
93         trim = String.prototype.trim,
94         indexOf = Array.prototype.indexOf,
95
96         // [[Class]] -> type pairs
97         class2type = {};
98
99 jQuery.fn = jQuery.prototype = {
100         constructor: jQuery,
101         init: function( selector, context, rootjQuery ) {
102                 var match, elem, ret, doc;
103
104                 // Handle $(""), $(null), or $(undefined)
105                 if ( !selector ) {
106                         return this;
107                 }
108
109                 // Handle $(DOMElement)
110                 if ( selector.nodeType ) {
111                         this.context = this[0] = selector;
112                         this.length = 1;
113                         return this;
114                 }
115
116                 // The body element only exists once, optimize finding it
117                 if ( selector === "body" && !context && document.body ) {
118                         this.context = document;
119                         this[0] = document.body;
120                         this.selector = selector;
121                         this.length = 1;
122                         return this;
123                 }
124
125                 // Handle HTML strings
126                 if ( typeof selector === "string" ) {
127                         // Are we dealing with HTML string or an ID?
128                         if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
129                                 // Assume that strings that start and end with <> are HTML and skip the regex check
130                                 match = [ null, selector, null ];
131
132                         } else {
133                                 match = quickExpr.exec( selector );
134                         }
135
136                         // Verify a match, and that no context was specified for #id
137                         if ( match && (match[1] || !context) ) {
138
139                                 // HANDLE: $(html) -> $(array)
140                                 if ( match[1] ) {
141                                         context = context instanceof jQuery ? context[0] : context;
142                                         doc = (context ? context.ownerDocument || context : document);
143
144                                         // If a single string is passed in and it's a single tag
145                                         // just do a createElement and skip the rest
146                                         ret = rsingleTag.exec( selector );
147
148                                         if ( ret ) {
149                                                 if ( jQuery.isPlainObject( context ) ) {
150                                                         selector = [ document.createElement( ret[1] ) ];
151                                                         jQuery.fn.attr.call( selector, context, true );
152
153                                                 } else {
154                                                         selector = [ doc.createElement( ret[1] ) ];
155                                                 }
156
157                                         } else {
158                                                 ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
159                                                 selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
160                                         }
161
162                                         return jQuery.merge( this, selector );
163
164                                 // HANDLE: $("#id")
165                                 } else {
166                                         elem = document.getElementById( match[2] );
167
168                                         // Check parentNode to catch when Blackberry 4.6 returns
169                                         // nodes that are no longer in the document #6963
170                                         if ( elem && elem.parentNode ) {
171                                                 // Handle the case where IE and Opera return items
172                                                 // by name instead of ID
173                                                 if ( elem.id !== match[2] ) {
174                                                         return rootjQuery.find( selector );
175                                                 }
176
177                                                 // Otherwise, we inject the element directly into the jQuery object
178                                                 this.length = 1;
179                                                 this[0] = elem;
180                                         }
181
182                                         this.context = document;
183                                         this.selector = selector;
184                                         return this;
185                                 }
186
187                         // HANDLE: $(expr, $(...))
188                         } else if ( !context || context.jquery ) {
189                                 return (context || rootjQuery).find( selector );
190
191                         // HANDLE: $(expr, context)
192                         // (which is just equivalent to: $(context).find(expr)
193                         } else {
194                                 return this.constructor( context ).find( selector );
195                         }
196
197                 // HANDLE: $(function)
198                 // Shortcut for document ready
199                 } else if ( jQuery.isFunction( selector ) ) {
200                         return rootjQuery.ready( selector );
201                 }
202
203                 if (selector.selector !== undefined) {
204                         this.selector = selector.selector;
205                         this.context = selector.context;
206                 }
207
208                 return jQuery.makeArray( selector, this );
209         },
210
211         // Start with an empty selector
212         selector: "",
213
214         // The current version of jQuery being used
215         jquery: "1.6.2",
216
217         // The default length of a jQuery object is 0
218         length: 0,
219
220         // The number of elements contained in the matched element set
221         size: function() {
222                 return this.length;
223         },
224
225         toArray: function() {
226                 return slice.call( this, 0 );
227         },
228
229         // Get the Nth element in the matched element set OR
230         // Get the whole matched element set as a clean array
231         get: function( num ) {
232                 return num == null ?
233
234                         // Return a 'clean' array
235                         this.toArray() :
236
237                         // Return just the object
238                         ( num < 0 ? this[ this.length + num ] : this[ num ] );
239         },
240
241         // Take an array of elements and push it onto the stack
242         // (returning the new matched element set)
243         pushStack: function( elems, name, selector ) {
244                 // Build a new jQuery matched element set
245                 var ret = this.constructor();
246
247                 if ( jQuery.isArray( elems ) ) {
248                         push.apply( ret, elems );
249
250                 } else {
251                         jQuery.merge( ret, elems );
252                 }
253
254                 // Add the old object onto the stack (as a reference)
255                 ret.prevObject = this;
256
257                 ret.context = this.context;
258
259                 if ( name === "find" ) {
260                         ret.selector = this.selector + (this.selector ? " " : "") + selector;
261                 } else if ( name ) {
262                         ret.selector = this.selector + "." + name + "(" + selector + ")";
263                 }
264
265                 // Return the newly-formed element set
266                 return ret;
267         },
268
269         // Execute a callback for every element in the matched set.
270         // (You can seed the arguments with an array of args, but this is
271         // only used internally.)
272         each: function( callback, args ) {
273                 return jQuery.each( this, callback, args );
274         },
275
276         ready: function( fn ) {
277                 // Attach the listeners
278                 jQuery.bindReady();
279
280                 // Add the callback
281                 readyList.done( fn );
282
283                 return this;
284         },
285
286         eq: function( i ) {
287                 return i === -1 ?
288                         this.slice( i ) :
289                         this.slice( i, +i + 1 );
290         },
291
292         first: function() {
293                 return this.eq( 0 );
294         },
295
296         last: function() {
297                 return this.eq( -1 );
298         },
299
300         slice: function() {
301                 return this.pushStack( slice.apply( this, arguments ),
302                         "slice", slice.call(arguments).join(",") );
303         },
304
305         map: function( callback ) {
306                 return this.pushStack( jQuery.map(this, function( elem, i ) {
307                         return callback.call( elem, i, elem );
308                 }));
309         },
310
311         end: function() {
312                 return this.prevObject || this.constructor(null);
313         },
314
315         // For internal use only.
316         // Behaves like an Array's method, not like a jQuery method.
317         push: push,
318         sort: [].sort,
319         splice: [].splice
320 };
321
322 // Give the init function the jQuery prototype for later instantiation
323 jQuery.fn.init.prototype = jQuery.fn;
324
325 jQuery.extend = jQuery.fn.extend = function() {
326         var options, name, src, copy, copyIsArray, clone,
327                 target = arguments[0] || {},
328                 i = 1,
329                 length = arguments.length,
330                 deep = false;
331
332         // Handle a deep copy situation
333         if ( typeof target === "boolean" ) {
334                 deep = target;
335                 target = arguments[1] || {};
336                 // skip the boolean and the target
337                 i = 2;
338         }
339
340         // Handle case when target is a string or something (possible in deep copy)
341         if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
342                 target = {};
343         }
344
345         // extend jQuery itself if only one argument is passed
346         if ( length === i ) {
347                 target = this;
348                 --i;
349         }
350
351         for ( ; i < length; i++ ) {
352                 // Only deal with non-null/undefined values
353                 if ( (options = arguments[ i ]) != null ) {
354                         // Extend the base object
355                         for ( name in options ) {
356                                 src = target[ name ];
357                                 copy = options[ name ];
358
359                                 // Prevent never-ending loop
360                                 if ( target === copy ) {
361                                         continue;
362                                 }
363
364                                 // Recurse if we're merging plain objects or arrays
365                                 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
366                                         if ( copyIsArray ) {
367                                                 copyIsArray = false;
368                                                 clone = src && jQuery.isArray(src) ? src : [];
369
370                                         } else {
371                                                 clone = src && jQuery.isPlainObject(src) ? src : {};
372                                         }
373
374                                         // Never move original objects, clone them
375                                         target[ name ] = jQuery.extend( deep, clone, copy );
376
377                                 // Don't bring in undefined values
378                                 } else if ( copy !== undefined ) {
379                                         target[ name ] = copy;
380                                 }
381                         }
382                 }
383         }
384
385         // Return the modified object
386         return target;
387 };
388
389 jQuery.extend({
390         noConflict: function( deep ) {
391                 if ( window.$ === jQuery ) {
392                         window.$ = _$;
393                 }
394
395                 if ( deep && window.jQuery === jQuery ) {
396                         window.jQuery = _jQuery;
397                 }
398
399                 return jQuery;
400         },
401
402         // Is the DOM ready to be used? Set to true once it occurs.
403         isReady: false,
404
405         // A counter to track how many items to wait for before
406         // the ready event fires. See #6781
407         readyWait: 1,
408
409         // Hold (or release) the ready event
410         holdReady: function( hold ) {
411                 if ( hold ) {
412                         jQuery.readyWait++;
413                 } else {
414                         jQuery.ready( true );
415                 }
416         },
417
418         // Handle when the DOM is ready
419         ready: function( wait ) {
420                 // Either a released hold or an DOMready/load event and not yet ready
421                 if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
422                         // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
423                         if ( !document.body ) {
424                                 return setTimeout( jQuery.ready, 1 );
425                         }
426
427                         // Remember that the DOM is ready
428                         jQuery.isReady = true;
429
430                         // If a normal DOM Ready event fired, decrement, and wait if need be
431                         if ( wait !== true && --jQuery.readyWait > 0 ) {
432                                 return;
433                         }
434
435                         // If there are functions bound, to execute
436                         readyList.resolveWith( document, [ jQuery ] );
437
438                         // Trigger any bound ready events
439                         if ( jQuery.fn.trigger ) {
440                                 jQuery( document ).trigger( "ready" ).unbind( "ready" );
441                         }
442                 }
443         },
444
445         bindReady: function() {
446                 if ( readyList ) {
447                         return;
448                 }
449
450                 readyList = jQuery._Deferred();
451
452                 // Catch cases where $(document).ready() is called after the
453                 // browser event has already occurred.
454                 if ( document.readyState === "complete" ) {
455                         // Handle it asynchronously to allow scripts the opportunity to delay ready
456                         return setTimeout( jQuery.ready, 1 );
457                 }
458
459                 // Mozilla, Opera and webkit nightlies currently support this event
460                 if ( document.addEventListener ) {
461                         // Use the handy event callback
462                         document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
463
464                         // A fallback to window.onload, that will always work
465                         window.addEventListener( "load", jQuery.ready, false );
466
467                 // If IE event model is used
468                 } else if ( document.attachEvent ) {
469                         // ensure firing before onload,
470                         // maybe late but safe also for iframes
471                         document.attachEvent( "onreadystatechange", DOMContentLoaded );
472
473                         // A fallback to window.onload, that will always work
474                         window.attachEvent( "onload", jQuery.ready );
475
476                         // If IE and not a frame
477                         // continually check to see if the document is ready
478                         var toplevel = false;
479
480                         try {
481                                 toplevel = window.frameElement == null;
482                         } catch(e) {}
483
484                         if ( document.documentElement.doScroll && toplevel ) {
485                                 doScrollCheck();
486                         }
487                 }
488         },
489
490         // See test/unit/core.js for details concerning isFunction.
491         // Since version 1.3, DOM methods and functions like alert
492         // aren't supported. They return false on IE (#2968).
493         isFunction: function( obj ) {
494                 return jQuery.type(obj) === "function";
495         },
496
497         isArray: Array.isArray || function( obj ) {
498                 return jQuery.type(obj) === "array";
499         },
500
501         // A crude way of determining if an object is a window
502         isWindow: function( obj ) {
503                 return obj && typeof obj === "object" && "setInterval" in obj;
504         },
505
506         isNaN: function( obj ) {
507                 return obj == null || !rdigit.test( obj ) || isNaN( obj );
508         },
509
510         type: function( obj ) {
511                 return obj == null ?
512                         String( obj ) :
513                         class2type[ toString.call(obj) ] || "object";
514         },
515
516         isPlainObject: function( obj ) {
517                 // Must be an Object.
518                 // Because of IE, we also have to check the presence of the constructor property.
519                 // Make sure that DOM nodes and window objects don't pass through, as well
520                 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
521                         return false;
522                 }
523
524                 // Not own constructor property must be Object
525                 if ( obj.constructor &&
526                         !hasOwn.call(obj, "constructor") &&
527                         !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
528                         return false;
529                 }
530
531                 // Own properties are enumerated firstly, so to speed up,
532                 // if last one is own, then all properties are own.
533
534                 var key;
535                 for ( key in obj ) {}
536
537                 return key === undefined || hasOwn.call( obj, key );
538         },
539
540         isEmptyObject: function( obj ) {
541                 for ( var name in obj ) {
542                         return false;
543                 }
544                 return true;
545         },
546
547         error: function( msg ) {
548                 throw msg;
549         },
550
551         parseJSON: function( data ) {
552                 if ( typeof data !== "string" || !data ) {
553                         return null;
554                 }
555
556                 // Make sure leading/trailing whitespace is removed (IE can't handle it)
557                 data = jQuery.trim( data );
558
559                 // Attempt to parse using the native JSON parser first
560                 if ( window.JSON && window.JSON.parse ) {
561                         return window.JSON.parse( data );
562                 }
563
564                 // Make sure the incoming data is actual JSON
565                 // Logic borrowed from http://json.org/json2.js
566                 if ( rvalidchars.test( data.replace( rvalidescape, "@" )
567                         .replace( rvalidtokens, "]" )
568                         .replace( rvalidbraces, "")) ) {
569
570                         return (new Function( "return " + data ))();
571
572                 }
573                 jQuery.error( "Invalid JSON: " + data );
574         },
575
576         // Cross-browser xml parsing
577         // (xml & tmp used internally)
578         parseXML: function( data , xml , tmp ) {
579
580                 if ( window.DOMParser ) { // Standard
581                         tmp = new DOMParser();
582                         xml = tmp.parseFromString( data , "text/xml" );
583                 } else { // IE
584                         xml = new ActiveXObject( "Microsoft.XMLDOM" );
585                         xml.async = "false";
586                         xml.loadXML( data );
587                 }
588
589                 tmp = xml.documentElement;
590
591                 if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
592                         jQuery.error( "Invalid XML: " + data );
593                 }
594
595                 return xml;
596         },
597
598         noop: function() {},
599
600         // Evaluates a script in a global context
601         // Workarounds based on findings by Jim Driscoll
602         // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
603         globalEval: function( data ) {
604                 if ( data && rnotwhite.test( data ) ) {
605                         // We use execScript on Internet Explorer
606                         // We use an anonymous function so that context is window
607                         // rather than jQuery in Firefox
608                         ( window.execScript || function( data ) {
609                                 window[ "eval" ].call( window, data );
610                         } )( data );
611                 }
612         },
613
614         // Converts a dashed string to camelCased string;
615         // Used by both the css and data modules
616         camelCase: function( string ) {
617                 return string.replace( rdashAlpha, fcamelCase );
618         },
619
620         nodeName: function( elem, name ) {
621                 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
622         },
623
624         // args is for internal usage only
625         each: function( object, callback, args ) {
626                 var name, i = 0,
627                         length = object.length,
628                         isObj = length === undefined || jQuery.isFunction( object );
629
630                 if ( args ) {
631                         if ( isObj ) {
632                                 for ( name in object ) {
633                                         if ( callback.apply( object[ name ], args ) === false ) {
634                                                 break;
635                                         }
636                                 }
637                         } else {
638                                 for ( ; i < length; ) {
639                                         if ( callback.apply( object[ i++ ], args ) === false ) {
640                                                 break;
641                                         }
642                                 }
643                         }
644
645                 // A special, fast, case for the most common use of each
646                 } else {
647                         if ( isObj ) {
648                                 for ( name in object ) {
649                                         if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
650                                                 break;
651                                         }
652                                 }
653                         } else {
654                                 for ( ; i < length; ) {
655                                         if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
656                                                 break;
657                                         }
658                                 }
659                         }
660                 }
661
662                 return object;
663         },
664
665         // Use native String.trim function wherever possible
666         trim: trim ?
667                 function( text ) {
668                         return text == null ?
669                                 "" :
670                                 trim.call( text );
671                 } :
672
673                 // Otherwise use our own trimming functionality
674                 function( text ) {
675                         return text == null ?
676                                 "" :
677                                 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
678                 },
679
680         // results is for internal usage only
681         makeArray: function( array, results ) {
682                 var ret = results || [];
683
684                 if ( array != null ) {
685                         // The window, strings (and functions) also have 'length'
686                         // The extra typeof function check is to prevent crashes
687                         // in Safari 2 (See: #3039)
688                         // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
689                         var type = jQuery.type( array );
690
691                         if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
692                                 push.call( ret, array );
693                         } else {
694                                 jQuery.merge( ret, array );
695                         }
696                 }
697
698                 return ret;
699         },
700
701         inArray: function( elem, array ) {
702
703                 if ( indexOf ) {
704                         return indexOf.call( array, elem );
705                 }
706
707                 for ( var i = 0, length = array.length; i < length; i++ ) {
708                         if ( array[ i ] === elem ) {
709                                 return i;
710                         }
711                 }
712
713                 return -1;
714         },
715
716         merge: function( first, second ) {
717                 var i = first.length,
718                         j = 0;
719
720                 if ( typeof second.length === "number" ) {
721                         for ( var l = second.length; j < l; j++ ) {
722                                 first[ i++ ] = second[ j ];
723                         }
724
725                 } else {
726                         while ( second[j] !== undefined ) {
727                                 first[ i++ ] = second[ j++ ];
728                         }
729                 }
730
731                 first.length = i;
732
733                 return first;
734         },
735
736         grep: function( elems, callback, inv ) {
737                 var ret = [], retVal;
738                 inv = !!inv;
739
740                 // Go through the array, only saving the items
741                 // that pass the validator function
742                 for ( var i = 0, length = elems.length; i < length; i++ ) {
743                         retVal = !!callback( elems[ i ], i );
744                         if ( inv !== retVal ) {
745                                 ret.push( elems[ i ] );
746                         }
747                 }
748
749                 return ret;
750         },
751
752         // arg is for internal usage only
753         map: function( elems, callback, arg ) {
754                 var value, key, ret = [],
755                         i = 0,
756                         length = elems.length,
757                         // jquery objects are treated as arrays
758                         isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
759
760                 // Go through the array, translating each of the items to their
761                 if ( isArray ) {
762                         for ( ; i < length; i++ ) {
763                                 value = callback( elems[ i ], i, arg );
764
765                                 if ( value != null ) {
766                                         ret[ ret.length ] = value;
767                                 }
768                         }
769
770                 // Go through every key on the object,
771                 } else {
772                         for ( key in elems ) {
773                                 value = callback( elems[ key ], key, arg );
774
775                                 if ( value != null ) {
776                                         ret[ ret.length ] = value;
777                                 }
778                         }
779                 }
780
781                 // Flatten any nested arrays
782                 return ret.concat.apply( [], ret );
783         },
784
785         // A global GUID counter for objects
786         guid: 1,
787
788         // Bind a function to a context, optionally partially applying any
789         // arguments.
790         proxy: function( fn, context ) {
791                 if ( typeof context === "string" ) {
792                         var tmp = fn[ context ];
793                         context = fn;
794                         fn = tmp;
795                 }
796
797                 // Quick check to determine if target is callable, in the spec
798                 // this throws a TypeError, but we will just return undefined.
799                 if ( !jQuery.isFunction( fn ) ) {
800                         return undefined;
801                 }
802
803                 // Simulated bind
804                 var args = slice.call( arguments, 2 ),
805                         proxy = function() {
806                                 return fn.apply( context, args.concat( slice.call( arguments ) ) );
807                         };
808
809                 // Set the guid of unique handler to the same of original handler, so it can be removed
810                 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
811
812                 return proxy;
813         },
814
815         // Mutifunctional method to get and set values to a collection
816         // The value/s can optionally be executed if it's a function
817         access: function( elems, key, value, exec, fn, pass ) {
818                 var length = elems.length;
819
820                 // Setting many attributes
821                 if ( typeof key === "object" ) {
822                         for ( var k in key ) {
823                                 jQuery.access( elems, k, key[k], exec, fn, value );
824                         }
825                         return elems;
826                 }
827
828                 // Setting one attribute
829                 if ( value !== undefined ) {
830                         // Optionally, function values get executed if exec is true
831                         exec = !pass && exec && jQuery.isFunction(value);
832
833                         for ( var i = 0; i < length; i++ ) {
834                                 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
835                         }
836
837                         return elems;
838                 }
839
840                 // Getting an attribute
841                 return length ? fn( elems[0], key ) : undefined;
842         },
843
844         now: function() {
845                 return (new Date()).getTime();
846         },
847
848         // Use of jQuery.browser is frowned upon.
849         // More details: http://docs.jquery.com/Utilities/jQuery.browser
850         uaMatch: function( ua ) {
851                 ua = ua.toLowerCase();
852
853                 var match = rwebkit.exec( ua ) ||
854                         ropera.exec( ua ) ||
855                         rmsie.exec( ua ) ||
856                         ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
857                         [];
858
859                 return { browser: match[1] || "", version: match[2] || "0" };
860         },
861
862         sub: function() {
863                 function jQuerySub( selector, context ) {
864                         return new jQuerySub.fn.init( selector, context );
865                 }
866                 jQuery.extend( true, jQuerySub, this );
867                 jQuerySub.superclass = this;
868                 jQuerySub.fn = jQuerySub.prototype = this();
869                 jQuerySub.fn.constructor = jQuerySub;
870                 jQuerySub.sub = this.sub;
871                 jQuerySub.fn.init = function init( selector, context ) {
872                         if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
873                                 context = jQuerySub( context );
874                         }
875
876                         return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
877                 };
878                 jQuerySub.fn.init.prototype = jQuerySub.fn;
879                 var rootjQuerySub = jQuerySub(document);
880                 return jQuerySub;
881         },
882
883         browser: {}
884 });
885
886 // Populate the class2type map
887 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
888         class2type[ "[object " + name + "]" ] = name.toLowerCase();
889 });
890
891 browserMatch = jQuery.uaMatch( userAgent );
892 if ( browserMatch.browser ) {
893         jQuery.browser[ browserMatch.browser ] = true;
894         jQuery.browser.version = browserMatch.version;
895 }
896
897 // Deprecated, use jQuery.browser.webkit instead
898 if ( jQuery.browser.webkit ) {
899         jQuery.browser.safari = true;
900 }
901
902 // IE doesn't match non-breaking spaces with \s
903 if ( rnotwhite.test( "\xA0" ) ) {
904         trimLeft = /^[\s\xA0]+/;
905         trimRight = /[\s\xA0]+$/;
906 }
907
908 // All jQuery objects should point back to these
909 rootjQuery = jQuery(document);
910
911 // Cleanup functions for the document ready method
912 if ( document.addEventListener ) {
913         DOMContentLoaded = function() {
914                 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
915                 jQuery.ready();
916         };
917
918 } else if ( document.attachEvent ) {
919         DOMContentLoaded = function() {
920                 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
921                 if ( document.readyState === "complete" ) {
922                         document.detachEvent( "onreadystatechange", DOMContentLoaded );
923                         jQuery.ready();
924                 }
925         };
926 }
927
928 // The DOM ready check for Internet Explorer
929 function doScrollCheck() {
930         if ( jQuery.isReady ) {
931                 return;
932         }
933
934         try {
935                 // If IE is used, use the trick by Diego Perini
936                 // http://javascript.nwbox.com/IEContentLoaded/
937                 document.documentElement.doScroll("left");
938         } catch(e) {
939                 setTimeout( doScrollCheck, 1 );
940                 return;
941         }
942
943         // and execute any waiting functions
944         jQuery.ready();
945 }
946
947 return jQuery;
948
949 })();
950
951
952 var // Promise methods
953         promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
954         // Static reference to slice
955         sliceDeferred = [].slice;
956
957 jQuery.extend({
958         // Create a simple deferred (one callbacks list)
959         _Deferred: function() {
960                 var // callbacks list
961                         callbacks = [],
962                         // stored [ context , args ]
963                         fired,
964                         // to avoid firing when already doing so
965                         firing,
966                         // flag to know if the deferred has been cancelled
967                         cancelled,
968                         // the deferred itself
969                         deferred  = {
970
971                                 // done( f1, f2, ...)
972                                 done: function() {
973                                         if ( !cancelled ) {
974                                                 var args = arguments,
975                                                         i,
976                                                         length,
977                                                         elem,
978                                                         type,
979                                                         _fired;
980                                                 if ( fired ) {
981                                                         _fired = fired;
982                                                         fired = 0;
983                                                 }
984                                                 for ( i = 0, length = args.length; i < length; i++ ) {
985                                                         elem = args[ i ];
986                                                         type = jQuery.type( elem );
987                                                         if ( type === "array" ) {
988                                                                 deferred.done.apply( deferred, elem );
989                                                         } else if ( type === "function" ) {
990                                                                 callbacks.push( elem );
991                                                         }
992                                                 }
993                                                 if ( _fired ) {
994                                                         deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
995                                                 }
996                                         }
997                                         return this;
998                                 },
999
1000                                 // resolve with given context and args
1001                                 resolveWith: function( context, args ) {
1002                                         if ( !cancelled && !fired && !firing ) {
1003                                                 // make sure args are available (#8421)
1004                                                 args = args || [];
1005                                                 firing = 1;
1006                                                 try {
1007                                                         while( callbacks[ 0 ] ) {
1008                                                                 callbacks.shift().apply( context, args );
1009                                                         }
1010                                                 }
1011                                                 finally {
1012                                                         fired = [ context, args ];
1013                                                         firing = 0;
1014                                                 }
1015                                         }
1016                                         return this;
1017                                 },
1018
1019                                 // resolve with this as context and given arguments
1020                                 resolve: function() {
1021                                         deferred.resolveWith( this, arguments );
1022                                         return this;
1023                                 },
1024
1025                                 // Has this deferred been resolved?
1026                                 isResolved: function() {
1027                                         return !!( firing || fired );
1028                                 },
1029
1030                                 // Cancel
1031                                 cancel: function() {
1032                                         cancelled = 1;
1033                                         callbacks = [];
1034                                         return this;
1035                                 }
1036                         };
1037
1038                 return deferred;
1039         },
1040
1041         // Full fledged deferred (two callbacks list)
1042         Deferred: function( func ) {
1043                 var deferred = jQuery._Deferred(),
1044                         failDeferred = jQuery._Deferred(),
1045                         promise;
1046                 // Add errorDeferred methods, then and promise
1047                 jQuery.extend( deferred, {
1048                         then: function( doneCallbacks, failCallbacks ) {
1049                                 deferred.done( doneCallbacks ).fail( failCallbacks );
1050                                 return this;
1051                         },
1052                         always: function() {
1053                                 return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
1054                         },
1055                         fail: failDeferred.done,
1056                         rejectWith: failDeferred.resolveWith,
1057                         reject: failDeferred.resolve,
1058                         isRejected: failDeferred.isResolved,
1059                         pipe: function( fnDone, fnFail ) {
1060                                 return jQuery.Deferred(function( newDefer ) {
1061                                         jQuery.each( {
1062                                                 done: [ fnDone, "resolve" ],
1063                                                 fail: [ fnFail, "reject" ]
1064                                         }, function( handler, data ) {
1065                                                 var fn = data[ 0 ],
1066                                                         action = data[ 1 ],
1067                                                         returned;
1068                                                 if ( jQuery.isFunction( fn ) ) {
1069                                                         deferred[ handler ](function() {
1070                                                                 returned = fn.apply( this, arguments );
1071                                                                 if ( returned && jQuery.isFunction( returned.promise ) ) {
1072                                                                         returned.promise().then( newDefer.resolve, newDefer.reject );
1073                                                                 } else {
1074                                                                         newDefer[ action ]( returned );
1075                                                                 }
1076                                                         });
1077                                                 } else {
1078                                                         deferred[ handler ]( newDefer[ action ] );
1079                                                 }
1080                                         });
1081                                 }).promise();
1082                         },
1083                         // Get a promise for this deferred
1084                         // If obj is provided, the promise aspect is added to the object
1085                         promise: function( obj ) {
1086                                 if ( obj == null ) {
1087                                         if ( promise ) {
1088                                                 return promise;
1089                                         }
1090                                         promise = obj = {};
1091                                 }
1092                                 var i = promiseMethods.length;
1093                                 while( i-- ) {
1094                                         obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
1095                                 }
1096                                 return obj;
1097                         }
1098                 });
1099                 // Make sure only one callback list will be used
1100                 deferred.done( failDeferred.cancel ).fail( deferred.cancel );
1101                 // Unexpose cancel
1102                 delete deferred.cancel;
1103                 // Call given func if any
1104                 if ( func ) {
1105                         func.call( deferred, deferred );
1106                 }
1107                 return deferred;
1108         },
1109
1110         // Deferred helper
1111         when: function( firstParam ) {
1112                 var args = arguments,
1113                         i = 0,
1114                         length = args.length,
1115                         count = length,
1116                         deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1117                                 firstParam :
1118                                 jQuery.Deferred();
1119                 function resolveFunc( i ) {
1120                         return function( value ) {
1121                                 args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1122                                 if ( !( --count ) ) {
1123                                         // Strange bug in FF4:
1124                                         // Values changed onto the arguments object sometimes end up as undefined values
1125                                         // outside the $.when method. Cloning the object into a fresh array solves the issue
1126                                         deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
1127                                 }
1128                         };
1129                 }
1130                 if ( length > 1 ) {
1131                         for( ; i < length; i++ ) {
1132                                 if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
1133                                         args[ i ].promise().then( resolveFunc(i), deferred.reject );
1134                                 } else {
1135                                         --count;
1136                                 }
1137                         }
1138                         if ( !count ) {
1139                                 deferred.resolveWith( deferred, args );
1140                         }
1141                 } else if ( deferred !== firstParam ) {
1142                         deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1143                 }
1144                 return deferred.promise();
1145         }
1146 });
1147
1148
1149
1150 jQuery.support = (function() {
1151
1152         var div = document.createElement( "div" ),
1153                 documentElement = document.documentElement,
1154                 all,
1155                 a,
1156                 select,
1157                 opt,
1158                 input,
1159                 marginDiv,
1160                 support,
1161                 fragment,
1162                 body,
1163                 testElementParent,
1164                 testElement,
1165                 testElementStyle,
1166                 tds,
1167                 events,
1168                 eventName,
1169                 i,
1170                 isSupported;
1171
1172         // Preliminary tests
1173         div.setAttribute("className", "t");
1174         div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1175
1176         all = div.getElementsByTagName( "*" );
1177         a = div.getElementsByTagName( "a" )[ 0 ];
1178
1179         // Can't get basic test support
1180         if ( !all || !all.length || !a ) {
1181                 return {};
1182         }
1183
1184         // First batch of supports tests
1185         select = document.createElement( "select" );
1186         opt = select.appendChild( document.createElement("option") );
1187         input = div.getElementsByTagName( "input" )[ 0 ];
1188
1189         support = {
1190                 // IE strips leading whitespace when .innerHTML is used
1191                 leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1192
1193                 // Make sure that tbody elements aren't automatically inserted
1194                 // IE will insert them into empty tables
1195                 tbody: !div.getElementsByTagName( "tbody" ).length,
1196
1197                 // Make sure that link elements get serialized correctly by innerHTML
1198                 // This requires a wrapper element in IE
1199                 htmlSerialize: !!div.getElementsByTagName( "link" ).length,
1200
1201                 // Get the style information from getAttribute
1202                 // (IE uses .cssText instead)
1203                 style: /top/.test( a.getAttribute("style") ),
1204
1205                 // Make sure that URLs aren't manipulated
1206                 // (IE normalizes it by default)
1207                 hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
1208
1209                 // Make sure that element opacity exists
1210                 // (IE uses filter instead)
1211                 // Use a regex to work around a WebKit issue. See #5145
1212                 opacity: /^0.55$/.test( a.style.opacity ),
1213
1214                 // Verify style float existence
1215                 // (IE uses styleFloat instead of cssFloat)
1216                 cssFloat: !!a.style.cssFloat,
1217
1218                 // Make sure that if no value is specified for a checkbox
1219                 // that it defaults to "on".
1220                 // (WebKit defaults to "" instead)
1221                 checkOn: ( input.value === "on" ),
1222
1223                 // Make sure that a selected-by-default option has a working selected property.
1224                 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1225                 optSelected: opt.selected,
1226
1227                 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1228                 getSetAttribute: div.className !== "t",
1229
1230                 // Will be defined later
1231                 submitBubbles: true,
1232                 changeBubbles: true,
1233                 focusinBubbles: false,
1234                 deleteExpando: true,
1235                 noCloneEvent: true,
1236                 inlineBlockNeedsLayout: false,
1237                 shrinkWrapBlocks: false,
1238                 reliableMarginRight: true
1239         };
1240
1241         // Make sure checked status is properly cloned
1242         input.checked = true;
1243         support.noCloneChecked = input.cloneNode( true ).checked;
1244
1245         // Make sure that the options inside disabled selects aren't marked as disabled
1246         // (WebKit marks them as disabled)
1247         select.disabled = true;
1248         support.optDisabled = !opt.disabled;
1249
1250         // Test to see if it's possible to delete an expando from an element
1251         // Fails in Internet Explorer
1252         try {
1253                 delete div.test;
1254         } catch( e ) {
1255                 support.deleteExpando = false;
1256         }
1257
1258         if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1259                 div.attachEvent( "onclick", function() {
1260                         // Cloning a node shouldn't copy over any
1261                         // bound event handlers (IE does this)
1262                         support.noCloneEvent = false;
1263                 });
1264                 div.cloneNode( true ).fireEvent( "onclick" );
1265         }
1266
1267         // Check if a radio maintains it's value
1268         // after being appended to the DOM
1269         input = document.createElement("input");
1270         input.value = "t";
1271         input.setAttribute("type", "radio");
1272         support.radioValue = input.value === "t";
1273
1274         input.setAttribute("checked", "checked");
1275         div.appendChild( input );
1276         fragment = document.createDocumentFragment();
1277         fragment.appendChild( div.firstChild );
1278
1279         // WebKit doesn't clone checked state correctly in fragments
1280         support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1281
1282         div.innerHTML = "";
1283
1284         // Figure out if the W3C box model works as expected
1285         div.style.width = div.style.paddingLeft = "1px";
1286
1287         body = document.getElementsByTagName( "body" )[ 0 ];
1288         // We use our own, invisible, body unless the body is already present
1289         // in which case we use a div (#9239)
1290         testElement = document.createElement( body ? "div" : "body" );
1291         testElementStyle = {
1292                 visibility: "hidden",
1293                 width: 0,
1294                 height: 0,
1295                 border: 0,
1296                 margin: 0
1297         };
1298         if ( body ) {
1299                 jQuery.extend( testElementStyle, {
1300                         position: "absolute",
1301                         left: -1000,
1302                         top: -1000
1303                 });
1304         }
1305         for ( i in testElementStyle ) {
1306                 testElement.style[ i ] = testElementStyle[ i ];
1307         }
1308         testElement.appendChild( div );
1309         testElementParent = body || documentElement;
1310         testElementParent.insertBefore( testElement, testElementParent.firstChild );
1311
1312         // Check if a disconnected checkbox will retain its checked
1313         // value of true after appended to the DOM (IE6/7)
1314         support.appendChecked = input.checked;
1315
1316         support.boxModel = div.offsetWidth === 2;
1317
1318         if ( "zoom" in div.style ) {
1319                 // Check if natively block-level elements act like inline-block
1320                 // elements when setting their display to 'inline' and giving
1321                 // them layout
1322                 // (IE < 8 does this)
1323                 div.style.display = "inline";
1324                 div.style.zoom = 1;
1325                 support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1326
1327                 // Check if elements with layout shrink-wrap their children
1328                 // (IE 6 does this)
1329                 div.style.display = "";
1330                 div.innerHTML = "<div style='width:4px;'></div>";
1331                 support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1332         }
1333
1334         div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1335         tds = div.getElementsByTagName( "td" );
1336
1337         // Check if table cells still have offsetWidth/Height when they are set
1338         // to display:none and there are still other visible table cells in a
1339         // table row; if so, offsetWidth/Height are not reliable for use when
1340         // determining if an element has been hidden directly using
1341         // display:none (it is still safe to use offsets if a parent element is
1342         // hidden; don safety goggles and see bug #4512 for more information).
1343         // (only IE 8 fails this test)
1344         isSupported = ( tds[ 0 ].offsetHeight === 0 );
1345
1346         tds[ 0 ].style.display = "";
1347         tds[ 1 ].style.display = "none";
1348
1349         // Check if empty table cells still have offsetWidth/Height
1350         // (IE < 8 fail this test)
1351         support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1352         div.innerHTML = "";
1353
1354         // Check if div with explicit width and no margin-right incorrectly
1355         // gets computed margin-right based on width of container. For more
1356         // info see bug #3333
1357         // Fails in WebKit before Feb 2011 nightlies
1358         // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1359         if ( document.defaultView && document.defaultView.getComputedStyle ) {
1360                 marginDiv = document.createElement( "div" );
1361                 marginDiv.style.width = "0";
1362                 marginDiv.style.marginRight = "0";
1363                 div.appendChild( marginDiv );
1364                 support.reliableMarginRight =
1365                         ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1366         }
1367
1368         // Remove the body element we added
1369         testElement.innerHTML = "";
1370         testElementParent.removeChild( testElement );
1371
1372         // Technique from Juriy Zaytsev
1373         // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1374         // We only care about the case where non-standard event systems
1375         // are used, namely in IE. Short-circuiting here helps us to
1376         // avoid an eval call (in setAttribute) which can cause CSP
1377         // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1378         if ( div.attachEvent ) {
1379                 for( i in {
1380                         submit: 1,
1381                         change: 1,
1382                         focusin: 1
1383                 } ) {
1384                         eventName = "on" + i;
1385                         isSupported = ( eventName in div );
1386                         if ( !isSupported ) {
1387                                 div.setAttribute( eventName, "return;" );
1388                                 isSupported = ( typeof div[ eventName ] === "function" );
1389                         }
1390                         support[ i + "Bubbles" ] = isSupported;
1391                 }
1392         }
1393
1394         // Null connected elements to avoid leaks in IE
1395         testElement = fragment = select = opt = body = marginDiv = div = input = null;
1396
1397         return support;
1398 })();
1399
1400 // Keep track of boxModel
1401 jQuery.boxModel = jQuery.support.boxModel;
1402
1403
1404
1405
1406 var rbrace = /^(?:\{.*\}|\[.*\])$/,
1407         rmultiDash = /([a-z])([A-Z])/g;
1408
1409 jQuery.extend({
1410         cache: {},
1411
1412         // Please use with caution
1413         uuid: 0,
1414
1415         // Unique for each copy of jQuery on the page
1416         // Non-digits removed to match rinlinejQuery
1417         expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1418
1419         // The following elements throw uncatchable exceptions if you
1420         // attempt to add expando properties to them.
1421         noData: {
1422                 "embed": true,
1423                 // Ban all objects except for Flash (which handle expandos)
1424                 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1425                 "applet": true
1426         },
1427
1428         hasData: function( elem ) {
1429                 elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1430
1431                 return !!elem && !isEmptyDataObject( elem );
1432         },
1433
1434         data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1435                 if ( !jQuery.acceptData( elem ) ) {
1436                         return;
1437                 }
1438
1439                 var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
1440
1441                         // We have to handle DOM nodes and JS objects differently because IE6-7
1442                         // can't GC object references properly across the DOM-JS boundary
1443                         isNode = elem.nodeType,
1444
1445                         // Only DOM nodes need the global jQuery cache; JS object data is
1446                         // attached directly to the object so GC can occur automatically
1447                         cache = isNode ? jQuery.cache : elem,
1448
1449                         // Only defining an ID for JS objects if its cache already exists allows
1450                         // the code to shortcut on the same path as a DOM node with no cache
1451                         id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1452
1453                 // Avoid doing any more work than we need to when trying to get data on an
1454                 // object that has no data at all
1455                 if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
1456                         return;
1457                 }
1458
1459                 if ( !id ) {
1460                         // Only DOM nodes need a new unique ID for each element since their data
1461                         // ends up in the global cache
1462                         if ( isNode ) {
1463                                 elem[ jQuery.expando ] = id = ++jQuery.uuid;
1464                         } else {
1465                                 id = jQuery.expando;
1466                         }
1467                 }
1468
1469                 if ( !cache[ id ] ) {
1470                         cache[ id ] = {};
1471
1472                         // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1473                         // metadata on plain JS objects when the object is serialized using
1474                         // JSON.stringify
1475                         if ( !isNode ) {
1476                                 cache[ id ].toJSON = jQuery.noop;
1477                         }
1478                 }
1479
1480                 // An object can be passed to jQuery.data instead of a key/value pair; this gets
1481                 // shallow copied over onto the existing cache
1482                 if ( typeof name === "object" || typeof name === "function" ) {
1483                         if ( pvt ) {
1484                                 cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1485                         } else {
1486                                 cache[ id ] = jQuery.extend(cache[ id ], name);
1487                         }
1488                 }
1489
1490                 thisCache = cache[ id ];
1491
1492                 // Internal jQuery data is stored in a separate object inside the object's data
1493                 // cache in order to avoid key collisions between internal data and user-defined
1494                 // data
1495                 if ( pvt ) {
1496                         if ( !thisCache[ internalKey ] ) {
1497                                 thisCache[ internalKey ] = {};
1498                         }
1499
1500                         thisCache = thisCache[ internalKey ];
1501                 }
1502
1503                 if ( data !== undefined ) {
1504                         thisCache[ jQuery.camelCase( name ) ] = data;
1505                 }
1506
1507                 // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1508                 // not attempt to inspect the internal events object using jQuery.data, as this
1509                 // internal data object is undocumented and subject to change.
1510                 if ( name === "events" && !thisCache[name] ) {
1511                         return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1512                 }
1513
1514                 return getByName ? 
1515                         // Check for both converted-to-camel and non-converted data property names
1516                         thisCache[ jQuery.camelCase( name ) ] || thisCache[ name ] :
1517                         thisCache;
1518         },
1519
1520         removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1521                 if ( !jQuery.acceptData( elem ) ) {
1522                         return;
1523                 }
1524
1525                 var internalKey = jQuery.expando, isNode = elem.nodeType,
1526
1527                         // See jQuery.data for more information
1528                         cache = isNode ? jQuery.cache : elem,
1529
1530                         // See jQuery.data for more information
1531                         id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1532
1533                 // If there is already no cache entry for this object, there is no
1534                 // purpose in continuing
1535                 if ( !cache[ id ] ) {
1536                         return;
1537                 }
1538
1539                 if ( name ) {
1540                         var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1541
1542                         if ( thisCache ) {
1543                                 delete thisCache[ name ];
1544
1545                                 // If there is no data left in the cache, we want to continue
1546                                 // and let the cache object itself get destroyed
1547                                 if ( !isEmptyDataObject(thisCache) ) {
1548                                         return;
1549                                 }
1550                         }
1551                 }
1552
1553                 // See jQuery.data for more information
1554                 if ( pvt ) {
1555                         delete cache[ id ][ internalKey ];
1556
1557                         // Don't destroy the parent cache unless the internal data object
1558                         // had been the only thing left in it
1559                         if ( !isEmptyDataObject(cache[ id ]) ) {
1560                                 return;
1561                         }
1562                 }
1563
1564                 var internalCache = cache[ id ][ internalKey ];
1565
1566                 // Browsers that fail expando deletion also refuse to delete expandos on
1567                 // the window, but it will allow it on all other JS objects; other browsers
1568                 // don't care
1569                 if ( jQuery.support.deleteExpando || cache != window ) {
1570                         delete cache[ id ];
1571                 } else {
1572                         cache[ id ] = null;
1573                 }
1574
1575                 // We destroyed the entire user cache at once because it's faster than
1576                 // iterating through each key, but we need to continue to persist internal
1577                 // data if it existed
1578                 if ( internalCache ) {
1579                         cache[ id ] = {};
1580                         // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1581                         // metadata on plain JS objects when the object is serialized using
1582                         // JSON.stringify
1583                         if ( !isNode ) {
1584                                 cache[ id ].toJSON = jQuery.noop;
1585                         }
1586
1587                         cache[ id ][ internalKey ] = internalCache;
1588
1589                 // Otherwise, we need to eliminate the expando on the node to avoid
1590                 // false lookups in the cache for entries that no longer exist
1591                 } else if ( isNode ) {
1592                         // IE does not allow us to delete expando properties from nodes,
1593                         // nor does it have a removeAttribute function on Document nodes;
1594                         // we must handle all of these cases
1595                         if ( jQuery.support.deleteExpando ) {
1596                                 delete elem[ jQuery.expando ];
1597                         } else if ( elem.removeAttribute ) {
1598                                 elem.removeAttribute( jQuery.expando );
1599                         } else {
1600                                 elem[ jQuery.expando ] = null;
1601                         }
1602                 }
1603         },
1604
1605         // For internal use only.
1606         _data: function( elem, name, data ) {
1607                 return jQuery.data( elem, name, data, true );
1608         },
1609
1610         // A method for determining if a DOM node can handle the data expando
1611         acceptData: function( elem ) {
1612                 if ( elem.nodeName ) {
1613                         var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1614
1615                         if ( match ) {
1616                                 return !(match === true || elem.getAttribute("classid") !== match);
1617                         }
1618                 }
1619
1620                 return true;
1621         }
1622 });
1623
1624 jQuery.fn.extend({
1625         data: function( key, value ) {
1626                 var data = null;
1627
1628                 if ( typeof key === "undefined" ) {
1629                         if ( this.length ) {
1630                                 data = jQuery.data( this[0] );
1631
1632                                 if ( this[0].nodeType === 1 ) {
1633                             var attr = this[0].attributes, name;
1634                                         for ( var i = 0, l = attr.length; i < l; i++ ) {
1635                                                 name = attr[i].name;
1636
1637                                                 if ( name.indexOf( "data-" ) === 0 ) {
1638                                                         name = jQuery.camelCase( name.substring(5) );
1639
1640                                                         dataAttr( this[0], name, data[ name ] );
1641                                                 }
1642                                         }
1643                                 }
1644                         }
1645
1646                         return data;
1647
1648                 } else if ( typeof key === "object" ) {
1649                         return this.each(function() {
1650                                 jQuery.data( this, key );
1651                         });
1652                 }
1653
1654                 var parts = key.split(".");
1655                 parts[1] = parts[1] ? "." + parts[1] : "";
1656
1657                 if ( value === undefined ) {
1658                         data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1659
1660                         // Try to fetch any internally stored data first
1661                         if ( data === undefined && this.length ) {
1662                                 data = jQuery.data( this[0], key );
1663                                 data = dataAttr( this[0], key, data );
1664                         }
1665
1666                         return data === undefined && parts[1] ?
1667                                 this.data( parts[0] ) :
1668                                 data;
1669
1670                 } else {
1671                         return this.each(function() {
1672                                 var $this = jQuery( this ),
1673                                         args = [ parts[0], value ];
1674
1675                                 $this.triggerHandler( "setData" + parts[1] + "!", args );
1676                                 jQuery.data( this, key, value );
1677                                 $this.triggerHandler( "changeData" + parts[1] + "!", args );
1678                         });
1679                 }
1680         },
1681
1682         removeData: function( key ) {
1683                 return this.each(function() {
1684                         jQuery.removeData( this, key );
1685                 });
1686         }
1687 });
1688
1689 function dataAttr( elem, key, data ) {
1690         // If nothing was found internally, try to fetch any
1691         // data from the HTML5 data-* attribute
1692         if ( data === undefined && elem.nodeType === 1 ) {
1693                 var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
1694
1695                 data = elem.getAttribute( name );
1696
1697                 if ( typeof data === "string" ) {
1698                         try {
1699                                 data = data === "true" ? true :
1700                                 data === "false" ? false :
1701                                 data === "null" ? null :
1702                                 !jQuery.isNaN( data ) ? parseFloat( data ) :
1703                                         rbrace.test( data ) ? jQuery.parseJSON( data ) :
1704                                         data;
1705                         } catch( e ) {}
1706
1707                         // Make sure we set the data so it isn't changed later
1708                         jQuery.data( elem, key, data );
1709
1710                 } else {
1711                         data = undefined;
1712                 }
1713         }
1714
1715         return data;
1716 }
1717
1718 // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
1719 // property to be considered empty objects; this property always exists in
1720 // order to make sure JSON.stringify does not expose internal metadata
1721 function isEmptyDataObject( obj ) {
1722         for ( var name in obj ) {
1723                 if ( name !== "toJSON" ) {
1724                         return false;
1725                 }
1726         }
1727
1728         return true;
1729 }
1730
1731
1732
1733
1734 function handleQueueMarkDefer( elem, type, src ) {
1735         var deferDataKey = type + "defer",
1736                 queueDataKey = type + "queue",
1737                 markDataKey = type + "mark",
1738                 defer = jQuery.data( elem, deferDataKey, undefined, true );
1739         if ( defer &&
1740                 ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
1741                 ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
1742                 // Give room for hard-coded callbacks to fire first
1743                 // and eventually mark/queue something else on the element
1744                 setTimeout( function() {
1745                         if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
1746                                 !jQuery.data( elem, markDataKey, undefined, true ) ) {
1747                                 jQuery.removeData( elem, deferDataKey, true );
1748                                 defer.resolve();
1749                         }
1750                 }, 0 );
1751         }
1752 }
1753
1754 jQuery.extend({
1755
1756         _mark: function( elem, type ) {
1757                 if ( elem ) {
1758                         type = (type || "fx") + "mark";
1759                         jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
1760                 }
1761         },
1762
1763         _unmark: function( force, elem, type ) {
1764                 if ( force !== true ) {
1765                         type = elem;
1766                         elem = force;
1767                         force = false;
1768                 }
1769                 if ( elem ) {
1770                         type = type || "fx";
1771                         var key = type + "mark",
1772                                 count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
1773                         if ( count ) {
1774                                 jQuery.data( elem, key, count, true );
1775                         } else {
1776                                 jQuery.removeData( elem, key, true );
1777                                 handleQueueMarkDefer( elem, type, "mark" );
1778                         }
1779                 }
1780         },
1781
1782         queue: function( elem, type, data ) {
1783                 if ( elem ) {
1784                         type = (type || "fx") + "queue";
1785                         var q = jQuery.data( elem, type, undefined, true );
1786                         // Speed up dequeue by getting out quickly if this is just a lookup
1787                         if ( data ) {
1788                                 if ( !q || jQuery.isArray(data) ) {
1789                                         q = jQuery.data( elem, type, jQuery.makeArray(data), true );
1790                                 } else {
1791                                         q.push( data );
1792                                 }
1793                         }
1794                         return q || [];
1795                 }
1796         },
1797
1798         dequeue: function( elem, type ) {
1799                 type = type || "fx";
1800
1801                 var queue = jQuery.queue( elem, type ),
1802                         fn = queue.shift(),
1803                         defer;
1804
1805                 // If the fx queue is dequeued, always remove the progress sentinel
1806                 if ( fn === "inprogress" ) {
1807                         fn = queue.shift();
1808                 }
1809
1810                 if ( fn ) {
1811                         // Add a progress sentinel to prevent the fx queue from being
1812                         // automatically dequeued
1813                         if ( type === "fx" ) {
1814                                 queue.unshift("inprogress");
1815                         }
1816
1817                         fn.call(elem, function() {
1818                                 jQuery.dequeue(elem, type);
1819                         });
1820                 }
1821
1822                 if ( !queue.length ) {
1823                         jQuery.removeData( elem, type + "queue", true );
1824                         handleQueueMarkDefer( elem, type, "queue" );
1825                 }
1826         }
1827 });
1828
1829 jQuery.fn.extend({
1830         queue: function( type, data ) {
1831                 if ( typeof type !== "string" ) {
1832                         data = type;
1833                         type = "fx";
1834                 }
1835
1836                 if ( data === undefined ) {
1837                         return jQuery.queue( this[0], type );
1838                 }
1839                 return this.each(function() {
1840                         var queue = jQuery.queue( this, type, data );
1841
1842                         if ( type === "fx" && queue[0] !== "inprogress" ) {
1843                                 jQuery.dequeue( this, type );
1844                         }
1845                 });
1846         },
1847         dequeue: function( type ) {
1848                 return this.each(function() {
1849                         jQuery.dequeue( this, type );
1850                 });
1851         },
1852         // Based off of the plugin by Clint Helfers, with permission.
1853         // http://blindsignals.com/index.php/2009/07/jquery-delay/
1854         delay: function( time, type ) {
1855                 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1856                 type = type || "fx";
1857
1858                 return this.queue( type, function() {
1859                         var elem = this;
1860                         setTimeout(function() {
1861                                 jQuery.dequeue( elem, type );
1862                         }, time );
1863                 });
1864         },
1865         clearQueue: function( type ) {
1866                 return this.queue( type || "fx", [] );
1867         },
1868         // Get a promise resolved when queues of a certain type
1869         // are emptied (fx is the type by default)
1870         promise: function( type, object ) {
1871                 if ( typeof type !== "string" ) {
1872                         object = type;
1873                         type = undefined;
1874                 }
1875                 type = type || "fx";
1876                 var defer = jQuery.Deferred(),
1877                         elements = this,
1878                         i = elements.length,
1879                         count = 1,
1880                         deferDataKey = type + "defer",
1881                         queueDataKey = type + "queue",
1882                         markDataKey = type + "mark",
1883                         tmp;
1884                 function resolve() {
1885                         if ( !( --count ) ) {
1886                                 defer.resolveWith( elements, [ elements ] );
1887                         }
1888                 }
1889                 while( i-- ) {
1890                         if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
1891                                         ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
1892                                                 jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
1893                                         jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
1894                                 count++;
1895                                 tmp.done( resolve );
1896                         }
1897                 }
1898                 resolve();
1899                 return defer.promise();
1900         }
1901 });
1902
1903
1904
1905
1906 var rclass = /[\n\t\r]/g,
1907         rspace = /\s+/,
1908         rreturn = /\r/g,
1909         rtype = /^(?:button|input)$/i,
1910         rfocusable = /^(?:button|input|object|select|textarea)$/i,
1911         rclickable = /^a(?:rea)?$/i,
1912         rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
1913         rinvalidChar = /\:|^on/,
1914         formHook, boolHook;
1915
1916 jQuery.fn.extend({
1917         attr: function( name, value ) {
1918                 return jQuery.access( this, name, value, true, jQuery.attr );
1919         },
1920
1921         removeAttr: function( name ) {
1922                 return this.each(function() {
1923                         jQuery.removeAttr( this, name );
1924                 });
1925         },
1926         
1927         prop: function( name, value ) {
1928                 return jQuery.access( this, name, value, true, jQuery.prop );
1929         },
1930         
1931         removeProp: function( name ) {
1932                 name = jQuery.propFix[ name ] || name;
1933                 return this.each(function() {
1934                         // try/catch handles cases where IE balks (such as removing a property on window)
1935                         try {
1936                                 this[ name ] = undefined;
1937                                 delete this[ name ];
1938                         } catch( e ) {}
1939                 });
1940         },
1941
1942         addClass: function( value ) {
1943                 var classNames, i, l, elem,
1944                         setClass, c, cl;
1945
1946                 if ( jQuery.isFunction( value ) ) {
1947                         return this.each(function( j ) {
1948                                 jQuery( this ).addClass( value.call(this, j, this.className) );
1949                         });
1950                 }
1951
1952                 if ( value && typeof value === "string" ) {
1953                         classNames = value.split( rspace );
1954
1955                         for ( i = 0, l = this.length; i < l; i++ ) {
1956                                 elem = this[ i ];
1957
1958                                 if ( elem.nodeType === 1 ) {
1959                                         if ( !elem.className && classNames.length === 1 ) {
1960                                                 elem.className = value;
1961
1962                                         } else {
1963                                                 setClass = " " + elem.className + " ";
1964
1965                                                 for ( c = 0, cl = classNames.length; c < cl; c++ ) {
1966                                                         if ( !~setClass.indexOf( " " + classNames[ c ] + " " ) ) {
1967                                                                 setClass += classNames[ c ] + " ";
1968                                                         }
1969                                                 }
1970                                                 elem.className = jQuery.trim( setClass );
1971                                         }
1972                                 }
1973                         }
1974                 }
1975
1976                 return this;
1977         },
1978
1979         removeClass: function( value ) {
1980                 var classNames, i, l, elem, className, c, cl;
1981
1982                 if ( jQuery.isFunction( value ) ) {
1983                         return this.each(function( j ) {
1984                                 jQuery( this ).removeClass( value.call(this, j, this.className) );
1985                         });
1986                 }
1987
1988                 if ( (value && typeof value === "string") || value === undefined ) {
1989                         classNames = (value || "").split( rspace );
1990
1991                         for ( i = 0, l = this.length; i < l; i++ ) {
1992                                 elem = this[ i ];
1993
1994                                 if ( elem.nodeType === 1 && elem.className ) {
1995                                         if ( value ) {
1996                                                 className = (" " + elem.className + " ").replace( rclass, " " );
1997                                                 for ( c = 0, cl = classNames.length; c < cl; c++ ) {
1998                                                         className = className.replace(" " + classNames[ c ] + " ", " ");
1999                                                 }
2000                                                 elem.className = jQuery.trim( className );
2001
2002                                         } else {
2003                                                 elem.className = "";
2004                                         }
2005                                 }
2006                         }
2007                 }
2008
2009                 return this;
2010         },
2011
2012         toggleClass: function( value, stateVal ) {
2013                 var type = typeof value,
2014                         isBool = typeof stateVal === "boolean";
2015
2016                 if ( jQuery.isFunction( value ) ) {
2017                         return this.each(function( i ) {
2018                                 jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
2019                         });
2020                 }
2021
2022                 return this.each(function() {
2023                         if ( type === "string" ) {
2024                                 // toggle individual class names
2025                                 var className,
2026                                         i = 0,
2027                                         self = jQuery( this ),
2028                                         state = stateVal,
2029                                         classNames = value.split( rspace );
2030
2031                                 while ( (className = classNames[ i++ ]) ) {
2032                                         // check each className given, space seperated list
2033                                         state = isBool ? state : !self.hasClass( className );
2034                                         self[ state ? "addClass" : "removeClass" ]( className );
2035                                 }
2036
2037                         } else if ( type === "undefined" || type === "boolean" ) {
2038                                 if ( this.className ) {
2039                                         // store className if set
2040                                         jQuery._data( this, "__className__", this.className );
2041                                 }
2042
2043                                 // toggle whole className
2044                                 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2045                         }
2046                 });
2047         },
2048
2049         hasClass: function( selector ) {
2050                 var className = " " + selector + " ";
2051                 for ( var i = 0, l = this.length; i < l; i++ ) {
2052                         if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2053                                 return true;
2054                         }
2055                 }
2056
2057                 return false;
2058         },
2059
2060         val: function( value ) {
2061                 var hooks, ret,
2062                         elem = this[0];
2063                 
2064                 if ( !arguments.length ) {
2065                         if ( elem ) {
2066                                 hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
2067
2068                                 if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2069                                         return ret;
2070                                 }
2071
2072                                 ret = elem.value;
2073
2074                                 return typeof ret === "string" ? 
2075                                         // handle most common string cases
2076                                         ret.replace(rreturn, "") : 
2077                                         // handle cases where value is null/undef or number
2078                                         ret == null ? "" : ret;
2079                         }
2080
2081                         return undefined;
2082                 }
2083
2084                 var isFunction = jQuery.isFunction( value );
2085
2086                 return this.each(function( i ) {
2087                         var self = jQuery(this), val;
2088
2089                         if ( this.nodeType !== 1 ) {
2090                                 return;
2091                         }
2092
2093                         if ( isFunction ) {
2094                                 val = value.call( this, i, self.val() );
2095                         } else {
2096                                 val = value;
2097                         }
2098
2099                         // Treat null/undefined as ""; convert numbers to string
2100                         if ( val == null ) {
2101                                 val = "";
2102                         } else if ( typeof val === "number" ) {
2103                                 val += "";
2104                         } else if ( jQuery.isArray( val ) ) {
2105                                 val = jQuery.map(val, function ( value ) {
2106                                         return value == null ? "" : value + "";
2107                                 });
2108                         }
2109
2110                         hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
2111
2112                         // If set returns undefined, fall back to normal setting
2113                         if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2114                                 this.value = val;
2115                         }
2116                 });
2117         }
2118 });
2119
2120 jQuery.extend({
2121         valHooks: {
2122                 option: {
2123                         get: function( elem ) {
2124                                 // attributes.value is undefined in Blackberry 4.7 but
2125                                 // uses .value. See #6932
2126                                 var val = elem.attributes.value;
2127                                 return !val || val.specified ? elem.value : elem.text;
2128                         }
2129                 },
2130                 select: {
2131                         get: function( elem ) {
2132                                 var value,
2133                                         index = elem.selectedIndex,
2134                                         values = [],
2135                                         options = elem.options,
2136                                         one = elem.type === "select-one";
2137
2138                                 // Nothing was selected
2139                                 if ( index < 0 ) {
2140                                         return null;
2141                                 }
2142
2143                                 // Loop through all the selected options
2144                                 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
2145                                         var option = options[ i ];
2146
2147                                         // Don't return options that are disabled or in a disabled optgroup
2148                                         if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2149                                                         (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2150
2151                                                 // Get the specific value for the option
2152                                                 value = jQuery( option ).val();
2153
2154                                                 // We don't need an array for one selects
2155                                                 if ( one ) {
2156                                                         return value;
2157                                                 }
2158
2159                                                 // Multi-Selects return an array
2160                                                 values.push( value );
2161                                         }
2162                                 }
2163
2164                                 // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2165                                 if ( one && !values.length && options.length ) {
2166                                         return jQuery( options[ index ] ).val();
2167                                 }
2168
2169                                 return values;
2170                         },
2171
2172                         set: function( elem, value ) {
2173                                 var values = jQuery.makeArray( value );
2174
2175                                 jQuery(elem).find("option").each(function() {
2176                                         this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2177                                 });
2178
2179                                 if ( !values.length ) {
2180                                         elem.selectedIndex = -1;
2181                                 }
2182                                 return values;
2183                         }
2184                 }
2185         },
2186
2187         attrFn: {
2188                 val: true,
2189                 css: true,
2190                 html: true,
2191                 text: true,
2192                 data: true,
2193                 width: true,
2194                 height: true,
2195                 offset: true
2196         },
2197         
2198         attrFix: {
2199                 // Always normalize to ensure hook usage
2200                 tabindex: "tabIndex"
2201         },
2202         
2203         attr: function( elem, name, value, pass ) {
2204                 var nType = elem.nodeType;
2205                 
2206                 // don't get/set attributes on text, comment and attribute nodes
2207                 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2208                         return undefined;
2209                 }
2210
2211                 if ( pass && name in jQuery.attrFn ) {
2212                         return jQuery( elem )[ name ]( value );
2213                 }
2214
2215                 // Fallback to prop when attributes are not supported
2216                 if ( !("getAttribute" in elem) ) {
2217                         return jQuery.prop( elem, name, value );
2218                 }
2219
2220                 var ret, hooks,
2221                         notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2222
2223                 // Normalize the name if needed
2224                 if ( notxml ) {
2225                         name = jQuery.attrFix[ name ] || name;
2226
2227                         hooks = jQuery.attrHooks[ name ];
2228
2229                         if ( !hooks ) {
2230                                 // Use boolHook for boolean attributes
2231                                 if ( rboolean.test( name ) ) {
2232
2233                                         hooks = boolHook;
2234
2235                                 // Use formHook for forms and if the name contains certain characters
2236                                 } else if ( formHook && name !== "className" &&
2237                                         (jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ) {
2238
2239                                         hooks = formHook;
2240                                 }
2241                         }
2242                 }
2243
2244                 if ( value !== undefined ) {
2245
2246                         if ( value === null ) {
2247                                 jQuery.removeAttr( elem, name );
2248                                 return undefined;
2249
2250                         } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2251                                 return ret;
2252
2253                         } else {
2254                                 elem.setAttribute( name, "" + value );
2255                                 return value;
2256                         }
2257
2258                 } else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
2259                         return ret;
2260
2261                 } else {
2262
2263                         ret = elem.getAttribute( name );
2264
2265                         // Non-existent attributes return null, we normalize to undefined
2266                         return ret === null ?
2267                                 undefined :
2268                                 ret;
2269                 }
2270         },
2271
2272         removeAttr: function( elem, name ) {
2273                 var propName;
2274                 if ( elem.nodeType === 1 ) {
2275                         name = jQuery.attrFix[ name ] || name;
2276                 
2277                         if ( jQuery.support.getSetAttribute ) {
2278                                 // Use removeAttribute in browsers that support it
2279                                 elem.removeAttribute( name );
2280                         } else {
2281                                 jQuery.attr( elem, name, "" );
2282                                 elem.removeAttributeNode( elem.getAttributeNode( name ) );
2283                         }
2284
2285                         // Set corresponding property to false for boolean attributes
2286                         if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
2287                                 elem[ propName ] = false;
2288                         }
2289                 }
2290         },
2291
2292         attrHooks: {
2293                 type: {
2294                         set: function( elem, value ) {
2295                                 // We can't allow the type property to be changed (since it causes problems in IE)
2296                                 if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2297                                         jQuery.error( "type property can't be changed" );
2298                                 } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2299                                         // Setting the type on a radio button after the value resets the value in IE6-9
2300                                         // Reset value to it's default in case type is set after value
2301                                         // This is for element creation
2302                                         var val = elem.value;
2303                                         elem.setAttribute( "type", value );
2304                                         if ( val ) {
2305                                                 elem.value = val;
2306                                         }
2307                                         return value;
2308                                 }
2309                         }
2310                 },
2311                 tabIndex: {
2312                         get: function( elem ) {
2313                                 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2314                                 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2315                                 var attributeNode = elem.getAttributeNode("tabIndex");
2316
2317                                 return attributeNode && attributeNode.specified ?
2318                                         parseInt( attributeNode.value, 10 ) :
2319                                         rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2320                                                 0 :
2321                                                 undefined;
2322                         }
2323                 },
2324                 // Use the value property for back compat
2325                 // Use the formHook for button elements in IE6/7 (#1954)
2326                 value: {
2327                         get: function( elem, name ) {
2328                                 if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2329                                         return formHook.get( elem, name );
2330                                 }
2331                                 return name in elem ?
2332                                         elem.value :
2333                                         null;
2334                         },
2335                         set: function( elem, value, name ) {
2336                                 if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2337                                         return formHook.set( elem, value, name );
2338                                 }
2339                                 // Does not return so that setAttribute is also used
2340                                 elem.value = value;
2341                         }
2342                 }
2343         },
2344
2345         propFix: {
2346                 tabindex: "tabIndex",
2347                 readonly: "readOnly",
2348                 "for": "htmlFor",
2349                 "class": "className",
2350                 maxlength: "maxLength",
2351                 cellspacing: "cellSpacing",
2352                 cellpadding: "cellPadding",
2353                 rowspan: "rowSpan",
2354                 colspan: "colSpan",
2355                 usemap: "useMap",
2356                 frameborder: "frameBorder",
2357                 contenteditable: "contentEditable"
2358         },
2359         
2360         prop: function( elem, name, value ) {
2361                 var nType = elem.nodeType;
2362
2363                 // don't get/set properties on text, comment and attribute nodes
2364                 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2365                         return undefined;
2366                 }
2367
2368                 var ret, hooks,
2369                         notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2370
2371                 if ( notxml ) {
2372                         // Fix name and attach hooks
2373                         name = jQuery.propFix[ name ] || name;
2374                         hooks = jQuery.propHooks[ name ];
2375                 }
2376
2377                 if ( value !== undefined ) {
2378                         if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2379                                 return ret;
2380
2381                         } else {
2382                                 return (elem[ name ] = value);
2383                         }
2384
2385                 } else {
2386                         if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) {
2387                                 return ret;
2388
2389                         } else {
2390                                 return elem[ name ];
2391                         }
2392                 }
2393         },
2394         
2395         propHooks: {}
2396 });
2397
2398 // Hook for boolean attributes
2399 boolHook = {
2400         get: function( elem, name ) {
2401                 // Align boolean attributes with corresponding properties
2402                 return jQuery.prop( elem, name ) ?
2403                         name.toLowerCase() :
2404                         undefined;
2405         },
2406         set: function( elem, value, name ) {
2407                 var propName;
2408                 if ( value === false ) {
2409                         // Remove boolean attributes when set to false
2410                         jQuery.removeAttr( elem, name );
2411                 } else {
2412                         // value is true since we know at this point it's type boolean and not false
2413                         // Set boolean attributes to the same name and set the DOM property
2414                         propName = jQuery.propFix[ name ] || name;
2415                         if ( propName in elem ) {
2416                                 // Only set the IDL specifically if it already exists on the element
2417                                 elem[ propName ] = true;
2418                         }
2419
2420                         elem.setAttribute( name, name.toLowerCase() );
2421                 }
2422                 return name;
2423         }
2424 };
2425
2426 // IE6/7 do not support getting/setting some attributes with get/setAttribute
2427 if ( !jQuery.support.getSetAttribute ) {
2428
2429         // propFix is more comprehensive and contains all fixes
2430         jQuery.attrFix = jQuery.propFix;
2431         
2432         // Use this for any attribute on a form in IE6/7
2433         formHook = jQuery.attrHooks.name = jQuery.attrHooks.title = jQuery.valHooks.button = {
2434                 get: function( elem, name ) {
2435                         var ret;
2436                         ret = elem.getAttributeNode( name );
2437                         // Return undefined if nodeValue is empty string
2438                         return ret && ret.nodeValue !== "" ?
2439                                 ret.nodeValue :
2440                                 undefined;
2441                 },
2442                 set: function( elem, value, name ) {
2443                         // Check form objects in IE (multiple bugs related)
2444                         // Only use nodeValue if the attribute node exists on the form
2445                         var ret = elem.getAttributeNode( name );
2446                         if ( ret ) {
2447                                 ret.nodeValue = value;
2448                                 return value;
2449                         }
2450                 }
2451         };
2452
2453         // Set width and height to auto instead of 0 on empty string( Bug #8150 )
2454         // This is for removals
2455         jQuery.each([ "width", "height" ], function( i, name ) {
2456                 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2457                         set: function( elem, value ) {
2458                                 if ( value === "" ) {
2459                                         elem.setAttribute( name, "auto" );
2460                                         return value;
2461                                 }
2462                         }
2463                 });
2464         });
2465 }
2466
2467
2468 // Some attributes require a special call on IE
2469 if ( !jQuery.support.hrefNormalized ) {
2470         jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2471                 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2472                         get: function( elem ) {
2473                                 var ret = elem.getAttribute( name, 2 );
2474                                 return ret === null ? undefined : ret;
2475                         }
2476                 });
2477         });
2478 }
2479
2480 if ( !jQuery.support.style ) {
2481         jQuery.attrHooks.style = {
2482                 get: function( elem ) {
2483                         // Return undefined in the case of empty string
2484                         // Normalize to lowercase since IE uppercases css property names
2485                         return elem.style.cssText.toLowerCase() || undefined;
2486                 },
2487                 set: function( elem, value ) {
2488                         return (elem.style.cssText = "" + value);
2489                 }
2490         };
2491 }
2492
2493 // Safari mis-reports the default selected property of an option
2494 // Accessing the parent's selectedIndex property fixes it
2495 if ( !jQuery.support.optSelected ) {
2496         jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2497                 get: function( elem ) {
2498                         var parent = elem.parentNode;
2499
2500                         if ( parent ) {
2501                                 parent.selectedIndex;
2502
2503                                 // Make sure that it also works with optgroups, see #5701
2504                                 if ( parent.parentNode ) {
2505                                         parent.parentNode.selectedIndex;
2506                                 }
2507                         }
2508                 }
2509         });
2510 }
2511
2512 // Radios and checkboxes getter/setter
2513 if ( !jQuery.support.checkOn ) {
2514         jQuery.each([ "radio", "checkbox" ], function() {
2515                 jQuery.valHooks[ this ] = {
2516                         get: function( elem ) {
2517                                 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2518                                 return elem.getAttribute("value") === null ? "on" : elem.value;
2519                         }
2520                 };
2521         });
2522 }
2523 jQuery.each([ "radio", "checkbox" ], function() {
2524         jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2525                 set: function( elem, value ) {
2526                         if ( jQuery.isArray( value ) ) {
2527                                 return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
2528                         }
2529                 }
2530         });
2531 });
2532
2533
2534
2535
2536 var rnamespaces = /\.(.*)$/,
2537         rformElems = /^(?:textarea|input|select)$/i,
2538         rperiod = /\./g,
2539         rspaces = / /g,
2540         rescape = /[^\w\s.|`]/g,
2541         fcleanup = function( nm ) {
2542                 return nm.replace(rescape, "\\$&");
2543         };
2544
2545 /*
2546  * A number of helper functions used for managing events.
2547  * Many of the ideas behind this code originated from
2548  * Dean Edwards' addEvent library.
2549  */
2550 jQuery.event = {
2551
2552         // Bind an event to an element
2553         // Original by Dean Edwards
2554         add: function( elem, types, handler, data ) {
2555                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2556                         return;
2557                 }
2558
2559                 if ( handler === false ) {
2560                         handler = returnFalse;
2561                 } else if ( !handler ) {
2562                         // Fixes bug #7229. Fix recommended by jdalton
2563                         return;
2564                 }
2565
2566                 var handleObjIn, handleObj;
2567
2568                 if ( handler.handler ) {
2569                         handleObjIn = handler;
2570                         handler = handleObjIn.handler;
2571                 }
2572
2573                 // Make sure that the function being executed has a unique ID
2574                 if ( !handler.guid ) {
2575                         handler.guid = jQuery.guid++;
2576                 }
2577
2578                 // Init the element's event structure
2579                 var elemData = jQuery._data( elem );
2580
2581                 // If no elemData is found then we must be trying to bind to one of the
2582                 // banned noData elements
2583                 if ( !elemData ) {
2584                         return;
2585                 }
2586
2587                 var events = elemData.events,
2588                         eventHandle = elemData.handle;
2589
2590                 if ( !events ) {
2591                         elemData.events = events = {};
2592                 }
2593
2594                 if ( !eventHandle ) {
2595                         elemData.handle = eventHandle = function( e ) {
2596                                 // Discard the second event of a jQuery.event.trigger() and
2597                                 // when an event is called after a page has unloaded
2598                                 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2599                                         jQuery.event.handle.apply( eventHandle.elem, arguments ) :
2600                                         undefined;
2601                         };
2602                 }
2603
2604                 // Add elem as a property of the handle function
2605                 // This is to prevent a memory leak with non-native events in IE.
2606                 eventHandle.elem = elem;
2607
2608                 // Handle multiple events separated by a space
2609                 // jQuery(...).bind("mouseover mouseout", fn);
2610                 types = types.split(" ");
2611
2612                 var type, i = 0, namespaces;
2613
2614                 while ( (type = types[ i++ ]) ) {
2615                         handleObj = handleObjIn ?
2616                                 jQuery.extend({}, handleObjIn) :
2617                                 { handler: handler, data: data };
2618
2619                         // Namespaced event handlers
2620                         if ( type.indexOf(".") > -1 ) {
2621                                 namespaces = type.split(".");
2622                                 type = namespaces.shift();
2623                                 handleObj.namespace = namespaces.slice(0).sort().join(".");
2624
2625                         } else {
2626                                 namespaces = [];
2627                                 handleObj.namespace = "";
2628                         }
2629
2630                         handleObj.type = type;
2631                         if ( !handleObj.guid ) {
2632                                 handleObj.guid = handler.guid;
2633                         }
2634
2635                         // Get the current list of functions bound to this event
2636                         var handlers = events[ type ],
2637                                 special = jQuery.event.special[ type ] || {};
2638
2639                         // Init the event handler queue
2640                         if ( !handlers ) {
2641                                 handlers = events[ type ] = [];
2642
2643                                 // Check for a special event handler
2644                                 // Only use addEventListener/attachEvent if the special
2645                                 // events handler returns false
2646                                 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2647                                         // Bind the global event handler to the element
2648                                         if ( elem.addEventListener ) {
2649                                                 elem.addEventListener( type, eventHandle, false );
2650
2651                                         } else if ( elem.attachEvent ) {
2652                                                 elem.attachEvent( "on" + type, eventHandle );
2653                                         }
2654                                 }
2655                         }
2656
2657                         if ( special.add ) {
2658                                 special.add.call( elem, handleObj );
2659
2660                                 if ( !handleObj.handler.guid ) {
2661                                         handleObj.handler.guid = handler.guid;
2662                                 }
2663                         }
2664
2665                         // Add the function to the element's handler list
2666                         handlers.push( handleObj );
2667
2668                         // Keep track of which events have been used, for event optimization
2669                         jQuery.event.global[ type ] = true;
2670                 }
2671
2672                 // Nullify elem to prevent memory leaks in IE
2673                 elem = null;
2674         },
2675
2676         global: {},
2677
2678         // Detach an event or set of events from an element
2679         remove: function( elem, types, handler, pos ) {
2680                 // don't do events on text and comment nodes
2681                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2682                         return;
2683                 }
2684
2685                 if ( handler === false ) {
2686                         handler = returnFalse;
2687                 }
2688
2689                 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
2690                         elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2691                         events = elemData && elemData.events;
2692
2693                 if ( !elemData || !events ) {
2694                         return;
2695                 }
2696
2697                 // types is actually an event object here
2698                 if ( types && types.type ) {
2699                         handler = types.handler;
2700                         types = types.type;
2701                 }
2702
2703                 // Unbind all events for the element
2704                 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
2705                         types = types || "";
2706
2707                         for ( type in events ) {
2708                                 jQuery.event.remove( elem, type + types );
2709                         }
2710
2711                         return;
2712                 }
2713
2714                 // Handle multiple events separated by a space
2715                 // jQuery(...).unbind("mouseover mouseout", fn);
2716                 types = types.split(" ");
2717
2718                 while ( (type = types[ i++ ]) ) {
2719                         origType = type;
2720                         handleObj = null;
2721                         all = type.indexOf(".") < 0;
2722                         namespaces = [];
2723
2724                         if ( !all ) {
2725                                 // Namespaced event handlers
2726                                 namespaces = type.split(".");
2727                                 type = namespaces.shift();
2728
2729                                 namespace = new RegExp("(^|\\.)" +
2730                                         jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
2731                         }
2732
2733                         eventType = events[ type ];
2734
2735                         if ( !eventType ) {
2736                                 continue;
2737                         }
2738
2739                         if ( !handler ) {
2740                                 for ( j = 0; j < eventType.length; j++ ) {
2741                                         handleObj = eventType[ j ];
2742
2743                                         if ( all || namespace.test( handleObj.namespace ) ) {
2744                                                 jQuery.event.remove( elem, origType, handleObj.handler, j );
2745                                                 eventType.splice( j--, 1 );
2746                                         }
2747                                 }
2748
2749                                 continue;
2750                         }
2751
2752                         special = jQuery.event.special[ type ] || {};
2753
2754                         for ( j = pos || 0; j < eventType.length; j++ ) {
2755                                 handleObj = eventType[ j ];
2756
2757                                 if ( handler.guid === handleObj.guid ) {
2758                                         // remove the given handler for the given type
2759                                         if ( all || namespace.test( handleObj.namespace ) ) {
2760                                                 if ( pos == null ) {
2761                                                         eventType.splice( j--, 1 );
2762                                                 }
2763
2764                                                 if ( special.remove ) {
2765                                                         special.remove.call( elem, handleObj );
2766                                                 }
2767                                         }
2768
2769                                         if ( pos != null ) {
2770                                                 break;
2771                                         }
2772                                 }
2773                         }
2774
2775                         // remove generic event handler if no more handlers exist
2776                         if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
2777                                 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2778                                         jQuery.removeEvent( elem, type, elemData.handle );
2779                                 }
2780
2781                                 ret = null;
2782                                 delete events[ type ];
2783                         }
2784                 }
2785
2786                 // Remove the expando if it's no longer used
2787                 if ( jQuery.isEmptyObject( events ) ) {
2788                         var handle = elemData.handle;
2789                         if ( handle ) {
2790                                 handle.elem = null;
2791                         }
2792
2793                         delete elemData.events;
2794                         delete elemData.handle;
2795
2796                         if ( jQuery.isEmptyObject( elemData ) ) {
2797                                 jQuery.removeData( elem, undefined, true );
2798                         }
2799                 }
2800         },
2801         
2802         // Events that are safe to short-circuit if no handlers are attached.
2803         // Native DOM events should not be added, they may have inline handlers.
2804         customEvent: {
2805                 "getData": true,
2806                 "setData": true,
2807                 "changeData": true
2808         },
2809
2810         trigger: function( event, data, elem, onlyHandlers ) {
2811                 // Event object or event type
2812                 var type = event.type || event,
2813                         namespaces = [],
2814                         exclusive;
2815
2816                 if ( type.indexOf("!") >= 0 ) {
2817                         // Exclusive events trigger only for the exact event (no namespaces)
2818                         type = type.slice(0, -1);
2819                         exclusive = true;
2820                 }
2821
2822                 if ( type.indexOf(".") >= 0 ) {
2823                         // Namespaced trigger; create a regexp to match event type in handle()
2824                         namespaces = type.split(".");
2825                         type = namespaces.shift();
2826                         namespaces.sort();
2827                 }
2828
2829                 if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
2830                         // No jQuery handlers for this event type, and it can't have inline handlers
2831                         return;
2832                 }
2833
2834                 // Caller can pass in an Event, Object, or just an event type string
2835                 event = typeof event === "object" ?
2836                         // jQuery.Event object
2837                         event[ jQuery.expando ] ? event :
2838                         // Object literal
2839                         new jQuery.Event( type, event ) :
2840                         // Just the event type (string)
2841                         new jQuery.Event( type );
2842
2843                 event.type = type;
2844                 event.exclusive = exclusive;
2845                 event.namespace = namespaces.join(".");
2846                 event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
2847                 
2848                 // triggerHandler() and global events don't bubble or run the default action
2849                 if ( onlyHandlers || !elem ) {
2850                         event.preventDefault();
2851                         event.stopPropagation();
2852                 }
2853
2854                 // Handle a global trigger
2855                 if ( !elem ) {
2856                         // TODO: Stop taunting the data cache; remove global events and always attach to document
2857                         jQuery.each( jQuery.cache, function() {
2858                                 // internalKey variable is just used to make it easier to find
2859                                 // and potentially change this stuff later; currently it just
2860                                 // points to jQuery.expando
2861                                 var internalKey = jQuery.expando,
2862                                         internalCache = this[ internalKey ];
2863                                 if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
2864                                         jQuery.event.trigger( event, data, internalCache.handle.elem );
2865                                 }
2866                         });
2867                         return;
2868                 }
2869
2870                 // Don't do events on text and comment nodes
2871                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2872                         return;
2873                 }
2874
2875                 // Clean up the event in case it is being reused
2876                 event.result = undefined;
2877                 event.target = elem;
2878
2879                 // Clone any incoming data and prepend the event, creating the handler arg list
2880                 data = data != null ? jQuery.makeArray( data ) : [];
2881                 data.unshift( event );
2882
2883                 var cur = elem,
2884                         // IE doesn't like method names with a colon (#3533, #8272)
2885                         ontype = type.indexOf(":") < 0 ? "on" + type : "";
2886
2887                 // Fire event on the current element, then bubble up the DOM tree
2888                 do {
2889                         var handle = jQuery._data( cur, "handle" );
2890
2891                         event.currentTarget = cur;
2892                         if ( handle ) {
2893                                 handle.apply( cur, data );
2894                         }
2895
2896                         // Trigger an inline bound script
2897                         if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
2898                                 event.result = false;
2899                                 event.preventDefault();
2900                         }
2901
2902                         // Bubble up to document, then to window
2903                         cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
2904                 } while ( cur && !event.isPropagationStopped() );
2905
2906                 // If nobody prevented the default action, do it now
2907                 if ( !event.isDefaultPrevented() ) {
2908                         var old,
2909                                 special = jQuery.event.special[ type ] || {};
2910
2911                         if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
2912                                 !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
2913
2914                                 // Call a native DOM method on the target with the same name name as the event.
2915                                 // Can't use an .isFunction)() check here because IE6/7 fails that test.
2916                                 // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
2917                                 try {
2918                                         if ( ontype && elem[ type ] ) {
2919                                                 // Don't re-trigger an onFOO event when we call its FOO() method
2920                                                 old = elem[ ontype ];
2921
2922                                                 if ( old ) {
2923                                                         elem[ ontype ] = null;
2924                                                 }
2925
2926                                                 jQuery.event.triggered = type;
2927                                                 elem[ type ]();
2928                                         }
2929                                 } catch ( ieError ) {}
2930
2931                                 if ( old ) {
2932                                         elem[ ontype ] = old;
2933                                 }
2934
2935                                 jQuery.event.triggered = undefined;
2936                         }
2937                 }
2938                 
2939                 return event.result;
2940         },
2941
2942         handle: function( event ) {
2943                 event = jQuery.event.fix( event || window.event );
2944                 // Snapshot the handlers list since a called handler may add/remove events.
2945                 var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
2946                         run_all = !event.exclusive && !event.namespace,
2947                         args = Array.prototype.slice.call( arguments, 0 );
2948
2949                 // Use the fix-ed Event rather than the (read-only) native event
2950                 args[0] = event;
2951                 event.currentTarget = this;
2952
2953                 for ( var j = 0, l = handlers.length; j < l; j++ ) {
2954                         var handleObj = handlers[ j ];
2955
2956                         // Triggered event must 1) be non-exclusive and have no namespace, or
2957                         // 2) have namespace(s) a subset or equal to those in the bound event.
2958                         if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
2959                                 // Pass in a reference to the handler function itself
2960                                 // So that we can later remove it
2961                                 event.handler = handleObj.handler;
2962                                 event.data = handleObj.data;
2963                                 event.handleObj = handleObj;
2964
2965                                 var ret = handleObj.handler.apply( this, args );
2966
2967                                 if ( ret !== undefined ) {
2968                                         event.result = ret;
2969                                         if ( ret === false ) {
2970                                                 event.preventDefault();
2971                                                 event.stopPropagation();
2972                                         }
2973                                 }
2974
2975                                 if ( event.isImmediatePropagationStopped() ) {
2976                                         break;
2977                                 }
2978                         }
2979                 }
2980                 return event.result;
2981         },
2982
2983         props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2984
2985         fix: function( event ) {
2986                 if ( event[ jQuery.expando ] ) {
2987                         return event;
2988                 }
2989
2990                 // store a copy of the original event object
2991                 // and "clone" to set read-only properties
2992                 var originalEvent = event;
2993                 event = jQuery.Event( originalEvent );
2994
2995                 for ( var i = this.props.length, prop; i; ) {
2996                         prop = this.props[ --i ];
2997                         event[ prop ] = originalEvent[ prop ];
2998                 }
2999
3000                 // Fix target property, if necessary
3001                 if ( !event.target ) {
3002                         // Fixes #1925 where srcElement might not be defined either
3003                         event.target = event.srcElement || document;
3004                 }
3005
3006                 // check if target is a textnode (safari)
3007                 if ( event.target.nodeType === 3 ) {
3008                         event.target = event.target.parentNode;
3009                 }
3010
3011                 // Add relatedTarget, if necessary
3012                 if ( !event.relatedTarget && event.fromElement ) {
3013                         event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
3014                 }
3015
3016                 // Calculate pageX/Y if missing and clientX/Y available
3017                 if ( event.pageX == null && event.clientX != null ) {
3018                         var eventDocument = event.target.ownerDocument || document,
3019                                 doc = eventDocument.documentElement,
3020                                 body = eventDocument.body;
3021
3022                         event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
3023                         event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
3024                 }
3025
3026                 // Add which for key events
3027                 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
3028                         event.which = event.charCode != null ? event.charCode : event.keyCode;
3029                 }
3030
3031                 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
3032                 if ( !event.metaKey && event.ctrlKey ) {
3033                         event.metaKey = event.ctrlKey;
3034                 }
3035
3036                 // Add which for click: 1 === left; 2 === middle; 3 === right
3037                 // Note: button is not normalized, so don't use it
3038                 if ( !event.which && event.button !== undefined ) {
3039                         event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
3040                 }
3041
3042                 return event;
3043         },
3044
3045         // Deprecated, use jQuery.guid instead
3046         guid: 1E8,
3047
3048         // Deprecated, use jQuery.proxy instead
3049         proxy: jQuery.proxy,
3050
3051         special: {
3052                 ready: {
3053                         // Make sure the ready event is setup
3054                         setup: jQuery.bindReady,
3055                         teardown: jQuery.noop
3056                 },
3057
3058                 live: {
3059                         add: function( handleObj ) {
3060                                 jQuery.event.add( this,
3061                                         liveConvert( handleObj.origType, handleObj.selector ),
3062                                         jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
3063                         },
3064
3065                         remove: function( handleObj ) {
3066                                 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
3067                         }
3068                 },
3069
3070                 beforeunload: {
3071                         setup: function( data, namespaces, eventHandle ) {
3072                                 // We only want to do this special case on windows
3073                                 if ( jQuery.isWindow( this ) ) {
3074                                         this.onbeforeunload = eventHandle;
3075                                 }
3076                         },
3077
3078                         teardown: function( namespaces, eventHandle ) {
3079                                 if ( this.onbeforeunload === eventHandle ) {
3080                                         this.onbeforeunload = null;
3081                                 }
3082                         }
3083                 }
3084         }
3085 };
3086
3087 jQuery.removeEvent = document.removeEventListener ?
3088         function( elem, type, handle ) {
3089                 if ( elem.removeEventListener ) {
3090                         elem.removeEventListener( type, handle, false );
3091                 }
3092         } :
3093         function( elem, type, handle ) {
3094                 if ( elem.detachEvent ) {
3095                         elem.detachEvent( "on" + type, handle );
3096                 }
3097         };
3098
3099 jQuery.Event = function( src, props ) {
3100         // Allow instantiation without the 'new' keyword
3101         if ( !this.preventDefault ) {
3102                 return new jQuery.Event( src, props );
3103         }
3104
3105         // Event object
3106         if ( src && src.type ) {
3107                 this.originalEvent = src;
3108                 this.type = src.type;
3109
3110                 // Events bubbling up the document may have been marked as prevented
3111                 // by a handler lower down the tree; reflect the correct value.
3112                 this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
3113                         src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
3114
3115         // Event type
3116         } else {
3117                 this.type = src;
3118         }
3119
3120         // Put explicitly provided properties onto the event object
3121         if ( props ) {
3122                 jQuery.extend( this, props );
3123         }
3124
3125         // timeStamp is buggy for some events on Firefox(#3843)
3126         // So we won't rely on the native value
3127         this.timeStamp = jQuery.now();
3128
3129         // Mark it as fixed
3130         this[ jQuery.expando ] = true;
3131 };
3132
3133 function returnFalse() {
3134         return false;
3135 }
3136 function returnTrue() {
3137         return true;
3138 }
3139
3140 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3141 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3142 jQuery.Event.prototype = {
3143         preventDefault: function() {
3144                 this.isDefaultPrevented = returnTrue;
3145
3146                 var e = this.originalEvent;
3147                 if ( !e ) {
3148                         return;
3149                 }
3150
3151                 // if preventDefault exists run it on the original event
3152                 if ( e.preventDefault ) {
3153                         e.preventDefault();
3154
3155                 // otherwise set the returnValue property of the original event to false (IE)
3156                 } else {
3157                         e.returnValue = false;
3158                 }