1 /*!
2 * jQuery JavaScript Library v1.6.1
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 May 12 15:04:36 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 // Keep a UserAgent string for use with jQuery.browser
69 userAgent = navigator.userAgent,
70
71 // For matching the engine and version of the browser
72 browserMatch,
73
74 // The deferred used on DOM ready
75 readyList,
76
77 // The ready event handler
78 DOMContentLoaded,
79
80 // Save a reference to some core methods
81 toString = Object.prototype.toString,
82 hasOwn = Object.prototype.hasOwnProperty,
83 push = Array.prototype.push,
84 slice = Array.prototype.slice,
85 trim = String.prototype.trim,
86 indexOf = Array.prototype.indexOf,
87
88 // [[Class]] -> type pairs
89 class2type = {};
90
91 jQuery.fn = jQuery.prototype = {
92 constructor: jQuery,
93 init: function( selector, context, rootjQuery ) {
94 var match, elem, ret, doc;
95
96 // Handle $(""), $(null), or $(undefined)
97 if ( !selector ) {
98 return this;
99 }
100
101 // Handle $(DOMElement)
102 if ( selector.nodeType ) {
103 this.context = this[0] = selector;
104 this.length = 1;
105 return this;
106 }
107
108 // The body element only exists once, optimize finding it
109 if ( selector === "body" && !context && document.body ) {
110 this.context = document;
111 this[0] = document.body;
112 this.selector = selector;
113 this.length = 1;
114 return this;
115 }
116
117 // Handle HTML strings
118 if ( typeof selector === "string" ) {
119 // Are we dealing with HTML string or an ID?
120 if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
121 // Assume that strings that start and end with <> are HTML and skip the regex check
122 match = [ null, selector, null ];
123
124 } else {
125 match = quickExpr.exec( selector );
126 }
127
128 // Verify a match, and that no context was specified for #id
129 if ( match && (match[1] || !context) ) {
130
131 // HANDLE: $(html) -> $(array)
132 if ( match[1] ) {
133 context = context instanceof jQuery ? context[0] : context;
134 doc = (context ? context.ownerDocument || context : document);
135
136 // If a single string is passed in and it's a single tag
137 // just do a createElement and skip the rest
138 ret = rsingleTag.exec( selector );
139
140 if ( ret ) {
141 if ( jQuery.isPlainObject( context ) ) {
142 selector = [ document.createElement( ret[1] ) ];
143 jQuery.fn.attr.call( selector, context, true );
144
145 } else {
146 selector = [ doc.createElement( ret[1] ) ];
147 }
148
149 } else {
150 ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
151 selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
152 }
153
154 return jQuery.merge( this, selector );
155
156 // HANDLE: $("#id")
157 } else {
158 elem = document.getElementById( match[2] );
159
160 // Check parentNode to catch when Blackberry 4.6 returns
161 // nodes that are no longer in the document #6963
162 if ( elem && elem.parentNode ) {
163 // Handle the case where IE and Opera return items
164 // by name instead of ID
165 if ( elem.id !== match[2] ) {
166 return rootjQuery.find( selector );
167 }
168
169 // Otherwise, we inject the element directly into the jQuery object
170 this.length = 1;
171 this[0] = elem;
172 }
173
174 this.context = document;
175 this.selector = selector;
176 return this;
177 }
178
179 // HANDLE: $(expr, $(...))
180 } else if ( !context || context.jquery ) {
181 return (context || rootjQuery).find( selector );
182
183 // HANDLE: $(expr, context)
184 // (which is just equivalent to: $(context).find(expr)
185 } else {
186 return this.constructor( context ).find( selector );
187 }
188
189 // HANDLE: $(function)
190 // Shortcut for document ready
191 } else if ( jQuery.isFunction( selector ) ) {
192 return rootjQuery.ready( selector );
193 }
194
195 if (selector.selector !== undefined) {
196 this.selector = selector.selector;
197 this.context = selector.context;
198 }
199
200 return jQuery.makeArray( selector, this );
201 },
202
203 // Start with an empty selector
204 selector: "",
205
206 // The current version of jQuery being used
207 jquery: "1.6.1",
208
209 // The default length of a jQuery object is 0
210 length: 0,
211
212 // The number of elements contained in the matched element set
213 size: function() {
214 return this.length;
215 },
216
217 toArray: function() {
218 return slice.call( this, 0 );
219 },
220
221 // Get the Nth element in the matched element set OR
222 // Get the whole matched element set as a clean array
223 get: function( num ) {
224 return num == null ?
225
226 // Return a 'clean' array
227 this.toArray() :
228
229 // Return just the object
230 ( num < 0 ? this[ this.length + num ] : this[ num ] );
231 },
232
233 // Take an array of elements and push it onto the stack
234 // (returning the new matched element set)
235 pushStack: function( elems, name, selector ) {
236 // Build a new jQuery matched element set
237 var ret = this.constructor();
238
239 if ( jQuery.isArray( elems ) ) {
240 push.apply( ret, elems );
241
242 } else {
243 jQuery.merge( ret, elems );
244 }
245
246 // Add the old object onto the stack (as a reference)
247 ret.prevObject = this;
248
249 ret.context = this.context;
250
251 if ( name === "find" ) {
252 ret.selector = this.selector + (this.selector ? " " : "") + selector;
253 } else if ( name ) {
254 ret.selector = this.selector + "." + name + "(" + selector + ")";
255 }
256
257 // Return the newly-formed element set
258 return ret;
259 },
260
261 // Execute a callback for every element in the matched set.
262 // (You can seed the arguments with an array of args, but this is
263 // only used internally.)
264 each: function( callback, args ) {
265 return jQuery.each( this, callback, args );
266 },
267
268 ready: function( fn ) {
269 // Attach the listeners
270 jQuery.bindReady();
271
272 // Add the callback
273 readyList.done( fn );
274
275 return this;
276 },
277
278 eq: function( i ) {
279 return i === -1 ?
280 this.slice( i ) :
281 this.slice( i, +i + 1 );
282 },
283
284 first: function() {
285 return this.eq( 0 );
286 },
287
288 last: function() {
289 return this.eq( -1 );
290 },
291
292 slice: function() {
293 return this.pushStack( slice.apply( this, arguments ),
294 "slice", slice.call(arguments).join(",") );
295 },
296
297 map: function( callback ) {
298 return this.pushStack( jQuery.map(this, function( elem, i ) {
299 return callback.call( elem, i, elem );
300 }));
301 },
302
303 end: function() {
304 return this.prevObject || this.constructor(null);
305 },
306
307 // For internal use only.
308 // Behaves like an Array's method, not like a jQuery method.
309 push: push,
310 sort: [].sort,
311 splice: [].splice
312 };
313
314 // Give the init function the jQuery prototype for later instantiation
315 jQuery.fn.init.prototype = jQuery.fn;
316
317 jQuery.extend = jQuery.fn.extend = function() {
318 var options, name, src, copy, copyIsArray, clone,
319 target = arguments[0] || {},
320 i = 1,
321 length = arguments.length,
322 deep = false;
323
324 // Handle a deep copy situation
325 if ( typeof target === "boolean" ) {
326 deep = target;
327 target = arguments[1] || {};
328 // skip the boolean and the target
329 i = 2;
330 }
331
332 // Handle case when target is a string or something (possible in deep copy)
333 if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
334 target = {};
335 }
336
337 // extend jQuery itself if only one argument is passed
338 if ( length === i ) {
339 target = this;
340 --i;
341 }
342
343 for ( ; i < length; i++ ) {
344 // Only deal with non-null/undefined values
345 if ( (options = arguments[ i ]) != null ) {
346 // Extend the base object
347 for ( name in options ) {
348 src = target[ name ];
349 copy = options[ name ];
350
351 // Prevent never-ending loop
352 if ( target === copy ) {
353 continue;
354 }
355
356 // Recurse if we're merging plain objects or arrays
357 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
358 if ( copyIsArray ) {
359 copyIsArray = false;
360 clone = src && jQuery.isArray(src) ? src : [];
361
362 } else {
363 clone = src && jQuery.isPlainObject(src) ? src : {};
364 }
365
366 // Never move original objects, clone them
367 target[ name ] = jQuery.extend( deep, clone, copy );
368
369 // Don't bring in undefined values
370 } else if ( copy !== undefined ) {
371 target[ name ] = copy;
372 }
373 }
374 }
375 }
376
377 // Return the modified object
378 return target;
379 };
380
381 jQuery.extend({
382 noConflict: function( deep ) {
383 if ( window.$ === jQuery ) {
384 window.$ = _$;
385 }
386
387 if ( deep && window.jQuery === jQuery ) {
388 window.jQuery = _jQuery;
389 }
390
391 return jQuery;
392 },
393
394 // Is the DOM ready to be used? Set to true once it occurs.
395 isReady: false,
396
397 // A counter to track how many items to wait for before
398 // the ready event fires. See #6781
399 readyWait: 1,
400
401 // Hold (or release) the ready event
402 holdReady: function( hold ) {
403 if ( hold ) {
404 jQuery.readyWait++;
405 } else {
406 jQuery.ready( true );
407 }
408 },
409
410 // Handle when the DOM is ready
411 ready: function( wait ) {
412 // Either a released hold or an DOMready/load event and not yet ready
413 if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
414 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
415 if ( !document.body ) {
416 return setTimeout( jQuery.ready, 1 );
417 }
418
419 // Remember that the DOM is ready
420 jQuery.isReady = true;
421
422 // If a normal DOM Ready event fired, decrement, and wait if need be
423 if ( wait !== true && --jQuery.readyWait > 0 ) {
424 return;
425 }
426
427 // If there are functions bound, to execute
428 readyList.resolveWith( document, [ jQuery ] );
429
430 // Trigger any bound ready events
431 if ( jQuery.fn.trigger ) {
432 jQuery( document ).trigger( "ready" ).unbind( "ready" );
433 }
434 }
435 },
436
437 bindReady: function() {
438 if ( readyList ) {
439 return;
440 }
441
442 readyList = jQuery._Deferred();
443
444 // Catch cases where $(document).ready() is called after the
445 // browser event has already occurred.
446 if ( document.readyState === "complete" ) {
447 // Handle it asynchronously to allow scripts the opportunity to delay ready
448 return setTimeout( jQuery.ready, 1 );
449 }
450
451 // Mozilla, Opera and webkit nightlies currently support this event
452 if ( document.addEventListener ) {
453 // Use the handy event callback
454 document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
455
456 // A fallback to window.onload, that will always work
457 window.addEventListener( "load", jQuery.ready, false );
458
459 // If IE event model is used
460 } else if ( document.attachEvent ) {
461 // ensure firing before onload,
462 // maybe late but safe also for iframes
463 document.attachEvent( "onreadystatechange", DOMContentLoaded );
464
465 // A fallback to window.onload, that will always work
466 window.attachEvent( "onload", jQuery.ready );
467
468 // If IE and not a frame
469 // continually check to see if the document is ready
470 var toplevel = false;
471
472 try {
473 toplevel = window.frameElement == null;
474 } catch(e) {}
475
476 if ( document.documentElement.doScroll && toplevel ) {
477 doScrollCheck();
478 }
479 }
480 },
481
482 // See test/unit/core.js for details concerning isFunction.
483 // Since version 1.3, DOM methods and functions like alert
484 // aren't supported. They return false on IE (#2968).
485 isFunction: function( obj ) {
486 return jQuery.type(obj) === "function";
487 },
488
489 isArray: Array.isArray || function( obj ) {
490 return jQuery.type(obj) === "array";
491 },
492
493 // A crude way of determining if an object is a window
494 isWindow: function( obj ) {
495 return obj && typeof obj === "object" && "setInterval" in obj;
496 },
497
498 isNaN: function( obj ) {
499 return obj == null || !rdigit.test( obj ) || isNaN( obj );
500 },
501
502 type: function( obj ) {
503 return obj == null ?
504 String( obj ) :
505 class2type[ toString.call(obj) ] || "object";
506 },
507
508 isPlainObject: function( obj ) {
509 // Must be an Object.
510 // Because of IE, we also have to check the presence of the constructor property.
511 // Make sure that DOM nodes and window objects don't pass through, as well
512 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
513 return false;
514 }
515
516 // Not own constructor property must be Object
517 if ( obj.constructor &&
518 !hasOwn.call(obj, "constructor") &&
519 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
520 return false;
521 }
522
523 // Own properties are enumerated firstly, so to speed up,
524 // if last one is own, then all properties are own.
525
526 var key;
527 for ( key in obj ) {}
528
529 return key === undefined || hasOwn.call( obj, key );
530 },
531
532 isEmptyObject: function( obj ) {
533 for ( var name in obj ) {
534 return false;
535 }
536 return true;
537 },
538
539 error: function( msg ) {
540 throw msg;
541 },
542
543 parseJSON: function( data ) {
544 if ( typeof data !== "string" || !data ) {
545 return null;
546 }
547
548 // Make sure leading/trailing whitespace is removed (IE can't handle it)
549 data = jQuery.trim( data );
550
551 // Attempt to parse using the native JSON parser first
552 if ( window.JSON && window.JSON.parse ) {
553 return window.JSON.parse( data );
554 }
555
556 // Make sure the incoming data is actual JSON
557 // Logic borrowed from http://json.org/json2.js
558 if ( rvalidchars.test( data.replace( rvalidescape, "@" )
559 .replace( rvalidtokens, "]" )
560 .replace( rvalidbraces, "")) ) {
561
562 return (new Function( "return " + data ))();
563
564 }
565 jQuery.error( "Invalid JSON: " + data );
566 },
567
568 // Cross-browser xml parsing
569 // (xml & tmp used internally)
570 parseXML: function( data , xml , tmp ) {
571
572 if ( window.DOMParser ) { // Standard
573 tmp = new DOMParser();
574 xml = tmp.parseFromString( data , "text/xml" );
575 } else { // IE
576 xml = new ActiveXObject( "Microsoft.XMLDOM" );
577 xml.async = "false";
578 xml.loadXML( data );
579 }
580
581 tmp = xml.documentElement;
582
583 if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
584 jQuery.error( "Invalid XML: " + data );
585 }
586
587 return xml;
588 },
589
590 noop: function() {},
591
592 // Evaluates a script in a global context
593 // Workarounds based on findings by Jim Driscoll
594 // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
595 globalEval: function( data ) {
596 if ( data && rnotwhite.test( data ) ) {
597 // We use execScript on Internet Explorer
598 // We use an anonymous function so that context is window
599 // rather than jQuery in Firefox
600 ( window.execScript || function( data ) {
601 window[ "eval" ].call( window, data );
602 } )( data );
603 }
604 },
605
606 nodeName: function( elem, name ) {
607 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
608 },
609
610 // args is for internal usage only
611 each: function( object, callback, args ) {
612 var name, i = 0,
613 length = object.length,
614 isObj = length === undefined || jQuery.isFunction( object );
615
616 if ( args ) {
617 if ( isObj ) {
618 for ( name in object ) {
619 if ( callback.apply( object[ name ], args ) === false ) {
620 break;
621 }
622 }
623 } else {
624 for ( ; i < length; ) {
625 if ( callback.apply( object[ i++ ], args ) === false ) {
626 break;
627 }
628 }
629 }
630
631 // A special, fast, case for the most common use of each
632 } else {
633 if ( isObj ) {
634 for ( name in object ) {
635 if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
636 break;
637 }
638 }
639 } else {
640 for ( ; i < length; ) {
641 if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
642 break;
643 }
644 }
645 }
646 }
647
648 return object;
649 },
650
651 // Use native String.trim function wherever possible
652 trim: trim ?
653 function( text ) {
654 return text == null ?
655 "" :
656 trim.call( text );
657 } :
658
659 // Otherwise use our own trimming functionality
660 function( text ) {
661 return text == null ?
662 "" :
663 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
664 },
665
666 // results is for internal usage only
667 makeArray: function( array, results ) {
668 var ret = results || [];
669
670 if ( array != null ) {
671 // The window, strings (and functions) also have 'length'
672 // The extra typeof function check is to prevent crashes
673 // in Safari 2 (See: #3039)
674 // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
675 var type = jQuery.type( array );
676
677 if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
678 push.call( ret, array );
679 } else {
680 jQuery.merge( ret, array );
681 }
682 }
683
684 return ret;
685 },
686
687 inArray: function( elem, array ) {
688
689 if ( indexOf ) {
690 return indexOf.call( array, elem );
691 }
692
693 for ( var i = 0, length = array.length; i < length; i++ ) {
694 if ( array[ i ] === elem ) {
695 return i;
696 }
697 }
698
699 return -1;
700 },
701
702 merge: function( first, second ) {
703 var i = first.length,
704 j = 0;
705
706 if ( typeof second.length === "number" ) {
707 for ( var l = second.length; j < l; j++ ) {
708 first[ i++ ] = second[ j ];
709 }
710
711 } else {
712 while ( second[j] !== undefined ) {
713 first[ i++ ] = second[ j++ ];
714 }
715 }
716
717 first.length = i;
718
719 return first;
720 },
721
722 grep: function( elems, callback, inv ) {
723 var ret = [], retVal;
724 inv = !!inv;
725
726 // Go through the array, only saving the items
727 // that pass the validator function
728 for ( var i = 0, length = elems.length; i < length; i++ ) {
729 retVal = !!callback( elems[ i ], i );
730 if ( inv !== retVal ) {
731 ret.push( elems[ i ] );
732 }
733 }
734
735 return ret;
736 },
737
738 // arg is for internal usage only
739 map: function( elems, callback, arg ) {
740 var value, key, ret = [],
741 i = 0,
742 length = elems.length,
743 // jquery objects are treated as arrays
744 isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
745
746 // Go through the array, translating each of the items to their
747 if ( isArray ) {
748 for ( ; i < length; i++ ) {
749 value = callback( elems[ i ], i, arg );
750
751 if ( value != null ) {
752 ret[ ret.length ] = value;
753 }
754 }
755
756 // Go through every key on the object,
757 } else {
758 for ( key in elems ) {
759 value = callback( elems[ key ], key, arg );
760
761 if ( value != null ) {
762 ret[ ret.length ] = value;
763 }
764 }
765 }
766
767 // Flatten any nested arrays
768 return ret.concat.apply( [], ret );
769 },
770
771 // A global GUID counter for objects
772 guid: 1,
773
774 // Bind a function to a context, optionally partially applying any
775 // arguments.
776 proxy: function( fn, context ) {
777 if ( typeof context === "string" ) {
778 var tmp = fn[ context ];
779 context = fn;
780 fn = tmp;
781 }
782
783 // Quick check to determine if target is callable, in the spec
784 // this throws a TypeError, but we will just return undefined.
785 if ( !jQuery.isFunction( fn ) ) {
786 return undefined;
787 }
788
789 // Simulated bind
790 var args = slice.call( arguments, 2 ),
791 proxy = function() {
792 return fn.apply( context, args.concat( slice.call( arguments ) ) );
793 };
794
795 // Set the guid of unique handler to the same of original handler, so it can be removed
796 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
797
798 return proxy;
799 },
800
801 // Mutifunctional method to get and set values to a collection
802 // The value/s can be optionally by executed if its a function
803 access: function( elems, key, value, exec, fn, pass ) {
804 var length = elems.length;
805
806 // Setting many attributes
807 if ( typeof key === "object" ) {
808 for ( var k in key ) {
809 jQuery.access( elems, k, key[k], exec, fn, value );
810 }
811 return elems;
812 }
813
814 // Setting one attribute
815 if ( value !== undefined ) {
816 // Optionally, function values get executed if exec is true
817 exec = !pass && exec && jQuery.isFunction(value);
818
819 for ( var i = 0; i < length; i++ ) {
820 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
821 }
822
823 return elems;
824 }
825
826 // Getting an attribute
827 return length ? fn( elems[0], key ) : undefined;
828 },
829
830 now: function() {
831 return (new Date()).getTime();
832 },
833
834 // Use of jQuery.browser is frowned upon.
835 // More details: http://docs.jquery.com/Utilities/jQuery.browser
836 uaMatch: function( ua ) {
837 ua = ua.toLowerCase();
838
839 var match = rwebkit.exec( ua ) ||
840 ropera.exec( ua ) ||
841 rmsie.exec( ua ) ||
842 ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
843 [];
844
845 return { browser: match[1] || "", version: match[2] || "0" };
846 },
847
848 sub: function() {
849 function jQuerySub( selector, context ) {
850 return new jQuerySub.fn.init( selector, context );
851 }
852 jQuery.extend( true, jQuerySub, this );
853 jQuerySub.superclass = this;
854 jQuerySub.fn = jQuerySub.prototype = this();
855 jQuerySub.fn.constructor = jQuerySub;
856 jQuerySub.sub = this.sub;
857 jQuerySub.fn.init = function init( selector, context ) {
858 if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
859 context = jQuerySub( context );
860 }
861
862 return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
863 };
864 jQuerySub.fn.init.prototype = jQuerySub.fn;
865 var rootjQuerySub = jQuerySub(document);
866 return jQuerySub;
867 },
868
869 browser: {}
870 });
871
872 // Populate the class2type map
873 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
874 class2type[ "[object " + name + "]" ] = name.toLowerCase();
875 });
876
877 browserMatch = jQuery.uaMatch( userAgent );
878 if ( browserMatch.browser ) {
879 jQuery.browser[ browserMatch.browser ] = true;
880 jQuery.browser.version = browserMatch.version;
881 }
882
883 // Deprecated, use jQuery.browser.webkit instead
884 if ( jQuery.browser.webkit ) {
885 jQuery.browser.safari = true;
886 }
887
888 // IE doesn't match non-breaking spaces with \s
889 if ( rnotwhite.test( "\xA0" ) ) {
890 trimLeft = /^[\s\xA0]+/;
891 trimRight = /[\s\xA0]+$/;
892 }
893
894 // All jQuery objects should point back to these
895 rootjQuery = jQuery(document);
896
897 // Cleanup functions for the document ready method
898 if ( document.addEventListener ) {
899 DOMContentLoaded = function() {
900 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
901 jQuery.ready();
902 };
903
904 } else if ( document.attachEvent ) {
905 DOMContentLoaded = function() {
906 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
907 if ( document.readyState === "complete" ) {
908 document.detachEvent( "onreadystatechange", DOMContentLoaded );
909 jQuery.ready();
910 }
911 };
912 }
913
914 // The DOM ready check for Internet Explorer
915 function doScrollCheck() {
916 if ( jQuery.isReady ) {
917 return;
918 }
919
920 try {
921 // If IE is used, use the trick by Diego Perini
922 // http://javascript.nwbox.com/IEContentLoaded/
923 document.documentElement.doScroll("left");
924 } catch(e) {
925 setTimeout( doScrollCheck, 1 );
926 return;
927 }
928
929 // and execute any waiting functions
930 jQuery.ready();
931 }
932
933 // Expose jQuery to the global object
934 return jQuery;
935
936 })();
937
938
939 var // Promise methods
940 promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
941 // Static reference to slice
942 sliceDeferred = [].slice;
943
944 jQuery.extend({
945 // Create a simple deferred (one callbacks list)
946 _Deferred: function() {
947 var // callbacks list
948 callbacks = [],
949 // stored [ context , args ]
950 fired,
951 // to avoid firing when already doing so
952 firing,
953 // flag to know if the deferred has been cancelled
954 cancelled,
955 // the deferred itself
956 deferred = {
957
958 // done( f1, f2, ...)
959 done: function() {
960 if ( !cancelled ) {
961 var args = arguments,
962 i,
963 length,
964 elem,
965 type,
966 _fired;
967 if ( fired ) {
968 _fired = fired;
969 fired = 0;
970 }
971 for ( i = 0, length = args.length; i < length; i++ ) {
972 elem = args[ i ];
973 type = jQuery.type( elem );
974 if ( type === "array" ) {
975 deferred.done.apply( deferred, elem );
976 } else if ( type === "function" ) {
977 callbacks.push( elem );
978 }
979 }
980 if ( _fired ) {
981 deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
982 }
983 }
984 return this;
985 },
986
987 // resolve with given context and args
988 resolveWith: function( context, args ) {
989 if ( !cancelled && !fired && !firing ) {
990 // make sure args are available (#8421)
991 args = args || [];
992 firing = 1;
993 try {
994 while( callbacks[ 0 ] ) {
995 callbacks.shift().apply( context, args );
996 }
997 }
998 finally {
999 fired = [ context, args ];
1000 firing = 0;
1001 }
1002 }
1003 return this;
1004 },
1005
1006 // resolve with this as context and given arguments
1007 resolve: function() {
1008 deferred.resolveWith( this, arguments );
1009 return this;
1010 },
1011
1012 // Has this deferred been resolved?
1013 isResolved: function() {
1014 return !!( firing || fired );
1015 },
1016
1017 // Cancel
1018 cancel: function() {
1019 cancelled = 1;
1020 callbacks = [];
1021 return this;
1022 }
1023 };
1024
1025 return deferred;
1026 },
1027
1028 // Full fledged deferred (two callbacks list)
1029 Deferred: function( func ) {
1030 var deferred = jQuery._Deferred(),
1031 failDeferred = jQuery._Deferred(),
1032 promise;
1033 // Add errorDeferred methods, then and promise
1034 jQuery.extend( deferred, {
1035 then: function( doneCallbacks, failCallbacks ) {
1036 deferred.done( doneCallbacks ).fail( failCallbacks );
1037 return this;
1038 },
1039 always: function() {
1040 return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
1041 },
1042 fail: failDeferred.done,
1043 rejectWith: failDeferred.resolveWith,
1044 reject: failDeferred.resolve,
1045 isRejected: failDeferred.isResolved,
1046 pipe: function( fnDone, fnFail ) {
1047 return jQuery.Deferred(function( newDefer ) {
1048 jQuery.each( {
1049 done: [ fnDone, "resolve" ],
1050 fail: [ fnFail, "reject" ]
1051 }, function( handler, data ) {
1052 var fn = data[ 0 ],
1053 action = data[ 1 ],
1054 returned;
1055 if ( jQuery.isFunction( fn ) ) {
1056 deferred[ handler ](function() {
1057 returned = fn.apply( this, arguments );
1058 if ( returned && jQuery.isFunction( returned.promise ) ) {
1059 returned.promise().then( newDefer.resolve, newDefer.reject );
1060 } else {
1061 newDefer[ action ]( returned );
1062 }
1063 });
1064 } else {
1065 deferred[ handler ]( newDefer[ action ] );
1066 }
1067 });
1068 }).promise();
1069 },
1070 // Get a promise for this deferred
1071 // If obj is provided, the promise aspect is added to the object
1072 promise: function( obj ) {
1073 if ( obj == null ) {
1074 if ( promise ) {
1075 return promise;
1076 }
1077 promise = obj = {};
1078 }
1079 var i = promiseMethods.length;
1080 while( i-- ) {
1081 obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
1082 }
1083 return obj;
1084 }
1085 });
1086 // Make sure only one callback list will be used
1087 deferred.done( failDeferred.cancel ).fail( deferred.cancel );
1088 // Unexpose cancel
1089 delete deferred.cancel;
1090 // Call given func if any
1091 if ( func ) {
1092 func.call( deferred, deferred );
1093 }
1094 return deferred;
1095 },
1096
1097 // Deferred helper
1098 when: function( firstParam ) {
1099 var args = arguments,
1100 i = 0,
1101 length = args.length,
1102 count = length,
1103 deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
1104 firstParam :
1105 jQuery.Deferred();
1106 function resolveFunc( i ) {
1107 return function( value ) {
1108 args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
1109 if ( !( --count ) ) {
1110 // Strange bug in FF4:
1111 // Values changed onto the arguments object sometimes end up as undefined values
1112 // outside the $.when method. Cloning the object into a fresh array solves the issue
1113 deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
1114 }
1115 };
1116 }
1117 if ( length > 1 ) {
1118 for( ; i < length; i++ ) {
1119 if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
1120 args[ i ].promise().then( resolveFunc(i), deferred.reject );
1121 } else {
1122 --count;
1123 }
1124 }
1125 if ( !count ) {
1126 deferred.resolveWith( deferred, args );
1127 }
1128 } else if ( deferred !== firstParam ) {
1129 deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
1130 }
1131 return deferred.promise();
1132 }
1133 });
1134
1135
1136
1137 jQuery.support = (function() {
1138
1139 var div = document.createElement( "div" ),
1140 documentElement = document.documentElement,
1141 all,
1142 a,
1143 select,
1144 opt,
1145 input,
1146 marginDiv,
1147 support,
1148 fragment,
1149 body,
1150 bodyStyle,
1151 tds,
1152 events,
1153 eventName,
1154 i,
1155 isSupported;
1156
1157 // Preliminary tests
1158 div.setAttribute("className", "t");
1159 div.innerHTML = " <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1160
1161 all = div.getElementsByTagName( "*" );
1162 a = div.getElementsByTagName( "a" )[ 0 ];
1163
1164 // Can't get basic test support
1165 if ( !all || !all.length || !a ) {
1166 return {};
1167 }
1168
1169 // First batch of supports tests
1170 select = document.createElement( "select" );
1171 opt = select.appendChild( document.createElement("option") );
1172 input = div.getElementsByTagName( "input" )[ 0 ];
1173
1174 support = {
1175 // IE strips leading whitespace when .innerHTML is used
1176 leadingWhitespace: ( div.firstChild.nodeType === 3 ),
1177
1178 // Make sure that tbody elements aren't automatically inserted
1179 // IE will insert them into empty tables
1180 tbody: !div.getElementsByTagName( "tbody" ).length,
1181
1182 // Make sure that link elements get serialized correctly by innerHTML
1183 // This requires a wrapper element in IE
1184 htmlSerialize: !!div.getElementsByTagName( "link" ).length,
1185
1186 // Get the style information from getAttribute
1187 // (IE uses .cssText instead)
1188 style: /top/.test( a.getAttribute("style") ),
1189
1190 // Make sure that URLs aren't manipulated
1191 // (IE normalizes it by default)
1192 hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
1193
1194 // Make sure that element opacity exists
1195 // (IE uses filter instead)
1196 // Use a regex to work around a WebKit issue. See #5145
1197 opacity: /^0.55$/.test( a.style.opacity ),
1198
1199 // Verify style float existence
1200 // (IE uses styleFloat instead of cssFloat)
1201 cssFloat: !!a.style.cssFloat,
1202
1203 // Make sure that if no value is specified for a checkbox
1204 // that it defaults to "on".
1205 // (WebKit defaults to "" instead)
1206 checkOn: ( input.value === "on" ),
1207
1208 // Make sure that a selected-by-default option has a working selected property.
1209 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1210 optSelected: opt.selected,
1211
1212 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
1213 getSetAttribute: div.className !== "t",
1214
1215 // Will be defined later
1216 submitBubbles: true,
1217 changeBubbles: true,
1218 focusinBubbles: false,
1219 deleteExpando: true,
1220 noCloneEvent: true,
1221 inlineBlockNeedsLayout: false,
1222 shrinkWrapBlocks: false,
1223 reliableMarginRight: true
1224 };
1225
1226 // Make sure checked status is properly cloned
1227 input.checked = true;
1228 support.noCloneChecked = input.cloneNode( true ).checked;
1229
1230 // Make sure that the options inside disabled selects aren't marked as disabled
1231 // (WebKit marks them as disabled)
1232 select.disabled = true;
1233 support.optDisabled = !opt.disabled;
1234
1235 // Test to see if it's possible to delete an expando from an element
1236 // Fails in Internet Explorer
1237 try {
1238 delete div.test;
1239 } catch( e ) {
1240 support.deleteExpando = false;
1241 }
1242
1243 if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
1244 div.attachEvent( "onclick", function click() {
1245 // Cloning a node shouldn't copy over any
1246 // bound event handlers (IE does this)
1247 support.noCloneEvent = false;
1248 div.detachEvent( "onclick", click );
1249 });
1250 div.cloneNode( true ).fireEvent( "onclick" );
1251 }
1252
1253 // Check if a radio maintains it's value
1254 // after being appended to the DOM
1255 input = document.createElement("input");
1256 input.value = "t";
1257 input.setAttribute("type", "radio");
1258 support.radioValue = input.value === "t";
1259
1260 input.setAttribute("checked", "checked");
1261 div.appendChild( input );
1262 fragment = document.createDocumentFragment();
1263 fragment.appendChild( div.firstChild );
1264
1265 // WebKit doesn't clone checked state correctly in fragments
1266 support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
1267
1268 div.innerHTML = "";
1269
1270 // Figure out if the W3C box model works as expected
1271 div.style.width = div.style.paddingLeft = "1px";
1272
1273 // We use our own, invisible, body
1274 body = document.createElement( "body" );
1275 bodyStyle = {
1276 visibility: "hidden",
1277 width: 0,
1278 height: 0,
1279 border: 0,
1280 margin: 0,
1281 // Set background to avoid IE crashes when removing (#9028)
1282 background: "none"
1283 };
1284 for ( i in bodyStyle ) {
1285 body.style[ i ] = bodyStyle[ i ];
1286 }
1287 body.appendChild( div );
1288 documentElement.insertBefore( body, documentElement.firstChild );
1289
1290 // Check if a disconnected checkbox will retain its checked
1291 // value of true after appended to the DOM (IE6/7)
1292 support.appendChecked = input.checked;
1293
1294 support.boxModel = div.offsetWidth === 2;
1295
1296 if ( "zoom" in div.style ) {
1297 // Check if natively block-level elements act like inline-block
1298 // elements when setting their display to 'inline' and giving
1299 // them layout
1300 // (IE < 8 does this)
1301 div.style.display = "inline";
1302 div.style.zoom = 1;
1303 support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
1304
1305 // Check if elements with layout shrink-wrap their children
1306 // (IE 6 does this)
1307 div.style.display = "";
1308 div.innerHTML = "<div style='width:4px;'></div>";
1309 support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
1310 }
1311
1312 div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1313 tds = div.getElementsByTagName( "td" );
1314
1315 // Check if table cells still have offsetWidth/Height when they are set
1316 // to display:none and there are still other visible table cells in a
1317 // table row; if so, offsetWidth/Height are not reliable for use when
1318 // determining if an element has been hidden directly using
1319 // display:none (it is still safe to use offsets if a parent element is
1320 // hidden; don safety goggles and see bug #4512 for more information).
1321 // (only IE 8 fails this test)
1322 isSupported = ( tds[ 0 ].offsetHeight === 0 );
1323
1324 tds[ 0 ].style.display = "";
1325 tds[ 1 ].style.display = "none";
1326
1327 // Check if empty table cells still have offsetWidth/Height
1328 // (IE < 8 fail this test)
1329 support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
1330 div.innerHTML = "";
1331
1332 // Check if div with explicit width and no margin-right incorrectly
1333 // gets computed margin-right based on width of container. For more
1334 // info see bug #3333
1335 // Fails in WebKit before Feb 2011 nightlies
1336 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
1337 if ( document.defaultView && document.defaultView.getComputedStyle ) {
1338 marginDiv = document.createElement( "div" );
1339 marginDiv.style.width = "0";
1340 marginDiv.style.marginRight = "0";
1341 div.appendChild( marginDiv );
1342 support.reliableMarginRight =
1343 ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
1344 }
1345
1346 // Remove the body element we added
1347 body.innerHTML = "";
1348 documentElement.removeChild( body );
1349
1350 // Technique from Juriy Zaytsev
1351 // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1352 // We only care about the case where non-standard event systems
1353 // are used, namely in IE. Short-circuiting here helps us to
1354 // avoid an eval call (in setAttribute) which can cause CSP
1355 // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1356 if ( div.attachEvent ) {
1357 for( i in {
1358 submit: 1,
1359 change: 1,
1360 focusin: 1
1361 } ) {
1362 eventName = "on" + i;
1363 isSupported = ( eventName in div );
1364 if ( !isSupported ) {
1365 div.setAttribute( eventName, "return;" );
1366 isSupported = ( typeof div[ eventName ] === "function" );
1367 }
1368 support[ i + "Bubbles" ] = isSupported;
1369 }
1370 }
1371
1372 return support;
1373 })();
1374
1375 // Keep track of boxModel
1376 jQuery.boxModel = jQuery.support.boxModel;
1377
1378
1379
1380
1381 var rbrace = /^(?:\{.*\}|\[.*\])$/,
1382 rmultiDash = /([a-z])([A-Z])/g;
1383
1384 jQuery.extend({
1385 cache: {},
1386
1387 // Please use with caution
1388 uuid: 0,
1389
1390 // Unique for each copy of jQuery on the page
1391 // Non-digits removed to match rinlinejQuery
1392 expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1393
1394 // The following elements throw uncatchable exceptions if you
1395 // attempt to add expando properties to them.
1396 noData: {
1397 "embed": true,
1398 // Ban all objects except for Flash (which handle expandos)
1399 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1400 "applet": true
1401 },
1402
1403 hasData: function( elem ) {
1404 elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1405
1406 return !!elem && !isEmptyDataObject( elem );
1407 },
1408
1409 data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1410 if ( !jQuery.acceptData( elem ) ) {
1411 return;
1412 }
1413
1414 var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
1415
1416 // We have to handle DOM nodes and JS objects differently because IE6-7
1417 // can't GC object references properly across the DOM-JS boundary
1418 isNode = elem.nodeType,
1419
1420 // Only DOM nodes need the global jQuery cache; JS object data is
1421 // attached directly to the object so GC can occur automatically
1422 cache = isNode ? jQuery.cache : elem,
1423
1424 // Only defining an ID for JS objects if its cache already exists allows
1425 // the code to shortcut on the same path as a DOM node with no cache
1426 id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1427
1428 // Avoid doing any more work than we need to when trying to get data on an
1429 // object that has no data at all
1430 if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
1431 return;
1432 }
1433
1434 if ( !id ) {
1435 // Only DOM nodes need a new unique ID for each element since their data
1436 // ends up in the global cache
1437 if ( isNode ) {
1438 elem[ jQuery.expando ] = id = ++jQuery.uuid;
1439 } else {
1440 id = jQuery.expando;
1441 }
1442 }
1443
1444 if ( !cache[ id ] ) {
1445 cache[ id ] = {};
1446
1447 // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1448 // metadata on plain JS objects when the object is serialized using
1449 // JSON.stringify
1450 if ( !isNode ) {
1451 cache[ id ].toJSON = jQuery.noop;
1452 }
1453 }
1454
1455 // An object can be passed to jQuery.data instead of a key/value pair; this gets
1456 // shallow copied over onto the existing cache
1457 if ( typeof name === "object" || typeof name === "function" ) {
1458 if ( pvt ) {
1459 cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1460 } else {
1461 cache[ id ] = jQuery.extend(cache[ id ], name);
1462 }
1463 }
1464
1465 thisCache = cache[ id ];
1466
1467 // Internal jQuery data is stored in a separate object inside the object's data
1468 // cache in order to avoid key collisions between internal data and user-defined
1469 // data
1470 if ( pvt ) {
1471 if ( !thisCache[ internalKey ] ) {
1472 thisCache[ internalKey ] = {};
1473 }
1474
1475 thisCache = thisCache[ internalKey ];
1476 }
1477
1478 if ( data !== undefined ) {
1479 thisCache[ jQuery.camelCase( name ) ] = data;
1480 }
1481
1482 // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1483 // not attempt to inspect the internal events object using jQuery.data, as this
1484 // internal data object is undocumented and subject to change.
1485 if ( name === "events" && !thisCache[name] ) {
1486 return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1487 }
1488
1489 return getByName ? thisCache[ jQuery.camelCase( name ) ] : thisCache;
1490 },
1491
1492 removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1493 if ( !jQuery.acceptData( elem ) ) {
1494 return;
1495 }
1496
1497 var internalKey = jQuery.expando, isNode = elem.nodeType,
1498
1499 // See jQuery.data for more information
1500 cache = isNode ? jQuery.cache : elem,
1501
1502 // See jQuery.data for more information
1503 id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1504
1505 // If there is already no cache entry for this object, there is no
1506 // purpose in continuing
1507 if ( !cache[ id ] ) {
1508 return;
1509 }
1510
1511 if ( name ) {
1512 var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1513
1514 if ( thisCache ) {
1515 delete thisCache[ name ];
1516
1517 // If there is no data left in the cache, we want to continue
1518 // and let the cache object itself get destroyed
1519 if ( !isEmptyDataObject(thisCache) ) {
1520 return;
1521 }
1522 }
1523 }
1524
1525 // See jQuery.data for more information
1526 if ( pvt ) {
1527 delete cache[ id ][ internalKey ];
1528
1529 // Don't destroy the parent cache unless the internal data object
1530 // had been the only thing left in it
1531 if ( !isEmptyDataObject(cache[ id ]) ) {
1532 return;
1533 }
1534 }
1535
1536 var internalCache = cache[ id ][ internalKey ];
1537
1538 // Browsers that fail expando deletion also refuse to delete expandos on
1539 // the window, but it will allow it on all other JS objects; other browsers
1540 // don't care
1541 if ( jQuery.support.deleteExpando || cache != window ) {
1542 delete cache[ id ];
1543 } else {
1544 cache[ id ] = null;
1545 }
1546
1547 // We destroyed the entire user cache at once because it's faster than
1548 // iterating through each key, but we need to continue to persist internal
1549 // data if it existed
1550 if ( internalCache ) {
1551 cache[ id ] = {};
1552 // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
1553 // metadata on plain JS objects when the object is serialized using
1554 // JSON.stringify
1555 if ( !isNode ) {
1556 cache[ id ].toJSON = jQuery.noop;
1557 }
1558
1559 cache[ id ][ internalKey ] = internalCache;
1560
1561 // Otherwise, we need to eliminate the expando on the node to avoid
1562 // false lookups in the cache for entries that no longer exist
1563 } else if ( isNode ) {
1564 // IE does not allow us to delete expando properties from nodes,
1565 // nor does it have a removeAttribute function on Document nodes;
1566 // we must handle all of these cases
1567 if ( jQuery.support.deleteExpando ) {
1568 delete elem[ jQuery.expando ];
1569 } else if ( elem.removeAttribute ) {
1570 elem.removeAttribute( jQuery.expando );
1571 } else {
1572 elem[ jQuery.expando ] = null;
1573 }
1574 }
1575 },
1576
1577 // For internal use only.
1578 _data: function( elem, name, data ) {
1579 return jQuery.data( elem, name, data, true );
1580 },
1581
1582 // A method for determining if a DOM node can handle the data expando
1583 acceptData: function( elem ) {
1584 if ( elem.nodeName ) {
1585 var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1586
1587 if ( match ) {
1588 return !(match === true || elem.getAttribute("classid") !== match);
1589 }
1590 }
1591
1592 return true;
1593 }
1594 });
1595
1596 jQuery.fn.extend({
1597 data: function( key, value ) {
1598 var data = null;
1599
1600 if ( typeof key === "undefined" ) {
1601 if ( this.length ) {
1602 data = jQuery.data( this[0] );
1603
1604 if ( this[0].nodeType === 1 ) {
1605 var attr = this[0].attributes, name;
1606 for ( var i = 0, l = attr.length; i < l; i++ ) {
1607 name = attr[i].name;
1608
1609 if ( name.indexOf( "data-" ) === 0 ) {
1610 name = jQuery.camelCase( name.substring(5) );
1611
1612 dataAttr( this[0], name, data[ name ] );
1613 }
1614 }
1615 }
1616 }
1617
1618 return data;
1619
1620 } else if ( typeof key === "object" ) {
1621 return this.each(function() {
1622 jQuery.data( this, key );
1623 });
1624 }
1625
1626 var parts = key.split(".");
1627 parts[1] = parts[1] ? "." + parts[1] : "";
1628
1629 if ( value === undefined ) {
1630 data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1631
1632 // Try to fetch any internally stored data first
1633 if ( data === undefined && this.length ) {
1634 data = jQuery.data( this[0], key );
1635 data = dataAttr( this[0], key, data );
1636 }
1637
1638 return data === undefined && parts[1] ?
1639 this.data( parts[0] ) :
1640 data;
1641
1642 } else {
1643 return this.each(function() {
1644 var $this = jQuery( this ),
1645 args = [ parts[0], value ];
1646
1647 $this.triggerHandler( "setData" + parts[1] + "!", args );
1648 jQuery.data( this, key, value );
1649 $this.triggerHandler( "changeData" + parts[1] + "!", args );
1650 });
1651 }
1652 },
1653
1654 removeData: function( key ) {
1655 return this.each(function() {
1656 jQuery.removeData( this, key );
1657 });
1658 }
1659 });
1660
1661 function dataAttr( elem, key, data ) {
1662 // If nothing was found internally, try to fetch any
1663 // data from the HTML5 data-* attribute
1664 if ( data === undefined && elem.nodeType === 1 ) {
1665 var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
1666
1667 data = elem.getAttribute( name );
1668
1669 if ( typeof data === "string" ) {
1670 try {
1671 data = data === "true" ? true :
1672 data === "false" ? false :
1673 data === "null" ? null :
1674 !jQuery.isNaN( data ) ? parseFloat( data ) :
1675 rbrace.test( data ) ? jQuery.parseJSON( data ) :
1676 data;
1677 } catch( e ) {}
1678
1679 // Make sure we set the data so it isn't changed later
1680 jQuery.data( elem, key, data );
1681
1682 } else {
1683 data = undefined;
1684 }
1685 }
1686
1687 return data;
1688 }
1689
1690 // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
1691 // property to be considered empty objects; this property always exists in
1692 // order to make sure JSON.stringify does not expose internal metadata
1693 function isEmptyDataObject( obj ) {
1694 for ( var name in obj ) {
1695 if ( name !== "toJSON" ) {
1696 return false;
1697 }
1698 }
1699
1700 return true;
1701 }
1702
1703
1704
1705
1706 function handleQueueMarkDefer( elem, type, src ) {
1707 var deferDataKey = type + "defer",
1708 queueDataKey = type + "queue",
1709 markDataKey = type + "mark",
1710 defer = jQuery.data( elem, deferDataKey, undefined, true );
1711 if ( defer &&
1712 ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
1713 ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
1714 // Give room for hard-coded callbacks to fire first
1715 // and eventually mark/queue something else on the element
1716 setTimeout( function() {
1717 if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
1718 !jQuery.data( elem, markDataKey, undefined, true ) ) {
1719 jQuery.removeData( elem, deferDataKey, true );
1720 defer.resolve();
1721 }
1722 }, 0 );
1723 }
1724 }
1725
1726 jQuery.extend({
1727
1728 _mark: function( elem, type ) {
1729 if ( elem ) {
1730 type = (type || "fx") + "mark";
1731 jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
1732 }
1733 },
1734
1735 _unmark: function( force, elem, type ) {
1736 if ( force !== true ) {
1737 type = elem;
1738 elem = force;
1739 force = false;
1740 }
1741 if ( elem ) {
1742 type = type || "fx";
1743 var key = type + "mark",
1744 count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
1745 if ( count ) {
1746 jQuery.data( elem, key, count, true );
1747 } else {
1748 jQuery.removeData( elem, key, true );
1749 handleQueueMarkDefer( elem, type, "mark" );
1750 }
1751 }
1752 },
1753
1754 queue: function( elem, type, data ) {
1755 if ( elem ) {
1756 type = (type || "fx") + "queue";
1757 var q = jQuery.data( elem, type, undefined, true );
1758 // Speed up dequeue by getting out quickly if this is just a lookup
1759 if ( data ) {
1760 if ( !q || jQuery.isArray(data) ) {
1761 q = jQuery.data( elem, type, jQuery.makeArray(data), true );
1762 } else {
1763 q.push( data );
1764 }
1765 }
1766 return q || [];
1767 }
1768 },
1769
1770 dequeue: function( elem, type ) {
1771 type = type || "fx";
1772
1773 var queue = jQuery.queue( elem, type ),
1774 fn = queue.shift(),
1775 defer;
1776
1777 // If the fx queue is dequeued, always remove the progress sentinel
1778 if ( fn === "inprogress" ) {
1779 fn = queue.shift();
1780 }
1781
1782 if ( fn ) {
1783 // Add a progress sentinel to prevent the fx queue from being
1784 // automatically dequeued
1785 if ( type === "fx" ) {
1786 queue.unshift("inprogress");
1787 }
1788
1789 fn.call(elem, function() {
1790 jQuery.dequeue(elem, type);
1791 });
1792 }
1793
1794 if ( !queue.length ) {
1795 jQuery.removeData( elem, type + "queue", true );
1796 handleQueueMarkDefer( elem, type, "queue" );
1797 }
1798 }
1799 });
1800
1801 jQuery.fn.extend({
1802 queue: function( type, data ) {
1803 if ( typeof type !== "string" ) {
1804 data = type;
1805 type = "fx";
1806 }
1807
1808 if ( data === undefined ) {
1809 return jQuery.queue( this[0], type );
1810 }
1811 return this.each(function() {
1812 var queue = jQuery.queue( this, type, data );
1813
1814 if ( type === "fx" && queue[0] !== "inprogress" ) {
1815 jQuery.dequeue( this, type );
1816 }
1817 });
1818 },
1819 dequeue: function( type ) {
1820 return this.each(function() {
1821 jQuery.dequeue( this, type );
1822 });
1823 },
1824 // Based off of the plugin by Clint Helfers, with permission.
1825 // http://blindsignals.com/index.php/2009/07/jquery-delay/
1826 delay: function( time, type ) {
1827 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1828 type = type || "fx";
1829
1830 return this.queue( type, function() {
1831 var elem = this;
1832 setTimeout(function() {
1833 jQuery.dequeue( elem, type );
1834 }, time );
1835 });
1836 },
1837 clearQueue: function( type ) {
1838 return this.queue( type || "fx", [] );
1839 },
1840 // Get a promise resolved when queues of a certain type
1841 // are emptied (fx is the type by default)
1842 promise: function( type, object ) {
1843 if ( typeof type !== "string" ) {
1844 object = type;
1845 type = undefined;
1846 }
1847 type = type || "fx";
1848 var defer = jQuery.Deferred(),
1849 elements = this,
1850 i = elements.length,
1851 count = 1,
1852 deferDataKey = type + "defer",
1853 queueDataKey = type + "queue",
1854 markDataKey = type + "mark",
1855 tmp;
1856 function resolve() {
1857 if ( !( --count ) ) {
1858 defer.resolveWith( elements, [ elements ] );
1859 }
1860 }
1861 while( i-- ) {
1862 if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
1863 ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
1864 jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
1865 jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
1866 count++;
1867 tmp.done( resolve );
1868 }
1869 }
1870 resolve();
1871 return defer.promise();
1872 }
1873 });
1874
1875
1876
1877
1878 var rclass = /[\n\t\r]/g,
1879 rspace = /\s+/,
1880 rreturn = /\r/g,
1881 rtype = /^(?:button|input)$/i,
1882 rfocusable = /^(?:button|input|object|select|textarea)$/i,
1883 rclickable = /^a(?:rea)?$/i,
1884 rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
1885 rinvalidChar = /\:/,
1886 formHook, boolHook;
1887
1888 jQuery.fn.extend({
1889 attr: function( name, value ) {
1890 return jQuery.access( this, name, value, true, jQuery.attr );
1891 },
1892
1893 removeAttr: function( name ) {
1894 return this.each(function() {
1895 jQuery.removeAttr( this, name );
1896 });
1897 },
1898
1899 prop: function( name, value ) {
1900 return jQuery.access( this, name, value, true, jQuery.prop );
1901 },
1902
1903 removeProp: function( name ) {
1904 name = jQuery.propFix[ name ] || name;
1905 return this.each(function() {
1906 // try/catch handles cases where IE balks (such as removing a property on window)
1907 try {
1908 this[ name ] = undefined;
1909 delete this[ name ];
1910 } catch( e ) {}
1911 });
1912 },
1913
1914 addClass: function( value ) {
1915 if ( jQuery.isFunction( value ) ) {
1916 return this.each(function(i) {
1917 var self = jQuery(this);
1918 self.addClass( value.call(this, i, self.attr("class") || "") );
1919 });
1920 }
1921
1922 if ( value && typeof value === "string" ) {
1923 var classNames = (value || "").split( rspace );
1924
1925 for ( var i = 0, l = this.length; i < l; i++ ) {
1926 var elem = this[i];
1927
1928 if ( elem.nodeType === 1 ) {
1929 if ( !elem.className ) {
1930 elem.className = value;
1931
1932 } else {
1933 var className = " " + elem.className + " ",
1934 setClass = elem.className;
1935
1936 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1937 if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1938 setClass += " " + classNames[c];
1939 }
1940 }
1941 elem.className = jQuery.trim( setClass );
1942 }
1943 }
1944 }
1945 }
1946
1947 return this;
1948 },
1949
1950 removeClass: function( value ) {
1951 if ( jQuery.isFunction(value) ) {
1952 return this.each(function(i) {
1953 var self = jQuery(this);
1954 self.removeClass( value.call(this, i, self.attr("class")) );
1955 });
1956 }
1957
1958 if ( (value && typeof value === "string") || value === undefined ) {
1959 var classNames = (value || "").split( rspace );
1960
1961 for ( var i = 0, l = this.length; i < l; i++ ) {
1962 var elem = this[i];
1963
1964 if ( elem.nodeType === 1 && elem.className ) {
1965 if ( value ) {
1966 var className = (" " + elem.className + " ").replace(rclass, " ");
1967 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1968 className = className.replace(" " + classNames[c] + " ", " ");
1969 }
1970 elem.className = jQuery.trim( className );
1971
1972 } else {
1973 elem.className = "";
1974 }
1975 }
1976 }
1977 }
1978
1979 return this;
1980 },
1981
1982 toggleClass: function( value, stateVal ) {
1983 var type = typeof value,
1984 isBool = typeof stateVal === "boolean";
1985
1986 if ( jQuery.isFunction( value ) ) {
1987 return this.each(function(i) {
1988 var self = jQuery(this);
1989 self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1990 });
1991 }
1992
1993 return this.each(function() {
1994 if ( type === "string" ) {
1995 // toggle individual class names
1996 var className,
1997 i = 0,
1998 self = jQuery( this ),
1999 state = stateVal,
2000 classNames = value.split( rspace );
2001
2002 while ( (className = classNames[ i++ ]) ) {
2003 // check each className given, space seperated list
2004 state = isBool ? state : !self.hasClass( className );
2005 self[ state ? "addClass" : "removeClass" ]( className );
2006 }
2007
2008 } else if ( type === "undefined" || type === "boolean" ) {
2009 if ( this.className ) {
2010 // store className if set
2011 jQuery._data( this, "__className__", this.className );
2012 }
2013
2014 // toggle whole className
2015 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
2016 }
2017 });
2018 },
2019
2020 hasClass: function( selector ) {
2021 var className = " " + selector + " ";
2022 for ( var i = 0, l = this.length; i < l; i++ ) {
2023 if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
2024 return true;
2025 }
2026 }
2027
2028 return false;
2029 },
2030
2031 val: function( value ) {
2032 var hooks, ret,
2033 elem = this[0];
2034
2035 if ( !arguments.length ) {
2036 if ( elem ) {
2037 hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
2038
2039 if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
2040 return ret;
2041 }
2042
2043 return (elem.value || "").replace(rreturn, "");
2044 }
2045
2046 return undefined;
2047 }
2048
2049 var isFunction = jQuery.isFunction( value );
2050
2051 return this.each(function( i ) {
2052 var self = jQuery(this), val;
2053
2054 if ( this.nodeType !== 1 ) {
2055 return;
2056 }
2057
2058 if ( isFunction ) {
2059 val = value.call( this, i, self.val() );
2060 } else {
2061 val = value;
2062 }
2063
2064 // Treat null/undefined as ""; convert numbers to string
2065 if ( val == null ) {
2066 val = "";
2067 } else if ( typeof val === "number" ) {
2068 val += "";
2069 } else if ( jQuery.isArray( val ) ) {
2070 val = jQuery.map(val, function ( value ) {
2071 return value == null ? "" : value + "";
2072 });
2073 }
2074
2075 hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
2076
2077 // If set returns undefined, fall back to normal setting
2078 if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
2079 this.value = val;
2080 }
2081 });
2082 }
2083 });
2084
2085 jQuery.extend({
2086 valHooks: {
2087 option: {
2088 get: function( elem ) {
2089 // attributes.value is undefined in Blackberry 4.7 but
2090 // uses .value. See #6932
2091 var val = elem.attributes.value;
2092 return !val || val.specified ? elem.value : elem.text;
2093 }
2094 },
2095 select: {
2096 get: function( elem ) {
2097 var value,
2098 index = elem.selectedIndex,
2099 values = [],
2100 options = elem.options,
2101 one = elem.type === "select-one";
2102
2103 // Nothing was selected
2104 if ( index < 0 ) {
2105 return null;
2106 }
2107
2108 // Loop through all the selected options
2109 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
2110 var option = options[ i ];
2111
2112 // Don't return options that are disabled or in a disabled optgroup
2113 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
2114 (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
2115
2116 // Get the specific value for the option
2117 value = jQuery( option ).val();
2118
2119 // We don't need an array for one selects
2120 if ( one ) {
2121 return value;
2122 }
2123
2124 // Multi-Selects return an array
2125 values.push( value );
2126 }
2127 }
2128
2129 // Fixes Bug #2551 -- select.val() broken in IE after form.reset()
2130 if ( one && !values.length && options.length ) {
2131 return jQuery( options[ index ] ).val();
2132 }
2133
2134 return values;
2135 },
2136
2137 set: function( elem, value ) {
2138 var values = jQuery.makeArray( value );
2139
2140 jQuery(elem).find("option").each(function() {
2141 this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
2142 });
2143
2144 if ( !values.length ) {
2145 elem.selectedIndex = -1;
2146 }
2147 return values;
2148 }
2149 }
2150 },
2151
2152 attrFn: {
2153 val: true,
2154 css: true,
2155 html: true,
2156 text: true,
2157 data: true,
2158 width: true,
2159 height: true,
2160 offset: true
2161 },
2162
2163 attrFix: {
2164 // Always normalize to ensure hook usage
2165 tabindex: "tabIndex"
2166 },
2167
2168 attr: function( elem, name, value, pass ) {
2169 var nType = elem.nodeType;
2170
2171 // don't get/set attributes on text, comment and attribute nodes
2172 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2173 return undefined;
2174 }
2175
2176 if ( pass && name in jQuery.attrFn ) {
2177 return jQuery( elem )[ name ]( value );
2178 }
2179
2180 // Fallback to prop when attributes are not supported
2181 if ( !("getAttribute" in elem) ) {
2182 return jQuery.prop( elem, name, value );
2183 }
2184
2185 var ret, hooks,
2186 notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2187
2188 // Normalize the name if needed
2189 name = notxml && jQuery.attrFix[ name ] || name;
2190
2191 hooks = jQuery.attrHooks[ name ];
2192
2193 if ( !hooks ) {
2194 // Use boolHook for boolean attributes
2195 if ( rboolean.test( name ) &&
2196 (typeof value === "boolean" || value === undefined || value.toLowerCase() === name.toLowerCase()) ) {
2197
2198 hooks = boolHook;
2199
2200 // Use formHook for forms and if the name contains certain characters
2201 } else if ( formHook && (jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ) {
2202 hooks = formHook;
2203 }
2204 }
2205
2206 if ( value !== undefined ) {
2207
2208 if ( value === null ) {
2209 jQuery.removeAttr( elem, name );
2210 return undefined;
2211
2212 } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
2213 return ret;
2214
2215 } else {
2216 elem.setAttribute( name, "" + value );
2217 return value;
2218 }
2219
2220 } else if ( hooks && "get" in hooks && notxml ) {
2221 return hooks.get( elem, name );
2222
2223 } else {
2224
2225 ret = elem.getAttribute( name );
2226
2227 // Non-existent attributes return null, we normalize to undefined
2228 return ret === null ?
2229 undefined :
2230 ret;
2231 }
2232 },
2233
2234 removeAttr: function( elem, name ) {
2235 var propName;
2236 if ( elem.nodeType === 1 ) {
2237 name = jQuery.attrFix[ name ] || name;
2238
2239 if ( jQuery.support.getSetAttribute ) {
2240 // Use removeAttribute in browsers that support it
2241 elem.removeAttribute( name );
2242 } else {
2243 jQuery.attr( elem, name, "" );
2244 elem.removeAttributeNode( elem.getAttributeNode( name ) );
2245 }
2246
2247 // Set corresponding property to false for boolean attributes
2248 if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
2249 elem[ propName ] = false;
2250 }
2251 }
2252 },
2253
2254 attrHooks: {
2255 type: {
2256 set: function( elem, value ) {
2257 // We can't allow the type property to be changed (since it causes problems in IE)
2258 if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
2259 jQuery.error( "type property can't be changed" );
2260 } else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
2261 // Setting the type on a radio button after the value resets the value in IE6-9
2262 // Reset value to it's default in case type is set after value
2263 // This is for element creation
2264 var val = elem.value;
2265 elem.setAttribute( "type", value );
2266 if ( val ) {
2267 elem.value = val;
2268 }
2269 return value;
2270 }
2271 }
2272 },
2273 tabIndex: {
2274 get: function( elem ) {
2275 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2276 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2277 var attributeNode = elem.getAttributeNode("tabIndex");
2278
2279 return attributeNode && attributeNode.specified ?
2280 parseInt( attributeNode.value, 10 ) :
2281 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2282 0 :
2283 undefined;
2284 }
2285 }
2286 },
2287
2288 propFix: {
2289 tabindex: "tabIndex",
2290 readonly: "readOnly",
2291 "for": "htmlFor",
2292 "class": "className",
2293 maxlength: "maxLength",
2294 cellspacing: "cellSpacing",
2295 cellpadding: "cellPadding",
2296 rowspan: "rowSpan",
2297 colspan: "colSpan",
2298 usemap: "useMap",
2299 frameborder: "frameBorder",
2300 contenteditable: "contentEditable"
2301 },
2302
2303 prop: function( elem, name, value ) {
2304 var nType = elem.nodeType;
2305
2306 // don't get/set properties on text, comment and attribute nodes
2307 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
2308 return undefined;
2309 }
2310
2311 var ret, hooks,
2312 notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
2313
2314 // Try to normalize/fix the name
2315 name = notxml && jQuery.propFix[ name ] || name;
2316
2317 hooks = jQuery.propHooks[ name ];
2318
2319 if ( value !== undefined ) {
2320 if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
2321 return ret;
2322
2323 } else {
2324 return (elem[ name ] = value);
2325 }
2326
2327 } else {
2328 if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) {
2329 return ret;
2330
2331 } else {
2332 return elem[ name ];
2333 }
2334 }
2335 },
2336
2337 propHooks: {}
2338 });
2339
2340 // Hook for boolean attributes
2341 boolHook = {
2342 get: function( elem, name ) {
2343 // Align boolean attributes with corresponding properties
2344 return elem[ jQuery.propFix[ name ] || name ] ?
2345 name.toLowerCase() :
2346 undefined;
2347 },
2348 set: function( elem, value, name ) {
2349 var propName;
2350 if ( value === false ) {
2351 // Remove boolean attributes when set to false
2352 jQuery.removeAttr( elem, name );
2353 } else {
2354 // value is true since we know at this point it's type boolean and not false
2355 // Set boolean attributes to the same name and set the DOM property
2356 propName = jQuery.propFix[ name ] || name;
2357 if ( propName in elem ) {
2358 // Only set the IDL specifically if it already exists on the element
2359 elem[ propName ] = value;
2360 }
2361
2362 elem.setAttribute( name, name.toLowerCase() );
2363 }
2364 return name;
2365 }
2366 };
2367
2368 // Use the value property for back compat
2369 // Use the formHook for button elements in IE6/7 (#1954)
2370 jQuery.attrHooks.value = {
2371 get: function( elem, name ) {
2372 if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2373 return formHook.get( elem, name );
2374 }
2375 return elem.value;
2376 },
2377 set: function( elem, value, name ) {
2378 if ( formHook && jQuery.nodeName( elem, "button" ) ) {
2379 return formHook.set( elem, value, name );
2380 }
2381 // Does not return so that setAttribute is also used
2382 elem.value = value;
2383 }
2384 };
2385
2386 // IE6/7 do not support getting/setting some attributes with get/setAttribute
2387 if ( !jQuery.support.getSetAttribute ) {
2388
2389 // propFix is more comprehensive and contains all fixes
2390 jQuery.attrFix = jQuery.propFix;
2391
2392 // Use this for any attribute on a form in IE6/7
2393 formHook = jQuery.attrHooks.name = jQuery.valHooks.button = {
2394 get: function( elem, name ) {
2395 var ret;
2396 ret = elem.getAttributeNode( name );
2397 // Return undefined if nodeValue is empty string
2398 return ret && ret.nodeValue !== "" ?
2399 ret.nodeValue :
2400 undefined;
2401 },
2402 set: function( elem, value, name ) {
2403 // Check form objects in IE (multiple bugs related)
2404 // Only use nodeValue if the attribute node exists on the form
2405 var ret = elem.getAttributeNode( name );
2406 if ( ret ) {
2407 ret.nodeValue = value;
2408 return value;
2409 }
2410 }
2411 };
2412
2413 // Set width and height to auto instead of 0 on empty string( Bug #8150 )
2414 // This is for removals
2415 jQuery.each([ "width", "height" ], function( i, name ) {
2416 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2417 set: function( elem, value ) {
2418 if ( value === "" ) {
2419 elem.setAttribute( name, "auto" );
2420 return value;
2421 }
2422 }
2423 });
2424 });
2425 }
2426
2427
2428 // Some attributes require a special call on IE
2429 if ( !jQuery.support.hrefNormalized ) {
2430 jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
2431 jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
2432 get: function( elem ) {
2433 var ret = elem.getAttribute( name, 2 );
2434 return ret === null ? undefined : ret;
2435 }
2436 });
2437 });
2438 }
2439
2440 if ( !jQuery.support.style ) {
2441 jQuery.attrHooks.style = {
2442 get: function( elem ) {
2443 // Return undefined in the case of empty string
2444 // Normalize to lowercase since IE uppercases css property names
2445 return elem.style.cssText.toLowerCase() || undefined;
2446 },
2447 set: function( elem, value ) {
2448 return (elem.style.cssText = "" + value);
2449 }
2450 };
2451 }
2452
2453 // Safari mis-reports the default selected property of an option
2454 // Accessing the parent's selectedIndex property fixes it
2455 if ( !jQuery.support.optSelected ) {
2456 jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
2457 get: function( elem ) {
2458 var parent = elem.parentNode;
2459
2460 if ( parent ) {
2461 parent.selectedIndex;
2462
2463 // Make sure that it also works with optgroups, see #5701
2464 if ( parent.parentNode ) {
2465 parent.parentNode.selectedIndex;
2466 }
2467 }
2468 }
2469 });
2470 }
2471
2472 // Radios and checkboxes getter/setter
2473 if ( !jQuery.support.checkOn ) {
2474 jQuery.each([ "radio", "checkbox" ], function() {
2475 jQuery.valHooks[ this ] = {
2476 get: function( elem ) {
2477 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
2478 return elem.getAttribute("value") === null ? "on" : elem.value;
2479 }
2480 };
2481 });
2482 }
2483 jQuery.each([ "radio", "checkbox" ], function() {
2484 jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
2485 set: function( elem, value ) {
2486 if ( jQuery.isArray( value ) ) {
2487 return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
2488 }
2489 }
2490 });
2491 });
2492
2493
2494
2495
2496 var hasOwn = Object.prototype.hasOwnProperty,
2497 rnamespaces = /\.(.*)$/,
2498 rformElems = /^(?:textarea|input|select)$/i,
2499 rperiod = /\./g,
2500 rspaces = / /g,
2501 rescape = /[^\w\s.|`]/g,
2502 fcleanup = function( nm ) {
2503 return nm.replace(rescape, "\\$&");
2504 };
2505
2506 /*
2507 * A number of helper functions used for managing events.
2508 * Many of the ideas behind this code originated from
2509 * Dean Edwards' addEvent library.
2510 */
2511 jQuery.event = {
2512
2513 // Bind an event to an element
2514 // Original by Dean Edwards
2515 add: function( elem, types, handler, data ) {
2516 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2517 return;
2518 }
2519
2520 if ( handler === false ) {
2521 handler = returnFalse;
2522 } else if ( !handler ) {
2523 // Fixes bug #7229. Fix recommended by jdalton
2524 return;
2525 }
2526
2527 var handleObjIn, handleObj;
2528
2529 if ( handler.handler ) {
2530 handleObjIn = handler;
2531 handler = handleObjIn.handler;
2532 }
2533
2534 // Make sure that the function being executed has a unique ID
2535 if ( !handler.guid ) {
2536 handler.guid = jQuery.guid++;
2537 }
2538
2539 // Init the element's event structure
2540 var elemData = jQuery._data( elem );
2541
2542 // If no elemData is found then we must be trying to bind to one of the
2543 // banned noData elements
2544 if ( !elemData ) {
2545 return;
2546 }
2547
2548 var events = elemData.events,
2549 eventHandle = elemData.handle;
2550
2551 if ( !events ) {
2552 elemData.events = events = {};
2553 }
2554
2555 if ( !eventHandle ) {
2556 elemData.handle = eventHandle = function( e ) {
2557 // Discard the second event of a jQuery.event.trigger() and
2558 // when an event is called after a page has unloaded
2559 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
2560 jQuery.event.handle.apply( eventHandle.elem, arguments ) :
2561 undefined;
2562 };
2563 }
2564
2565 // Add elem as a property of the handle function
2566 // This is to prevent a memory leak with non-native events in IE.
2567 eventHandle.elem = elem;
2568
2569 // Handle multiple events separated by a space
2570 // jQuery(...).bind("mouseover mouseout", fn);
2571 types = types.split(" ");
2572
2573 var type, i = 0, namespaces;
2574
2575 while ( (type = types[ i++ ]) ) {
2576 handleObj = handleObjIn ?
2577 jQuery.extend({}, handleObjIn) :
2578 { handler: handler, data: data };
2579
2580 // Namespaced event handlers
2581 if ( type.indexOf(".") > -1 ) {
2582 namespaces = type.split(".");
2583 type = namespaces.shift();
2584 handleObj.namespace = namespaces.slice(0).sort().join(".");
2585
2586 } else {
2587 namespaces = [];
2588 handleObj.namespace = "";
2589 }
2590
2591 handleObj.type = type;
2592 if ( !handleObj.guid ) {
2593 handleObj.guid = handler.guid;
2594 }
2595
2596 // Get the current list of functions bound to this event
2597 var handlers = events[ type ],
2598 special = jQuery.event.special[ type ] || {};
2599
2600 // Init the event handler queue
2601 if ( !handlers ) {
2602 handlers = events[ type ] = [];
2603
2604 // Check for a special event handler
2605 // Only use addEventListener/attachEvent if the special
2606 // events handler returns false
2607 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2608 // Bind the global event handler to the element
2609 if ( elem.addEventListener ) {
2610 elem.addEventListener( type, eventHandle, false );
2611
2612 } else if ( elem.attachEvent ) {
2613 elem.attachEvent( "on" + type, eventHandle );
2614 }
2615 }
2616 }
2617
2618 if ( special.add ) {
2619 special.add.call( elem, handleObj );
2620
2621 if ( !handleObj.handler.guid ) {
2622 handleObj.handler.guid = handler.guid;
2623 }
2624 }
2625
2626 // Add the function to the element's handler list
2627 handlers.push( handleObj );
2628
2629 // Keep track of which events have been used, for event optimization
2630 jQuery.event.global[ type ] = true;
2631 }
2632
2633 // Nullify elem to prevent memory leaks in IE
2634 elem = null;
2635 },
2636
2637 global: {},
2638
2639 // Detach an event or set of events from an element
2640 remove: function( elem, types, handler, pos ) {
2641 // don't do events on text and comment nodes
2642 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2643 return;
2644 }
2645
2646 if ( handler === false ) {
2647 handler = returnFalse;
2648 }
2649
2650 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
2651 elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2652 events = elemData && elemData.events;
2653
2654 if ( !elemData || !events ) {
2655 return;
2656 }
2657
2658 // types is actually an event object here
2659 if ( types && types.type ) {
2660 handler = types.handler;
2661 types = types.type;
2662 }
2663
2664 // Unbind all events for the element
2665 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
2666 types = types || "";
2667
2668 for ( type in events ) {
2669 jQuery.event.remove( elem, type + types );
2670 }
2671
2672 return;
2673 }
2674
2675 // Handle multiple events separated by a space
2676 // jQuery(...).unbind("mouseover mouseout", fn);
2677 types = types.split(" ");
2678
2679 while ( (type = types[ i++ ]) ) {
2680 origType = type;
2681 handleObj = null;
2682 all = type.indexOf(".") < 0;
2683 namespaces = [];
2684
2685 if ( !all ) {
2686 // Namespaced event handlers
2687 namespaces = type.split(".");
2688 type = namespaces.shift();
2689
2690 namespace = new RegExp("(^|\\.)" +
2691 jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
2692 }
2693
2694 eventType = events[ type ];
2695
2696 if ( !eventType ) {
2697 continue;
2698 }
2699
2700 if ( !handler ) {
2701 for ( j = 0; j < eventType.length; j++ ) {
2702 handleObj = eventType[ j ];
2703
2704 if ( all || namespace.test( handleObj.namespace ) ) {
2705 jQuery.event.remove( elem, origType, handleObj.handler, j );
2706 eventType.splice( j--, 1 );
2707 }
2708 }
2709
2710 continue;
2711 }
2712
2713 special = jQuery.event.special[ type ] || {};
2714
2715 for ( j = pos || 0; j < eventType.length; j++ ) {
2716 handleObj = eventType[ j ];
2717
2718 if ( handler.guid === handleObj.guid ) {
2719 // remove the given handler for the given type
2720 if ( all || namespace.test( handleObj.namespace ) ) {
2721 if ( pos == null ) {
2722 eventType.splice( j--, 1 );
2723 }
2724
2725 if ( special.remove ) {
2726 special.remove.call( elem, handleObj );
2727 }
2728 }
2729
2730 if ( pos != null ) {
2731 break;
2732 }
2733 }
2734 }
2735
2736 // remove generic event handler if no more handlers exist
2737 if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
2738 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2739 jQuery.removeEvent( elem, type, elemData.handle );
2740 }
2741
2742 ret = null;
2743 delete events[ type ];
2744 }
2745 }
2746
2747 // Remove the expando if it's no longer used
2748 if ( jQuery.isEmptyObject( events ) ) {
2749 var handle = elemData.handle;
2750 if ( handle ) {
2751 handle.elem = null;
2752 }
2753
2754 delete elemData.events;
2755 delete elemData.handle;
2756
2757 if ( jQuery.isEmptyObject( elemData ) ) {
2758 jQuery.removeData( elem, undefined, true );
2759 }
2760 }
2761 },
2762
2763 // Events that are safe to short-circuit if no handlers are attached.
2764 // Native DOM events should not be added, they may have inline handlers.
2765 customEvent: {
2766 "getData": true,
2767 "setData": true,
2768 "changeData": true
2769 },
2770
2771 trigger: function( event, data, elem, onlyHandlers ) {
2772 // Event object or event type
2773 var type = event.type || event,
2774 namespaces = [],
2775 exclusive;
2776
2777 if ( type.indexOf("!") >= 0 ) {
2778 // Exclusive events trigger only for the exact event (no namespaces)
2779 type = type.slice(0, -1);
2780 exclusive = true;
2781 }
2782
2783 if ( type.indexOf(".") >= 0 ) {
2784 // Namespaced trigger; create a regexp to match event type in handle()
2785 namespaces = type.split(".");
2786 type = namespaces.shift();
2787 namespaces.sort();
2788 }
2789
2790 if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
2791 // No jQuery handlers for this event type, and it can't have inline handlers
2792 return;
2793 }
2794
2795 // Caller can pass in an Event, Object, or just an event type string
2796 event = typeof event === "object" ?
2797 // jQuery.Event object
2798 event[ jQuery.expando ] ? event :
2799 // Object literal
2800 new jQuery.Event( type, event ) :
2801 // Just the event type (string)
2802 new jQuery.Event( type );
2803
2804 event.type = type;
2805 event.exclusive = exclusive;
2806 event.namespace = namespaces.join(".");
2807 event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
2808
2809 // triggerHandler() and global events don't bubble or run the default action
2810 if ( onlyHandlers || !elem ) {
2811 event.preventDefault();
2812 event.stopPropagation();
2813 }
2814
2815 // Handle a global trigger
2816 if ( !elem ) {
2817 // TODO: Stop taunting the data cache; remove global events and always attach to document
2818 jQuery.each( jQuery.cache, function() {
2819 // internalKey variable is just used to make it easier to find
2820 // and potentially change this stuff later; currently it just
2821 // points to jQuery.expando
2822 var internalKey = jQuery.expando,
2823 internalCache = this[ internalKey ];
2824 if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
2825 jQuery.event.trigger( event, data, internalCache.handle.elem );
2826 }
2827 });
2828 return;
2829 }
2830
2831 // Don't do events on text and comment nodes
2832 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2833 return;
2834 }
2835
2836 // Clean up the event in case it is being reused
2837 event.result = undefined;
2838 event.target = elem;
2839
2840 // Clone any incoming data and prepend the event, creating the handler arg list
2841 data = data ? jQuery.makeArray( data ) : [];
2842 data.unshift( event );
2843
2844 var cur = elem,
2845 // IE doesn't like method names with a colon (#3533, #8272)
2846 ontype = type.indexOf(":") < 0 ? "on" + type : "";
2847
2848 // Fire event on the current element, then bubble up the DOM tree
2849 do {
2850 var handle = jQuery._data( cur, "handle" );
2851
2852 event.currentTarget = cur;
2853 if ( handle ) {
2854 handle.apply( cur, data );
2855 }
2856
2857 // Trigger an inline bound script
2858 if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
2859 event.result = false;
2860 event.preventDefault();
2861 }
2862
2863 // Bubble up to document, then to window
2864 cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
2865 } while ( cur && !event.isPropagationStopped() );
2866
2867 // If nobody prevented the default action, do it now
2868 if ( !event.isDefaultPrevented() ) {
2869 var old,
2870 special = jQuery.event.special[ type ] || {};
2871
2872 if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
2873 !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
2874
2875 // Call a native DOM method on the target with the same name name as the event.
2876 // Can't use an .isFunction)() check here because IE6/7 fails that test.
2877 // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
2878 try {
2879 if ( ontype && elem[ type ] ) {
2880 // Don't re-trigger an onFOO event when we call its FOO() method
2881 old = elem[ ontype ];
2882
2883 if ( old ) {
2884 elem[ ontype ] = null;
2885 }
2886
2887 jQuery.event.triggered = type;
2888 elem[ type ]();
2889 }
2890 } catch ( ieError ) {}
2891
2892 if ( old ) {
2893 elem[ ontype ] = old;
2894 }
2895
2896 jQuery.event.triggered = undefined;
2897 }
2898 }
2899
2900 return event.result;
2901 },
2902
2903 handle: function( event ) {
2904 event = jQuery.event.fix( event || window.event );
2905 // Snapshot the handlers list since a called handler may add/remove events.
2906 var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
2907 run_all = !event.exclusive && !event.namespace,
2908 args = Array.prototype.slice.call( arguments, 0 );
2909
2910 // Use the fix-ed Event rather than the (read-only) native event
2911 args[0] = event;
2912 event.currentTarget = this;
2913
2914 for ( var j = 0, l = handlers.length; j < l; j++ ) {
2915 var handleObj = handlers[ j ];
2916
2917 // Triggered event must 1) be non-exclusive and have no namespace, or
2918 // 2) have namespace(s) a subset or equal to those in the bound event.
2919 if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
2920 // Pass in a reference to the handler function itself
2921 // So that we can later remove it
2922 event.handler = handleObj.handler;
2923 event.data = handleObj.data;
2924 event.handleObj = handleObj;
2925
2926 var ret = handleObj.handler.apply( this, args );
2927
2928 if ( ret !== undefined ) {
2929 event.result = ret;
2930 if ( ret === false ) {
2931 event.preventDefault();
2932 event.stopPropagation();
2933 }
2934 }
2935
2936 if ( event.isImmediatePropagationStopped() ) {
2937 break;
2938 }
2939 }
2940 }
2941 return event.result;
2942 },
2943
2944 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(" "),
2945
2946 fix: function( event ) {
2947 if ( event[ jQuery.expando ] ) {
2948 return event;
2949 }
2950
2951 // store a copy of the original event object
2952 // and "clone" to set read-only properties
2953 var originalEvent = event;
2954 event = jQuery.Event( originalEvent );
2955
2956 for ( var i = this.props.length, prop; i; ) {
2957 prop = this.props[ --i ];
2958 event[ prop ] = originalEvent[ prop ];
2959 }
2960
2961 // Fix target property, if necessary
2962 if ( !event.target ) {
2963 // Fixes #1925 where srcElement might not be defined either
2964 event.target = event.srcElement || document;
2965 }
2966
2967 // check if target is a textnode (safari)
2968 if ( event.target.nodeType === 3 ) {
2969 event.target = event.target.parentNode;
2970 }
2971
2972 // Add relatedTarget, if necessary
2973 if ( !event.relatedTarget && event.fromElement ) {
2974 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
2975 }
2976
2977 // Calculate pageX/Y if missing and clientX/Y available
2978 if ( event.pageX == null && event.clientX != null ) {
2979 var eventDocument = event.target.ownerDocument || document,
2980 doc = eventDocument.documentElement,
2981 body = eventDocument.body;
2982
2983 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
2984 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
2985 }
2986
2987 // Add which for key events
2988 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
2989 event.which = event.charCode != null ? event.charCode : event.keyCode;
2990 }
2991
2992 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2993 if ( !event.metaKey && event.ctrlKey ) {
2994 event.metaKey = event.ctrlKey;
2995 }
2996
2997 // Add which for click: 1 === left; 2 === middle; 3 === right
2998 // Note: button is not normalized, so don't use it
2999 if ( !event.which && event.button !== undefined ) {
3000 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
3001 }
3002
3003 return event;
3004 },
3005
3006 // Deprecated, use jQuery.guid instead
3007 guid: 1E8,
3008
3009 // Deprecated, use jQuery.proxy instead
3010 proxy: jQuery.proxy,
3011
3012 special: {
3013 ready: {
3014 // Make sure the ready event is setup
3015 setup: jQuery.bindReady,
3016 teardown: jQuery.noop
3017 },
3018
3019 live: {
3020 add: function( handleObj ) {
3021 jQuery.event.add( this,
3022 liveConvert( handleObj.origType, handleObj.selector ),
3023 jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
3024 },
3025
3026 remove: function( handleObj ) {
3027 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
3028 }
3029 },
3030
3031 beforeunload: {
3032 setup: function( data, namespaces, eventHandle ) {
3033 // We only want to do this special case on windows
3034 if ( jQuery.isWindow( this ) ) {
3035 this.onbeforeunload = eventHandle;
3036 }
3037 },
3038
3039 teardown: function( namespaces, eventHandle ) {
3040 if ( this.onbeforeunload === eventHandle ) {
3041 this.onbeforeunload = null;
3042 }
3043 }
3044 }
3045 }
3046 };
3047
3048 jQuery.removeEvent = document.removeEventListener ?
3049 function( elem, type, handle ) {
3050 if ( elem.removeEventListener ) {
3051 elem.removeEventListener( type, handle, false );
3052 }
3053 } :
3054 function( elem, type, handle ) {
3055 if ( elem.detachEvent ) {
3056 elem.detachEvent( "on" + type, handle );
3057 }
3058 };
3059
3060 jQuery.Event = function( src, props ) {
3061 // Allow instantiation without the 'new' keyword
3062 if ( !this.preventDefault ) {
3063 return new jQuery.Event( src, props );
3064 }
3065
3066 // Event object
3067 if ( src && src.type ) {
3068 this.originalEvent = src;
3069 this.type = src.type;
3070
3071 // Events bubbling up the document may have been marked as prevented
3072 // by a handler lower down the tree; reflect the correct value.
3073 this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
3074 src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
3075
3076 // Event type
3077 } else {
3078 this.type = src;
3079 }
3080
3081 // Put explicitly provided properties onto the event object
3082 if ( props ) {
3083 jQuery.extend( this, props );
3084 }
3085
3086 // timeStamp is buggy for some events on Firefox(#3843)
3087 // So we won't rely on the native value
3088 this.timeStamp = jQuery.now();
3089
3090 // Mark it as fixed
3091 this[ jQuery.expando ] = true;
3092 };
3093
3094 function returnFalse() {
3095 return false;
3096 }
3097 function returnTrue() {
3098 return true;
3099 }
3100
3101 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
3102 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
3103 jQuery.Event.prototype = {
3104 preventDefault: function() {
3105 this.isDefaultPrevented = returnTrue;
3106
3107 var e = this.originalEvent;
3108 if ( !e ) {
3109 return;
3110 }
3111
3112 // if preventDefault exists run it on the original event
3113 if ( e.preventDefault ) {
3114 e.preventDefault();
3115
3116 // otherwise set the returnValue property of the original event to false (IE)
3117 } else {
3118 e.returnValue = false;
3119 }
3120 },
3121 stopPropagation: function() {
3122 this.isPropagationStopped = returnTrue;
3123
3124 var e = this.originalEvent;
3125 if ( !e ) {
3126 return;
3127 }
3128 // if stopPropagation exists run it on the original event
3129 if ( e.stopPropagation ) {
3130 e.stopPropagation();
3131 }
3132 // otherwise set the cancelBubble property of the original event to true (IE)
3133 e.cancelBubble = true;
3134 },
3135 stopImmediatePropagation: function() {
3136 this.isImmediatePropagationStopped = returnTrue;
3137 this.stopPropagation();
3138 },
3139 isDefaultPrevented: returnFalse,
3140 isPropagationStopped: returnFalse,
3141 isImmediatePropagationStopped: returnFalse
3142 };
3143
3144 // Checks if an event happened on an element within another element
3145 // Used in jQuery.event.special.mouseenter and mouseleave handlers
3146 var withinElement = function( event ) {
3147 // Check if mouse(over|out) are still within the same parent element
3148 var parent = event.relatedTarget;
3149
3150 // set the correct event type
3151 event.type = event.data;
3152
3153 // Firefox sometimes assigns relatedTarget a XUL element
3154 // which we cannot access the parentNode property of
3155 try {
3156
3157 // Chrome does something similar, the parentNode property
3158 // can be accessed but is null.
3159 if ( parent && parent !== document && !parent.parentNode ) {
3160 return;
3161 }
3162
3163 // Traverse up the tree
3164 while ( parent && parent !== this ) {
3165 parent = parent.parentNode;
3166 }
3167
3168 if ( parent !== this ) {
3169 // handle event if we actually just moused on to a non sub-element
3170 jQuery.event.handle.apply( this, arguments );
3171 }
3172
3173 // assuming we've left the element since we most likely mousedover a xul element
3174 } catch(e) { }
3175 },
3176
3177 // In case of event delegation, we only need to rename the event.type,
3178 // liveHandler will take care of the rest.
3179 delegate = function( event ) {
3180 event.type = event.data;
3181 jQuery.event.handle.apply( this, arguments );
3182 };
3183
3184 // Create mouseenter and mouseleave events
3185 jQuery.each({
3186 mouseenter: "mouseover",
3187 mouseleave: "mouseout"
3188 }, function( orig, fix ) {
3189 jQuery.event.special[ orig ] = {
3190 setup: function( data ) {
3191 jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
3192 },
3193 teardown: function( data ) {
3194 jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
3195 }
3196 };
3197 });
3198
3199 // submit delegation
3200 if ( !jQuery.support.submitBubbles ) {
3201
3202 jQuery.event.special.submit = {
3203 setup: function( data, namespaces ) {
3204 if ( !jQuery.nodeName( this, "form" ) ) {
3205 jQuery.event.add(this, "click.specialSubmit", function( e ) {
3206 var elem = e.target,
3207 type = elem.type;
3208
3209 if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
3210 trigger( "submit", this, arguments );
3211 }
3212 });
3213
3214 jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
3215 var elem = e.target,
3216 type = elem.type;
3217
3218 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
3219 trigger( "submit", this, arguments );
3220 }
3221 });
3222
3223 } else {
3224 return false;
3225 }
3226 },
3227
3228 teardown: function( namespaces ) {
3229 jQuery.event.remove( this, ".specialSubmit" );
3230 }
3231 };
3232
3233 }
3234
3235 // change delegation, happens here so we have bind.
3236 if ( !jQuery.support.changeBubbles ) {
3237
3238 var changeFilters,
3239
3240 getVal = function( elem ) {
3241 var type = elem.type, val = elem.value;
3242
3243 if ( type === "radio" || type === "checkbox" ) {
3244 val = elem.checked;
3245
3246 } else if ( type === "select-multiple" ) {
3247 val = elem.selectedIndex > -1 ?
3248 jQuery.map( elem.options, function( elem ) {
3249 return elem.selected;
3250 }).join("-") :
3251 "";
3252
3253 } else if ( jQuery.nodeName( elem, "select" ) ) {
3254 val = elem.selectedIndex;
3255 }
3256
3257 return val;
3258 },
3259
3260 testChange = function testChange( e ) {
3261 var elem = e.target, data, val;
3262
3263 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
3264 return;
3265 }
3266
3267 data = jQuery._data( elem, "_change_data" );
3268 val = getVal(elem);
3269
3270 // the current data will be also retrieved by beforeactivate
3271 if ( e.type !== "focusout" || elem.type !== "radio" ) {
3272 jQuery._data( elem, "_change_data", val );
3273 }
3274
3275 if ( data === undefined || val === data ) {
3276 return;
3277 }
3278
3279 if ( data != null || val ) {
3280 e.type = "change";
3281 e.liveFired = undefined;
3282 jQuery.event.trigger( e, arguments[1], elem );
3283 }
3284 };
3285
3286 jQuery.event.special.change = {
3287 filters: {
3288 focusout: testChange,
3289
3290 beforedeactivate: testChange,
3291
3292 click: function( e ) {
3293 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3294
3295 if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
3296 testChange.call( this, e );
3297 }
3298 },
3299
3300 // Change has to be called before submit
3301 // Keydown will be called before keypress, which is used in submit-event delegation
3302 keydown: function( e ) {
3303 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
3304
3305 if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
3306 (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
3307 type === "select-multiple" ) {
3308 testChange.call( this, e );
3309 }
3310 },
3311
3312 // Beforeactivate happens also before the previous element is blurred
3313 // with this event you can't trigger a change event, but you can store
3314 // information
3315 beforeactivate: function( e ) {
3316 var elem = e.target;
3317 jQuery._data( elem, "_change_data", getVal(elem) );
3318 }
3319 },
3320
3321 setup: function( data, namespaces ) {
3322 if ( this.type === "file" ) {
3323 return false;
3324 }
3325
3326 for ( var type in changeFilters ) {
3327 jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
3328 }
3329
3330 return rformElems.test( this.nodeName );
3331 },
3332
3333 teardown: function( namespaces ) {
3334 jQuery.event.remove( this, ".specialChange" );
3335
3336 return rformElems.test( this.nodeName );
3337 }
3338 };
3339
3340 changeFilters = jQuery.event.special.change.filters;
3341
3342 // Handle when the input is .focus()'d
3343 changeFilters.focus = changeFilters.beforeactivate;
3344 }
3345
3346 function trigger( type, elem, args ) {
3347 // Piggyback on a donor event to simulate a different one.
3348 // Fake originalEvent to avoid donor's stopPropagation, but if the
3349 // simulated event prevents default then we do the same on the donor.
3350 // Don't pass args or remember liveFired; they apply to the donor event.
3351 var event = jQuery.extend( {}, args[ 0 ] );
3352 event.type = type;
3353 event.originalEvent = {};
3354 event.liveFired = undefined;
3355 jQuery.event.handle.call( elem, event );
3356 if ( event.isDefaultPrevented() ) {
3357 args[ 0 ].preventDefault();
3358 }
3359 }
3360
3361 // Create "bubbling" focus and blur events
3362 if ( !jQuery.support.focusinBubbles ) {
3363 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
3364
3365 // Attach a single capturing handler while someone wants focusin/focusout
3366 var attaches = 0;
3367
3368 jQuery.event.special[ fix ] = {
3369 setup: function() {
3370 if ( attaches++ === 0 ) {
3371 document.addEventListener( orig, handler, true );
3372 }
3373 },
3374 teardown: function() {
3375 if ( --attaches === 0 ) {
3376 document.removeEventListener( orig, handler, true );
3377 }
3378 }
3379 };
3380
3381 function handler( donor ) {
3382 // Donor event is always a native one; fix it and switch its type.
3383 // Let focusin/out handler cancel the donor focus/blur event.
3384 var e = jQuery.event.fix( donor );
3385 e.type = fix;
3386 e.originalEvent = {};
3387 jQuery.event.trigger( e, null, e.target );
3388 if ( e.isDefaultPrevented() ) {
3389 donor.preventDefault();
3390 }
3391 }
3392 });
3393 }
3394
3395 jQuery.each(["bind", "one"], function( i, name ) {
3396 jQuery.fn[ name ] = function( type, data, fn ) {
3397 var handler;
3398
3399 // Handle object literals
3400 if ( typeof type === "object" ) {
3401 for ( var key in type ) {
3402 this[ name ](key, data, type[key], fn);
3403 }
3404 return this;
3405 }
3406
3407 if ( arguments.length === 2 || data === false ) {
3408 fn = data;
3409 data = undefined;
3410 }
3411
3412 if ( name === "one" ) {
3413 handler = function( event ) {
3414 jQuery( this ).unbind( event, handler );
3415 return fn.apply( this, arguments );
3416 };
3417 handler.guid = fn.guid || jQuery.guid++;
3418 } else {
3419 handler = fn;
3420 }
3421
3422 if ( type === "unload" && name !== "one" ) {
3423 this.one( type, data, fn );
3424
3425 } else {
3426 for ( var i = 0, l = this.length; i < l; i++ ) {
3427 jQuery.event.add( this[i], type, handler, data );
3428 }
3429 }
3430
3431 return this;
3432 };
3433 });
3434
3435 jQuery.fn.extend({
3436 unbind: function( type, fn ) {
3437 // Handle object literals
3438 if ( typeof type === "object" && !type.preventDefault ) {
3439 for ( var key in type ) {
3440 this.unbind(key, type[key]);
3441 }
3442
3443 } else {
3444 for ( var i = 0, l = this.length; i < l; i++ ) {
3445 jQuery.event.remove( this[i], type, fn );
3446 }
3447 }
3448
3449 return this;
3450 },
3451
3452 delegate: function( selector, types, data, fn ) {
3453 return this.live( types, data, fn, selector );
3454 },
3455
3456 undelegate: function( selector, types, fn ) {
3457 if ( arguments.length === 0 ) {
3458 return this.unbind( "live" );
3459
3460 } else {
3461 return this.die( types, null, fn, selector );
3462 }
3463 },
3464
3465 trigger: function( type, data ) {
3466 return this.each(function() {
3467 jQuery.event.trigger( type, data, this );
3468 });
3469 },
3470
3471 triggerHandler: function( type, data ) {
3472 if ( this[0] ) {
3473 return jQuery.event.trigger( type, data, this[0], true );
3474 }
3475 },
3476
3477 toggle: function( fn ) {
3478 // Save reference to arguments for access in closure
3479 var args = arguments,
3480 guid = fn.guid || jQuery.guid++,
3481 i = 0,
3482 toggler = function( event ) {
3483 // Figure out which function to execute
3484 var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3485 jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3486
3487 // Make sure that clicks stop
3488 event.preventDefault();
3489
3490 // and execute the function
3491 return args[ lastToggle ].apply( this, arguments ) || false;
3492 };
3493
3494 // link all the functions, so any of them can unbind this click handler
3495 toggler.guid = guid;
3496 while ( i < args.length ) {
3497 args[ i++ ].guid = guid;
3498 }
3499
3500 return this.click( toggler );
3501 },
3502
3503 hover: function( fnOver, fnOut ) {
3504 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
3505 }
3506 });
3507
3508 var liveMap = {
3509 focus: "focusin",
3510 blur: "focusout",
3511 mouseenter: "mouseover",
3512 mouseleave: "mouseout"
3513 };
3514
3515 jQuery.each(["live", "die"], function( i, name ) {
3516 jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
3517 var type, i = 0, match, namespaces, preType,
3518 selector = origSelector || this.selector,
3519 context = origSelector ? this : jQuery( this.context );
3520
3521 if ( typeof types === "object" && !types.preventDefault ) {
3522 for ( var key in types ) {
3523 context[ name ]( key, data, types[key], selector );
3524 }
3525
3526 return this;
3527 }
3528
3529 if ( name === "die" && !types &&
3530 origSelector && origSelector.charAt(0) === "." ) {
3531
3532 context.unbind( origSelector );
3533
3534 return this;
3535 }
3536
3537 if ( data === false || jQuery.isFunction( data ) ) {
3538 fn = data || returnFalse;
3539 data = undefined;
3540 }
3541
3542 types = (types || "").split(" ");
3543
3544 while ( (type = types[ i++ ]) != null ) {
3545 match = rnamespaces.exec( type );
3546 namespaces = "";
3547
3548 if ( match ) {
3549 namespaces = match[0];
3550 type = type.replace( rnamespaces, "" );
3551 }
3552
3553 if ( type === "hover" ) {
3554 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
3555 continue;
3556 }
3557
3558 preType = type;
3559
3560 if ( liveMap[ type ] ) {
3561 types.push( liveMap[ type ] + namespaces );
3562 type = type + namespaces;
3563
3564 } else {
3565 type = (liveMap[ type ] || type) + namespaces;
3566 }
3567
3568 if ( name === "live" ) {
3569 // bind live handler
3570 for ( var j = 0, l = context.length; j < l; j++ ) {
3571 jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
3572 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
3573 }
3574
3575 } else {
3576 // unbind live handler
3577 context.unbind( "live." + liveConvert( type, selector ), fn );
3578 }
3579 }
3580
3581 return this;
3582 };
3583 });
3584
3585 function liveHandler( event ) {
3586 var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
3587 elems = [],
3588 selectors = [],
3589 events = jQuery._data( this, "events" );
3590
3591 // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
3592 if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
3593 return;
3594 }
3595
3596 if ( event.namespace ) {
3597 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
3598 }
3599
3600 event.liveFired = this;
3601
3602 var live = events.live.slice(0);
3603
3604 for ( j = 0; j < live.length; j++ ) {
3605 handleObj = live[j];
3606
3607 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
3608 selectors.push( handleObj.selector );
3609
3610 } else {
3611 live.splice( j--, 1 );
3612 }
3613 }
3614
3615 match = jQuery( event.target ).closest( selectors, event.currentTarget );
3616
3617 for ( i = 0, l = match.length; i < l; i++ ) {
3618 close = match[i];
3619
3620 for ( j = 0; j < live.length; j++ ) {
3621 handleObj = live[j];
3622
3623 if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
3624 elem = close.elem;
3625 related = null;
3626
3627 // Those two events require additional checking
3628 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
3629 event.type = handleObj.preType;
3630 related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
3631
3632 // Make sure not to accidentally match a child element with the same selector
3633 if ( related && jQuery.contains( elem, related ) ) {
3634 related = elem;
3635 }
3636 }
3637
3638 if ( !related || related !== elem ) {
3639 elems.push({ elem: elem, handleObj: handleObj, level: close.level });
3640 }
3641 }
3642 }
3643 }
3644
3645 for ( i = 0, l = elems.length; i < l; i++ ) {
3646 match = elems[i];
3647
3648 if ( maxLevel && match.level > maxLevel ) {
3649 break;
3650 }
3651
3652 event.currentTarget = match.elem;
3653 event.data = match.handleObj.data;
3654 event.handleObj = match.handleObj;
3655
3656 ret = match.handleObj.origHandler.apply( match.elem, arguments );
3657
3658 if ( ret === false || event.isPropagationStopped() ) {
3659 maxLevel = match.level;
3660
3661 if ( ret === false ) {
3662 stop = false;
3663 }
3664 if ( event.isImmediatePropagationStopped() ) {
3665 break;
3666 }
3667 }
3668 }
3669
3670 return stop;
3671 }
3672
3673 function liveConvert( type, selector ) {
3674 return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
3675 }
3676
3677 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3678 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3679 "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
3680
3681 // Handle event binding
3682 jQuery.fn[ name ] = function( data, fn ) {
3683 if ( fn == null ) {
3684 fn = data;
3685 data = null;
3686 }
3687
3688 return arguments.length > 0 ?
3689 this.bind( name, data, fn ) :
3690 this.trigger( name );
3691 };
3692
3693 if ( jQuery.attrFn ) {
3694 jQuery.attrFn[ name ] = true;
3695 }
3696 });
3697
3698
3699
3700 /*!
3701 * Sizzle CSS Selector Engine
3702 * Copyright 2011, The Dojo Foundation
3703 * Released under the MIT, BSD, and GPL Licenses.
3704 * More information: http://sizzlejs.com/
3705 */
3706 (function(){
3707
3708 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3709 done = 0,
3710 toString = Object.prototype.toString,
3711 hasDuplicate = false,
3712 baseHasDuplicate = true,
3713 rBackslash = /\\/g,
3714 rNonWord = /\W/;
3715
3716 // Here we check if the JavaScript engine is using some sort of
3717 // optimization where it does not always call our comparision
3718 // function. If that is the case, discard the hasDuplicate value.
3719 // Thus far that includes Google Chrome.
3720 [0, 0].sort(function() {
3721 baseHasDuplicate = false;
3722 return 0;
3723 });
3724
3725 var Sizzle = function( selector, context, results, seed ) {
3726 results = results || [];
3727 context = context || document;
3728
3729 var origContext = context;
3730
3731 if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3732 return [];
3733 }
3734
3735 if ( !selector || typeof selector !== "string" ) {
3736 return results;
3737 }
3738
3739 var m, set, checkSet, extra, ret, cur, pop, i,
3740 prune = true,
3741 contextXML = Sizzle.isXML( context ),
3742 parts = [],
3743 soFar = selector;
3744
3745 // Reset the position of the chunker regexp (start from head)
3746 do {
3747 chunker.exec( "" );
3748 m = chunker.exec( soFar );
3749
3750 if ( m ) {
3751 soFar = m[3];
3752
3753 parts.push( m[1] );
3754
3755 if ( m[2] ) {
3756 extra = m[3];
3757 break;
3758 }
3759 }
3760 } while ( m );
3761
3762 if ( parts.length > 1 && origPOS.exec( selector ) ) {
3763
3764 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3765 set = posProcess( parts[0] + parts[1], context );
3766
3767 } else {
3768 set = Expr.relative[ parts[0] ] ?
3769 [ context ] :
3770 Sizzle( parts.shift(), context );
3771
3772 while ( parts.length ) {
3773 selector = parts.shift();
3774
3775 if ( Expr.relative[ selector ] ) {
3776 selector += parts.shift();
3777 }
3778
3779 set = posProcess( selector, set );
3780 }
3781 }
3782
3783 } else {
3784 // Take a shortcut and set the context if the root selector is an ID
3785 // (but not if it'll be faster if the inner selector is an ID)
3786 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3787 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3788
3789 ret = Sizzle.find( parts.shift(), context, contextXML );
3790 context = ret.expr ?
3791 Sizzle.filter( ret.expr, ret.set )[0] :
3792 ret.set[0];
3793 }
3794
3795 if ( context ) {
3796 ret = seed ?
3797 { expr: parts.pop(), set: makeArray(seed) } :
3798 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3799
3800 set = ret.expr ?
3801 Sizzle.filter( ret.expr, ret.set ) :
3802 ret.set;
3803
3804 if ( parts.length > 0 ) {
3805 checkSet = makeArray( set );
3806
3807 } else {
3808 prune = false;
3809 }
3810
3811 while ( parts.length ) {
3812 cur = parts.pop();
3813 pop = cur;
3814
3815 if ( !Expr.relative[ cur ] ) {
3816 cur = "";
3817 } else {
3818 pop = parts.pop();
3819 }
3820
3821 if ( pop == null ) {
3822 pop = context;
3823 }
3824
3825 Expr.relative[ cur ]( checkSet, pop, contextXML );
3826 }
3827
3828 } else {
3829 checkSet = parts = [];
3830 }
3831 }
3832
3833 if ( !checkSet ) {
3834 checkSet = set;
3835 }
3836
3837 if ( !checkSet ) {
3838 Sizzle.error( cur || selector );
3839 }
3840
3841 if ( toString.call(checkSet) === "[object Array]" ) {
3842 if ( !prune ) {
3843 results.push.apply( results, checkSet );
3844
3845 } else if ( context && context.nodeType === 1 ) {
3846 for ( i = 0; checkSet[i] != null; i++ ) {
3847 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
3848 results.push( set[i] );
3849 }
3850 }
3851
3852 } else {
3853 for ( i = 0; checkSet[i] != null; i++ ) {
3854 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
3855 results.push( set[i] );
3856 }
3857 }
3858 }
3859
3860 } else {
3861 makeArray( checkSet, results );
3862 }
3863
3864 if ( extra ) {
3865 Sizzle( extra, origContext, results, seed );
3866 Sizzle.uniqueSort( results );
3867 }
3868
3869 return results;
3870 };
3871
3872 Sizzle.uniqueSort = function( results ) {
3873 if ( sortOrder ) {
3874 hasDuplicate = baseHasDuplicate;
3875 results.sort( sortOrder );
3876
3877 if ( hasDuplicate ) {
3878 for ( var i = 1; i < results.length; i++ ) {
3879 if ( results[i] === results[ i - 1 ] ) {
3880 results.splice( i--, 1 );
3881 }
3882 }
3883 }
3884 }
3885
3886 return results;
3887 };
3888
3889 Sizzle.matches = function( expr, set ) {
3890 return Sizzle( expr, null, null, set );
3891 };
3892
3893 Sizzle.matchesSelector = function( node, expr ) {
3894 return Sizzle( expr, null, null, [node] ).length > 0;
3895 };
3896
3897 Sizzle.find = function( expr, context, isXML ) {
3898 var set;
3899
3900 if ( !expr ) {
3901 return [];
3902 }
3903
3904 for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
3905 var match,
3906 type = Expr.order[i];
3907
3908 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
3909 var left = match[1];
3910 match.splice( 1, 1 );
3911
3912 if ( left.substr( left.length - 1 ) !== "\\" ) {
3913 match[1] = (match[1] || "").replace( rBackslash, "" );
3914 set = Expr.find[ type ]( match, context, isXML );
3915
3916 if ( set != null ) {
3917 expr = expr.replace( Expr.match[ type ], "" );
3918 break;
3919 }
3920 }
3921 }
3922 }
3923
3924 if ( !set ) {
3925 set = typeof context.getElementsByTagName !== "undefined" ?
3926 context.getElementsByTagName( "*" ) :
3927 [];
3928 }
3929
3930 return { set: set, expr: expr };
3931 };
3932
3933 Sizzle.filter = function( expr, set, inplace, not ) {
3934 var match, anyFound,
3935 old = expr,
3936 result = [],
3937 curLoop = set,
3938 isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
3939
3940 while ( expr && set.length ) {
3941 for ( var type in Expr.filter ) {
3942 if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
3943 var found, item,
3944 filter = Expr.filter[ type ],
3945 left = match[1];
3946
3947 anyFound = false;
3948
3949 match.splice(1,1);
3950
3951 if ( left.substr( left.length - 1 ) === "\\" ) {
3952 continue;
3953 }
3954
3955 if ( curLoop === result ) {
3956 result = [];
3957 }
3958
3959 if ( Expr.preFilter[ type ] ) {
3960 match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
3961
3962 if ( !match ) {
3963 anyFound = found = true;
3964
3965 } else if ( match === true ) {
3966 continue;
3967 }
3968 }
3969
3970 if ( match ) {
3971 for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
3972 if ( item ) {
3973 found = filter( item, match, i, curLoop );
3974 var pass = not ^ !!found;
3975
3976 if ( inplace && found != null ) {
3977 if ( pass ) {
3978 anyFound = true;
3979
3980 } else {
3981 curLoop[i] = false;
3982 }
3983
3984 } else if ( pass ) {
3985 result.push( item );
3986 anyFound = true;
3987 }
3988 }
3989 }
3990 }
3991
3992 if ( found !== undefined ) {
3993 if ( !inplace ) {
3994 curLoop = result;
3995 }
3996
3997 expr = expr.replace( Expr.match[ type ], "" );
3998
3999 if ( !anyFound ) {
4000 return [];
4001 }
4002
4003 break;
4004 }
4005 }
4006 }
4007
4008 // Improper expression
4009 if ( expr === old ) {
4010 if ( anyFound == null ) {
4011 Sizzle.error( expr );
4012
4013 } else {
4014 break;
4015 }
4016 }
4017
4018 old = expr;
4019 }
4020
4021 return curLoop;
4022 };
4023
4024 Sizzle.error = function( msg ) {
4025 throw "Syntax error, unrecognized expression: " + msg;
4026 };
4027
4028 var Expr = Sizzle.selectors = {
4029 order: [ "ID", "NAME", "TAG" ],
4030
4031 match: {
4032 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4033 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
4034 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
4035 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
4036 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
4037 CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
4038 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
4039 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
4040 },
4041
4042 leftMatch: {},
4043
4044 attrMap: {
4045 "class": "className",
4046 "for": "htmlFor"
4047 },
4048
4049 attrHandle: {
4050 href: function( elem ) {
4051 return elem.getAttribute( "href" );
4052 },
4053 type: function( elem ) {
4054 return elem.getAttribute( "type" );
4055 }
4056 },
4057
4058 relative: {
4059 "+": function(checkSet, part){
4060 var isPartStr = typeof part === "string",
4061 isTag = isPartStr && !rNonWord.test( part ),
4062 isPartStrNotTag = isPartStr && !isTag;
4063
4064 if ( isTag ) {
4065 part = part.toLowerCase();
4066 }
4067
4068 for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
4069 if ( (elem = checkSet[i]) ) {
4070 while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
4071
4072 checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
4073 elem || false :
4074 elem === part;
4075 }
4076 }
4077
4078 if ( isPartStrNotTag ) {
4079 Sizzle.filter( part, checkSet, true );
4080 }
4081 },
4082
4083 ">": function( checkSet, part ) {
4084 var elem,
4085 isPartStr = typeof part === "string",
4086 i = 0,
4087 l = checkSet.length;
4088
4089 if ( isPartStr && !rNonWord.test( part ) ) {
4090 part = part.toLowerCase();
4091
4092 for ( ; i < l; i++ ) {
4093 elem = checkSet[i];
4094
4095 if ( elem ) {
4096 var parent = elem.parentNode;
4097 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
4098 }
4099 }
4100
4101 } else {
4102 for ( ; i < l; i++ ) {
4103 elem = checkSet[i];
4104
4105 if ( elem ) {
4106 checkSet[i] = isPartStr ?
4107 elem.parentNode :
4108 elem.parentNode === part;
4109 }
4110 }
4111
4112 if ( isPartStr ) {
4113 Sizzle.filter( part, checkSet, true );
4114 }
4115 }
4116 },
4117
4118 "": function(checkSet, part, isXML){
4119 var nodeCheck,
4120 doneName = done++,
4121 checkFn = dirCheck;
4122
4123 if ( typeof part === "string" && !rNonWord.test( part ) ) {
4124 part = part.toLowerCase();
4125 nodeCheck = part;
4126 checkFn = dirNodeCheck;
4127 }
4128
4129 checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
4130 },
4131
4132 "~": function( checkSet, part, isXML ) {
4133 var nodeCheck,
4134 doneName = done++,
4135 checkFn = dirCheck;
4136
4137 if ( typeof part === "string" && !rNonWord.test( part ) ) {
4138 part = part.toLowerCase();
4139 nodeCheck = part;
4140 checkFn = dirNodeCheck;
4141 }
4142
4143 checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
4144 }
4145 },
4146
4147 find: {
4148 ID: function( match, context, isXML ) {
4149 if ( typeof context.getElementById !== "undefined" && !isXML ) {
4150 var m = context.getElementById(match[1]);
4151 // Check parentNode to catch when Blackberry 4.6 returns
4152 // nodes that are no longer in the document #6963
4153 return m && m.parentNode ? [m] : [];
4154 }
4155 },
4156
4157 NAME: function( match, context ) {
4158 if ( typeof context.getElementsByName !== "undefined" ) {
4159 var ret = [],
4160 results = context.getElementsByName( match[1] );
4161
4162 for ( var i = 0, l = results.length; i < l; i++ ) {
4163 if ( results[i].getAttribute("name") === match[1] ) {
4164 ret.push( results[i] );
4165 }
4166 }
4167
4168 return ret.length === 0 ? null : ret;
4169 }
4170 },
4171
4172 TAG: function( match, context ) {
4173 if ( typeof context.getElementsByTagName !== "undefined" ) {
4174 return context.getElementsByTagName( match[1] );
4175 }
4176 }
4177 },
4178 preFilter: {
4179 CLASS: function( match, curLoop, inplace, result, not, isXML ) {
4180 match = " " + match[1].replace( rBackslash, "" ) + " ";
4181
4182 if ( isXML ) {
4183 return match;
4184 }
4185
4186 for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
4187 if ( elem ) {
4188 if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
4189 if ( !inplace ) {
4190 result.push( elem );
4191 }
4192
4193 } else if ( inplace ) {
4194 curLoop[i] = false;
4195 }
4196 }
4197 }
4198
4199 return false;
4200 },
4201
4202 ID: function( match ) {
4203 return match[1].replace( rBackslash, "" );
4204 },
4205
4206 TAG: function( match, curLoop ) {
4207 return match[1].replace( rBackslash, "" ).toLowerCase();
4208 },
4209
4210 CHILD: function( match ) {
4211 if ( match[1] === "nth" ) {
4212 if ( !match[2] ) {
4213 Sizzle.error( match[0] );
4214 }
4215
4216 match[2] = match[2].replace(/^\+|\s*/g, '');
4217
4218 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
4219 var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
4220 match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
4221 !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
4222
4223 // calculate the numbers (first)n+(last) including if they are negative
4224 match[2] = (test[1] + (test[2] || 1)) - 0;
4225 match[3] = test[3] - 0;
4226 }
4227 else if ( match[2] ) {
4228 Sizzle.error( match[0] );
4229 }
4230
4231 // TODO: Move to normal caching system
4232 match[0] = done++;
4233
4234 return match;
4235 },
4236
4237 ATTR: function( match, curLoop, inplace, result, not, isXML ) {
4238 var name = match[1] = match[1].replace( rBackslash, "" );
4239
4240 if ( !isXML && Expr.attrMap[name] ) {
4241 match[1] = Expr.attrMap[name];
4242 }
4243
4244 // Handle if an un-quoted value was used
4245 match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
4246
4247 if ( match[2] === "~=" ) {
4248 match[4] = " " + match[4] + " ";
4249 }
4250
4251 return match;
4252 },
4253
4254 PSEUDO: function( match, curLoop, inplace, result, not ) {
4255 if ( match[1] === "not" ) {
4256 // If we're dealing with a complex expression, or a simple one
4257 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
4258 match[3] = Sizzle(match[3], null, null, curLoop);
4259
4260 } else {
4261 var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
4262
4263 if ( !inplace ) {
4264 result.push.apply( result, ret );
4265 }
4266
4267 return false;
4268 }
4269
4270 } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
4271 return true;
4272 }
4273
4274 return match;
4275 },
4276
4277 POS: function( match ) {
4278 match.unshift( true );
4279
4280 return match;
4281 }
4282 },
4283
4284 filters: {
4285 enabled: function( elem ) {
4286 return elem.disabled === false && elem.type !== "hidden";
4287 },
4288
4289 disabled: function( elem ) {
4290 return elem.disabled === true;
4291 },
4292
4293 checked: function( elem ) {
4294 return elem.checked === true;
4295 },
4296
4297 selected: function( elem ) {
4298 // Accessing this property makes selected-by-default
4299 // options in Safari work properly
4300 if ( elem.parentNode ) {
4301 elem.parentNode.selectedIndex;
4302 }
4303
4304 return elem.selected === true;
4305 },
4306
4307 parent: function( elem ) {
4308 return !!elem.firstChild;
4309 },
4310
4311 empty: function( elem ) {
4312 return !elem.firstChild;
4313 },
4314
4315 has: function( elem, i, match ) {
4316 return !!Sizzle( match[3], elem ).length;
4317 },
4318
4319 header: function( elem ) {
4320 return (/h\d/i).test( elem.nodeName );
4321 },
4322
4323 text: function( elem ) {
4324 var attr = elem.getAttribute( "type" ), type = elem.type;
4325 // IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
4326 // use getAttribute instead to test this case
4327 return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
4328 },
4329
4330 radio: function( elem ) {
4331 return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
4332 },
4333
4334 checkbox: function( elem ) {
4335 return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
4336 },
4337
4338 file: function( elem ) {
4339 return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
4340 },
4341
4342 password: function( elem ) {
4343 return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
4344 },
4345
4346 submit: function( elem ) {
4347 var name = elem.nodeName.toLowerCase();
4348 return (name === "input" || name === "button") && "submit" === elem.type;
4349 },
4350
4351 image: function( elem ) {
4352 return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
4353 },
4354
4355 reset: function( elem ) {
4356 var name = elem.nodeName.toLowerCase();
4357 return (name === "input" || name === "button") && "reset" === elem.type;
4358 },
4359
4360 button: function( elem ) {
4361 var name = elem.nodeName.toLowerCase();
4362 return name === "input" && "button" === elem.type || name === "button";
4363 },
4364
4365 input: function( elem ) {
4366 return (/input|select|textarea|button/i).test( elem.nodeName );
4367 },
4368
4369 focus: function( elem ) {
4370 return elem === elem.ownerDocument.activeElement;
4371 }
4372 },
4373 setFilters: {
4374 first: function( elem, i ) {
4375 return i === 0;
4376 },
4377
4378 last: function( elem, i, match, array ) {
4379 return i === array.length - 1;
4380 },
4381
4382 even: function( elem, i ) {
4383 return i % 2 === 0;
4384 },
4385
4386 odd: function( elem, i ) {
4387 return i % 2 === 1;
4388 },
4389
4390 lt: function( elem, i, match ) {
4391 return i < match[3] - 0;
4392 },
4393
4394 gt: function( elem, i, match ) {
4395 return i > match[3] - 0;
4396 },
4397
4398 nth: function( elem, i, match ) {
4399 return match[3] - 0 === i;
4400 },
4401
4402 eq: function( elem, i, match ) {
4403 return match[3] - 0 === i;
4404 }
4405 },
4406 filter: {
4407 PSEUDO: function( elem, match, i, array ) {
4408 var name = match[1],
4409 filter = Expr.filters[ name ];
4410
4411 if ( filter ) {
4412 return filter( elem, i, match, array );
4413
4414 } else if ( name === "contains" ) {
4415 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
4416
4417 } else if ( name === "not" ) {
4418 var not = match[3];
4419
4420 for ( var j = 0, l = not.length; j < l; j++ ) {
4421 if ( not[j] === elem ) {
4422 return false;
4423 }
4424 }
4425
4426 return true;
4427
4428 } else {
4429 Sizzle.error( name );
4430 }
4431 },
4432
4433 CHILD: function( elem, match ) {
4434 var type = match[1],
4435 node = elem;
4436
4437 switch ( type ) {
4438 case "only":
4439 case "first":
4440 while ( (node = node.previousSibling) ) {
4441 if ( node.nodeType === 1 ) {
4442 return false;
4443 }
4444 }
4445
4446 if ( type === "first" ) {
4447 return true;
4448 }
4449
4450 node = elem;
4451
4452 case "last":
4453 while ( (node = node.nextSibling) ) {
4454 if ( node.nodeType === 1 ) {
4455 return false;
4456 }
4457 }
4458
4459 return true;
4460
4461 case "nth":
4462 var first = match[2],
4463 last = match[3];
4464
4465 if ( first === 1 && last === 0 ) {
4466 return true;
4467 }
4468
4469 var doneName = match[0],
4470 parent = elem.parentNode;
4471
4472 if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
4473 var count = 0;
4474
4475 for ( node = parent.firstChild; node; node = node.nextSibling ) {
4476 if ( node.nodeType === 1 ) {
4477 node.nodeIndex = ++count;
4478 }
4479 }
4480
4481 parent.sizcache = doneName;
4482 }
4483
4484 var diff = elem.nodeIndex - last;
4485
4486 if ( first === 0 ) {
4487 return diff === 0;
4488
4489 } else {
4490 return ( diff % first === 0 && diff / first >= 0 );
4491 }
4492 }
4493 },
4494
4495 ID: function( elem, match ) {
4496 return elem.nodeType === 1 && elem.getAttribute("id") === match;
4497 },
4498
4499 TAG: function( elem, match ) {
4500 return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
4501 },
4502
4503 CLASS: function( elem, match ) {
4504 return (" " + (elem.className || elem.getAttribute("class")) + " ")
4505 .indexOf( match ) > -1;
4506 },
4507
4508 ATTR: function( elem, match ) {
4509 var name = match[1],
4510 result = Expr.attrHandle[ name ] ?
4511 Expr.attrHandle[ name ]( elem ) :
4512 elem[ name ] != null ?
4513 elem[ name ] :
4514 elem.getAttribute( name ),
4515 value = result + "",
4516 type = match[2],
4517 check = match[4];
4518
4519 return result == null ?
4520 type === "!=" :
4521 type === "=" ?
4522 value === check :
4523 type === "*=" ?
4524 value.indexOf(check) >= 0 :
4525 type === "~=" ?
4526 (" " + value + " ").indexOf(check) >= 0 :
4527 !check ?
4528 value && result !== false :
4529 type === "!=" ?
4530 value !== check :
4531 type === "^=" ?
4532 value.indexOf(check) === 0 :
4533 type === "$=" ?
4534 value.substr(value.length - check.length) === check :
4535 type === "|=" ?
4536 value === check || value.substr(0, check.length + 1) === check + "-" :
4537 false;
4538 },
4539
4540 POS: function( elem, match, i, array ) {
4541 var name = match[2],
4542 filter = Expr.setFilters[ name ];
4543
4544 if ( filter ) {
4545 return filter( elem, i, match, array );
4546 }
4547 }
4548 }
4549 };
4550
4551 var origPOS = Expr.match.POS,
4552 fescape = function(all, num){
4553 return "\\" + (num - 0 + 1);
4554 };
4555
4556 for ( var type in Expr.match ) {
4557 Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
4558 Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
4559 }
4560
4561 var makeArray = function( array, results ) {
4562 array = Array.prototype.slice.call( array, 0 );
4563
4564 if ( results ) {
4565 results.push.apply( results, array );
4566 return results;
4567 }
4568
4569 return array;
4570 };
4571
4572 // Perform a simple check to determine if the browser is capable of
4573 // converting a NodeList to an array using builtin methods.
4574 // Also verifies that the returned array holds DOM nodes
4575 // (which is not the case in the Blackberry browser)
4576 try {
4577 Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
4578
4579 // Provide a fallback method if it does not work
4580 } catch( e ) {
4581 makeArray = function( array, results ) {
4582 var i = 0,
4583 ret = results || [];
4584
4585 if ( toString.call(array) === "[object Array]" ) {
4586 Array.prototype.push.apply( ret, array );
4587
4588 } else {
4589 if ( typeof array.length === "number" ) {
4590 for ( var l = array.length; i < l; i++ ) {
4591 ret.push( array[i] );
4592 }
4593
4594 } else {
4595 for ( ; array[i]; i++ ) {
4596 ret.push( array[i] );
4597 }
4598 }
4599 }
4600
4601 return ret;
4602 };
4603 }
4604
4605 var sortOrder, siblingCheck;
4606
4607 if ( document.documentElement.compareDocumentPosition ) {
4608 sortOrder = function( a, b ) {
4609 if ( a === b ) {
4610 hasDuplicate = true;
4611 return 0;
4612 }
4613
4614 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
4615 return a.compareDocumentPosition ? -1 : 1;
4616 }
4617
4618 return a.compareDocumentPosition(b) & 4 ? -1 : 1;
4619 };
4620
4621 } else {
4622 sortOrder = function( a, b ) {
4623 // The nodes are identical, we can exit early
4624 if ( a === b ) {
4625 hasDuplicate = true;
4626 return 0;
4627
4628 // Fallback to using sourceIndex (in IE) if it's available on both nodes
4629 } else if ( a.sourceIndex && b.sourceIndex ) {
4630 return a.sourceIndex - b.sourceIndex;
4631 }
4632
4633 var al, bl,
4634 ap = [],
4635 bp = [],
4636 aup = a.parentNode,
4637 bup = b.parentNode,
4638 cur = aup;
4639
4640 // If the nodes are siblings (or identical) we can do a quick check
4641 if ( aup === bup ) {
4642 return siblingCheck( a, b );
4643
4644 // If no parents were found then the nodes are disconnected
4645 } else if ( !aup ) {
4646 return -1;
4647
4648 } else if ( !bup ) {
4649 return 1;
4650 }
4651
4652 // Otherwise they're somewhere else in the tree so we need
4653 // to build up a full list of the parentNodes for comparison
4654 while ( cur ) {
4655 ap.unshift( cur );
4656 cur = cur.parentNode;
4657 }
4658
4659 cur = bup;
4660
4661 while ( cur ) {
4662 bp.unshift( cur );
4663 cur = cur.parentNode;
4664 }
4665
4666 al = ap.length;
4667 bl = bp.length;
4668
4669 // Start walking down the tree looking for a discrepancy
4670 for ( var i = 0; i < al && i < bl; i++ ) {
4671 if ( ap[i] !== bp[i] ) {
4672 return siblingCheck( ap[i], bp[i] );
4673 }
4674 }
4675
4676 // We ended someplace up the tree so do a sibling check
4677 return i === al ?
4678 siblingCheck( a, bp[i], -1 ) :
4679 siblingCheck( ap[i], b, 1 );
4680 };
4681
4682 siblingCheck = function( a, b, ret ) {
4683 if ( a === b ) {
4684 return ret;
4685 }
4686
4687 var cur = a.nextSibling;
4688
4689 while ( cur ) {
4690 if ( cur === b ) {
4691 return -1;
4692 }
4693
4694 cur = cur.nextSibling;
4695 }
4696
4697 return 1;
4698 };
4699 }
4700
4701 // Utility function for retreiving the text value of an array of DOM nodes
4702 Sizzle.getText = function( elems ) {
4703 var ret = "", elem;
4704
4705 for ( var i = 0; elems[i]; i++ ) {
4706 elem = elems[i];
4707
4708 // Get the text from text nodes and CDATA nodes
4709 if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
4710 ret += elem.nodeValue;
4711
4712 // Traverse everything else, except comment nodes
4713 } else if ( elem.nodeType !== 8 ) {
4714 ret += Sizzle.getText( elem.childNodes );
4715 }
4716 }
4717
4718 return ret;
4719 };
4720
4721 // Check to see if the browser returns elements by name when
4722 // querying by getElementById (and provide a workaround)
4723 (function(){
4724 // We're going to inject a fake input element with a specified name
4725 var form = document.createElement("div"),
4726 id = "script" + (new Date()).getTime(),
4727 root = document.documentElement;
4728
4729 form.innerHTML = "<a name='" + id + "'/>";
4730
4731 // Inject it into the root element, check its status, and remove it quickly
4732 root.insertBefore( form, root.firstChild );
4733
4734 // The workaround has to do additional checks after a getElementById
4735 // Which slows things down for other browsers (hence the branching)
4736 if ( document.getElementById( id ) ) {
4737 Expr.find.ID = function( match, context, isXML ) {
4738 if ( typeof context.getElementById !== "undefined" && !isXML ) {
4739 var m = context.getElementById(match[1]);
4740
4741 return m ?
4742 m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4743 [m] :
4744 undefined :
4745 [];
4746 }
4747 };
4748
4749 Expr.filter.ID = function( elem, match ) {
4750 var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4751
4752 return elem.nodeType === 1 && node && node.nodeValue === match;
4753 };
4754 }
4755
4756 root.removeChild( form );
4757
4758 // release memory in IE
4759 root = form = null;
4760 })();
4761
4762 (function(){
4763 // Check to see if the browser returns only elements
4764 // when doing getElementsByTagName("*")
4765
4766 // Create a fake element
4767 var div = document.createElement("div");
4768 div.appendChild( document.createComment("") );
4769
4770 // Make sure no comments are found
4771 if ( div.getElementsByTagName("*").length > 0 ) {
4772 Expr.find.TAG = function( match, context ) {
4773 var results = context.getElementsByTagName( match[1] );
4774
4775 // Filter out possible comments
4776 if ( match[1] === "*" ) {
4777 var tmp = [];
4778
4779 for ( var i = 0; results[i]; i++ ) {
4780 if ( results[i].nodeType === 1 ) {
4781 tmp.push( results[i] );
4782 }
4783 }
4784
4785 results = tmp;
4786 }
4787
4788 return results;
4789 };
4790 }
4791
4792 // Check to see if an attribute returns normalized href attributes
4793 div.innerHTML = "<a href='#'></a>";
4794
4795 if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4796 div.firstChild.getAttribute("href") !== "#" ) {
4797
4798 Expr.attrHandle.href = function( elem ) {
4799 return elem.getAttribute( "href", 2 );
4800 };
4801 }
4802
4803 // release memory in IE
4804 div = null;
4805 })();
4806
4807 if ( document.querySelectorAll ) {
4808 (function(){
4809 var oldSizzle = Sizzle,
4810 div = document.createElement("div"),
4811 id = "__sizzle__";
4812
4813 div.innerHTML = "<p class='TEST'></p>";
4814
4815 // Safari can't handle uppercase or unicode characters when
4816 // in quirks mode.
4817 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4818 return;
4819 }
4820
4821 Sizzle = function( query, context, extra, seed ) {
4822 context = context || document;
4823
4824 // Only use querySelectorAll on non-XML documents
4825 // (ID selectors don't work in non-HTML documents)
4826 if ( !seed && !Sizzle.isXML(context) ) {
4827 // See if we find a selector to speed up
4828 var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
4829
4830 if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
4831 // Speed-up: Sizzle("TAG")
4832 if ( match[1] ) {
4833 return makeArray( context.getElementsByTagName( query ), extra );
4834
4835 // Speed-up: Sizzle(".CLASS")
4836 } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
4837 return makeArray( context.getElementsByClassName( match[2] ), extra );
4838 }
4839 }
4840
4841 if ( context.nodeType === 9 ) {
4842 // Speed-up: Sizzle("body")
4843 // The body element only exists once, optimize finding it
4844 if ( query === "body" && context.body ) {
4845 return makeArray( [ context.body ], extra );
4846
4847 // Speed-up: Sizzle("#ID")
4848 } else if ( match && match[3] ) {
4849 var elem = context.getElementById( match[3] );
4850
4851 // Check parentNode to catch when Blackberry 4.6 returns
4852 // nodes that are no longer in the document #6963
4853 if ( elem && elem.parentNode ) {
4854 // Handle the case where IE and Opera return items
4855 // by name instead of ID
4856 if ( elem.id === match[3] ) {
4857 return makeArray( [ elem ], extra );
4858 }
4859
4860 } else {
4861 return makeArray( [], extra );
4862 }
4863 }
4864
4865 try {
4866 return makeArray( context.querySelectorAll(query), extra );
4867 } catch(qsaError) {}
4868
4869 // qSA works strangely on Element-rooted queries
4870 // We can work around this by specifying an extra ID on the root
4871 // and working up from there (Thanks to Andrew Dupont for the technique)
4872 // IE 8 doesn't work on object elements
4873 } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
4874 var oldContext = context,
4875 old = context.getAttribute( "id" ),
4876 nid = old || id,
4877 hasParent = context.parentNode,
4878 relativeHierarchySelector = /^\s*[+~]/.test( query );
4879
4880 if ( !old ) {
4881 context.setAttribute( "id", nid );
4882 } else {
4883 nid = nid.replace( /'/g, "\\$&" );
4884 }
4885 if ( relativeHierarchySelector && hasParent ) {
4886 context = context.parentNode;
4887 }
4888
4889 try {
4890 if ( !relativeHierarchySelector || hasParent ) {
4891 return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
4892 }
4893
4894 } catch(pseudoError) {
4895 } finally {
4896 if ( !old ) {
4897 oldContext.removeAttribute( "id" );
4898 }
4899 }
4900 }
4901 }
4902
4903 return oldSizzle(query, context, extra, seed);
4904 };
4905
4906 for ( var prop in oldSizzle ) {
4907 Sizzle[ prop ] = oldSizzle[ prop ];
4908 }
4909
4910 // release memory in IE
4911 div = null;
4912 })();
4913 }
4914
4915 (function(){
4916 var html = document.documentElement,
4917 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
4918
4919 if ( matches ) {
4920 // Check to see if it's possible to do matchesSelector
4921 // on a disconnected node (IE 9 fails this)
4922 var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
4923 pseudoWorks = false;
4924
4925 try {
4926 // This should fail with an exception
4927 // Gecko does not error, returns false instead
4928 matches.call( document.documentElement, "[test!='']:sizzle" );
4929
4930 } catch( pseudoError ) {
4931 pseudoWorks = true;
4932 }
4933
4934 Sizzle.matchesSelector = function( node, expr ) {
4935 // Make sure that attribute selectors are quoted
4936 expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
4937
4938 if ( !Sizzle.isXML( node ) ) {
4939 try {
4940 if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
4941 var ret = matches.call( node, expr );
4942
4943 // IE 9's matchesSelector returns false on disconnected nodes
4944 if ( ret || !disconnectedMatch ||
4945 // As well, disconnected nodes are said to be in a document
4946 // fragment in IE 9, so check for that
4947 node.document && node.document.nodeType !== 11 ) {
4948 return ret;
4949 }
4950 }
4951 } catch(e) {}
4952 }
4953
4954 return Sizzle(expr, null, null, [node]).length > 0;
4955 };
4956 }
4957 })();
4958
4959 (function(){
4960 var div = document.createElement("div");
4961
4962 div.innerHTML = "<div class='test e'></div><div class='test'></div>";
4963
4964 // Opera can't find a second classname (in 9.6)
4965 // Also, make sure that getElementsByClassName actually exists
4966 if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
4967 return;
4968 }
4969
4970 // Safari caches class attributes, doesn't catch changes (in 3.2)
4971 div.lastChild.className = "e";
4972
4973 if ( div.getElementsByClassName("e").length === 1 ) {
4974 return;
4975 }
4976
4977 Expr.order.splice(1, 0, "CLASS");
4978 Expr.find.CLASS = function( match, context, isXML ) {
4979 if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
4980 return context.getElementsByClassName(match[1]);
4981 }
4982 };
4983
4984 // release memory in IE
4985 div = null;
4986 })();
4987
4988 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
4989 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
4990 var elem = checkSet[i];
4991
4992 if ( elem ) {
4993 var match = false;
4994
4995 elem = elem[dir];
4996
4997 while ( elem ) {
4998 if ( elem.sizcache === doneName ) {
4999 match = checkSet[elem.sizset];
5000 break;
5001 }
5002
5003 if ( elem.nodeType === 1 && !isXML ){
5004 elem.sizcache = doneName;
5005 elem.sizset = i;
5006 }
5007
5008 if ( elem.nodeName.toLowerCase() === cur ) {
5009 match = elem;
5010 break;
5011 }
5012
5013 elem = elem[dir];
5014 }
5015
5016 checkSet[i] = match;
5017 }
5018 }
5019 }
5020
5021 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
5022 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
5023 var elem = checkSet[i];
5024
5025 if ( elem ) {
5026 var match = false;
5027
5028 elem = elem[dir];
5029
5030 while ( elem ) {
5031 if ( elem.sizcache === doneName ) {
5032 match = checkSet[elem.sizset];
5033 break;
5034 }
5035
5036 if ( elem.nodeType === 1 ) {
5037 if ( !isXML ) {
5038 elem.sizcache = doneName;
5039 elem.sizset = i;
5040 }
5041
5042 if ( typeof cur !== "string" ) {
5043 if ( elem === cur ) {
5044 match = true;
5045 break;
5046 }
5047
5048 } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
5049 match = elem;
5050 break;
5051 }
5052 }
5053
5054 elem = elem[dir];
5055 }
5056
5057 checkSet[i] = match;
5058 }
5059 }
5060 }
5061
5062 if ( document.documentElement.contains ) {
5063 Sizzle.contains = function( a, b ) {
5064 return a !== b && (a.contains ? a.contains(b) : true);
5065 };
5066
5067 } else if ( document.documentElement.compareDocumentPosition ) {
5068 Sizzle.contains = function( a, b ) {
5069 return !!(a.compareDocumentPosition(b) & 16);
5070 };
5071
5072 } else {
5073 Sizzle.contains = function() {
5074 return false;
5075 };
5076 }
5077
5078 Sizzle.isXML = function( elem ) {
5079 // documentElement is verified for cases where it doesn't yet exist
5080 // (such as loading iframes in IE - #4833)
5081 var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
5082
5083 return documentElement ? documentElement.nodeName !== "HTML" : false;
5084 };
5085
5086 var posProcess = function( selector, context ) {
5087 var match,
5088 tmpSet = [],
5089 later = "",
5090 root = context.nodeType ? [context] : context;
5091
5092 // Position selectors must be done after the filter
5093 // And so must :not(positional) so we move all PSEUDOs to the end
5094 while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
5095 later += match[0];
5096 selector = selector.replace( Expr.match.PSEUDO, "" );
5097 }
5098
5099 selector = Expr.relative[selector] ? selector + "*" : selector;
5100
5101 for ( var i = 0, l = root.length; i < l; i++ ) {
5102 Sizzle( selector, root[i], tmpSet );
5103 }
5104
5105 return Sizzle.filter( later, tmpSet );
5106 };
5107
5108 // EXPOSE
5109 jQuery.find = Sizzle;
5110 jQuery.expr = Sizzle.selectors;
5111 jQuery.expr[":"] = jQuery.expr.filters;
5112 jQuery.unique = Sizzle.uniqueSort;
5113 jQuery.text = Sizzle.getText;
5114 jQuery.isXMLDoc = Sizzle.isXML;
5115 jQuery.contains = Sizzle.contains;
5116
5117
5118 })();
5119
5120
5121 var runtil = /Until$/,
5122 rparentsprev = /^(?:parents|prevUntil|prevAll)/,
5123 // Note: This RegExp should be improved, or likely pulled from Sizzle
5124 rmultiselector = /,/,
5125 isSimple = /^.[^:#\[\.,]*$/,
5126 slice = Array.prototype.slice,
5127 POS = jQuery.expr.match.POS,
5128 // methods guaranteed to produce a unique set when starting from a unique set
5129 guaranteedUnique = {
5130 children: true,
5131 contents: true,
5132 next: true,
5133 prev: true
5134 };
5135
5136 jQuery.fn.extend({
5137 find: function( selector ) {
5138 var self = this,
5139 i, l;
5140
5141 if ( typeof selector !== "string" ) {
5142 return jQuery( selector ).filter(function() {
5143 for ( i = 0, l = self.length; i < l; i++ ) {
5144 if ( jQuery.contains( self[ i ], this ) ) {
5145 return true;
5146 }
5147 }
5148 });
5149 }
5150
5151 var ret = this.pushStack( "", "find", selector ),
5152 length, n, r;
5153
5154 for ( i = 0, l = this.length; i < l; i++ ) {
5155 length = ret.length;
5156 jQuery.find( selector, this[i], ret );
5157
5158 if ( i > 0 ) {
5159 // Make sure that the results are unique
5160 for ( n = length; n < ret.length; n++ ) {
5161 for ( r = 0; r < length; r++ ) {
5162 if ( ret[r] === ret[n] ) {
5163 ret.splice(n--, 1);
5164 break;
5165 }
5166 }
5167 }
5168 }
5169 }
5170
5171 return ret;
5172 },
5173
5174 has: function( target ) {
5175 var targets = jQuery( target );
5176 return this.filter(function() {
5177 for ( var i = 0, l = targets.length; i < l; i++ ) {
5178 if ( jQuery.contains( this, targets[i] ) ) {
5179 return true;
5180 }
5181 }
5182 });
5183 },
5184
5185 not: function( selector ) {
5186 return this.pushStack( winnow(this, selector, false), "not", selector);
5187 },
5188
5189 filter: function( selector ) {
5190 return this.pushStack( winnow(this, selector, true), "filter", selector );
5191 },
5192
5193 is: function( selector ) {
5194 return !!selector && ( typeof selector === "string" ?
5195 jQuery.filter( selector, this ).length > 0 :
5196 this.filter( selector ).length > 0 );
5197 },
5198
5199 closest: function( selectors, context ) {
5200 var ret = [], i, l, cur = this[0];
5201
5202 // Array
5203 if ( jQuery.isArray( selectors ) ) {
5204 var match, selector,
5205 matches = {},
5206 level = 1;
5207
5208 if ( cur && selectors.length ) {
5209 for ( i = 0, l = selectors.length; i < l; i++ ) {
5210 selector = selectors[i];
5211
5212 if ( !matches[ selector ] ) {
5213 matches[ selector ] = POS.test( selector ) ?
5214 jQuery( selector, context || this.context ) :
5215 selector;
5216 }
5217 }
5218
5219 while ( cur && cur.ownerDocument && cur !== context ) {
5220 for ( selector in matches ) {
5221 match = matches[ selector ];
5222
5223 if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
5224 ret.push({ selector: selector, elem: cur, level: level });
5225 }
5226 }
5227
5228 cur = cur.parentNode;
5229 level++;
5230 }
5231 }
5232
5233 return ret;
5234 }
5235
5236 // String
5237 var pos = POS.test( selectors ) || typeof selectors !== "string" ?
5238 jQuery( selectors, context || this.context ) :
5239 0;
5240
5241 for ( i = 0, l = this.length; i < l; i++ ) {
5242 cur = this[i];
5243
5244 while ( cur ) {
5245 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
5246 ret.push( cur );
5247 break;
5248
5249 } else {
5250 cur = cur.parentNode;
5251 if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
5252 break;
5253 }
5254 }
5255 }
5256 }
5257
5258 ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
5259
5260 return this.pushStack( ret, "closest", selectors );
5261 },
5262
5263 // Determine the position of an element within
5264 // the matched set of elements
5265 index: function( elem ) {
5266 if ( !elem || typeof elem === "string" ) {
5267 return jQuery.inArray( this[0],
5268 // If it receives a string, the selector is used
5269 // If it receives nothing, the siblings are used
5270 elem ? jQuery( elem ) : this.parent().children() );
5271 }
5272 // Locate the position of the desired element
5273 return jQuery.inArray(
5274 // If it receives a jQuery object, the first element is used
5275 elem.jquery ? elem[0] : elem, this );
5276 },
5277
5278 add: function( selector, context ) {
5279 var set = typeof selector === "string" ?
5280 jQuery( selector, context ) :
5281 jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
5282 all = jQuery.merge( this.get(), set );
5283
5284 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
5285 all :
5286 jQuery.unique( all ) );
5287 },
5288
5289 andSelf: function() {
5290 return this.add( this.prevObject );
5291 }
5292 });
5293
5294 // A painfully simple check to see if an element is disconnected
5295 // from a document (should be improved, where feasible).
5296 function isDisconnected( node ) {
5297 return !node || !node.parentNode || node.parentNode.nodeType === 11;
5298 }
5299
5300 jQuery.each({
5301 parent: function( elem ) {
5302 var parent = elem.parentNode;
5303 return parent && parent.nodeType !== 11 ? parent : null;
5304 },
5305 parents: function( elem ) {
5306 return jQuery.dir( elem, "parentNode" );
5307 },
5308 parentsUntil: function( elem, i, until ) {
5309 return jQuery.dir( elem, "parentNode", until );
5310 },
5311 next: function( elem ) {
5312 return jQuery.nth( elem, 2, "nextSibling" );
5313 },
5314 prev: function( elem ) {
5315 return jQuery.nth( elem, 2, "previousSibling" );
5316 },
5317 nextAll: function( elem ) {
5318 return jQuery.dir( elem, "nextSibling" );
5319 },
5320 prevAll: function( elem ) {
5321 return jQuery.dir( elem, "previousSibling" );
5322 },
5323 nextUntil: function( elem, i, until ) {
5324 return jQuery.dir( elem, "nextSibling", until );
5325 },
5326 prevUntil: function( elem, i, until ) {
5327 return jQuery.dir( elem, "previousSibling", until );
5328 },
5329 siblings: function( elem ) {
5330 return jQuery.sibling( elem.parentNode.firstChild, elem );
5331 },
5332 children: function( elem ) {
5333 return jQuery.sibling( elem.firstChild );
5334 },
5335 contents: function( elem ) {
5336 return jQuery.nodeName( elem, "iframe" ) ?
5337 elem.contentDocument || elem.contentWindow.document :
5338 jQuery.makeArray( elem.childNodes );
5339 }
5340 }, function( name, fn ) {
5341 jQuery.fn[ name ] = function( until, selector ) {
5342 var ret = jQuery.map( this, fn, until ),
5343 // The variable 'args' was introduced in
5344 // https://github.com/jquery/jquery/commit/52a0238
5345 // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
5346 // http://code.google.com/p/v8/issues/detail?id=1050
5347 args = slice.call(arguments);
5348
5349 if ( !runtil.test( name ) ) {
5350 selector = until;
5351 }
5352
5353 if ( selector && typeof selector === "string" ) {
5354 ret = jQuery.filter( selector, ret );
5355 }
5356
5357 ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
5358
5359 if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
5360 ret = ret.reverse();
5361 }
5362
5363 return this.pushStack( ret, name, args.join(",") );
5364 };
5365 });
5366
5367 jQuery.extend({
5368 filter: function( expr, elems, not ) {
5369 if ( not ) {
5370 expr = ":not(" + expr + ")";
5371 }
5372
5373 return elems.length === 1 ?
5374 jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
5375 jQuery.find.matches(expr, elems);
5376 },
5377
5378 dir: function( elem, dir, until ) {
5379 var matched = [],
5380 cur = elem[ dir ];
5381
5382 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
5383 if ( cur.nodeType === 1 ) {
5384 matched.push( cur );
5385 }
5386 cur = cur[dir];
5387 }
5388 return matched;
5389 },
5390
5391 nth: function( cur, result, dir, elem ) {
5392 result = result || 1;
5393 var num = 0;
5394
5395 for ( ; cur; cur = cur[dir] ) {
5396 if ( cur.nodeType === 1 && ++num === result ) {
5397 break;
5398 }
5399 }
5400
5401 return cur;
5402 },
5403
5404 sibling: function( n, elem ) {
5405 var r = [];
5406
5407 for ( ; n; n = n.nextSibling ) {
5408 if ( n.nodeType === 1 && n !== elem ) {
5409 r.push( n );
5410 }
5411 }
5412
5413 return r;
5414 }
5415 });
5416
5417 // Implement the identical functionality for filter and not
5418 function winnow( elements, qualifier, keep ) {
5419
5420 // Can't pass null or undefined to indexOf in Firefox 4
5421 // Set to 0 to skip string check
5422 qualifier = qualifier || 0;
5423
5424 if ( jQuery.isFunction( qualifier ) ) {
5425 return jQuery.grep(elements, function( elem, i ) {
5426 var retVal = !!qualifier.call( elem, i, elem );
5427 return retVal === keep;
5428 });
5429
5430 } else if ( qualifier.nodeType ) {
5431 return jQuery.grep(elements, function( elem, i ) {
5432 return (elem === qualifier) === keep;
5433 });
5434
5435 } else if ( typeof qualifier === "string" ) {
5436 var filtered = jQuery.grep(elements, function( elem ) {
5437 return elem.nodeType === 1;
5438 });
5439
5440 if ( isSimple.test( qualifier ) ) {
5441 return jQuery.filter(qualifier, filtered, !keep);
5442 } else {
5443 qualifier = jQuery.filter( qualifier, filtered );
5444 }
5445 }
5446
5447 return jQuery.grep(elements, function( elem, i ) {
5448 return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
5449 });
5450 }
5451
5452
5453
5454
5455 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
5456 rleadingWhitespace = /^\s+/,
5457 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
5458 rtagName = /<([\w:]+)/,
5459 rtbody = /<tbody/i,
5460 rhtml = /<|&#?\w+;/,
5461 rnocache = /<(?:script|object|embed|option|style)/i,
5462 // checked="checked" or checked
5463 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5464 rscriptType = /\/(java|ecma)script/i,
5465 rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
5466 wrapMap = {
5467 option: [ 1, "<select multiple='multiple'>", "</select>" ],
5468 legend: [ 1, "<fieldset>", "</fieldset>" ],
5469 thead: [ 1, "<table>", "</table>" ],
5470 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
5471 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
5472 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
5473 area: [ 1, "<map>", "</map>" ],
5474 _default: [ 0, "", "" ]
5475 };
5476
5477 wrapMap.optgroup = wrapMap.option;
5478 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
5479 wrapMap.th = wrapMap.td;
5480
5481 // IE can't serialize <link> and <script> tags normally
5482 if ( !jQuery.support.htmlSerialize ) {
5483 wrapMap._default = [ 1, "div<div>", "</div>" ];
5484 }
5485
5486 jQuery.fn.extend({
5487 text: function( text ) {
5488 if ( jQuery.isFunction(text) ) {
5489 return this.each(function(i) {
5490 var self = jQuery( this );
5491
5492 self.text( text.call(this, i, self.text()) );
5493 });
5494 }
5495
5496 if ( typeof text !== "object" && text !== undefined ) {
5497 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
5498 }
5499
5500 return jQuery.text( this );
5501 },
5502
5503 wrapAll: function( html ) {
5504 if ( jQuery.isFunction( html ) ) {
5505 return this.each(function(i) {
5506 jQuery(this).wrapAll( html.call(this, i) );
5507 });
5508 }
5509
5510 if ( this[0] ) {
5511 // The elements to wrap the target around
5512 var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
5513
5514 if ( this[0].parentNode ) {
5515 wrap.insertBefore( this[0] );
5516 }
5517
5518 wrap.map(function() {
5519 var elem = this;
5520
5521 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
5522 elem = elem.firstChild;
5523 }
5524
5525 return elem;
5526 }).append( this );
5527 }
5528
5529 return this;
5530 },
5531
5532 wrapInner: function( html ) {
5533 if ( jQuery.isFunction( html ) ) {
5534 return this.each(function(i) {
5535 jQuery(this).wrapInner( html.call(this, i) );
5536 });
5537 }
5538
5539 return this.each(function() {
5540 var self = jQuery( this ),
5541 contents = self.contents();
5542
5543 if ( contents.length ) {
5544 contents.wrapAll( html );
5545
5546 } else {
5547 self.append( html );
5548 }
5549 });
5550 },
5551
5552 wrap: function( html ) {
5553 return this.each(function() {
5554 jQuery( this ).wrapAll( html );
5555 });
5556 },
5557
5558 unwrap: function() {
5559 return this.parent().each(function() {
5560 if ( !jQuery.nodeName( this, "body" ) ) {
5561 jQuery( this ).replaceWith( this.childNodes );
5562 }
5563 }).end();
5564 },
5565
5566 append: function() {
5567 return this.domManip(arguments, true, function( elem ) {
5568 if ( this.nodeType === 1 ) {
5569 this.appendChild( elem );
5570 }
5571 });
5572 },
5573
5574 prepend: function() {
5575 return this.domManip(arguments, true, function( elem ) {
5576 if ( this.nodeType === 1 ) {
5577 this.insertBefore( elem, this.firstChild );
5578 }
5579 });
5580 },
5581
5582 before: function() {
5583 if ( this[0] && this[0].parentNode ) {
5584 return this.domManip(arguments, false, function( elem ) {
5585 this.parentNode.insertBefore( elem, this );
5586 });
5587 } else if ( arguments.length ) {
5588 var set = jQuery(arguments[0]);
5589 set.push.apply( set, this.toArray() );
5590 return this.pushStack( set, "before", arguments );
5591 }
5592 },
5593
5594 after: function() {
5595 if ( this[0] && this[0].parentNode ) {
5596 return this.domManip(arguments, false, function( elem ) {
5597 this.parentNode.insertBefore( elem, this.nextSibling );
5598 });
5599 } else if ( arguments.length ) {
5600 var set = this.pushStack( this, "after", arguments );
5601 set.push.apply( set, jQuery(arguments[0]).toArray() );
5602 return set;
5603 }
5604 },
5605
5606 // keepData is for internal use only--do not document
5607 remove: function( selector, keepData ) {
5608 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5609 if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
5610 if ( !keepData && elem.nodeType === 1 ) {
5611 jQuery.cleanData( elem.getElementsByTagName("*") );
5612 jQuery.cleanData( [ elem ] );
5613 }
5614
5615 if ( elem.parentNode ) {
5616 elem.parentNode.removeChild( elem );
5617 }
5618 }
5619 }
5620
5621 return this;
5622 },
5623
5624 empty: function() {
5625 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5626 // Remove element nodes and prevent memory leaks
5627 if ( elem.nodeType === 1 ) {
5628 jQuery.cleanData( elem.getElementsByTagName("*") );
5629 }
5630
5631 // Remove any remaining nodes
5632 while ( elem.firstChild ) {
5633 elem.removeChild( elem.firstChild );
5634 }
5635 }
5636
5637 return this;
5638 },
5639
5640 clone: function( dataAndEvents, deepDataAndEvents ) {
5641 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
5642 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5643
5644 return this.map( function () {
5645 return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5646 });
5647 },
5648
5649 html: function( value ) {
5650 if ( value === undefined ) {
5651 return this[0] && this[0].nodeType === 1 ?
5652 this[0].innerHTML.replace(rinlinejQuery, "") :
5653 null;
5654
5655 // See if we can take a shortcut and just use innerHTML
5656 } else if ( typeof value === "string" && !rnocache.test( value ) &&
5657 (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
5658 !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
5659
5660 value = value.replace(rxhtmlTag, "<$1></$2>");
5661
5662 try {
5663 for ( var i = 0, l = this.length; i < l; i++ ) {
5664 // Remove element nodes and prevent memory leaks
5665 if ( this[i].nodeType === 1 ) {
5666 jQuery.cleanData( this[i].getElementsByTagName("*") );
5667 this[i].innerHTML = value;
5668 }
5669 }
5670
5671 // If using innerHTML throws an exception, use the fallback method
5672 } catch(e) {
5673 this.empty().append( value );
5674 }
5675
5676 } else if ( jQuery.isFunction( value ) ) {
5677 this.each(function(i){
5678 var self = jQuery( this );
5679
5680 self.html( value.call(this, i, self.html()) );
5681 });
5682
5683 } else {
5684 this.empty().append( value );
5685 }
5686
5687 return this;
5688 },
5689
5690 replaceWith: function( value ) {
5691 if ( this[0] && this[0].parentNode ) {
5692 // Make sure that the elements are removed from the DOM before they are inserted
5693 // this can help fix replacing a parent with child elements
5694 if ( jQuery.isFunction( value ) ) {
5695 return this.each(function(i) {
5696 var self = jQuery(this), old = self.html();
5697 self.replaceWith( value.call( this, i, old ) );
5698 });
5699 }
5700
5701 if ( typeof value !== "string" ) {
5702 value = jQuery( value ).detach();
5703 }
5704
5705 return this.each(function() {
5706 var next = this.nextSibling,
5707 parent = this.parentNode;
5708
5709 jQuery( this ).remove();
5710
5711 if ( next ) {
5712 jQuery(next).before( value );
5713 } else {
5714 jQuery(parent).append( value );
5715 }
5716 });
5717 } else {
5718 return this.length ?
5719 this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
5720 this;
5721 }
5722 },
5723
5724 detach: function( selector ) {
5725 return this.remove( selector, true );
5726 },
5727
5728 domManip: function( args, table, callback ) {
5729 var results, first, fragment, parent,
5730 value = args[0],
5731 scripts = [];
5732
5733 // We can't cloneNode fragments that contain checked, in WebKit
5734 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
5735 return this.each(function() {
5736 jQuery(this).domManip( args, table, callback, true );
5737 });
5738 }
5739
5740 if ( jQuery.isFunction(value) ) {
5741 return this.each(function(i) {
5742 var self = jQuery(this);
5743 args[0] = value.call(this, i, table ? self.html() : undefined);
5744 self.domManip( args, table, callback );
5745 });
5746 }
5747
5748 if ( this[0] ) {
5749 parent = value && value.parentNode;
5750
5751 // If we're in a fragment, just use that instead of building a new one
5752 if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
5753 results = { fragment: parent };
5754
5755 } else {
5756 results = jQuery.buildFragment( args, this, scripts );
5757 }
5758
5759 fragment = results.fragment;
5760
5761 if ( fragment.childNodes.length === 1 ) {
5762 first = fragment = fragment.firstChild;
5763 } else {
5764 first = fragment.firstChild;
5765 }
5766
5767 if ( first ) {
5768 table = table && jQuery.nodeName( first, "tr" );
5769
5770 for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
5771 callback.call(
5772 table ?
5773 root(this[i], first) :
5774 this[i],
5775 // Make sure that we do not leak memory by inadvertently discarding
5776 // the original fragment (which might have attached data) instead of
5777 // using it; in addition, use the original fragment object for the last
5778 // item instead of first because it can end up being emptied incorrectly
5779 // in certain situations (Bug #8070).
5780 // Fragments from the fragment cache must always be cloned and never used
5781 // in place.
5782 results.cacheable || (l > 1 && i < lastIndex) ?
5783 jQuery.clone( fragment, true, true ) :
5784 fragment
5785 );
5786 }
5787 }
5788
5789 if ( scripts.length ) {
5790 jQuery.each( scripts, evalScript );
5791 }
5792 }
5793
5794 return this;
5795 }
5796 });
5797
5798 function root( elem, cur ) {
5799 return jQuery.nodeName(elem, "table") ?
5800 (elem.getElementsByTagName("tbody")[0] ||
5801 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
5802 elem;
5803 }
5804
5805 function cloneCopyEvent( src, dest ) {
5806
5807 if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
5808 return;
5809 }
5810
5811 var internalKey = jQuery.expando,
5812 oldData = jQuery.data( src ),
5813 curData = jQuery.data( dest, oldData );
5814
5815 // Switch to use the internal data object, if it exists, for the next
5816 // stage of data copying
5817 if ( (oldData = oldData[ internalKey ]) ) {
5818 var events = oldData.events;
5819 curData = curData[ internalKey ] = jQuery.extend({}, oldData);
5820
5821 if ( events ) {
5822 delete curData.handle;
5823 curData.events = {};
5824
5825 for ( var type in events ) {
5826 for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
5827 jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
5828 }
5829 }
5830 }
5831 }
5832 }
5833
5834 function cloneFixAttributes( src, dest ) {
5835 var nodeName;
5836
5837 // We do not need to do anything for non-Elements
5838 if ( dest.nodeType !== 1 ) {
5839 return;
5840 }
5841
5842 // clearAttributes removes the attributes, which we don't want,
5843 // but also removes the attachEvent events, which we *do* want
5844 if ( dest.clearAttributes ) {
5845 dest.clearAttributes();
5846 }
5847
5848 // mergeAttributes, in contrast, only merges back on the
5849 // original attributes, not the events
5850 if ( dest.mergeAttributes ) {
5851 dest.mergeAttributes( src );
5852 }
5853
5854 nodeName = dest.nodeName.toLowerCase();
5855
5856 // IE6-8 fail to clone children inside object elements that use
5857 // the proprietary classid attribute value (rather than the type
5858 // attribute) to identify the type of content to display
5859 if ( nodeName === "object" ) {
5860 dest.outerHTML = src.outerHTML;
5861
5862 } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
5863 // IE6-8 fails to persist the checked state of a cloned checkbox
5864 // or radio button. Worse, IE6-7 fail to give the cloned element
5865 // a checked appearance if the defaultChecked value isn't also set
5866 if ( src.checked ) {
5867 dest.defaultChecked = dest.checked = src.checked;
5868 }
5869
5870 // IE6-7 get confused and end up setting the value of a cloned
5871 // checkbox/radio button to an empty string instead of "on"
5872 if ( dest.value !== src.value ) {
5873 dest.value = src.value;
5874 }
5875
5876 // IE6-8 fails to return the selected option to the default selected
5877 // state when cloning options
5878 } else if ( nodeName === "option" ) {
5879 dest.selected = src.defaultSelected;
5880
5881 // IE6-8 fails to set the defaultValue to the correct value when
5882 // cloning other types of input fields
5883 } else if ( nodeName === "input" || nodeName === "textarea" ) {
5884 dest.defaultValue = src.defaultValue;
5885 }
5886
5887 // Event data gets referenced instead of copied if the expando
5888 // gets copied too
5889 dest.removeAttribute( jQuery.expando );
5890 }
5891
5892 jQuery.buildFragment = function( args, nodes, scripts ) {
5893 var fragment, cacheable, cacheresults,
5894 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
5895
5896 // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
5897 // Cloning options loses the selected state, so don't cache them
5898 // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
5899 // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
5900 if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
5901 args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
5902
5903 cacheable = true;
5904
5905 cacheresults = jQuery.fragments[ args[0] ];
5906 if ( cacheresults && cacheresults !== 1 ) {
5907 fragment = cacheresults;
5908 }
5909 }
5910
5911 if ( !fragment ) {
5912 fragment = doc.createDocumentFragment();
5913 jQuery.clean( args, doc, fragment, scripts );
5914 }
5915
5916 if ( cacheable ) {
5917 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
5918 }
5919
5920 return { fragment: fragment, cacheable: cacheable };
5921 };
5922
5923 jQuery.fragments = {};
5924
5925 jQuery.each({
5926 appendTo: "append",
5927 prependTo: "prepend",
5928 insertBefore: "before",
5929 insertAfter: "after",
5930 replaceAll: "replaceWith"
5931 }, function( name, original ) {
5932 jQuery.fn[ name ] = function( selector ) {
5933 var ret = [],
5934 insert = jQuery( selector ),
5935 parent = this.length === 1 && this[0].parentNode;
5936
5937 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
5938 insert[ original ]( this[0] );
5939 return this;
5940
5941 } else {
5942 for ( var i = 0, l = insert.length; i < l; i++ ) {
5943 var elems = (i > 0 ? this.clone(true) : this).get();
5944 jQuery( insert[i] )[ original ]( elems );
5945 ret = ret.concat( elems );
5946 }
5947
5948 return this.pushStack( ret, name, insert.selector );
5949 }
5950 };
5951 });
5952
5953 function getAll( elem ) {
5954 if ( "getElementsByTagName" in elem ) {
5955 return elem.getElementsByTagName( "*" );
5956
5957 } else if ( "querySelectorAll" in elem ) {
5958 return elem.querySelectorAll( "*" );
5959
5960 } else {
5961 return [];
5962 }
5963 }
5964
5965 // Used in clean, fixes the defaultChecked property
5966 function fixDefaultChecked( elem ) {
5967 if ( elem.type === "checkbox" || elem.type === "radio" ) {
5968 elem.defaultChecked = elem.checked;
5969 }
5970 }
5971 // Finds all inputs and passes them to fixDefaultChecked
5972 function findInputs( elem ) {
5973 if ( jQuery.nodeName( elem, "input" ) ) {
5974 fixDefaultChecked( elem );
5975 } else if ( elem.getElementsByTagName ) {
5976 jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
5977 }
5978 }
5979
5980 jQuery.extend({
5981 clone: function( elem, dataAndEvents, deepDataAndEvents ) {
5982 var clone = elem.cloneNode(true),
5983 srcElements,
5984 destElements,
5985 i;
5986
5987 if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
5988 (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
5989 // IE copies events bound via attachEvent when using cloneNode.
5990 // Calling detachEvent on the clone will also remove the events
5991 // from the original. In order to get around this, we use some
5992 // proprietary methods to clear the events. Thanks to MooTools
5993 // guys for this hotness.
5994
5995 cloneFixAttributes( elem, clone );
5996
5997 // Using Sizzle here is crazy slow, so we use getElementsByTagName
5998 // instead
5999 srcElements = getAll( elem );
6000 destElements = getAll( clone );
6001
6002 // Weird iteration because IE will replace the length property
6003 // with an element if you are cloning the body and one of the
6004 // elements on the page has a name or id of "length"
6005 for ( i = 0; srcElements[i]; ++i ) {
6006 cloneFixAttributes( srcElements[i], destElements[i] );
6007 }
6008 }
6009
6010 // Copy the events from the original to the clone
6011 if ( dataAndEvents ) {
6012 cloneCopyEvent( elem, clone );
6013
6014 if ( deepDataAndEvents ) {
6015 srcElements = getAll( elem );
6016 destElements = getAll( clone );
6017
6018 for ( i = 0; srcElements[i]; ++i ) {
6019 cloneCopyEvent( srcElements[i], destElements[i] );
6020 }
6021 }
6022 }
6023
6024 // Return the cloned set
6025 return clone;
6026 },
6027
6028 clean: function( elems, context, fragment, scripts ) {
6029 var checkScriptType;
6030
6031 context = context || document;
6032
6033 // !context.createElement fails in IE with an error but returns typeof 'object'
6034 if ( typeof context.createElement === "undefined" ) {
6035 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
6036 }
6037
6038 var ret = [], j;
6039
6040 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6041 if ( typeof elem === "number" ) {
6042 elem += "";
6043 }
6044
6045 if ( !elem ) {
6046 continue;
6047 }
6048
6049 // Convert html string into DOM nodes
6050 if ( typeof elem === "string" ) {
6051 if ( !rhtml.test( elem ) ) {
6052 elem = context.createTextNode( elem );
6053 } else {
6054 // Fix "XHTML"-style tags in all browsers
6055 elem = elem.replace(rxhtmlTag, "<$1></$2>");
6056
6057 // Trim whitespace, otherwise indexOf won't work as expected
6058 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
6059 wrap = wrapMap[ tag ] || wrapMap._default,
6060 depth = wrap[0],
6061 div = context.createElement("div");
6062
6063 // Go to html and back, then peel off extra wrappers
6064 div.innerHTML = wrap[1] + elem + wrap[2];
6065
6066 // Move to the right depth
6067 while ( depth-- ) {
6068 div = div.lastChild;
6069 }
6070
6071 // Remove IE's autoinserted <tbody> from table fragments
6072 if ( !jQuery.support.tbody ) {
6073
6074 // String was a <table>, *may* have spurious <tbody>
6075 var hasBody = rtbody.test(elem),
6076 tbody = tag === "table" && !hasBody ?
6077 div.firstChild && div.firstChild.childNodes :
6078
6079 // String was a bare <thead> or <tfoot>
6080 wrap[1] === "<table>" && !hasBody ?
6081 div.childNodes :
6082 [];
6083
6084 for ( j = tbody.length - 1; j >= 0 ; --j ) {
6085 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
6086 tbody[ j ].parentNode.removeChild( tbody[ j ] );
6087 }
6088 }
6089 }
6090
6091 // IE completely kills leading whitespace when innerHTML is used
6092 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
6093 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
6094 }
6095
6096 elem = div.childNodes;
6097 }
6098 }
6099
6100 // Resets defaultChecked for any radios and checkboxes
6101 // about to be appended to the DOM in IE 6/7 (#8060)
6102 var len;
6103 if ( !jQuery.support.appendChecked ) {
6104 if ( elem[0] && typeof (len = elem.length) === "number" ) {
6105 for ( j = 0; j < len; j++ ) {
6106 findInputs( elem[j] );
6107 }
6108 } else {
6109 findInputs( elem );
6110 }
6111 }
6112
6113 if ( elem.nodeType ) {
6114 ret.push( elem );
6115 } else {
6116 ret = jQuery.merge( ret, elem );
6117 }
6118 }
6119
6120 if ( fragment ) {
6121 checkScriptType = function( elem ) {
6122 return !elem.type || rscriptType.test( elem.type );
6123 };
6124 for ( i = 0; ret[i]; i++ ) {
6125 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
6126 scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
6127
6128 } else {
6129 if ( ret[i].nodeType === 1 ) {
6130 var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
6131
6132 ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
6133 }
6134 fragment.appendChild( ret[i] );
6135 }
6136 }
6137 }
6138
6139 return ret;
6140 },
6141
6142 cleanData: function( elems ) {
6143 var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
6144 deleteExpando = jQuery.support.deleteExpando;
6145
6146 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
6147 if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
6148 continue;
6149 }
6150
6151 id = elem[ jQuery.expando ];
6152
6153 if ( id ) {
6154 data = cache[ id ] && cache[ id ][ internalKey ];
6155
6156 if ( data && data.events ) {
6157 for ( var type in data.events ) {
6158 if ( special[ type ] ) {
6159 jQuery.event.remove( elem, type );
6160
6161 // This is a shortcut to avoid jQuery.event.remove's overhead
6162 } else {
6163 jQuery.removeEvent( elem, type, data.handle );
6164 }
6165 }
6166
6167 // Null the DOM reference to avoid IE6/7/8 leak (#7054)
6168 if ( data.handle ) {
6169 data.handle.elem = null;
6170 }
6171 }
6172
6173 if ( deleteExpando ) {
6174 delete elem[ jQuery.expando ];
6175
6176 } else if ( elem.removeAttribute ) {
6177 elem.removeAttribute( jQuery.expando );
6178 }
6179
6180 delete cache[ id ];
6181 }
6182 }
6183 }
6184 });
6185
6186 function evalScript( i, elem ) {
6187 if ( elem.src ) {
6188 jQuery.ajax({
6189 url: elem.src,
6190 async: false,
6191 dataType: "script"
6192 });
6193 } else {
6194 jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
6195 }
6196
6197 if ( elem.parentNode ) {
6198 elem.parentNode.removeChild( elem );
6199 }
6200 }
6201
6202
6203
6204
6205 var ralpha = /alpha\([^)]*\)/i,
6206 ropacity = /opacity=([^)]*)/,
6207 rdashAlpha = /-([a-z])/ig,
6208 // fixed for IE9, see #8346
6209 rupper = /([A-Z]|^ms)/g,
6210 rnumpx = /^-?\d+(?:px)?$/i,
6211 rnum = /^-?\d/,
6212 rrelNum = /^[+\-]=/,
6213 rrelNumFilter = /[^+\-\.\de]+/g,
6214
6215 cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6216 cssWidth = [ "Left", "Right" ],
6217 cssHeight = [ "Top", "Bottom" ],
6218 curCSS,
6219
6220 getComputedStyle,
6221 currentStyle,
6222
6223 fcamelCase = function( all, letter ) {
6224 return letter.toUpperCase();
6225 };
6226
6227 jQuery.fn.css = function( name, value ) {
6228 // Setting 'undefined' is a no-op
6229 if ( arguments.length === 2 && value === undefined ) {
6230 return this;
6231 }
6232
6233 return jQuery.access( this, name, value, true, function( elem, name, value ) {
6234 return value !== undefined ?
6235 jQuery.style( elem, name, value ) :
6236 jQuery.css( elem, name );
6237 });
6238 };
6239
6240 jQuery.extend({
6241 // Add in style property hooks for overriding the default
6242 // behavior of getting and setting a style property
6243 cssHooks: {
6244 opacity: {
6245 get: function( elem, computed ) {
6246 if ( computed ) {
6247 // We should always get a number back from opacity
6248 var ret = curCSS( elem, "opacity", "opacity" );
6249 return ret === "" ? "1" : ret;
6250
6251 } else {
6252 return elem.style.opacity;
6253 }
6254 }
6255 }
6256 },
6257
6258 // Exclude the following css properties to add px
6259 cssNumber: {
6260 "zIndex": true,
6261 "fontWeight": true,
6262 "opacity": true,
6263 "zoom": true,
6264 "lineHeight": true,
6265 "widows": true,
6266 "orphans": true
6267 },
6268
6269 // Add in properties whose names you wish to fix before
6270 // setting or getting the value
6271 cssProps: {
6272 // normalize float css property
6273 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
6274 },
6275
6276 // Get and set the style property on a DOM Node
6277 style: function( elem, name, value, extra ) {
6278 // Don't set styles on text and comment nodes
6279 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6280 return;
6281 }
6282
6283 // Make sure that we're working with the right name
6284 var ret, type, origName = jQuery.camelCase( name ),
6285 style = elem.style, hooks = jQuery.cssHooks[ origName ];
6286
6287 name = jQuery.cssProps[ origName ] || origName;
6288
6289 // Check if we're setting a value
6290 if ( value !== undefined ) {
6291 type = typeof value;
6292
6293 // Make sure that NaN and null values aren't set. See: #7116
6294 if ( type === "number" && isNaN( value ) || value == null ) {
6295 return;
6296 }
6297
6298 // convert relative number strings (+= or -=) to relative numbers. #7345
6299 if ( type === "string" && rrelNum.test( value ) ) {
6300 value = +value.replace( rrelNumFilter, "" ) + parseFloat( jQuery.css( elem, name ) );
6301 }
6302
6303 // If a number was passed in, add 'px' to the (except for certain CSS properties)
6304 if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
6305 value += "px";
6306 }
6307
6308 // If a hook was provided, use that value, otherwise just set the specified value
6309 if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
6310 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
6311 // Fixes bug #5509
6312 try {
6313 style[ name ] = value;
6314 } catch(e) {}
6315 }
6316
6317 } else {
6318 // If a hook was provided get the non-computed value from there
6319 if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
6320 return ret;
6321 }
6322
6323 // Otherwise just get the value from the style object
6324 return style[ name ];
6325 }
6326 },
6327
6328 css: function( elem, name, extra ) {
6329 var ret, hooks;
6330
6331 // Make sure that we're working with the right name
6332 name = jQuery.camelCase( name );
6333 hooks = jQuery.cssHooks[ name ];
6334 name = jQuery.cssProps[ name ] || name;
6335
6336 // cssFloat needs a special treatment
6337 if ( name === "cssFloat" ) {
6338 name = "float";
6339 }
6340
6341 // If a hook was provided get the computed value from there
6342 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
6343 return ret;
6344
6345 // Otherwise, if a way to get the computed value exists, use that
6346 } else if ( curCSS ) {
6347 return curCSS( elem, name );
6348 }
6349 },
6350
6351 // A method for quickly swapping in/out CSS properties to get correct calculations
6352 swap: function( elem, options, callback ) {
6353 var old = {};
6354
6355 // Remember the old values, and insert the new ones
6356 for ( var name in options ) {
6357 old[ name ] = elem.style[ name ];
6358 elem.style[ name ] = options[ name ];
6359 }
6360
6361 callback.call( elem );
6362
6363 // Revert the old values
6364 for ( name in options ) {
6365 elem.style[ name ] = old[ name ];
6366 }
6367 },
6368
6369 camelCase: function( string ) {
6370 return string.replace( rdashAlpha, fcamelCase );
6371 }
6372 });
6373
6374 // DEPRECATED, Use jQuery.css() instead
6375 jQuery.curCSS = jQuery.css;
6376
6377 jQuery.each(["height", "width"], function( i, name ) {
6378 jQuery.cssHooks[ name ] = {
6379 get: function( elem, computed, extra ) {
6380 var val;
6381
6382 if ( computed ) {
6383 if ( elem.offsetWidth !== 0 ) {
6384 val = getWH( elem, name, extra );
6385
6386 } else {
6387 jQuery.swap( elem, cssShow, function() {
6388 val = getWH( elem, name, extra );
6389 });
6390 }
6391
6392 if ( val <= 0 ) {
6393 val = curCSS( elem, name, name );
6394
6395 if ( val === "0px" && currentStyle ) {
6396 val = currentStyle( elem, name, name );
6397 }
6398
6399 if ( val != null ) {
6400 // Should return "auto" instead of 0, use 0 for
6401 // temporary backwards-compat
6402 return val === "" || val === "auto" ? "0px" : val;
6403 }
6404 }
6405
6406 if ( val < 0 || val == null ) {
6407 val = elem.style[ name ];
6408
6409 // Should return "auto" instead of 0, use 0 for
6410 // temporary backwards-compat
6411 return val === "" || val === "auto" ? "0px" : val;
6412 }
6413
6414 return typeof val === "string" ? val : val + "px";
6415 }
6416 },
6417
6418 set: function( elem, value ) {
6419 if ( rnumpx.test( value ) ) {
6420 // ignore negative width and height values #1599
6421 value = parseFloat(value);
6422
6423 if ( value >= 0 ) {
6424 return value + "px";
6425 }
6426
6427 } else {
6428 return value;
6429 }
6430 }
6431 };
6432 });
6433
6434 if ( !jQuery.support.opacity ) {
6435 jQuery.cssHooks.opacity = {
6436 get: function( elem, computed ) {
6437 // IE uses filters for opacity
6438 return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
6439 ( parseFloat( RegExp.$1 ) / 100 ) + "" :
6440 computed ? "1" : "";
6441 },
6442
6443 set: function( elem, value ) {
6444 var style = elem.style,
6445 currentStyle = elem.currentStyle;
6446
6447 // IE has trouble with opacity if it does not have layout
6448 // Force it by setting the zoom level
6449 style.zoom = 1;
6450
6451 // Set the alpha filter to set the opacity
6452 var opacity = jQuery.isNaN( value ) ?
6453 "" :
6454 "alpha(opacity=" + value * 100 + ")",
6455 filter = currentStyle && currentStyle.filter || style.filter || "";
6456
6457 style.filter = ralpha.test( filter ) ?
6458 filter.replace( ralpha, opacity ) :
6459 filter + " " + opacity;
6460 }
6461 };
6462 }
6463
6464 jQuery(function() {
6465 // This hook cannot be added until DOM ready because the support test
6466 // for it is not run until after DOM ready
6467 if ( !jQuery.support.reliableMarginRight ) {
6468 jQuery.cssHooks.marginRight = {
6469 get: function( elem, computed ) {
6470 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
6471 // Work around by temporarily setting element display to inline-block
6472 var ret;
6473 jQuery.swap( elem, { "display": "inline-block" }, function() {
6474 if ( computed ) {
6475 ret = curCSS( elem, "margin-right", "marginRight" );
6476 } else {
6477 ret = elem.style.marginRight;
6478 }
6479 });
6480 return ret;
6481 }
6482 };
6483 }
6484 });
6485
6486 if ( document.defaultView && document.defaultView.getComputedStyle ) {
6487 getComputedStyle = function( elem, name ) {
6488 var ret, defaultView, computedStyle;
6489
6490 name = name.replace( rupper, "-$1" ).toLowerCase();
6491
6492 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
6493 return undefined;
6494 }
6495
6496 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
6497 ret = computedStyle.getPropertyValue( name );
6498 if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
6499 ret = jQuery.style( elem, name );
6500 }
6501 }
6502
6503 return ret;
6504 };
6505 }
6506
6507 if ( document.documentElement.currentStyle ) {
6508 currentStyle = function( elem, name ) {
6509 var left,
6510 ret = elem.currentStyle && elem.currentStyle[ name ],
6511 rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
6512 style = elem.style;
6513
6514 // From the awesome hack by Dean Edwards
6515 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
6516
6517 // If we're not dealing with a regular pixel number
6518 // but a number that has a weird ending, we need to convert it to pixels
6519 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
6520 // Remember the original values
6521 left = style.left;
6522
6523 // Put in the new values to get a computed value out
6524 if ( rsLeft ) {
6525 elem.runtimeStyle.left = elem.currentStyle.left;
6526 }
6527 style.left = name === "fontSize" ? "1em" : (ret || 0);
6528 ret = style.pixelLeft + "px";
6529
6530 // Revert the changed values
6531 style.left = left;
6532 if ( rsLeft ) {
6533 elem.runtimeStyle.left = rsLeft;
6534 }
6535 }
6536
6537 return ret === "" ? "auto" : ret;
6538 };
6539 }
6540
6541 curCSS = getComputedStyle || currentStyle;
6542
6543 function getWH( elem, name, extra ) {
6544 var which = name === "width" ? cssWidth : cssHeight,
6545 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
6546
6547 if ( extra === "border" ) {
6548 return val;
6549 }
6550
6551 jQuery.each( which, function() {
6552 if ( !extra ) {
6553 val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
6554 }
6555
6556 if ( extra === "margin" ) {
6557 val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
6558
6559 } else {
6560 val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
6561 }
6562 });
6563
6564 return val;
6565 }
6566
6567 if ( jQuery.expr && jQuery.expr.filters ) {
6568 jQuery.expr.filters.hidden = function( elem ) {
6569 var width = elem.offsetWidth,
6570 height = elem.offsetHeight;
6571
6572 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
6573 };
6574
6575 jQuery.expr.filters.visible = function( elem ) {
6576 return !jQuery.expr.filters.hidden( elem );
6577 };
6578 }
6579
6580
6581
6582
6583 var r20 = /%20/g,
6584 rbracket = /\[\]$/,
6585 rCRLF = /\r?\n/g,
6586 rhash = /#.*$/,
6587 rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
6588 rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
6589 // #7653, #8125, #8152: local protocol detection
6590 rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|widget):$/,
6591 rnoContent = /^(?:GET|HEAD)$/,
6592 rprotocol = /^\/\//,
6593 rquery = /\?/,
6594 rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
6595 rselectTextarea = /^(?:select|textarea)/i,
6596 rspacesAjax = /\s+/,
6597 rts = /([?&])_=[^&]*/,
6598 rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
6599
6600 // Keep a copy of the old load method
6601 _load = jQuery.fn.load,
6602
6603 /* Prefilters
6604 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
6605 * 2) These are called:
6606 * - BEFORE asking for a transport
6607 * - AFTER param serialization (s.data is a string if s.processData is true)
6608 * 3) key is the dataType
6609 * 4) the catchall symbol "*" can be used
6610 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
6611 */
6612 prefilters = {},
6613
6614 /* Transports bindings
6615 * 1) key is the dataType
6616 * 2) the catchall symbol "*" can be used
6617 * 3) selection will start with transport dataType and THEN go to "*" if needed
6618 */
6619 transports = {},
6620
6621 // Document location
6622 ajaxLocation,
6623
6624 // Document location segments
6625 ajaxLocParts;
6626
6627 // #8138, IE may throw an exception when accessing
6628 // a field from window.location if document.domain has been set
6629 try {
6630 ajaxLocation = location.href;
6631 } catch( e ) {
6632 // Use the href attribute of an A element
6633 // since IE will modify it given document.location
6634 ajaxLocation = document.createElement( "a" );
6635 ajaxLocation.href = "";
6636 ajaxLocation = ajaxLocation.href;
6637 }
6638
6639 // Segment location into parts
6640 ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
6641
6642 // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
6643 function addToPrefiltersOrTransports( structure ) {
6644
6645 // dataTypeExpression is optional and defaults to "*"
6646 return function( dataTypeExpression, func ) {
6647
6648 if ( typeof dataTypeExpression !== "string" ) {
6649 func = dataTypeExpression;
6650 dataTypeExpression = "*";
6651 }
6652
6653 if ( jQuery.isFunction( func ) ) {
6654 var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
6655 i = 0,
6656 length = dataTypes.length,
6657 dataType,
6658 list,
6659 placeBefore;
6660
6661 // For each dataType in the dataTypeExpression
6662 for(; i < length; i++ ) {
6663 dataType = dataTypes[ i ];
6664 // We control if we're asked to add before
6665 // any existing element
6666 placeBefore = /^\+/.test( dataType );
6667 if ( placeBefore ) {
6668 dataType = dataType.substr( 1 ) || "*";
6669 }
6670 list = structure[ dataType ] = structure[ dataType ] || [];
6671 // then we add to the structure accordingly
6672 list[ placeBefore ? "unshift" : "push" ]( func );
6673 }
6674 }
6675 };
6676 }
6677
6678 // Base inspection function for prefilters and transports
6679 function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
6680 dataType /* internal */, inspected /* internal */ ) {
6681
6682 dataType = dataType || options.dataTypes[ 0 ];
6683 inspected = inspected || {};
6684
6685 inspected[ dataType ] = true;
6686
6687 var list = structure[ dataType ],
6688 i = 0,
6689 length = list ? list.length : 0,
6690 executeOnly = ( structure === prefilters ),
6691 selection;
6692
6693 for(; i < length && ( executeOnly || !selection ); i++ ) {
6694 selection = list[ i ]( options, originalOptions, jqXHR );
6695 // If we got redirected to another dataType
6696 // we try there if executing only and not done already
6697 if ( typeof selection === "string" ) {
6698 if ( !executeOnly || inspected[ selection ] ) {
6699 selection = undefined;
6700 } else {
6701 options.dataTypes.unshift( selection );
6702 selection = inspectPrefiltersOrTransports(
6703 structure, options, originalOptions, jqXHR, selection, inspected );
6704 }
6705 }
6706 }
6707 // If we're only executing or nothing was selected
6708 // we try the catchall dataType if not done already
6709 if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
6710 selection = inspectPrefiltersOrTransports(
6711 structure, options, originalOptions, jqXHR, "*", inspected );
6712 }
6713 // unnecessary when only executing (prefilters)
6714 // but it'll be ignored by the caller in that case
6715 return selection;
6716 }
6717
6718 jQuery.fn.extend({
6719 load: function( url, params, callback ) {
6720 if ( typeof url !== "string" && _load ) {
6721 return _load.apply( this, arguments );
6722
6723 // Don't do a request if no elements are being requested
6724 } else if ( !this.length ) {
6725 return this;
6726 }
6727
6728 var off = url.indexOf( " " );
6729 if ( off >= 0 ) {
6730 var selector = url.slice( off, url.length );
6731 url = url.slice( 0, off );
6732 }
6733
6734 // Default to a GET request
6735 var type = "GET";
6736
6737 // If the second parameter was provided
6738 if ( params ) {
6739 // If it's a function
6740 if ( jQuery.isFunction( params ) ) {
6741 // We assume that it's the callback
6742 callback = params;
6743 params = undefined;
6744
6745 // Otherwise, build a param string
6746 } else if ( typeof params === "object" ) {
6747 params = jQuery.param( params, jQuery.ajaxSettings.traditional );
6748 type = "POST";
6749 }
6750 }
6751
6752 var self = this;
6753
6754 // Request the remote document
6755 jQuery.ajax({
6756 url: url,
6757 type: type,
6758 dataType: "html",
6759 data: params,
6760 // Complete callback (responseText is used internally)
6761 complete: function( jqXHR, status, responseText ) {
6762 // Store the response as specified by the jqXHR object
6763 responseText = jqXHR.responseText;
6764 // If successful, inject the HTML into all the matched elements
6765 if ( jqXHR.isResolved() ) {
6766 // #4825: Get the actual response in case
6767 // a dataFilter is present in ajaxSettings
6768 jqXHR.done(function( r ) {
6769 responseText = r;
6770 });
6771 // See if a selector was specified
6772 self.html( selector ?
6773 // Create a dummy div to hold the results
6774 jQuery("<div>")
6775 // inject the contents of the document in, removing the scripts
6776 // to avoid any 'Permission Denied' errors in IE
6777 .append(responseText.replace(rscript, ""))
6778
6779 // Locate the specified elements
6780 .find(selector) :
6781
6782 // If not, just inject the full result
6783 responseText );
6784 }
6785
6786 if ( callback ) {
6787 self.each( callback, [ responseText, status, jqXHR ] );
6788 }
6789 }
6790 });
6791
6792 return this;
6793 },
6794
6795 serialize: function() {
6796 return jQuery.param( this.serializeArray() );
6797 },
6798
6799 serializeArray: function() {
6800 return this.map(function(){
6801 return this.elements ? jQuery.makeArray( this.elements ) : this;
6802 })
6803 .filter(function(){
6804 return this.name && !this.disabled &&
6805 ( this.checked || rselectTextarea.test( this.nodeName ) ||
6806 rinput.test( this.type ) );
6807 })
6808 .map(function( i, elem ){
6809 var val = jQuery( this ).val();
6810
6811 return val == null ?
6812 null :
6813 jQuery.isArray( val ) ?
6814 jQuery.map( val, function( val, i ){
6815 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6816 }) :
6817 { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6818 }).get();
6819 }
6820 });
6821
6822 // Attach a bunch of functions for handling common AJAX events
6823 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
6824 jQuery.fn[ o ] = function( f ){
6825 return this.bind( o, f );
6826 };
6827 });
6828
6829 jQuery.each( [ "get", "post" ], function( i, method ) {
6830 jQuery[ method ] = function( url, data, callback, type ) {
6831 // shift arguments if data argument was omitted
6832 if ( jQuery.isFunction( data ) ) {
6833 type = type || callback;
6834 callback = data;
6835 data = undefined;
6836 }
6837
6838 return jQuery.ajax({
6839 type: method,
6840 url: url,
6841 data: data,
6842 success: callback,
6843 dataType: type
6844 });
6845 };
6846 });
6847
6848 jQuery.extend({
6849
6850 getScript: function( url, callback ) {
6851 return jQuery.get( url, undefined, callback, "script" );
6852 },
6853
6854 getJSON: function( url, data, callback ) {
6855 return jQuery.get( url, data, callback, "json" );
6856 },
6857
6858 // Creates a full fledged settings object into target
6859 // with both ajaxSettings and settings fields.
6860 // If target is omitted, writes into ajaxSettings.
6861 ajaxSetup: function ( target, settings ) {
6862 if ( !settings ) {
6863 // Only one parameter, we extend ajaxSettings
6864 settings = target;
6865 target = jQuery.extend( true, jQuery.ajaxSettings, settings );
6866 } else {
6867 // target was provided, we extend into it
6868 jQuery.extend( true, target, jQuery.ajaxSettings, settings );
6869 }
6870 // Flatten fields we don't want deep extended
6871 for( var field in { context: 1, url: 1 } ) {
6872 if ( field in settings ) {
6873 target[ field ] = settings[ field ];
6874 } else if( field in jQuery.ajaxSettings ) {
6875 target[ field ] = jQuery.ajaxSettings[ field ];
6876 }
6877 }
6878 return target;
6879 },
6880
6881 ajaxSettings: {
6882 url: ajaxLocation,
6883 isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
6884 global: true,
6885 type: "GET",
6886 contentType: "application/x-www-form-urlencoded",
6887 processData: true,
6888 async: true,
6889 /*
6890 timeout: 0,
6891 data: null,
6892 dataType: null,
6893 username: null,
6894 password: null,
6895 cache: null,
6896 traditional: false,
6897 headers: {},
6898 */
6899
6900 accepts: {
6901 xml: "application/xml, text/xml",
6902 html: "text/html",
6903 text: "text/plain",
6904 json: "application/json, text/javascript",
6905 "*": "*/*"
6906 },
6907
6908 contents: {
6909 xml: /xml/,
6910 html: /html/,
6911 json: /json/
6912 },
6913
6914 responseFields: {
6915 xml: "responseXML",
6916 text: "responseText"
6917 },
6918
6919 // List of data converters
6920 // 1) key format is "source_type destination_type" (a single space in-between)
6921 // 2) the catchall symbol "*" can be used for source_type
6922 converters: {
6923
6924 // Convert anything to text
6925 "* text": window.String,
6926
6927 // Text to html (true = no transformation)
6928 "text html": true,
6929
6930 // Evaluate text as a json expression
6931 "text json": jQuery.parseJSON,
6932
6933 // Parse text as xml
6934 "text xml": jQuery.parseXML
6935 }
6936 },
6937
6938 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
6939 ajaxTransport: addToPrefiltersOrTransports( transports ),
6940
6941 // Main method
6942 ajax: function( url, options ) {
6943
6944 // If url is an object, simulate pre-1.5 signature
6945 if ( typeof url === "object" ) {
6946 options = url;
6947 url = undefined;
6948 }
6949
6950 // Force options to be an object
6951 options = options || {};
6952
6953 var // Create the final options object
6954 s = jQuery.ajaxSetup( {}, options ),
6955 // Callbacks context
6956 callbackContext = s.context || s,
6957 // Context for global events
6958 // It's the callbackContext if one was provided in the options
6959 // and if it's a DOM node or a jQuery collection
6960 globalEventContext = callbackContext !== s &&
6961 ( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
6962 jQuery( callbackContext ) : jQuery.event,
6963 // Deferreds
6964 deferred = jQuery.Deferred(),
6965 completeDeferred = jQuery._Deferred(),
6966 // Status-dependent callbacks
6967 statusCode = s.statusCode || {},
6968 // ifModified key
6969 ifModifiedKey,
6970 // Headers (they are sent all at once)
6971 requestHeaders = {},
6972 requestHeadersNames = {},
6973 // Response headers
6974 responseHeadersString,
6975 responseHeaders,
6976 // transport
6977 transport,
6978 // timeout handle
6979 timeoutTimer,
6980 // Cross-domain detection vars
6981 parts,
6982 // The jqXHR state
6983 state = 0,
6984 // To know if global events are to be dispatched
6985 fireGlobals,
6986 // Loop variable
6987 i,
6988 // Fake xhr
6989 jqXHR = {
6990
6991 readyState: 0,
6992
6993 // Caches the header
6994 setRequestHeader: function( name, value ) {
6995 if ( !state ) {
6996 var lname = name.toLowerCase();
6997 name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
6998 requestHeaders[ name ] = value;
6999 }
7000 return this;
7001 },
7002
7003 // Raw string
7004 getAllResponseHeaders: function() {
7005 return state === 2 ? responseHeadersString : null;
7006 },
7007
7008 // Builds headers hashtable if needed
7009 getResponseHeader: function( key ) {
7010 var match;
7011 if ( state === 2 ) {
7012 if ( !responseHeaders ) {
7013 responseHeaders = {};
7014 while( ( match = rheaders.exec( responseHeadersString ) ) ) {
7015 responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
7016 }
7017 }
7018 match = responseHeaders[ key.toLowerCase() ];
7019 }
7020 return match === undefined ? null : match;
7021 },
7022
7023 // Overrides response content-type header
7024 overrideMimeType: function( type ) {
7025 if ( !state ) {
7026 s.mimeType = type;
7027 }
7028 return this;
7029 },
7030
7031 // Cancel the request
7032 abort: function( statusText ) {
7033 statusText = statusText || "abort";
7034 if ( transport ) {
7035 transport.abort( statusText );
7036 }
7037 done( 0, statusText );
7038 return this;
7039 }
7040 };
7041
7042 // Callback for when everything is done
7043 // It is defined here because jslint complains if it is declared
7044 // at the end of the function (which would be more logical and readable)
7045 function done( status, statusText, responses, headers ) {
7046
7047 // Called once
7048 if ( state === 2 ) {
7049 return;
7050 }
7051
7052 // State is "done" now
7053 state = 2;
7054
7055 // Clear timeout if it exists
7056 if ( timeoutTimer ) {
7057 clearTimeout( timeoutTimer );
7058 }
7059
7060 // Dereference transport for early garbage collection
7061 // (no matter how long the jqXHR object will be used)
7062 transport = undefined;
7063
7064 // Cache response headers
7065 responseHeadersString = headers || "";
7066
7067 // Set readyState
7068 jqXHR.readyState = status ? 4 : 0;
7069
7070 var isSuccess,
7071 success,
7072 error,
7073 response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
7074 lastModified,
7075 etag;
7076
7077 // If successful, handle type chaining
7078 if ( status >= 200 && status < 300 || status === 304 ) {
7079
7080 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7081 if ( s.ifModified ) {
7082
7083 if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
7084 jQuery.lastModified[ ifModifiedKey ] = lastModified;
7085 }
7086 if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
7087 jQuery.etag[ ifModifiedKey ] = etag;
7088 }
7089 }
7090
7091 // If not modified
7092 if ( status === 304 ) {
7093
7094 statusText = "notmodified";
7095 isSuccess = true;
7096
7097 // If we have data
7098 } else {
7099
7100 try {
7101 success = ajaxConvert( s, response );
7102 statusText = "success";
7103 isSuccess = true;
7104 } catch(e) {
7105 // We have a parsererror
7106 statusText = "parsererror";
7107 error = e;
7108 }
7109 }
7110 } else {
7111 // We extract error from statusText
7112 // then normalize statusText and status for non-aborts
7113 error = statusText;
7114 if( !statusText || status ) {
7115 statusText = "error";
7116 if ( status < 0 ) {
7117 status = 0;
7118 }
7119 }
7120 }
7121
7122 // Set data for the fake xhr object
7123 jqXHR.status = status;
7124 jqXHR.statusText = statusText;
7125
7126 // Success/Error
7127 if ( isSuccess ) {
7128 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
7129 } else {
7130 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
7131 }
7132
7133 // Status-dependent callbacks
7134 jqXHR.statusCode( statusCode );
7135 statusCode = undefined;
7136
7137 if ( fireGlobals ) {
7138 globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
7139 [ jqXHR, s, isSuccess ? success : error ] );
7140 }
7141
7142 // Complete
7143 completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
7144
7145 if ( fireGlobals ) {
7146 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s] );
7147 // Handle the global AJAX counter
7148 if ( !( --jQuery.active ) ) {
7149 jQuery.event.trigger( "ajaxStop" );
7150 }
7151 }
7152 }
7153
7154 // Attach deferreds
7155 deferred.promise( jqXHR );
7156 jqXHR.success = jqXHR.done;
7157 jqXHR.error = jqXHR.fail;
7158 jqXHR.complete = completeDeferred.done;
7159
7160 // Status-dependent callbacks
7161 jqXHR.statusCode = function( map ) {
7162 if ( map ) {
7163 var tmp;
7164 if ( state < 2 ) {
7165 for( tmp in map ) {
7166 statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
7167 }
7168 } else {
7169 tmp = map[ jqXHR.status ];
7170 jqXHR.then( tmp, tmp );
7171 }
7172 }
7173 return this;
7174 };
7175
7176 // Remove hash character (#7531: and string promotion)
7177 // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
7178 // We also use the url parameter if available
7179 s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
7180
7181 // Extract dataTypes list
7182 s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
7183
7184 // Determine if a cross-domain request is in order
7185 if ( s.crossDomain == null ) {
7186 parts = rurl.exec( s.url.toLowerCase() );
7187 s.crossDomain = !!( parts &&
7188 ( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
7189 ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
7190 ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
7191 );
7192 }
7193
7194 // Convert data if not already a string
7195 if ( s.data && s.processData && typeof s.data !== "string" ) {
7196 s.data = jQuery.param( s.data, s.traditional );
7197 }
7198
7199 // Apply prefilters
7200 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
7201
7202 // If request was aborted inside a prefiler, stop there
7203 if ( state === 2 ) {
7204 return false;
7205 }
7206
7207 // We can fire global events as of now if asked to
7208 fireGlobals = s.global;
7209
7210 // Uppercase the type
7211 s.type = s.type.toUpperCase();
7212
7213 // Determine if request has content
7214 s.hasContent = !rnoContent.test( s.type );
7215
7216 // Watch for a new set of requests
7217 if ( fireGlobals && jQuery.active++ === 0 ) {
7218 jQuery.event.trigger( "ajaxStart" );
7219 }
7220
7221 // More options handling for requests with no content
7222 if ( !s.hasContent ) {
7223
7224 // If data is available, append data to url
7225 if ( s.data ) {
7226 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
7227 }
7228
7229 // Get ifModifiedKey before adding the anti-cache parameter
7230 ifModifiedKey = s.url;
7231
7232 // Add anti-cache in url if needed
7233 if ( s.cache === false ) {
7234
7235 var ts = jQuery.now(),
7236 // try replacing _= if it is there
7237 ret = s.url.replace( rts, "$1_=" + ts );
7238
7239 // if nothing was replaced, add timestamp to the end
7240 s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
7241 }
7242 }
7243
7244 // Set the correct header, if data is being sent
7245 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
7246 jqXHR.setRequestHeader( "Content-Type", s.contentType );
7247 }
7248
7249 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
7250 if ( s.ifModified ) {
7251 ifModifiedKey = ifModifiedKey || s.url;
7252 if ( jQuery.lastModified[ ifModifiedKey ] ) {
7253 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
7254 }
7255 if ( jQuery.etag[ ifModifiedKey ] ) {
7256 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
7257 }
7258 }
7259
7260 // Set the Accepts header for the server, depending on the dataType
7261 jqXHR.setRequestHeader(
7262 "Accept",
7263 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
7264 s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
7265 s.accepts[ "*" ]
7266 );
7267
7268 // Check for headers option
7269 for ( i in s.headers ) {
7270 jqXHR.setRequestHeader( i, s.headers[ i ] );
7271 }
7272
7273 // Allow custom headers/mimetypes and early abort
7274 if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
7275 // Abort if not done already
7276 jqXHR.abort();
7277 return false;
7278
7279 }
7280
7281 // Install callbacks on deferreds
7282 for ( i in { success: 1, error: 1, complete: 1 } ) {
7283 jqXHR[ i ]( s[ i ] );
7284 }
7285
7286 // Get transport
7287 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
7288
7289 // If no transport, we auto-abort
7290 if ( !transport ) {
7291 done( -1, "No Transport" );
7292 } else {
7293 jqXHR.readyState = 1;
7294 // Send global event
7295 if ( fireGlobals ) {
7296 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
7297 }
7298 // Timeout
7299 if ( s.async && s.timeout > 0 ) {
7300 timeoutTimer = setTimeout( function(){
7301 jqXHR.abort( "timeout" );
7302 }, s.timeout );
7303 }
7304
7305 try {
7306 state = 1;
7307 transport.send( requestHeaders, done );
7308 } catch (e) {
7309 // Propagate exception as error if not done
7310 if ( status < 2 ) {
7311 done( -1, e );
7312 // Simply rethrow otherwise
7313 } else {
7314 jQuery.error( e );
7315 }
7316 }
7317 }
7318
7319 return jqXHR;
7320 },
7321
7322 // Serialize an array of form elements or a set of
7323 // key/values into a query string
7324 param: function( a, traditional ) {
7325 var s = [],
7326 add = function( key, value ) {
7327 // If value is a function, invoke it and return its value
7328 value = jQuery.isFunction( value ) ? value() : value;
7329 s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
7330 };
7331
7332 // Set traditional to true for jQuery <= 1.3.2 behavior.
7333 if ( traditional === undefined ) {
7334 traditional = jQuery.ajaxSettings.traditional;
7335 }
7336
7337 // If an array was passed in, assume that it is an array of form elements.
7338 if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
7339 // Serialize the form elements
7340 jQuery.each( a, function() {
7341 add( this.name, this.value );
7342 });
7343
7344 } else {
7345 // If traditional, encode the "old" way (the way 1.3.2 or older
7346 // did it), otherwise encode params recursively.
7347 for ( var prefix in a ) {
7348 buildParams( prefix, a[ prefix ], traditional, add );
7349 }
7350 }
7351
7352 // Return the resulting serialization
7353 return s.join( "&" ).replace( r20, "+" );
7354 }
7355 });
7356
7357 function buildParams( prefix, obj, traditional, add ) {
7358 if ( jQuery.isArray( obj ) ) {
7359 // Serialize array item.
7360 jQuery.each( obj, function( i, v ) {
7361 if ( traditional || rbracket.test( prefix ) ) {
7362 // Treat each array item as a scalar.
7363 add( prefix, v );
7364
7365 } else {
7366 // If array item is non-scalar (array or object), encode its
7367 // numeric index to resolve deserialization ambiguity issues.
7368 // Note that rack (as of 1.0.0) can't currently deserialize
7369 // nested arrays properly, and attempting to do so may cause
7370 // a server error. Possible fixes are to modify rack's
7371 // deserialization algorithm or to provide an option or flag
7372 // to force array serialization to be shallow.
7373 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
7374 }
7375 });
7376
7377 } else if ( !traditional && obj != null && typeof obj === "object" ) {
7378 // Serialize object item.
7379 for ( var name in obj ) {
7380 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
7381 }
7382
7383 } else {
7384 // Serialize scalar item.
7385 add( prefix, obj );
7386 }
7387 }
7388
7389 // This is still on the jQuery object... for now
7390 // Want to move this to jQuery.ajax some day
7391 jQuery.extend({
7392
7393 // Counter for holding the number of active queries
7394 active: 0,
7395
7396 // Last-Modified header cache for next request
7397 lastModified: {},
7398 etag: {}
7399
7400 });
7401
7402 /* Handles responses to an ajax request:
7403 * - sets all responseXXX fields accordingly
7404 * - finds the right dataType (mediates between content-type and expected dataType)
7405 * - returns the corresponding response
7406 */
7407 function ajaxHandleResponses( s, jqXHR, responses ) {
7408
7409 var contents = s.contents,
7410 dataTypes = s.dataTypes,
7411 responseFields = s.responseFields,
7412 ct,
7413 type,
7414 finalDataType,
7415 firstDataType;
7416
7417 // Fill responseXXX fields
7418 for( type in responseFields ) {
7419 if ( type in responses ) {
7420 jqXHR[ responseFields[type] ] = responses[ type ];
7421 }
7422 }
7423
7424 // Remove auto dataType and get content-type in the process
7425 while( dataTypes[ 0 ] === "*" ) {
7426 dataTypes.shift();
7427 if ( ct === undefined ) {
7428 ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
7429 }
7430 }
7431
7432 // Check if we're dealing with a known content-type
7433 if ( ct ) {
7434 for ( type in contents ) {
7435 if ( contents[ type ] && contents[ type ].test( ct ) ) {
7436 dataTypes.unshift( type );
7437 break;
7438 }
7439 }
7440 }
7441
7442 // Check to see if we have a response for the expected dataType
7443 if ( dataTypes[ 0 ] in responses ) {
7444 finalDataType = dataTypes[ 0 ];
7445 } else {
7446 // Try convertible dataTypes
7447 for ( type in responses ) {
7448 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
7449 finalDataType = type;
7450 break;
7451 }
7452 if ( !firstDataType ) {
7453 firstDataType = type;
7454 }
7455 }
7456 // Or just use first one
7457 finalDataType = finalDataType || firstDataType;
7458 }
7459
7460 // If we found a dataType
7461 // We add the dataType to the list if needed
7462 // and return the corresponding response
7463 if ( finalDataType ) {
7464 if ( finalDataType !== dataTypes[ 0 ] ) {
7465 dataTypes.unshift( finalDataType );
7466 }
7467 return responses[ finalDataType ];
7468 }
7469 }
7470
7471 // Chain conversions given the request and the original response
7472 function ajaxConvert( s, response ) {
7473
7474 // Apply the dataFilter if provided
7475 if ( s.dataFilter ) {
7476 response = s.dataFilter( response, s.dataType );
7477 }
7478
7479 var dataTypes = s.dataTypes,
7480 converters = {},
7481 i,
7482 key,
7483 length = dataTypes.length,
7484 tmp,
7485 // Current and previous dataTypes
7486 current = dataTypes[ 0 ],
7487 prev,
7488 // Conversion expression
7489 conversion,
7490 // Conversion function
7491 conv,
7492 // Conversion functions (transitive conversion)
7493 conv1,
7494 conv2;
7495
7496 // For each dataType in the chain
7497 for( i = 1; i < length; i++ ) {
7498
7499 // Create converters map
7500 // with lowercased keys
7501 if ( i === 1 ) {
7502 for( key in s.converters ) {
7503 if( typeof key === "string" ) {
7504 converters[ key.toLowerCase() ] = s.converters[ key ];
7505 }
7506 }
7507 }
7508
7509 // Get the dataTypes
7510 prev = current;
7511 current = dataTypes[ i ];
7512
7513 // If current is auto dataType, update it to prev
7514 if( current === "*" ) {
7515 current = prev;
7516 // If no auto and dataTypes are actually different
7517 } else if ( prev !== "*" && prev !== current ) {
7518
7519 // Get the converter
7520 conversion = prev + " " + current;
7521 conv = converters[ conversion ] || converters[ "* " + current ];
7522
7523 // If there is no direct converter, search transitively
7524 if ( !conv ) {
7525 conv2 = undefined;
7526 for( conv1 in converters ) {
7527 tmp = conv1.split( " " );
7528 if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
7529 conv2 = converters[ tmp[1] + " " + current ];
7530 if ( conv2 ) {
7531 conv1 = converters[ conv1 ];
7532 if ( conv1 === true ) {
7533 conv = conv2;
7534 } else if ( conv2 === true ) {
7535 conv = conv1;
7536 }
7537 break;
7538 }
7539 }
7540 }
7541 }
7542 // If we found no converter, dispatch an error
7543 if ( !( conv || conv2 ) ) {
7544 jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
7545 }
7546 // If found converter is not an equivalence
7547 if ( conv !== true ) {
7548 // Convert with 1 or 2 converters accordingly
7549 response = conv ? conv( response ) : conv2( conv1(response) );
7550 }
7551 }
7552 }
7553 return response;
7554 }
7555
7556
7557
7558
7559 var jsc = jQuery.now(),
7560 jsre = /(\=)\?(&|$)|\?\?/i;
7561
7562 // Default jsonp settings
7563 jQuery.ajaxSetup({
7564 jsonp: "callback",
7565 jsonpCallback: function() {
7566 return jQuery.expando + "_" + ( jsc++ );
7567 }
7568 });
7569
7570 // Detect, normalize options and install callbacks for jsonp requests
7571 jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
7572
7573 var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
7574 ( typeof s.data === "string" );
7575
7576 if ( s.dataTypes[ 0 ] === "jsonp" ||
7577 s.jsonp !== false && ( jsre.test( s.url ) ||
7578 inspectData && jsre.test( s.data ) ) ) {
7579
7580 var responseContainer,
7581 jsonpCallback = s.jsonpCallback =
7582 jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
7583 previous = window[ jsonpCallback ],
7584 url = s.url,
7585 data = s.data,
7586 replace = "$1" + jsonpCallback + "$2";
7587
7588 if ( s.jsonp !== false ) {
7589 url = url.replace( jsre, replace );
7590 if ( s.url === url ) {
7591 if ( inspectData ) {
7592 data = data.replace( jsre, replace );
7593 }
7594 if ( s.data === data ) {
7595 // Add callback manually
7596 url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
7597 }
7598 }
7599 }
7600
7601 s.url = url;
7602 s.data = data;
7603
7604 // Install callback
7605 window[ jsonpCallback ] = function( response ) {
7606 responseContainer = [ response ];
7607 };
7608
7609 // Clean-up function
7610 jqXHR.always(function() {
7611 // Set callback back to previous value
7612 window[ jsonpCallback ] = previous;
7613 // Call if it was a function and we have a response
7614 if ( responseContainer && jQuery.isFunction( previous ) ) {
7615 window[ jsonpCallback ]( responseContainer[ 0 ] );
7616 }
7617 });
7618
7619 // Use data converter to retrieve json after script execution
7620 s.converters["script json"] = function() {
7621 if ( !responseContainer ) {
7622 jQuery.error( jsonpCallback + " was not called" );
7623 }
7624 return responseContainer[ 0 ];
7625 };
7626
7627 // force json dataType
7628 s.dataTypes[ 0 ] = "json";
7629
7630 // Delegate to script
7631 return "script";
7632 }
7633 });
7634
7635
7636
7637
7638 // Install script dataType
7639 jQuery.ajaxSetup({
7640 accepts: {
7641 script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
7642 },
7643 contents: {
7644 script: /javascript|ecmascript/
7645 },
7646 converters: {
7647 "text script": function( text ) {
7648 jQuery.globalEval( text );
7649 return text;
7650 }
7651 }
7652 });
7653
7654 // Handle cache's special case and global
7655 jQuery.ajaxPrefilter( "script", function( s ) {
7656 if ( s.cache === undefined ) {
7657 s.cache = false;
7658 }
7659 if ( s.crossDomain ) {
7660 s.type = "GET";
7661 s.global = false;
7662 }
7663 });
7664
7665 // Bind script tag hack transport
7666 jQuery.ajaxTransport( "script", function(s) {
7667
7668 // This transport only deals with cross domain requests
7669 if ( s.crossDomain ) {
7670
7671 var script,
7672 head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
7673
7674 return {
7675
7676 send: function( _, callback ) {
7677
7678 script = document.createElement( "script" );
7679
7680 script.async = "async";
7681
7682 if ( s.scriptCharset ) {
7683 script.charset = s.scriptCharset;
7684 }
7685
7686 script.src = s.url;
7687
7688 // Attach handlers for all browsers
7689 script.onload = script.onreadystatechange = function( _, isAbort ) {
7690
7691 if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
7692
7693 // Handle memory leak in IE
7694 script.onload = script.onreadystatechange = null;
7695
7696 // Remove the script
7697 if ( head && script.parentNode ) {
7698 head.removeChild( script );
7699 }
7700
7701 // Dereference the script
7702 script = undefined;
7703
7704 // Callback if not abort
7705 if ( !isAbort ) {
7706 callback( 200, "success" );
7707 }
7708 }
7709 };
7710 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
7711 // This arises when a base node is used (#2709 and #4378).
7712 head.insertBefore( script, head.firstChild );
7713 },
7714
7715 abort: function() {
7716 if ( script ) {
7717 script.onload( 0, 1 );
7718 }
7719 }
7720 };
7721 }
7722 });
7723
7724
7725
7726
7727 var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
7728 xhrOnUnloadAbort = window.ActiveXObject ? function() {
7729 // Abort all pending requests
7730 for ( var key in xhrCallbacks ) {
7731 xhrCallbacks[ key ]( 0, 1 );
7732 }
7733 } : false,
7734 xhrId = 0,
7735 xhrCallbacks;
7736
7737 // Functions to create xhrs
7738 function createStandardXHR() {
7739 try {
7740 return new window.XMLHttpRequest();
7741 } catch( e ) {}
7742 }
7743
7744 function createActiveXHR() {
7745 try {
7746 return new window.ActiveXObject( "Microsoft.XMLHTTP" );
7747 } catch( e ) {}
7748 }
7749
7750 // Create the request object
7751 // (This is still attached to ajaxSettings for backward compatibility)
7752 jQuery.ajaxSettings.xhr = window.ActiveXObject ?
7753 /* Microsoft failed to properly
7754 * implement the XMLHttpRequest in IE7 (can't request local files),
7755 * so we use the ActiveXObject when it is available
7756 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
7757 * we need a fallback.
7758 */
7759 function() {
7760 return !this.isLocal && createStandardXHR() || createActiveXHR();
7761 } :
7762 // For all other browsers, use the standard XMLHttpRequest object
7763 createStandardXHR;
7764
7765 // Determine support properties
7766 (function( xhr ) {
7767 jQuery.extend( jQuery.support, {
7768 ajax: !!xhr,
7769 cors: !!xhr && ( "withCredentials" in xhr )
7770 });
7771 })( jQuery.ajaxSettings.xhr() );
7772
7773 // Create transport if the browser can provide an xhr
7774 if ( jQuery.support.ajax ) {
7775
7776 jQuery.ajaxTransport(function( s ) {
7777 // Cross domain only allowed if supported through XMLHttpRequest
7778 if ( !s.crossDomain || jQuery.support.cors ) {
7779
7780 var callback;
7781
7782 return {
7783 send: function( headers, complete ) {
7784
7785 // Get a new xhr
7786 var xhr = s.xhr(),
7787 handle,
7788 i;
7789
7790 // Open the socket
7791 // Passing null username, generates a login popup on Opera (#2865)
7792 if ( s.username ) {
7793 xhr.open( s.type, s.url, s.async, s.username, s.password );
7794 } else {
7795 xhr.open( s.type, s.url, s.async );
7796 }
7797
7798 // Apply custom fields if provided
7799 if ( s.xhrFields ) {
7800 for ( i in s.xhrFields ) {
7801 xhr[ i ] = s.xhrFields[ i ];
7802 }
7803 }
7804
7805 // Override mime type if needed
7806 if ( s.mimeType && xhr.overrideMimeType ) {
7807 xhr.overrideMimeType( s.mimeType );
7808 }
7809
7810 // X-Requested-With header
7811 // For cross-domain requests, seeing as conditions for a preflight are
7812 // akin to a jigsaw puzzle, we simply never set it to be sure.
7813 // (it can always be set on a per-request basis or even using ajaxSetup)
7814 // For same-domain requests, won't change header if already provided.
7815 if ( !s.crossDomain && !headers["X-Requested-With"] ) {
7816 headers[ "X-Requested-With" ] = "XMLHttpRequest";
7817 }
7818
7819 // Need an extra try/catch for cross domain requests in Firefox 3
7820 try {
7821 for ( i in headers ) {
7822 xhr.setRequestHeader( i, headers[ i ] );
7823 }
7824 } catch( _ ) {}
7825
7826 // Do send the request
7827 // This may raise an exception which is actually
7828 // handled in jQuery.ajax (so no try/catch here)
7829 xhr.send( ( s.hasContent && s.data ) || null );
7830
7831 // Listener
7832 callback = function( _, isAbort ) {
7833
7834 var status,
7835 statusText,
7836 responseHeaders,
7837 responses,
7838 xml;
7839
7840 // Firefox throws exceptions when accessing properties
7841 // of an xhr when a network error occured
7842 // http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
7843 try {
7844
7845 // Was never called and is aborted or complete
7846 if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
7847
7848 // Only called once
7849 callback = undefined;
7850
7851 // Do not keep as active anymore
7852 if ( handle ) {
7853 xhr.onreadystatechange = jQuery.noop;
7854 if ( xhrOnUnloadAbort ) {
7855 delete xhrCallbacks[ handle ];
7856 }
7857 }
7858
7859 // If it's an abort
7860 if ( isAbort ) {
7861 // Abort it manually if needed
7862 if ( xhr.readyState !== 4 ) {
7863 xhr.abort();
7864 }
7865 } else {
7866 status = xhr.status;
7867 responseHeaders = xhr.getAllResponseHeaders();
7868 responses = {};
7869 xml = xhr.responseXML;
7870
7871 // Construct response list
7872 if ( xml && xml.documentElement /* #4958 */ ) {
7873 responses.xml = xml;
7874 }
7875 responses.text = xhr.responseText;
7876
7877 // Firefox throws an exception when accessing
7878 // statusText for faulty cross-domain requests
7879 try {
7880 statusText = xhr.statusText;
7881 } catch( e ) {
7882 // We normalize with Webkit giving an empty statusText
7883 statusText = "";
7884 }
7885
7886 // Filter status for non standard behaviors
7887
7888 // If the request is local and we have data: assume a success
7889 // (success with no data won't get notified, that's the best we
7890 // can do given current implementations)
7891 if ( !status && s.isLocal && !s.crossDomain ) {
7892 status = responses.text ? 200 : 404;
7893 // IE - #1450: sometimes returns 1223 when it should be 204
7894 } else if ( status === 1223 ) {
7895 status = 204;
7896 }
7897 }
7898 }
7899 } catch( firefoxAccessException ) {
7900 if ( !isAbort ) {
7901 complete( -1, firefoxAccessException );
7902 }
7903 }
7904
7905 // Call complete if needed
7906 if ( responses ) {
7907 complete( status, statusText, responses, responseHeaders );
7908 }
7909 };
7910
7911 // if we're in sync mode or it's in cache
7912 // and has been retrieved directly (IE6 & IE7)
7913 // we need to manually fire the callback
7914 if ( !s.async || xhr.readyState === 4 ) {
7915 callback();
7916 } else {
7917 handle = ++xhrId;
7918 if ( xhrOnUnloadAbort ) {
7919 // Create the active xhrs callbacks list if needed
7920 // and attach the unload handler
7921 if ( !xhrCallbacks ) {
7922 xhrCallbacks = {};
7923 jQuery( window ).unload( xhrOnUnloadAbort );
7924 }
7925 // Add to list of active xhrs callbacks
7926 xhrCallbacks[ handle ] = callback;
7927 }
7928 xhr.onreadystatechange = callback;
7929 }
7930 },
7931
7932 abort: function() {
7933 if ( callback ) {
7934 callback(0,1);
7935 }
7936 }
7937 };
7938 }
7939 });
7940 }
7941
7942
7943
7944
7945 var elemdisplay = {},
7946 iframe, iframeDoc,
7947 rfxtypes = /^(?:toggle|show|hide)$/,
7948 rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
7949 timerId,
7950 fxAttrs = [
7951 // height animations
7952 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
7953 // width animations
7954 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
7955 // opacity animations
7956 [ "opacity" ]
7957 ],
7958 fxNow,
7959 requestAnimationFrame = window.webkitRequestAnimationFrame ||
7960 window.mozRequestAnimationFrame ||
7961 window.oRequestAnimationFrame;
7962
7963 jQuery.fn.extend({
7964 show: function( speed, easing, callback ) {
7965 var elem, display;
7966
7967 if ( speed || speed === 0 ) {
7968 return this.animate( genFx("show", 3), speed, easing, callback);
7969
7970 } else {
7971 for ( var i = 0, j = this.length; i < j; i++ ) {
7972 elem = this[i];
7973
7974 if ( elem.style ) {
7975 display = elem.style.display;
7976
7977 // Reset the inline display of this element to learn if it is
7978 // being hidden by cascaded rules or not
7979 if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
7980 display = elem.style.display = "";
7981 }
7982
7983 // Set elements which have been overridden with display: none
7984 // in a stylesheet to whatever the default browser style is
7985 // for such an element
7986 if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
7987 jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
7988 }
7989 }
7990 }
7991
7992 // Set the display of most of the elements in a second loop
7993 // to avoid the constant reflow
7994 for ( i = 0; i < j; i++ ) {
7995 elem = this[i];
7996
7997 if ( elem.style ) {
7998 display = elem.style.display;
7999
8000 if ( display === "" || display === "none" ) {
8001 elem.style.display = jQuery._data(elem, "olddisplay") || "";
8002 }
8003 }
8004 }
8005
8006 return this;
8007 }
8008 },
8009
8010 hide: function( speed, easing, callback ) {
8011 if ( speed || speed === 0 ) {
8012 return this.animate( genFx("hide", 3), speed, easing, callback);
8013
8014 } else {
8015 for ( var i = 0, j = this.length; i < j; i++ ) {
8016 if ( this[i].style ) {
8017 var display = jQuery.css( this[i], "display" );
8018
8019 if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
8020 jQuery._data( this[i], "olddisplay", display );
8021 }
8022 }
8023 }
8024
8025 // Set the display of the elements in a second loop
8026 // to avoid the constant reflow
8027 for ( i = 0; i < j; i++ ) {
8028 if ( this[i].style ) {
8029 this[i].style.display = "none";
8030 }
8031 }
8032
8033 return this;
8034 }
8035 },
8036
8037 // Save the old toggle function
8038 _toggle: jQuery.fn.toggle,
8039
8040 toggle: function( fn, fn2, callback ) {
8041 var bool = typeof fn === "boolean";
8042
8043 if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
8044 this._toggle.apply( this, arguments );
8045
8046 } else if ( fn == null || bool ) {
8047 this.each(function() {
8048 var state = bool ? fn : jQuery(this).is(":hidden");
8049 jQuery(this)[ state ? "show" : "hide" ]();
8050 });
8051
8052 } else {
8053 this.animate(genFx("toggle", 3), fn, fn2, callback);
8054 }
8055
8056 return this;
8057 },
8058
8059 fadeTo: function( speed, to, easing, callback ) {
8060 return this.filter(":hidden").css("opacity", 0).show().end()
8061 .animate({opacity: to}, speed, easing, callback);
8062 },
8063
8064 animate: function( prop, speed, easing, callback ) {
8065 var optall = jQuery.speed(speed, easing, callback);
8066
8067 if ( jQuery.isEmptyObject( prop ) ) {
8068 return this.each( optall.complete, [ false ] );
8069 }
8070
8071 // Do not change referenced properties as per-property easing will be lost
8072 prop = jQuery.extend( {}, prop );
8073
8074 return this[ optall.queue === false ? "each" : "queue" ](function() {
8075 // XXX 'this' does not always have a nodeName when running the
8076 // test suite
8077
8078 if ( optall.queue === false ) {
8079 jQuery._mark( this );
8080 }
8081
8082 var opt = jQuery.extend( {}, optall ),
8083 isElement = this.nodeType === 1,
8084 hidden = isElement && jQuery(this).is(":hidden"),
8085 name, val, p,
8086 display, e,
8087 parts, start, end, unit;
8088
8089 // will store per property easing and be used to determine when an animation is complete
8090 opt.animatedProperties = {};
8091
8092 for ( p in prop ) {
8093
8094 // property name normalization
8095 name = jQuery.camelCase( p );
8096 if ( p !== name ) {
8097 prop[ name ] = prop[ p ];
8098 delete prop[ p ];
8099 }
8100
8101 val = prop[ name ];
8102
8103 // easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
8104 if ( jQuery.isArray( val ) ) {
8105 opt.animatedProperties[ name ] = val[ 1 ];
8106 val = prop[ name ] = val[ 0 ];
8107 } else {
8108 opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
8109 }
8110
8111 if ( val === "hide" && hidden || val === "show" && !hidden ) {
8112 return opt.complete.call( this );
8113 }
8114
8115 if ( isElement && ( name === "height" || name === "width" ) ) {
8116 // Make sure that nothing sneaks out
8117 // Record all 3 overflow attributes because IE does not
8118 // change the overflow attribute when overflowX and
8119 // overflowY are set to the same value
8120 opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
8121
8122 // Set display property to inline-block for height/width
8123 // animations on inline elements that are having width/height
8124 // animated
8125 if ( jQuery.css( this, "display" ) === "inline" &&
8126 jQuery.css( this, "float" ) === "none" ) {
8127 if ( !jQuery.support.inlineBlockNeedsLayout ) {
8128 this.style.display = "inline-block";
8129
8130 } else {
8131 display = defaultDisplay( this.nodeName );
8132
8133 // inline-level elements accept inline-block;
8134 // block-level elements need to be inline with layout
8135 if ( display === "inline" ) {
8136 this.style.display = "inline-block";
8137
8138 } else {
8139 this.style.display = "inline";
8140 this.style.zoom = 1;
8141 }
8142 }
8143 }
8144 }
8145 }
8146
8147 if ( opt.overflow != null ) {
8148 this.style.overflow = "hidden";
8149 }
8150
8151 for ( p in prop ) {
8152 e = new jQuery.fx( this, opt, p );
8153 val = prop[ p ];
8154
8155 if ( rfxtypes.test(val) ) {
8156 e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
8157
8158 } else {
8159 parts = rfxnum.exec( val );
8160 start = e.cur();
8161
8162 if ( parts ) {
8163 end = parseFloat( parts[2] );
8164 unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
8165
8166 // We need to compute starting value
8167 if ( unit !== "px" ) {
8168 jQuery.style( this, p, (end || 1) + unit);
8169 start = ((end || 1) / e.cur()) * start;
8170 jQuery.style( this, p, start + unit);
8171 }
8172
8173 // If a +=/-= token was provided, we're doing a relative animation
8174 if ( parts[1] ) {
8175 end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
8176 }
8177
8178 e.custom( start, end, unit );
8179
8180 } else {
8181 e.custom( start, val, "" );
8182 }
8183 }
8184 }
8185
8186 // For JS strict compliance
8187 return true;
8188 });
8189 },
8190
8191 stop: function( clearQueue, gotoEnd ) {
8192 if ( clearQueue ) {
8193 this.queue([]);
8194 }
8195
8196 this.each(function() {
8197 var timers = jQuery.timers,
8198 i = timers.length;
8199 // clear marker counters if we know they won't be
8200 if ( !gotoEnd ) {
8201 jQuery._unmark( true, this );
8202 }
8203 while ( i-- ) {
8204 if ( timers[i].elem === this ) {
8205 if (gotoEnd) {
8206 // force the next step to be the last
8207 timers[i](true);
8208 }
8209
8210 timers.splice(i, 1);
8211 }
8212 }
8213 });
8214
8215 // start the next in the queue if the last step wasn't forced
8216 if ( !gotoEnd ) {
8217 this.dequeue();
8218 }
8219
8220 return this;
8221 }
8222
8223 });
8224
8225 // Animations created synchronously will run synchronously
8226 function createFxNow() {
8227 setTimeout( clearFxNow, 0 );
8228 return ( fxNow = jQuery.now() );
8229 }
8230
8231 function clearFxNow() {
8232 fxNow = undefined;
8233 }
8234
8235 // Generate parameters to create a standard animation
8236 function genFx( type, num ) {
8237 var obj = {};
8238
8239 jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
8240 obj[ this ] = type;
8241 });
8242
8243 return obj;
8244 }
8245
8246 // Generate shortcuts for custom animations
8247 jQuery.each({
8248 slideDown: genFx("show", 1),
8249 slideUp: genFx("hide", 1),
8250 slideToggle: genFx("toggle", 1),
8251 fadeIn: { opacity: "show" },
8252 fadeOut: { opacity: "hide" },
8253 fadeToggle: { opacity: "toggle" }
8254 }, function( name, props ) {
8255 jQuery.fn[ name ] = function( speed, easing, callback ) {
8256 return this.animate( props, speed, easing, callback );
8257 };
8258 });
8259
8260 jQuery.extend({
8261 speed: function( speed, easing, fn ) {
8262 var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
8263 complete: fn || !fn && easing ||
8264 jQuery.isFunction( speed ) && speed,
8265 duration: speed,
8266 easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
8267 };
8268
8269 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
8270 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
8271
8272 // Queueing
8273 opt.old = opt.complete;
8274 opt.complete = function( noUnmark ) {
8275 if ( opt.queue !== false ) {
8276 jQuery.dequeue( this );
8277 } else if ( noUnmark !== false ) {
8278 jQuery._unmark( this );
8279 }
8280
8281 if ( jQuery.isFunction( opt.old ) ) {
8282 opt.old.call( this );
8283 }
8284 };
8285
8286 return opt;
8287 },
8288
8289 easing: {
8290 linear: function( p, n, firstNum, diff ) {
8291 return firstNum + diff * p;
8292 },
8293 swing: function( p, n, firstNum, diff ) {
8294 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
8295 }
8296 },
8297
8298 timers: [],
8299
8300 fx: function( elem, options, prop ) {
8301 this.options = options;
8302 this.elem = elem;
8303 this.prop = prop;
8304
8305 options.orig = options.orig || {};
8306 }
8307
8308 });
8309
8310 jQuery.fx.prototype = {
8311 // Simple function for setting a style value
8312 update: function() {
8313 if ( this.options.step ) {
8314 this.options.step.call( this.elem, this.now, this );
8315 }
8316
8317 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
8318 },
8319
8320 // Get the current size
8321 cur: function() {
8322 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
8323 return this.elem[ this.prop ];
8324 }
8325
8326 var parsed,
8327 r = jQuery.css( this.elem, this.prop );
8328 // Empty strings, null, undefined and "auto" are converted to 0,
8329 // complex values such as "rotate(1rad)" are returned as is,
8330 // simple values such as "10px" are parsed to Float.
8331 return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
8332 },
8333
8334 // Start an animation from one number to another
8335 custom: function( from, to, unit ) {
8336 var self = this,
8337 fx = jQuery.fx,
8338 raf;
8339
8340 this.startTime = fxNow || createFxNow();
8341 this.start = from;
8342 this.end = to;
8343 this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
8344 this.now = this.start;
8345 this.pos = this.state = 0;
8346
8347 function t( gotoEnd ) {
8348 return self.step(gotoEnd);
8349 }
8350
8351 t.elem = this.elem;
8352
8353 if ( t() && jQuery.timers.push(t) && !timerId ) {
8354 // Use requestAnimationFrame instead of setInterval if available
8355 if ( requestAnimationFrame ) {
8356 timerId = 1;
8357 raf = function() {
8358 // When timerId gets set to null at any point, this stops
8359 if ( timerId ) {
8360 requestAnimationFrame( raf );
8361 fx.tick();
8362 }
8363 };
8364 requestAnimationFrame( raf );
8365 } else {
8366 timerId = setInterval( fx.tick, fx.interval );
8367 }
8368 }
8369 },
8370
8371 // Simple 'show' function
8372 show: function() {
8373 // Remember where we started, so that we can go back to it later
8374 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8375 this.options.show = true;
8376
8377 // Begin the animation
8378 // Make sure that we start at a small width/height to avoid any
8379 // flash of content
8380 this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
8381
8382 // Start by showing the element
8383 jQuery( this.elem ).show();
8384 },
8385
8386 // Simple 'hide' function
8387 hide: function() {
8388 // Remember where we started, so that we can go back to it later
8389 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
8390 this.options.hide = true;
8391
8392 // Begin the animation
8393 this.custom(this.cur(), 0);
8394 },
8395
8396 // Each step of an animation
8397 step: function( gotoEnd ) {
8398 var t = fxNow || createFxNow(),
8399 done = true,
8400 elem = this.elem,
8401 options = this.options,
8402 i, n;
8403
8404 if ( gotoEnd || t >= options.duration + this.startTime ) {
8405 this.now = this.end;
8406 this.pos = this.state = 1;
8407 this.update();
8408
8409 options.animatedProperties[ this.prop ] = true;
8410
8411 for ( i in options.animatedProperties ) {
8412 if ( options.animatedProperties[i] !== true ) {
8413 done = false;
8414 }
8415 }
8416
8417 if ( done ) {
8418 // Reset the overflow
8419 if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
8420
8421 jQuery.each( [ "", "X", "Y" ], function (index, value) {
8422 elem.style[ "overflow" + value ] = options.overflow[index];
8423 });
8424 }
8425
8426 // Hide the element if the "hide" operation was done
8427 if ( options.hide ) {
8428 jQuery(elem).hide();
8429 }
8430
8431 // Reset the properties, if the item has been hidden or shown
8432 if ( options.hide || options.show ) {
8433 for ( var p in options.animatedProperties ) {
8434 jQuery.style( elem, p, options.orig[p] );
8435 }
8436 }
8437
8438 // Execute the complete function
8439 options.complete.call( elem );
8440 }
8441
8442 return false;
8443
8444 } else {
8445 // classical easing cannot be used with an Infinity duration
8446 if ( options.duration == Infinity ) {
8447 this.now = t;
8448 } else {
8449 n = t - this.startTime;
8450 this.state = n / options.duration;
8451
8452 // Perform the easing function, defaults to swing
8453 this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
8454 this.now = this.start + ((this.end - this.start) * this.pos);
8455 }
8456 // Perform the next step of the animation
8457 this.update();
8458 }
8459
8460 return true;
8461 }
8462 };
8463
8464 jQuery.extend( jQuery.fx, {
8465 tick: function() {
8466 for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
8467 if ( !timers[i]() ) {
8468 timers.splice(i--, 1);
8469 }
8470 }
8471
8472 if ( !timers.length ) {
8473 jQuery.fx.stop();
8474 }
8475 },
8476
8477 interval: 13,
8478
8479 stop: function() {
8480 clearInterval( timerId );
8481 timerId = null;
8482 },
8483
8484 speeds: {
8485 slow: 600,
8486 fast: 200,
8487 // Default speed
8488 _default: 400
8489 },
8490
8491 step: {
8492 opacity: function( fx ) {
8493 jQuery.style( fx.elem, "opacity", fx.now );
8494 },
8495
8496 _default: function( fx ) {
8497 if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
8498 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
8499 } else {
8500 fx.elem[ fx.prop ] = fx.now;
8501 }
8502 }
8503 }
8504 });
8505
8506 if ( jQuery.expr && jQuery.expr.filters ) {
8507 jQuery.expr.filters.animated = function( elem ) {
8508 return jQuery.grep(jQuery.timers, function( fn ) {
8509 return elem === fn.elem;
8510 }).length;
8511 };
8512 }
8513
8514 // Try to restore the default display value of an element
8515 function defaultDisplay( nodeName ) {
8516
8517 if ( !elemdisplay[ nodeName ] ) {
8518
8519 var elem = jQuery( "<" + nodeName + ">" ).appendTo( "body" ),
8520 display = elem.css( "display" );
8521
8522 elem.remove();
8523
8524 // If the simple way fails,
8525 // get element's real default display by attaching it to a temp iframe
8526 if ( display === "none" || display === "" ) {
8527 // No iframe to use yet, so create it
8528 if ( !iframe ) {
8529 iframe = document.createElement( "iframe" );
8530 iframe.frameBorder = iframe.width = iframe.height = 0;
8531 }
8532
8533 document.body.appendChild( iframe );
8534
8535 // Create a cacheable copy of the iframe document on first call.
8536 // IE and Opera will allow us to reuse the iframeDoc without re-writing the fake html
8537 // document to it, Webkit & Firefox won't allow reusing the iframe document
8538 if ( !iframeDoc || !iframe.createElement ) {
8539 iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
8540 iframeDoc.write( "<!doctype><html><body></body></html>" );
8541 }
8542
8543 elem = iframeDoc.createElement( nodeName );
8544
8545 iframeDoc.body.appendChild( elem );
8546
8547 display = jQuery.css( elem, "display" );
8548
8549 document.body.removeChild( iframe );
8550 }
8551
8552 // Store the correct default display
8553 elemdisplay[ nodeName ] = display;
8554 }
8555
8556 return elemdisplay[ nodeName ];
8557 }
8558
8559
8560
8561
8562 var rtable = /^t(?:able|d|h)$/i,
8563 rroot = /^(?:body|html)$/i;
8564
8565 if ( "getBoundingClientRect" in document.documentElement ) {
8566 jQuery.fn.offset = function( options ) {
8567 var elem = this[0], box;
8568
8569 if ( options ) {
8570 return this.each(function( i ) {
8571 jQuery.offset.setOffset( this, options, i );
8572 });
8573 }
8574
8575 if ( !elem || !elem.ownerDocument ) {
8576 return null;
8577 }
8578
8579 if ( elem === elem.ownerDocument.body ) {
8580 return jQuery.offset.bodyOffset( elem );
8581 }
8582
8583 try {
8584 box = elem.getBoundingClientRect();
8585 } catch(e) {}
8586
8587 var doc = elem.ownerDocument,
8588 docElem = doc.documentElement;
8589
8590 // Make sure we're not dealing with a disconnected DOM node
8591 if ( !box || !jQuery.contains( docElem, elem ) ) {
8592 return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
8593 }
8594
8595 var body = doc.body,
8596 win = getWindow(doc),
8597 clientTop = docElem.clientTop || body.clientTop || 0,
8598 clientLeft = docElem.clientLeft || body.clientLeft || 0,
8599 scrollTop = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop,
8600 scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
8601 top = box.top + scrollTop - clientTop,
8602 left = box.left + scrollLeft - clientLeft;
8603
8604 return { top: top, left: left };
8605 };
8606
8607 } else {
8608 jQuery.fn.offset = function( options ) {
8609 var elem = this[0];
8610
8611 if ( options ) {
8612 return this.each(function( i ) {
8613 jQuery.offset.setOffset( this, options, i );
8614 });
8615 }
8616
8617 if ( !elem || !elem.ownerDocument ) {
8618 return null;
8619 }
8620
8621 if ( elem === elem.ownerDocument.body ) {
8622 return jQuery.offset.bodyOffset( elem );
8623 }
8624
8625 jQuery.offset.initialize();
8626
8627 var computedStyle,
8628 offsetParent = elem.offsetParent,
8629 prevOffsetParent = elem,
8630 doc = elem.ownerDocument,
8631 docElem = doc.documentElement,
8632 body = doc.body,
8633 defaultView = doc.defaultView,
8634 prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
8635 top = elem.offsetTop,
8636 left = elem.offsetLeft;
8637
8638 while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
8639 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
8640 break;
8641 }
8642
8643 computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
8644 top -= elem.scrollTop;
8645 left -= elem.scrollLeft;
8646
8647 if ( elem === offsetParent ) {
8648 top += elem.offsetTop;
8649 left += elem.offsetLeft;
8650
8651 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
8652 top += parseFloat( computedStyle.borderTopWidth ) || 0;
8653 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8654 }
8655
8656 prevOffsetParent = offsetParent;
8657 offsetParent = elem.offsetParent;
8658 }
8659
8660 if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
8661 top += parseFloat( computedStyle.borderTopWidth ) || 0;
8662 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
8663 }
8664
8665 prevComputedStyle = computedStyle;
8666 }
8667
8668 if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
8669 top += body.offsetTop;
8670 left += body.offsetLeft;
8671 }
8672
8673 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
8674 top += Math.max( docElem.scrollTop, body.scrollTop );
8675 left += Math.max( docElem.scrollLeft, body.scrollLeft );
8676 }
8677
8678 return { top: top, left: left };
8679 };
8680 }
8681
8682 jQuery.offset = {
8683 initialize: function() {
8684 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
8685 html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
8686
8687 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
8688
8689 container.innerHTML = html;
8690 body.insertBefore( container, body.firstChild );
8691 innerDiv = container.firstChild;
8692 checkDiv = innerDiv.firstChild;
8693 td = innerDiv.nextSibling.firstChild.firstChild;
8694
8695 this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
8696 this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
8697
8698 checkDiv.style.position = "fixed";
8699 checkDiv.style.top = "20px";
8700
8701 // safari subtracts parent border width here which is 5px
8702 this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
8703 checkDiv.style.position = checkDiv.style.top = "";
8704
8705 innerDiv.style.overflow = "hidden";
8706 innerDiv.style.position = "relative";
8707
8708 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
8709
8710 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
8711
8712 body.removeChild( container );
8713 jQuery.offset.initialize = jQuery.noop;
8714 },
8715
8716 bodyOffset: function( body ) {
8717 var top = body.offsetTop,
8718 left = body.offsetLeft;
8719
8720 jQuery.offset.initialize();
8721
8722 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
8723 top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
8724 left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
8725 }
8726
8727 return { top: top, left: left };
8728 },
8729
8730 setOffset: function( elem, options, i ) {
8731 var position = jQuery.css( elem, "position" );
8732
8733 // set position first, in-case top/left are set even on static elem
8734 if ( position === "static" ) {
8735 elem.style.position = "relative";
8736 }
8737
8738 var curElem = jQuery( elem ),
8739 curOffset = curElem.offset(),
8740 curCSSTop = jQuery.css( elem, "top" ),
8741 curCSSLeft = jQuery.css( elem, "left" ),
8742 calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
8743 props = {}, curPosition = {}, curTop, curLeft;
8744
8745 // need to be able to calculate position if either top or left is auto and position is either absolute or fixed
8746 if ( calculatePosition ) {
8747 curPosition = curElem.position();
8748 curTop = curPosition.top;
8749 curLeft = curPosition.left;
8750 } else {
8751 curTop = parseFloat( curCSSTop ) || 0;
8752 curLeft = parseFloat( curCSSLeft ) || 0;
8753 }
8754
8755 if ( jQuery.isFunction( options ) ) {
8756 options = options.call( elem, i, curOffset );
8757 }
8758
8759 if (options.top != null) {
8760 props.top = (options.top - curOffset.top) + curTop;
8761 }
8762 if (options.left != null) {
8763 props.left = (options.left - curOffset.left) + curLeft;
8764 }
8765
8766 if ( "using" in options ) {
8767 options.using.call( elem, props );
8768 } else {
8769 curElem.css( props );
8770 }
8771 }
8772 };
8773
8774
8775 jQuery.fn.extend({
8776 position: function() {
8777 if ( !this[0] ) {
8778 return null;
8779 }
8780
8781 var elem = this[0],
8782
8783 // Get *real* offsetParent
8784 offsetParent = this.offsetParent(),
8785
8786 // Get correct offsets
8787 offset = this.offset(),
8788 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
8789
8790 // Subtract element margins
8791 // note: when an element has margin: auto the offsetLeft and marginLeft
8792 // are the same in Safari causing offset.left to incorrectly be 0
8793 offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
8794 offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
8795
8796 // Add offsetParent borders
8797 parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
8798 parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
8799
8800 // Subtract the two offsets
8801 return {
8802 top: offset.top - parentOffset.top,
8803 left: offset.left - parentOffset.left
8804 };
8805 },
8806
8807 offsetParent: function() {
8808 return this.map(function() {
8809 var offsetParent = this.offsetParent || document.body;
8810 while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
8811 offsetParent = offsetParent.offsetParent;
8812 }
8813 return offsetParent;
8814 });
8815 }
8816 });
8817
8818
8819 // Create scrollLeft and scrollTop methods
8820 jQuery.each( ["Left", "Top"], function( i, name ) {
8821 var method = "scroll" + name;
8822
8823 jQuery.fn[ method ] = function( val ) {
8824 var elem, win;
8825
8826 if ( val === undefined ) {
8827 elem = this[ 0 ];
8828
8829 if ( !elem ) {
8830 return null;
8831 }
8832
8833 win = getWindow( elem );
8834
8835 // Return the scroll offset
8836 return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
8837 jQuery.support.boxModel && win.document.documentElement[ method ] ||
8838 win.document.body[ method ] :
8839 elem[ method ];
8840 }
8841
8842 // Set the scroll offset
8843 return this.each(function() {
8844 win = getWindow( this );
8845
8846 if ( win ) {
8847 win.scrollTo(
8848 !i ? val : jQuery( win ).scrollLeft(),
8849 i ? val : jQuery( win ).scrollTop()
8850 );
8851
8852 } else {
8853 this[ method ] = val;
8854 }
8855 });
8856 };
8857 });
8858
8859 function getWindow( elem ) {
8860 return jQuery.isWindow( elem ) ?
8861 elem :
8862 elem.nodeType === 9 ?
8863 elem.defaultView || elem.parentWindow :
8864 false;
8865 }
8866
8867
8868
8869
8870 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
8871 jQuery.each([ "Height", "Width" ], function( i, name ) {
8872
8873 var type = name.toLowerCase();
8874
8875 // innerHeight and innerWidth
8876 jQuery.fn["inner" + name] = function() {
8877 return this[0] ?
8878 parseFloat( jQuery.css( this[0], type, "padding" ) ) :
8879 null;
8880 };
8881
8882 // outerHeight and outerWidth
8883 jQuery.fn["outer" + name] = function( margin ) {
8884 return this[0] ?
8885 parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
8886 null;
8887 };
8888
8889 jQuery.fn[ type ] = function( size ) {
8890 // Get window width or height
8891 var elem = this[0];
8892 if ( !elem ) {
8893 return size == null ? null : this;
8894 }
8895
8896 if ( jQuery.isFunction( size ) ) {
8897 return this.each(function( i ) {
8898 var self = jQuery( this );
8899 self[ type ]( size.call( this, i, self[ type ]() ) );
8900 });
8901 }
8902
8903 if ( jQuery.isWindow( elem ) ) {
8904 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
8905 // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
8906 var docElemProp = elem.document.documentElement[ "client" + name ];
8907 return elem.document.compatMode === "CSS1Compat" && docElemProp ||
8908 elem.document.body[ "client" + name ] || docElemProp;
8909
8910 // Get document width or height
8911 } else if ( elem.nodeType === 9 ) {
8912 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
8913 return Math.max(
8914 elem.documentElement["client" + name],
8915 elem.body["scroll" + name], elem.documentElement["scroll" + name],
8916 elem.body["offset" + name], elem.documentElement["offset" + name]
8917 );
8918
8919 // Get or set width or height on the element
8920 } else if ( size === undefined ) {
8921 var orig = jQuery.css( elem, type ),
8922 ret = parseFloat( orig );
8923
8924 return jQuery.isNaN( ret ) ? orig : ret;
8925
8926 // Set the width or height on the element (default to pixels if value is unitless)
8927 } else {
8928 return this.css( type, typeof size === "string" ? size : size + "px" );
8929 }
8930 };
8931
8932 });
8933
8934
8935 window.jQuery = window.$ = jQuery;
8936 })(window);
