1 /*!
2 * jQuery JavaScript Library v1.4.4
3 * http://jquery.com/
4 *
5 * Copyright 2010, 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 2010, The Dojo Foundation
12 * Released under the MIT, BSD, and GPL Licenses.
13 *
14 * Date: Thu Nov 11 19:04:53 2010 -0500
15 */
16 (function( window, undefined ) {
17
18 // Use the correct document accordingly with window argument (sandbox)
19 var document = window.document;
20 var jQuery = (function() {
21
22 // Define a local copy of jQuery
23 var jQuery = function( selector, context ) {
24 // The jQuery object is actually just the init constructor 'enhanced'
25 return new jQuery.fn.init( selector, context );
26 },
27
28 // Map over jQuery in case of overwrite
29 _jQuery = window.jQuery,
30
31 // Map over the $ in case of overwrite
32 _$ = window.$,
33
34 // A central reference to the root jQuery(document)
35 rootjQuery,
36
37 // A simple way to check for HTML strings or ID strings
38 // (both of which we optimize for)
39 quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,
40
41 // Is it a simple selector
42 isSimple = /^.[^:#\[\.,]*$/,
43
44 // Check if a string has a non-whitespace character in it
45 rnotwhite = /\S/,
46 rwhite = /\s/,
47
48 // Used for trimming whitespace
49 trimLeft = /^\s+/,
50 trimRight = /\s+$/,
51
52 // Check for non-word characters
53 rnonword = /\W/,
54
55 // Check for digits
56 rdigit = /\d/,
57
58 // Match a standalone tag
59 rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
60
61 // JSON RegExp
62 rvalidchars = /^[\],:{}\s]*$/,
63 rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
64 rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
65 rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
66
67 // Useragent RegExp
68 rwebkit = /(webkit)[ \/]([\w.]+)/,
69 ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
70 rmsie = /(msie) ([\w.]+)/,
71 rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
72
73 // Keep a UserAgent string for use with jQuery.browser
74 userAgent = navigator.userAgent,
75
76 // For matching the engine and version of the browser
77 browserMatch,
78
79 // Has the ready events already been bound?
80 readyBound = false,
81
82 // The functions to execute on DOM ready
83 readyList = [],
84
85 // The ready event handler
86 DOMContentLoaded,
87
88 // Save a reference to some core methods
89 toString = Object.prototype.toString,
90 hasOwn = Object.prototype.hasOwnProperty,
91 push = Array.prototype.push,
92 slice = Array.prototype.slice,
93 trim = String.prototype.trim,
94 indexOf = Array.prototype.indexOf,
95
96 // [[Class]] -> type pairs
97 class2type = {};
98
99 jQuery.fn = jQuery.prototype = {
100 init: function( selector, context ) {
101 var match, elem, ret, doc;
102
103 // Handle $(""), $(null), or $(undefined)
104 if ( !selector ) {
105 return this;
106 }
107
108 // Handle $(DOMElement)
109 if ( selector.nodeType ) {
110 this.context = this[0] = selector;
111 this.length = 1;
112 return this;
113 }
114
115 // The body element only exists once, optimize finding it
116 if ( selector === "body" && !context && document.body ) {
117 this.context = document;
118 this[0] = document.body;
119 this.selector = "body";
120 this.length = 1;
121 return this;
122 }
123
124 // Handle HTML strings
125 if ( typeof selector === "string" ) {
126 // Are we dealing with HTML string or an ID?
127 match = quickExpr.exec( selector );
128
129 // Verify a match, and that no context was specified for #id
130 if ( match && (match[1] || !context) ) {
131
132 // HANDLE: $(html) -> $(array)
133 if ( match[1] ) {
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 ? ret.fragment.cloneNode(true) : 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: $("TAG")
180 } else if ( !context && !rnonword.test( selector ) ) {
181 this.selector = selector;
182 this.context = document;
183 selector = document.getElementsByTagName( selector );
184 return jQuery.merge( this, selector );
185
186 // HANDLE: $(expr, $(...))
187 } else if ( !context || context.jquery ) {
188 return (context || rootjQuery).find( selector );
189
190 // HANDLE: $(expr, context)
191 // (which is just equivalent to: $(context).find(expr)
192 } else {
193 return jQuery( context ).find( selector );
194 }
195
196 // HANDLE: $(function)
197 // Shortcut for document ready
198 } else if ( jQuery.isFunction( selector ) ) {
199 return rootjQuery.ready( selector );
200 }
201
202 if (selector.selector !== undefined) {
203 this.selector = selector.selector;
204 this.context = selector.context;
205 }
206
207 return jQuery.makeArray( selector, this );
208 },
209
210 // Start with an empty selector
211 selector: "",
212
213 // The current version of jQuery being used
214 jquery: "1.4.4",
215
216 // The default length of a jQuery object is 0
217 length: 0,
218
219 // The number of elements contained in the matched element set
220 size: function() {
221 return this.length;
222 },
223
224 toArray: function() {
225 return slice.call( this, 0 );
226 },
227
228 // Get the Nth element in the matched element set OR
229 // Get the whole matched element set as a clean array
230 get: function( num ) {
231 return num == null ?
232
233 // Return a 'clean' array
234 this.toArray() :
235
236 // Return just the object
237 ( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
238 },
239
240 // Take an array of elements and push it onto the stack
241 // (returning the new matched element set)
242 pushStack: function( elems, name, selector ) {
243 // Build a new jQuery matched element set
244 var ret = jQuery();
245
246 if ( jQuery.isArray( elems ) ) {
247 push.apply( ret, elems );
248
249 } else {
250 jQuery.merge( ret, elems );
251 }
252
253 // Add the old object onto the stack (as a reference)
254 ret.prevObject = this;
255
256 ret.context = this.context;
257
258 if ( name === "find" ) {
259 ret.selector = this.selector + (this.selector ? " " : "") + selector;
260 } else if ( name ) {
261 ret.selector = this.selector + "." + name + "(" + selector + ")";
262 }
263
264 // Return the newly-formed element set
265 return ret;
266 },
267
268 // Execute a callback for every element in the matched set.
269 // (You can seed the arguments with an array of args, but this is
270 // only used internally.)
271 each: function( callback, args ) {
272 return jQuery.each( this, callback, args );
273 },
274
275 ready: function( fn ) {
276 // Attach the listeners
277 jQuery.bindReady();
278
279 // If the DOM is already ready
280 if ( jQuery.isReady ) {
281 // Execute the function immediately
282 fn.call( document, jQuery );
283
284 // Otherwise, remember the function for later
285 } else if ( readyList ) {
286 // Add the function to the wait list
287 readyList.push( fn );
288 }
289
290 return this;
291 },
292
293 eq: function( i ) {
294 return i === -1 ?
295 this.slice( i ) :
296 this.slice( i, +i + 1 );
297 },
298
299 first: function() {
300 return this.eq( 0 );
301 },
302
303 last: function() {
304 return this.eq( -1 );
305 },
306
307 slice: function() {
308 return this.pushStack( slice.apply( this, arguments ),
309 "slice", slice.call(arguments).join(",") );
310 },
311
312 map: function( callback ) {
313 return this.pushStack( jQuery.map(this, function( elem, i ) {
314 return callback.call( elem, i, elem );
315 }));
316 },
317
318 end: function() {
319 return this.prevObject || jQuery(null);
320 },
321
322 // For internal use only.
323 // Behaves like an Array's method, not like a jQuery method.
324 push: push,
325 sort: [].sort,
326 splice: [].splice
327 };
328
329 // Give the init function the jQuery prototype for later instantiation
330 jQuery.fn.init.prototype = jQuery.fn;
331
332 jQuery.extend = jQuery.fn.extend = function() {
333 var options, name, src, copy, copyIsArray, clone,
334 target = arguments[0] || {},
335 i = 1,
336 length = arguments.length,
337 deep = false;
338
339 // Handle a deep copy situation
340 if ( typeof target === "boolean" ) {
341 deep = target;
342 target = arguments[1] || {};
343 // skip the boolean and the target
344 i = 2;
345 }
346
347 // Handle case when target is a string or something (possible in deep copy)
348 if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
349 target = {};
350 }
351
352 // extend jQuery itself if only one argument is passed
353 if ( length === i ) {
354 target = this;
355 --i;
356 }
357
358 for ( ; i < length; i++ ) {
359 // Only deal with non-null/undefined values
360 if ( (options = arguments[ i ]) != null ) {
361 // Extend the base object
362 for ( name in options ) {
363 src = target[ name ];
364 copy = options[ name ];
365
366 // Prevent never-ending loop
367 if ( target === copy ) {
368 continue;
369 }
370
371 // Recurse if we're merging plain objects or arrays
372 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
373 if ( copyIsArray ) {
374 copyIsArray = false;
375 clone = src && jQuery.isArray(src) ? src : [];
376
377 } else {
378 clone = src && jQuery.isPlainObject(src) ? src : {};
379 }
380
381 // Never move original objects, clone them
382 target[ name ] = jQuery.extend( deep, clone, copy );
383
384 // Don't bring in undefined values
385 } else if ( copy !== undefined ) {
386 target[ name ] = copy;
387 }
388 }
389 }
390 }
391
392 // Return the modified object
393 return target;
394 };
395
396 jQuery.extend({
397 noConflict: function( deep ) {
398 window.$ = _$;
399
400 if ( deep ) {
401 window.jQuery = _jQuery;
402 }
403
404 return jQuery;
405 },
406
407 // Is the DOM ready to be used? Set to true once it occurs.
408 isReady: false,
409
410 // A counter to track how many items to wait for before
411 // the ready event fires. See #6781
412 readyWait: 1,
413
414 // Handle when the DOM is ready
415 ready: function( wait ) {
416 // A third-party is pushing the ready event forwards
417 if ( wait === true ) {
418 jQuery.readyWait--;
419 }
420
421 // Make sure that the DOM is not already loaded
422 if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) {
423 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
424 if ( !document.body ) {
425 return setTimeout( jQuery.ready, 1 );
426 }
427
428 // Remember that the DOM is ready
429 jQuery.isReady = true;
430
431 // If a normal DOM Ready event fired, decrement, and wait if need be
432 if ( wait !== true && --jQuery.readyWait > 0 ) {
433 return;
434 }
435
436 // If there are functions bound, to execute
437 if ( readyList ) {
438 // Execute all of them
439 var fn,
440 i = 0,
441 ready = readyList;
442
443 // Reset the list of functions
444 readyList = null;
445
446 while ( (fn = ready[ i++ ]) ) {
447 fn.call( document, jQuery );
448 }
449
450 // Trigger any bound ready events
451 if ( jQuery.fn.trigger ) {
452 jQuery( document ).trigger( "ready" ).unbind( "ready" );
453 }
454 }
455 }
456 },
457
458 bindReady: function() {
459 if ( readyBound ) {
460 return;
461 }
462
463 readyBound = true;
464
465 // Catch cases where $(document).ready() is called after the
466 // browser event has already occurred.
467 if ( document.readyState === "complete" ) {
468 // Handle it asynchronously to allow scripts the opportunity to delay ready
469 return setTimeout( jQuery.ready, 1 );
470 }
471
472 // Mozilla, Opera and webkit nightlies currently support this event
473 if ( document.addEventListener ) {
474 // Use the handy event callback
475 document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
476
477 // A fallback to window.onload, that will always work
478 window.addEventListener( "load", jQuery.ready, false );
479
480 // If IE event model is used
481 } else if ( document.attachEvent ) {
482 // ensure firing before onload,
483 // maybe late but safe also for iframes
484 document.attachEvent("onreadystatechange", DOMContentLoaded);
485
486 // A fallback to window.onload, that will always work
487 window.attachEvent( "onload", jQuery.ready );
488
489 // If IE and not a frame
490 // continually check to see if the document is ready
491 var toplevel = false;
492
493 try {
494 toplevel = window.frameElement == null;
495 } catch(e) {}
496
497 if ( document.documentElement.doScroll && toplevel ) {
498 doScrollCheck();
499 }
500 }
501 },
502
503 // See test/unit/core.js for details concerning isFunction.
504 // Since version 1.3, DOM methods and functions like alert
505 // aren't supported. They return false on IE (#2968).
506 isFunction: function( obj ) {
507 return jQuery.type(obj) === "function";
508 },
509
510 isArray: Array.isArray || function( obj ) {
511 return jQuery.type(obj) === "array";
512 },
513
514 // A crude way of determining if an object is a window
515 isWindow: function( obj ) {
516 return obj && typeof obj === "object" && "setInterval" in obj;
517 },
518
519 isNaN: function( obj ) {
520 return obj == null || !rdigit.test( obj ) || isNaN( obj );
521 },
522
523 type: function( obj ) {
524 return obj == null ?
525 String( obj ) :
526 class2type[ toString.call(obj) ] || "object";
527 },
528
529 isPlainObject: function( obj ) {
530 // Must be an Object.
531 // Because of IE, we also have to check the presence of the constructor property.
532 // Make sure that DOM nodes and window objects don't pass through, as well
533 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
534 return false;
535 }
536
537 // Not own constructor property must be Object
538 if ( obj.constructor &&
539 !hasOwn.call(obj, "constructor") &&
540 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
541 return false;
542 }
543
544 // Own properties are enumerated firstly, so to speed up,
545 // if last one is own, then all properties are own.
546
547 var key;
548 for ( key in obj ) {}
549
550 return key === undefined || hasOwn.call( obj, key );
551 },
552
553 isEmptyObject: function( obj ) {
554 for ( var name in obj ) {
555 return false;
556 }
557 return true;
558 },
559
560 error: function( msg ) {
561 throw msg;
562 },
563
564 parseJSON: function( data ) {
565 if ( typeof data !== "string" || !data ) {
566 return null;
567 }
568
569 // Make sure leading/trailing whitespace is removed (IE can't handle it)
570 data = jQuery.trim( data );
571
572 // Make sure the incoming data is actual JSON
573 // Logic borrowed from http://json.org/json2.js
574 if ( rvalidchars.test(data.replace(rvalidescape, "@")
575 .replace(rvalidtokens, "]")
576 .replace(rvalidbraces, "")) ) {
577
578 // Try to use the native JSON parser first
579 return window.JSON && window.JSON.parse ?
580 window.JSON.parse( data ) :
581 (new Function("return " + data))();
582
583 } else {
584 jQuery.error( "Invalid JSON: " + data );
585 }
586 },
587
588 noop: function() {},
589
590 // Evalulates a script in a global context
591 globalEval: function( data ) {
592 if ( data && rnotwhite.test(data) ) {
593 // Inspired by code by Andrea Giammarchi
594 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
595 var head = document.getElementsByTagName("head")[0] || document.documentElement,
596 script = document.createElement("script");
597
598 script.type = "text/javascript";
599
600 if ( jQuery.support.scriptEval ) {
601 script.appendChild( document.createTextNode( data ) );
602 } else {
603 script.text = data;
604 }
605
606 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
607 // This arises when a base node is used (#2709).
608 head.insertBefore( script, head.firstChild );
609 head.removeChild( script );
610 }
611 },
612
613 nodeName: function( elem, name ) {
614 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
615 },
616
617 // args is for internal usage only
618 each: function( object, callback, args ) {
619 var name, i = 0,
620 length = object.length,
621 isObj = length === undefined || jQuery.isFunction(object);
622
623 if ( args ) {
624 if ( isObj ) {
625 for ( name in object ) {
626 if ( callback.apply( object[ name ], args ) === false ) {
627 break;
628 }
629 }
630 } else {
631 for ( ; i < length; ) {
632 if ( callback.apply( object[ i++ ], args ) === false ) {
633 break;
634 }
635 }
636 }
637
638 // A special, fast, case for the most common use of each
639 } else {
640 if ( isObj ) {
641 for ( name in object ) {
642 if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
643 break;
644 }
645 }
646 } else {
647 for ( var value = object[0];
648 i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
649 }
650 }
651
652 return object;
653 },
654
655 // Use native String.trim function wherever possible
656 trim: trim ?
657 function( text ) {
658 return text == null ?
659 "" :
660 trim.call( text );
661 } :
662
663 // Otherwise use our own trimming functionality
664 function( text ) {
665 return text == null ?
666 "" :
667 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
668 },
669
670 // results is for internal usage only
671 makeArray: function( array, results ) {
672 var ret = results || [];
673
674 if ( array != null ) {
675 // The window, strings (and functions) also have 'length'
676 // The extra typeof function check is to prevent crashes
677 // in Safari 2 (See: #3039)
678 // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
679 var type = jQuery.type(array);
680
681 if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
682 push.call( ret, array );
683 } else {
684 jQuery.merge( ret, array );
685 }
686 }
687
688 return ret;
689 },
690
691 inArray: function( elem, array ) {
692 if ( array.indexOf ) {
693 return array.indexOf( elem );
694 }
695
696 for ( var i = 0, length = array.length; i < length; i++ ) {
697 if ( array[ i ] === elem ) {
698 return i;
699 }
700 }
701
702 return -1;
703 },
704
705 merge: function( first, second ) {
706 var i = first.length,
707 j = 0;
708
709 if ( typeof second.length === "number" ) {
710 for ( var l = second.length; j < l; j++ ) {
711 first[ i++ ] = second[ j ];
712 }
713
714 } else {
715 while ( second[j] !== undefined ) {
716 first[ i++ ] = second[ j++ ];
717 }
718 }
719
720 first.length = i;
721
722 return first;
723 },
724
725 grep: function( elems, callback, inv ) {
726 var ret = [], retVal;
727 inv = !!inv;
728
729 // Go through the array, only saving the items
730 // that pass the validator function
731 for ( var i = 0, length = elems.length; i < length; i++ ) {
732 retVal = !!callback( elems[ i ], i );
733 if ( inv !== retVal ) {
734 ret.push( elems[ i ] );
735 }
736 }
737
738 return ret;
739 },
740
741 // arg is for internal usage only
742 map: function( elems, callback, arg ) {
743 var ret = [], value;
744
745 // Go through the array, translating each of the items to their
746 // new value (or values).
747 for ( var i = 0, length = elems.length; i < length; i++ ) {
748 value = callback( elems[ i ], i, arg );
749
750 if ( value != null ) {
751 ret[ ret.length ] = value;
752 }
753 }
754
755 return ret.concat.apply( [], ret );
756 },
757
758 // A global GUID counter for objects
759 guid: 1,
760
761 proxy: function( fn, proxy, thisObject ) {
762 if ( arguments.length === 2 ) {
763 if ( typeof proxy === "string" ) {
764 thisObject = fn;
765 fn = thisObject[ proxy ];
766 proxy = undefined;
767
768 } else if ( proxy && !jQuery.isFunction( proxy ) ) {
769 thisObject = proxy;
770 proxy = undefined;
771 }
772 }
773
774 if ( !proxy && fn ) {
775 proxy = function() {
776 return fn.apply( thisObject || this, arguments );
777 };
778 }
779
780 // Set the guid of unique handler to the same of original handler, so it can be removed
781 if ( fn ) {
782 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
783 }
784
785 // So proxy can be declared as an argument
786 return proxy;
787 },
788
789 // Mutifunctional method to get and set values to a collection
790 // The value/s can be optionally by executed if its a function
791 access: function( elems, key, value, exec, fn, pass ) {
792 var length = elems.length;
793
794 // Setting many attributes
795 if ( typeof key === "object" ) {
796 for ( var k in key ) {
797 jQuery.access( elems, k, key[k], exec, fn, value );
798 }
799 return elems;
800 }
801
802 // Setting one attribute
803 if ( value !== undefined ) {
804 // Optionally, function values get executed if exec is true
805 exec = !pass && exec && jQuery.isFunction(value);
806
807 for ( var i = 0; i < length; i++ ) {
808 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
809 }
810
811 return elems;
812 }
813
814 // Getting an attribute
815 return length ? fn( elems[0], key ) : undefined;
816 },
817
818 now: function() {
819 return (new Date()).getTime();
820 },
821
822 // Use of jQuery.browser is frowned upon.
823 // More details: http://docs.jquery.com/Utilities/jQuery.browser
824 uaMatch: function( ua ) {
825 ua = ua.toLowerCase();
826
827 var match = rwebkit.exec( ua ) ||
828 ropera.exec( ua ) ||
829 rmsie.exec( ua ) ||
830 ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
831 [];
832
833 return { browser: match[1] || "", version: match[2] || "0" };
834 },
835
836 browser: {}
837 });
838
839 // Populate the class2type map
840 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
841 class2type[ "[object " + name + "]" ] = name.toLowerCase();
842 });
843
844 browserMatch = jQuery.uaMatch( userAgent );
845 if ( browserMatch.browser ) {
846 jQuery.browser[ browserMatch.browser ] = true;
847 jQuery.browser.version = browserMatch.version;
848 }
849
850 // Deprecated, use jQuery.browser.webkit instead
851 if ( jQuery.browser.webkit ) {
852 jQuery.browser.safari = true;
853 }
854
855 if ( indexOf ) {
856 jQuery.inArray = function( elem, array ) {
857 return indexOf.call( array, elem );
858 };
859 }
860
861 // Verify that \s matches non-breaking spaces
862 // (IE fails on this test)
863 if ( !rwhite.test( "\xA0" ) ) {
864 trimLeft = /^[\s\xA0]+/;
865 trimRight = /[\s\xA0]+$/;
866 }
867
868 // All jQuery objects should point back to these
869 rootjQuery = jQuery(document);
870
871 // Cleanup functions for the document ready method
872 if ( document.addEventListener ) {
873 DOMContentLoaded = function() {
874 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
875 jQuery.ready();
876 };
877
878 } else if ( document.attachEvent ) {
879 DOMContentLoaded = function() {
880 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
881 if ( document.readyState === "complete" ) {
882 document.detachEvent( "onreadystatechange", DOMContentLoaded );
883 jQuery.ready();
884 }
885 };
886 }
887
888 // The DOM ready check for Internet Explorer
889 function doScrollCheck() {
890 if ( jQuery.isReady ) {
891 return;
892 }
893
894 try {
895 // If IE is used, use the trick by Diego Perini
896 // http://javascript.nwbox.com/IEContentLoaded/
897 document.documentElement.doScroll("left");
898 } catch(e) {
899 setTimeout( doScrollCheck, 1 );
900 return;
901 }
902
903 // and execute any waiting functions
904 jQuery.ready();
905 }
906
907 // Expose jQuery to the global object
908 return (window.jQuery = window.$ = jQuery);
909
910 })();
911
912
913 (function() {
914
915 jQuery.support = {};
916
917 var root = document.documentElement,
918 script = document.createElement("script"),
919 div = document.createElement("div"),
920 id = "script" + jQuery.now();
921
922 div.style.display = "none";
923 div.innerHTML = " <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
924
925 var all = div.getElementsByTagName("*"),
926 a = div.getElementsByTagName("a")[0],
927 select = document.createElement("select"),
928 opt = select.appendChild( document.createElement("option") );
929
930 // Can't get basic test support
931 if ( !all || !all.length || !a ) {
932 return;
933 }
934
935 jQuery.support = {
936 // IE strips leading whitespace when .innerHTML is used
937 leadingWhitespace: div.firstChild.nodeType === 3,
938
939 // Make sure that tbody elements aren't automatically inserted
940 // IE will insert them into empty tables
941 tbody: !div.getElementsByTagName("tbody").length,
942
943 // Make sure that link elements get serialized correctly by innerHTML
944 // This requires a wrapper element in IE
945 htmlSerialize: !!div.getElementsByTagName("link").length,
946
947 // Get the style information from getAttribute
948 // (IE uses .cssText insted)
949 style: /red/.test( a.getAttribute("style") ),
950
951 // Make sure that URLs aren't manipulated
952 // (IE normalizes it by default)
953 hrefNormalized: a.getAttribute("href") === "/a",
954
955 // Make sure that element opacity exists
956 // (IE uses filter instead)
957 // Use a regex to work around a WebKit issue. See #5145
958 opacity: /^0.55$/.test( a.style.opacity ),
959
960 // Verify style float existence
961 // (IE uses styleFloat instead of cssFloat)
962 cssFloat: !!a.style.cssFloat,
963
964 // Make sure that if no value is specified for a checkbox
965 // that it defaults to "on".
966 // (WebKit defaults to "" instead)
967 checkOn: div.getElementsByTagName("input")[0].value === "on",
968
969 // Make sure that a selected-by-default option has a working selected property.
970 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
971 optSelected: opt.selected,
972
973 // Will be defined later
974 deleteExpando: true,
975 optDisabled: false,
976 checkClone: false,
977 scriptEval: false,
978 noCloneEvent: true,
979 boxModel: null,
980 inlineBlockNeedsLayout: false,
981 shrinkWrapBlocks: false,
982 reliableHiddenOffsets: true
983 };
984
985 // Make sure that the options inside disabled selects aren't marked as disabled
986 // (WebKit marks them as diabled)
987 select.disabled = true;
988 jQuery.support.optDisabled = !opt.disabled;
989
990 script.type = "text/javascript";
991 try {
992 script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
993 } catch(e) {}
994
995 root.insertBefore( script, root.firstChild );
996
997 // Make sure that the execution of code works by injecting a script
998 // tag with appendChild/createTextNode
999 // (IE doesn't support this, fails, and uses .text instead)
1000 if ( window[ id ] ) {
1001 jQuery.support.scriptEval = true;
1002 delete window[ id ];
1003 }
1004
1005 // Test to see if it's possible to delete an expando from an element
1006 // Fails in Internet Explorer
1007 try {
1008 delete script.test;
1009
1010 } catch(e) {
1011 jQuery.support.deleteExpando = false;
1012 }
1013
1014 root.removeChild( script );
1015
1016 if ( div.attachEvent && div.fireEvent ) {
1017 div.attachEvent("onclick", function click() {
1018 // Cloning a node shouldn't copy over any
1019 // bound event handlers (IE does this)
1020 jQuery.support.noCloneEvent = false;
1021 div.detachEvent("onclick", click);
1022 });
1023 div.cloneNode(true).fireEvent("onclick");
1024 }
1025
1026 div = document.createElement("div");
1027 div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
1028
1029 var fragment = document.createDocumentFragment();
1030 fragment.appendChild( div.firstChild );
1031
1032 // WebKit doesn't clone checked state correctly in fragments
1033 jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
1034
1035 // Figure out if the W3C box model works as expected
1036 // document.body must exist before we can do this
1037 jQuery(function() {
1038 var div = document.createElement("div");
1039 div.style.width = div.style.paddingLeft = "1px";
1040
1041 document.body.appendChild( div );
1042 jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
1043
1044 if ( "zoom" in div.style ) {
1045 // Check if natively block-level elements act like inline-block
1046 // elements when setting their display to 'inline' and giving
1047 // them layout
1048 // (IE < 8 does this)
1049 div.style.display = "inline";
1050 div.style.zoom = 1;
1051 jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2;
1052
1053 // Check if elements with layout shrink-wrap their children
1054 // (IE 6 does this)
1055 div.style.display = "";
1056 div.innerHTML = "<div style='width:4px;'></div>";
1057 jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2;
1058 }
1059
1060 div.innerHTML = "<table><tr><td style='padding:0;display:none'></td><td>t</td></tr></table>";
1061 var tds = div.getElementsByTagName("td");
1062
1063 // Check if table cells still have offsetWidth/Height when they are set
1064 // to display:none and there are still other visible table cells in a
1065 // table row; if so, offsetWidth/Height are not reliable for use when
1066 // determining if an element has been hidden directly using
1067 // display:none (it is still safe to use offsets if a parent element is
1068 // hidden; don safety goggles and see bug #4512 for more information).
1069 // (only IE 8 fails this test)
1070 jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0;
1071
1072 tds[0].style.display = "";
1073 tds[1].style.display = "none";
1074
1075 // Check if empty table cells still have offsetWidth/Height
1076 // (IE < 8 fail this test)
1077 jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
1078 div.innerHTML = "";
1079
1080 document.body.removeChild( div ).style.display = "none";
1081 div = tds = null;
1082 });
1083
1084 // Technique from Juriy Zaytsev
1085 // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1086 var eventSupported = function( eventName ) {
1087 var el = document.createElement("div");
1088 eventName = "on" + eventName;
1089
1090 var isSupported = (eventName in el);
1091 if ( !isSupported ) {
1092 el.setAttribute(eventName, "return;");
1093 isSupported = typeof el[eventName] === "function";
1094 }
1095 el = null;
1096
1097 return isSupported;
1098 };
1099
1100 jQuery.support.submitBubbles = eventSupported("submit");
1101 jQuery.support.changeBubbles = eventSupported("change");
1102
1103 // release memory in IE
1104 root = script = div = all = a = null;
1105 })();
1106
1107
1108
1109 var windowData = {},
1110 rbrace = /^(?:\{.*\}|\[.*\])$/;
1111
1112 jQuery.extend({
1113 cache: {},
1114
1115 // Please use with caution
1116 uuid: 0,
1117
1118 // Unique for each copy of jQuery on the page
1119 expando: "jQuery" + jQuery.now(),
1120
1121 // The following elements throw uncatchable exceptions if you
1122 // attempt to add expando properties to them.
1123 noData: {
1124 "embed": true,
1125 // Ban all objects except for Flash (which handle expandos)
1126 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1127 "applet": true
1128 },
1129
1130 data: function( elem, name, data ) {
1131 if ( !jQuery.acceptData( elem ) ) {
1132 return;
1133 }
1134
1135 elem = elem == window ?
1136 windowData :
1137 elem;
1138
1139 var isNode = elem.nodeType,
1140 id = isNode ? elem[ jQuery.expando ] : null,
1141 cache = jQuery.cache, thisCache;
1142
1143 if ( isNode && !id && typeof name === "string" && data === undefined ) {
1144 return;
1145 }
1146
1147 // Get the data from the object directly
1148 if ( !isNode ) {
1149 cache = elem;
1150
1151 // Compute a unique ID for the element
1152 } else if ( !id ) {
1153 elem[ jQuery.expando ] = id = ++jQuery.uuid;
1154 }
1155
1156 // Avoid generating a new cache unless none exists and we
1157 // want to manipulate it.
1158 if ( typeof name === "object" ) {
1159 if ( isNode ) {
1160 cache[ id ] = jQuery.extend(cache[ id ], name);
1161
1162 } else {
1163 jQuery.extend( cache, name );
1164 }
1165
1166 } else if ( isNode && !cache[ id ] ) {
1167 cache[ id ] = {};
1168 }
1169
1170 thisCache = isNode ? cache[ id ] : cache;
1171
1172 // Prevent overriding the named cache with undefined values
1173 if ( data !== undefined ) {
1174 thisCache[ name ] = data;
1175 }
1176
1177 return typeof name === "string" ? thisCache[ name ] : thisCache;
1178 },
1179
1180 removeData: function( elem, name ) {
1181 if ( !jQuery.acceptData( elem ) ) {
1182 return;
1183 }
1184
1185 elem = elem == window ?
1186 windowData :
1187 elem;
1188
1189 var isNode = elem.nodeType,
1190 id = isNode ? elem[ jQuery.expando ] : elem,
1191 cache = jQuery.cache,
1192 thisCache = isNode ? cache[ id ] : id;
1193
1194 // If we want to remove a specific section of the element's data
1195 if ( name ) {
1196 if ( thisCache ) {
1197 // Remove the section of cache data
1198 delete thisCache[ name ];
1199
1200 // If we've removed all the data, remove the element's cache
1201 if ( isNode && jQuery.isEmptyObject(thisCache) ) {
1202 jQuery.removeData( elem );
1203 }
1204 }
1205
1206 // Otherwise, we want to remove all of the element's data
1207 } else {
1208 if ( isNode && jQuery.support.deleteExpando ) {
1209 delete elem[ jQuery.expando ];
1210
1211 } else if ( elem.removeAttribute ) {
1212 elem.removeAttribute( jQuery.expando );
1213
1214 // Completely remove the data cache
1215 } else if ( isNode ) {
1216 delete cache[ id ];
1217
1218 // Remove all fields from the object
1219 } else {
1220 for ( var n in elem ) {
1221 delete elem[ n ];
1222 }
1223 }
1224 }
1225 },
1226
1227 // A method for determining if a DOM node can handle the data expando
1228 acceptData: function( elem ) {
1229 if ( elem.nodeName ) {
1230 var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1231
1232 if ( match ) {
1233 return !(match === true || elem.getAttribute("classid") !== match);
1234 }
1235 }
1236
1237 return true;
1238 }
1239 });
1240
1241 jQuery.fn.extend({
1242 data: function( key, value ) {
1243 var data = null;
1244
1245 if ( typeof key === "undefined" ) {
1246 if ( this.length ) {
1247 var attr = this[0].attributes, name;
1248 data = jQuery.data( this[0] );
1249
1250 for ( var i = 0, l = attr.length; i < l; i++ ) {
1251 name = attr[i].name;
1252
1253 if ( name.indexOf( "data-" ) === 0 ) {
1254 name = name.substr( 5 );
1255 dataAttr( this[0], name, data[ name ] );
1256 }
1257 }
1258 }
1259
1260 return data;
1261
1262 } else if ( typeof key === "object" ) {
1263 return this.each(function() {
1264 jQuery.data( this, key );
1265 });
1266 }
1267
1268 var parts = key.split(".");
1269 parts[1] = parts[1] ? "." + parts[1] : "";
1270
1271 if ( value === undefined ) {
1272 data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1273
1274 // Try to fetch any internally stored data first
1275 if ( data === undefined && this.length ) {
1276 data = jQuery.data( this[0], key );
1277 data = dataAttr( this[0], key, data );
1278 }
1279
1280 return data === undefined && parts[1] ?
1281 this.data( parts[0] ) :
1282 data;
1283
1284 } else {
1285 return this.each(function() {
1286 var $this = jQuery( this ),
1287 args = [ parts[0], value ];
1288
1289 $this.triggerHandler( "setData" + parts[1] + "!", args );
1290 jQuery.data( this, key, value );
1291 $this.triggerHandler( "changeData" + parts[1] + "!", args );
1292 });
1293 }
1294 },
1295
1296 removeData: function( key ) {
1297 return this.each(function() {
1298 jQuery.removeData( this, key );
1299 });
1300 }
1301 });
1302
1303 function dataAttr( elem, key, data ) {
1304 // If nothing was found internally, try to fetch any
1305 // data from the HTML5 data-* attribute
1306 if ( data === undefined && elem.nodeType === 1 ) {
1307 data = elem.getAttribute( "data-" + key );
1308
1309 if ( typeof data === "string" ) {
1310 try {
1311 data = data === "true" ? true :
1312 data === "false" ? false :
1313 data === "null" ? null :
1314 !jQuery.isNaN( data ) ? parseFloat( data ) :
1315 rbrace.test( data ) ? jQuery.parseJSON( data ) :
1316 data;
1317 } catch( e ) {}
1318
1319 // Make sure we set the data so it isn't changed later
1320 jQuery.data( elem, key, data );
1321
1322 } else {
1323 data = undefined;
1324 }
1325 }
1326
1327 return data;
1328 }
1329
1330
1331
1332
1333 jQuery.extend({
1334 queue: function( elem, type, data ) {
1335 if ( !elem ) {
1336 return;
1337 }
1338
1339 type = (type || "fx") + "queue";
1340 var q = jQuery.data( elem, type );
1341
1342 // Speed up dequeue by getting out quickly if this is just a lookup
1343 if ( !data ) {
1344 return q || [];
1345 }
1346
1347 if ( !q || jQuery.isArray(data) ) {
1348 q = jQuery.data( elem, type, jQuery.makeArray(data) );
1349
1350 } else {
1351 q.push( data );
1352 }
1353
1354 return q;
1355 },
1356
1357 dequeue: function( elem, type ) {
1358 type = type || "fx";
1359
1360 var queue = jQuery.queue( elem, type ),
1361 fn = queue.shift();
1362
1363 // If the fx queue is dequeued, always remove the progress sentinel
1364 if ( fn === "inprogress" ) {
1365 fn = queue.shift();
1366 }
1367
1368 if ( fn ) {
1369 // Add a progress sentinel to prevent the fx queue from being
1370 // automatically dequeued
1371 if ( type === "fx" ) {
1372 queue.unshift("inprogress");
1373 }
1374
1375 fn.call(elem, function() {
1376 jQuery.dequeue(elem, type);
1377 });
1378 }
1379 }
1380 });
1381
1382 jQuery.fn.extend({
1383 queue: function( type, data ) {
1384 if ( typeof type !== "string" ) {
1385 data = type;
1386 type = "fx";
1387 }
1388
1389 if ( data === undefined ) {
1390 return jQuery.queue( this[0], type );
1391 }
1392 return this.each(function( i ) {
1393 var queue = jQuery.queue( this, type, data );
1394
1395 if ( type === "fx" && queue[0] !== "inprogress" ) {
1396 jQuery.dequeue( this, type );
1397 }
1398 });
1399 },
1400 dequeue: function( type ) {
1401 return this.each(function() {
1402 jQuery.dequeue( this, type );
1403 });
1404 },
1405
1406 // Based off of the plugin by Clint Helfers, with permission.
1407 // http://blindsignals.com/index.php/2009/07/jquery-delay/
1408 delay: function( time, type ) {
1409 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1410 type = type || "fx";
1411
1412 return this.queue( type, function() {
1413 var elem = this;
1414 setTimeout(function() {
1415 jQuery.dequeue( elem, type );
1416 }, time );
1417 });
1418 },
1419
1420 clearQueue: function( type ) {
1421 return this.queue( type || "fx", [] );
1422 }
1423 });
1424
1425
1426
1427
1428 var rclass = /[\n\t]/g,
1429 rspaces = /\s+/,
1430 rreturn = /\r/g,
1431 rspecialurl = /^(?:href|src|style)$/,
1432 rtype = /^(?:button|input)$/i,
1433 rfocusable = /^(?:button|input|object|select|textarea)$/i,
1434 rclickable = /^a(?:rea)?$/i,
1435 rradiocheck = /^(?:radio|checkbox)$/i;
1436
1437 jQuery.props = {
1438 "for": "htmlFor",
1439 "class": "className",
1440 readonly: "readOnly",
1441 maxlength: "maxLength",
1442 cellspacing: "cellSpacing",
1443 rowspan: "rowSpan",
1444 colspan: "colSpan",
1445 tabindex: "tabIndex",
1446 usemap: "useMap",
1447 frameborder: "frameBorder"
1448 };
1449
1450 jQuery.fn.extend({
1451 attr: function( name, value ) {
1452 return jQuery.access( this, name, value, true, jQuery.attr );
1453 },
1454
1455 removeAttr: function( name, fn ) {
1456 return this.each(function(){
1457 jQuery.attr( this, name, "" );
1458 if ( this.nodeType === 1 ) {
1459 this.removeAttribute( name );
1460 }
1461 });
1462 },
1463
1464 addClass: function( value ) {
1465 if ( jQuery.isFunction(value) ) {
1466 return this.each(function(i) {
1467 var self = jQuery(this);
1468 self.addClass( value.call(this, i, self.attr("class")) );
1469 });
1470 }
1471
1472 if ( value && typeof value === "string" ) {
1473 var classNames = (value || "").split( rspaces );
1474
1475 for ( var i = 0, l = this.length; i < l; i++ ) {
1476 var elem = this[i];
1477
1478 if ( elem.nodeType === 1 ) {
1479 if ( !elem.className ) {
1480 elem.className = value;
1481
1482 } else {
1483 var className = " " + elem.className + " ",
1484 setClass = elem.className;
1485
1486 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1487 if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1488 setClass += " " + classNames[c];
1489 }
1490 }
1491 elem.className = jQuery.trim( setClass );
1492 }
1493 }
1494 }
1495 }
1496
1497 return this;
1498 },
1499
1500 removeClass: function( value ) {
1501 if ( jQuery.isFunction(value) ) {
1502 return this.each(function(i) {
1503 var self = jQuery(this);
1504 self.removeClass( value.call(this, i, self.attr("class")) );
1505 });
1506 }
1507
1508 if ( (value && typeof value === "string") || value === undefined ) {
1509 var classNames = (value || "").split( rspaces );
1510
1511 for ( var i = 0, l = this.length; i < l; i++ ) {
1512 var elem = this[i];
1513
1514 if ( elem.nodeType === 1 && elem.className ) {
1515 if ( value ) {
1516 var className = (" " + elem.className + " ").replace(rclass, " ");
1517 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1518 className = className.replace(" " + classNames[c] + " ", " ");
1519 }
1520 elem.className = jQuery.trim( className );
1521
1522 } else {
1523 elem.className = "";
1524 }
1525 }
1526 }
1527 }
1528
1529 return this;
1530 },
1531
1532 toggleClass: function( value, stateVal ) {
1533 var type = typeof value,
1534 isBool = typeof stateVal === "boolean";
1535
1536 if ( jQuery.isFunction( value ) ) {
1537 return this.each(function(i) {
1538 var self = jQuery(this);
1539 self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1540 });
1541 }
1542
1543 return this.each(function() {
1544 if ( type === "string" ) {
1545 // toggle individual class names
1546 var className,
1547 i = 0,
1548 self = jQuery( this ),
1549 state = stateVal,
1550 classNames = value.split( rspaces );
1551
1552 while ( (className = classNames[ i++ ]) ) {
1553 // check each className given, space seperated list
1554 state = isBool ? state : !self.hasClass( className );
1555 self[ state ? "addClass" : "removeClass" ]( className );
1556 }
1557
1558 } else if ( type === "undefined" || type === "boolean" ) {
1559 if ( this.className ) {
1560 // store className if set
1561 jQuery.data( this, "__className__", this.className );
1562 }
1563
1564 // toggle whole className
1565 this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1566 }
1567 });
1568 },
1569
1570 hasClass: function( selector ) {
1571 var className = " " + selector + " ";
1572 for ( var i = 0, l = this.length; i < l; i++ ) {
1573 if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1574 return true;
1575 }
1576 }
1577
1578 return false;
1579 },
1580
1581 val: function( value ) {
1582 if ( !arguments.length ) {
1583 var elem = this[0];
1584
1585 if ( elem ) {
1586 if ( jQuery.nodeName( elem, "option" ) ) {
1587 // attributes.value is undefined in Blackberry 4.7 but
1588 // uses .value. See #6932
1589 var val = elem.attributes.value;
1590 return !val || val.specified ? elem.value : elem.text;
1591 }
1592
1593 // We need to handle select boxes special
1594 if ( jQuery.nodeName( elem, "select" ) ) {
1595 var index = elem.selectedIndex,
1596 values = [],
1597 options = elem.options,
1598 one = elem.type === "select-one";
1599
1600 // Nothing was selected
1601 if ( index < 0 ) {
1602 return null;
1603 }
1604
1605 // Loop through all the selected options
1606 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1607 var option = options[ i ];
1608
1609 // Don't return options that are disabled or in a disabled optgroup
1610 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
1611 (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
1612
1613 // Get the specific value for the option
1614 value = jQuery(option).val();
1615
1616 // We don't need an array for one selects
1617 if ( one ) {
1618 return value;
1619 }
1620
1621 // Multi-Selects return an array
1622 values.push( value );
1623 }
1624 }
1625
1626 return values;
1627 }
1628
1629 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1630 if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1631 return elem.getAttribute("value") === null ? "on" : elem.value;
1632 }
1633
1634
1635 // Everything else, we just grab the value
1636 return (elem.value || "").replace(rreturn, "");
1637
1638 }
1639
1640 return undefined;
1641 }
1642
1643 var isFunction = jQuery.isFunction(value);
1644
1645 return this.each(function(i) {
1646 var self = jQuery(this), val = value;
1647
1648 if ( this.nodeType !== 1 ) {
1649 return;
1650 }
1651
1652 if ( isFunction ) {
1653 val = value.call(this, i, self.val());
1654 }
1655
1656 // Treat null/undefined as ""; convert numbers to string
1657 if ( val == null ) {
1658 val = "";
1659 } else if ( typeof val === "number" ) {
1660 val += "";
1661 } else if ( jQuery.isArray(val) ) {
1662 val = jQuery.map(val, function (value) {
1663 return value == null ? "" : value + "";
1664 });
1665 }
1666
1667 if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1668 this.checked = jQuery.inArray( self.val(), val ) >= 0;
1669
1670 } else if ( jQuery.nodeName( this, "select" ) ) {
1671 var values = jQuery.makeArray(val);
1672
1673 jQuery( "option", this ).each(function() {
1674 this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1675 });
1676
1677 if ( !values.length ) {
1678 this.selectedIndex = -1;
1679 }
1680
1681 } else {
1682 this.value = val;
1683 }
1684 });
1685 }
1686 });
1687
1688 jQuery.extend({
1689 attrFn: {
1690 val: true,
1691 css: true,
1692 html: true,
1693 text: true,
1694 data: true,
1695 width: true,
1696 height: true,
1697 offset: true
1698 },
1699
1700 attr: function( elem, name, value, pass ) {
1701 // don't set attributes on text and comment nodes
1702 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1703 return undefined;
1704 }
1705
1706 if ( pass && name in jQuery.attrFn ) {
1707 return jQuery(elem)[name](value);
1708 }
1709
1710 var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
1711 // Whether we are setting (or getting)
1712 set = value !== undefined;
1713
1714 // Try to normalize/fix the name
1715 name = notxml && jQuery.props[ name ] || name;
1716
1717 // These attributes require special treatment
1718 var special = rspecialurl.test( name );
1719
1720 // Safari mis-reports the default selected property of an option
1721 // Accessing the parent's selectedIndex property fixes it
1722 if ( name === "selected" && !jQuery.support.optSelected ) {
1723 var parent = elem.parentNode;
1724 if ( parent ) {
1725 parent.selectedIndex;
1726
1727 // Make sure that it also works with optgroups, see #5701
1728 if ( parent.parentNode ) {
1729 parent.parentNode.selectedIndex;
1730 }
1731 }
1732 }
1733
1734 // If applicable, access the attribute via the DOM 0 way
1735 // 'in' checks fail in Blackberry 4.7 #6931
1736 if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
1737 if ( set ) {
1738 // We can't allow the type property to be changed (since it causes problems in IE)
1739 if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
1740 jQuery.error( "type property can't be changed" );
1741 }
1742
1743 if ( value === null ) {
1744 if ( elem.nodeType === 1 ) {
1745 elem.removeAttribute( name );
1746 }
1747
1748 } else {
1749 elem[ name ] = value;
1750 }
1751 }
1752
1753 // browsers index elements by id/name on forms, give priority to attributes.
1754 if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
1755 return elem.getAttributeNode( name ).nodeValue;
1756 }
1757
1758 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1759 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1760 if ( name === "tabIndex" ) {
1761 var attributeNode = elem.getAttributeNode( "tabIndex" );
1762
1763 return attributeNode && attributeNode.specified ?
1764 attributeNode.value :
1765 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
1766 0 :
1767 undefined;
1768 }
1769
1770 return elem[ name ];
1771 }
1772
1773 if ( !jQuery.support.style && notxml && name === "style" ) {
1774 if ( set ) {
1775 elem.style.cssText = "" + value;
1776 }
1777
1778 return elem.style.cssText;
1779 }
1780
1781 if ( set ) {
1782 // convert the value to a string (all browsers do this but IE) see #1070
1783 elem.setAttribute( name, "" + value );
1784 }
1785
1786 // Ensure that missing attributes return undefined
1787 // Blackberry 4.7 returns "" from getAttribute #6938
1788 if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
1789 return undefined;
1790 }
1791
1792 var attr = !jQuery.support.hrefNormalized && notxml && special ?
1793 // Some attributes require a special call on IE
1794 elem.getAttribute( name, 2 ) :
1795 elem.getAttribute( name );
1796
1797 // Non-existent attributes return null, we normalize to undefined
1798 return attr === null ? undefined : attr;
1799 }
1800 });
1801
1802
1803
1804
1805 var rnamespaces = /\.(.*)$/,
1806 rformElems = /^(?:textarea|input|select)$/i,
1807 rperiod = /\./g,
1808 rspace = / /g,
1809 rescape = /[^\w\s.|`]/g,
1810 fcleanup = function( nm ) {
1811 return nm.replace(rescape, "\\$&");
1812 },
1813 focusCounts = { focusin: 0, focusout: 0 };
1814
1815 /*
1816 * A number of helper functions used for managing events.
1817 * Many of the ideas behind this code originated from
1818 * Dean Edwards' addEvent library.
1819 */
1820 jQuery.event = {
1821
1822 // Bind an event to an element
1823 // Original by Dean Edwards
1824 add: function( elem, types, handler, data ) {
1825 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1826 return;
1827 }
1828
1829 // For whatever reason, IE has trouble passing the window object
1830 // around, causing it to be cloned in the process
1831 if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
1832 elem = window;
1833 }
1834
1835 if ( handler === false ) {
1836 handler = returnFalse;
1837 } else if ( !handler ) {
1838 // Fixes bug #7229. Fix recommended by jdalton
1839 return;
1840 }
1841
1842 var handleObjIn, handleObj;
1843
1844 if ( handler.handler ) {
1845 handleObjIn = handler;
1846 handler = handleObjIn.handler;
1847 }
1848
1849 // Make sure that the function being executed has a unique ID
1850 if ( !handler.guid ) {
1851 handler.guid = jQuery.guid++;
1852 }
1853
1854 // Init the element's event structure
1855 var elemData = jQuery.data( elem );
1856
1857 // If no elemData is found then we must be trying to bind to one of the
1858 // banned noData elements
1859 if ( !elemData ) {
1860 return;
1861 }
1862
1863 // Use a key less likely to result in collisions for plain JS objects.
1864 // Fixes bug #7150.
1865 var eventKey = elem.nodeType ? "events" : "__events__",
1866 events = elemData[ eventKey ],
1867 eventHandle = elemData.handle;
1868
1869 if ( typeof events === "function" ) {
1870 // On plain objects events is a fn that holds the the data
1871 // which prevents this data from being JSON serialized
1872 // the function does not need to be called, it just contains the data
1873 eventHandle = events.handle;
1874 events = events.events;
1875
1876 } else if ( !events ) {
1877 if ( !elem.nodeType ) {
1878 // On plain objects, create a fn that acts as the holder
1879 // of the values to avoid JSON serialization of event data
1880 elemData[ eventKey ] = elemData = function(){};
1881 }
1882
1883 elemData.events = events = {};
1884 }
1885
1886 if ( !eventHandle ) {
1887 elemData.handle = eventHandle = function() {
1888 // Handle the second event of a trigger and when
1889 // an event is called after a page has unloaded
1890 return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
1891 jQuery.event.handle.apply( eventHandle.elem, arguments ) :
1892 undefined;
1893 };
1894 }
1895
1896 // Add elem as a property of the handle function
1897 // This is to prevent a memory leak with non-native events in IE.
1898 eventHandle.elem = elem;
1899
1900 // Handle multiple events separated by a space
1901 // jQuery(...).bind("mouseover mouseout", fn);
1902 types = types.split(" ");
1903
1904 var type, i = 0, namespaces;
1905
1906 while ( (type = types[ i++ ]) ) {
1907 handleObj = handleObjIn ?
1908 jQuery.extend({}, handleObjIn) :
1909 { handler: handler, data: data };
1910
1911 // Namespaced event handlers
1912 if ( type.indexOf(".") > -1 ) {
1913 namespaces = type.split(".");
1914 type = namespaces.shift();
1915 handleObj.namespace = namespaces.slice(0).sort().join(".");
1916
1917 } else {
1918 namespaces = [];
1919 handleObj.namespace = "";
1920 }
1921
1922 handleObj.type = type;
1923 if ( !handleObj.guid ) {
1924 handleObj.guid = handler.guid;
1925 }
1926
1927 // Get the current list of functions bound to this event
1928 var handlers = events[ type ],
1929 special = jQuery.event.special[ type ] || {};
1930
1931 // Init the event handler queue
1932 if ( !handlers ) {
1933 handlers = events[ type ] = [];
1934
1935 // Check for a special event handler
1936 // Only use addEventListener/attachEvent if the special
1937 // events handler returns false
1938 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
1939 // Bind the global event handler to the element
1940 if ( elem.addEventListener ) {
1941 elem.addEventListener( type, eventHandle, false );
1942
1943 } else if ( elem.attachEvent ) {
1944 elem.attachEvent( "on" + type, eventHandle );
1945 }
1946 }
1947 }
1948
1949 if ( special.add ) {
1950 special.add.call( elem, handleObj );
1951
1952 if ( !handleObj.handler.guid ) {
1953 handleObj.handler.guid = handler.guid;
1954 }
1955 }
1956
1957 // Add the function to the element's handler list
1958 handlers.push( handleObj );
1959
1960 // Keep track of which events have been used, for global triggering
1961 jQuery.event.global[ type ] = true;
1962 }
1963
1964 // Nullify elem to prevent memory leaks in IE
1965 elem = null;
1966 },
1967
1968 global: {},
1969
1970 // Detach an event or set of events from an element
1971 remove: function( elem, types, handler, pos ) {
1972 // don't do events on text and comment nodes
1973 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1974 return;
1975 }
1976
1977 if ( handler === false ) {
1978 handler = returnFalse;
1979 }
1980
1981 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
1982 eventKey = elem.nodeType ? "events" : "__events__",
1983 elemData = jQuery.data( elem ),
1984 events = elemData && elemData[ eventKey ];
1985
1986 if ( !elemData || !events ) {
1987 return;
1988 }
1989
1990 if ( typeof events === "function" ) {
1991 elemData = events;
1992 events = events.events;
1993 }
1994
1995 // types is actually an event object here
1996 if ( types && types.type ) {
1997 handler = types.handler;
1998 types = types.type;
1999 }
2000
2001 // Unbind all events for the element
2002 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
2003 types = types || "";
2004
2005 for ( type in events ) {
2006 jQuery.event.remove( elem, type + types );
2007 }
2008
2009 return;
2010 }
2011
2012 // Handle multiple events separated by a space
2013 // jQuery(...).unbind("mouseover mouseout", fn);
2014 types = types.split(" ");
2015
2016 while ( (type = types[ i++ ]) ) {
2017 origType = type;
2018 handleObj = null;
2019 all = type.indexOf(".") < 0;
2020 namespaces = [];
2021
2022 if ( !all ) {
2023 // Namespaced event handlers
2024 namespaces = type.split(".");
2025 type = namespaces.shift();
2026
2027 namespace = new RegExp("(^|\\.)" +
2028 jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
2029 }
2030
2031 eventType = events[ type ];
2032
2033 if ( !eventType ) {
2034 continue;
2035 }
2036
2037 if ( !handler ) {
2038 for ( j = 0; j < eventType.length; j++ ) {
2039 handleObj = eventType[ j ];
2040
2041 if ( all || namespace.test( handleObj.namespace ) ) {
2042 jQuery.event.remove( elem, origType, handleObj.handler, j );
2043 eventType.splice( j--, 1 );
2044 }
2045 }
2046
2047 continue;
2048 }
2049
2050 special = jQuery.event.special[ type ] || {};
2051
2052 for ( j = pos || 0; j < eventType.length; j++ ) {
2053 handleObj = eventType[ j ];
2054
2055 if ( handler.guid === handleObj.guid ) {
2056 // remove the given handler for the given type
2057 if ( all || namespace.test( handleObj.namespace ) ) {
2058 if ( pos == null ) {
2059 eventType.splice( j--, 1 );
2060 }
2061
2062 if ( special.remove ) {
2063 special.remove.call( elem, handleObj );
2064 }
2065 }
2066
2067 if ( pos != null ) {
2068 break;
2069 }
2070 }
2071 }
2072
2073 // remove generic event handler if no more handlers exist
2074 if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
2075 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2076 jQuery.removeEvent( elem, type, elemData.handle );
2077 }
2078
2079 ret = null;
2080 delete events[ type ];
2081 }
2082 }
2083
2084 // Remove the expando if it's no longer used
2085 if ( jQuery.isEmptyObject( events ) ) {
2086 var handle = elemData.handle;
2087 if ( handle ) {
2088 handle.elem = null;
2089 }
2090
2091 delete elemData.events;
2092 delete elemData.handle;
2093
2094 if ( typeof elemData === "function" ) {
2095 jQuery.removeData( elem, eventKey );
2096
2097 } else if ( jQuery.isEmptyObject( elemData ) ) {
2098 jQuery.removeData( elem );
2099 }
2100 }
2101 },
2102
2103 // bubbling is internal
2104 trigger: function( event, data, elem /*, bubbling */ ) {
2105 // Event object or event type
2106 var type = event.type || event,
2107 bubbling = arguments[3];
2108
2109 if ( !bubbling ) {
2110 event = typeof event === "object" ?
2111 // jQuery.Event object
2112 event[ jQuery.expando ] ? event :
2113 // Object literal
2114 jQuery.extend( jQuery.Event(type), event ) :
2115 // Just the event type (string)
2116 jQuery.Event(type);
2117
2118 if ( type.indexOf("!") >= 0 ) {
2119 event.type = type = type.slice(0, -1);
2120 event.exclusive = true;
2121 }
2122
2123 // Handle a global trigger
2124 if ( !elem ) {
2125 // Don't bubble custom events when global (to avoid too much overhead)
2126 event.stopPropagation();
2127
2128 // Only trigger if we've ever bound an event for it
2129 if ( jQuery.event.global[ type ] ) {
2130 jQuery.each( jQuery.cache, function() {
2131 if ( this.events && this.events[type] ) {
2132 jQuery.event.trigger( event, data, this.handle.elem );
2133 }
2134 });
2135 }
2136 }
2137
2138 // Handle triggering a single element
2139
2140 // don't do events on text and comment nodes
2141 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
2142 return undefined;
2143 }
2144
2145 // Clean up in case it is reused
2146 event.result = undefined;
2147 event.target = elem;
2148
2149 // Clone the incoming data, if any
2150 data = jQuery.makeArray( data );
2151 data.unshift( event );
2152 }
2153
2154 event.currentTarget = elem;
2155
2156 // Trigger the event, it is assumed that "handle" is a function
2157 var handle = elem.nodeType ?
2158 jQuery.data( elem, "handle" ) :
2159 (jQuery.data( elem, "__events__" ) || {}).handle;
2160
2161 if ( handle ) {
2162 handle.apply( elem, data );
2163 }
2164
2165 var parent = elem.parentNode || elem.ownerDocument;
2166
2167 // Trigger an inline bound script
2168 try {
2169 if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
2170 if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
2171 event.result = false;
2172 event.preventDefault();
2173 }
2174 }
2175
2176 // prevent IE from throwing an error for some elements with some event types, see #3533
2177 } catch (inlineError) {}
2178
2179 if ( !event.isPropagationStopped() && parent ) {
2180 jQuery.event.trigger( event, data, parent, true );
2181
2182 } else if ( !event.isDefaultPrevented() ) {
2183 var old,
2184 target = event.target,
2185 targetType = type.replace( rnamespaces, "" ),
2186 isClick = jQuery.nodeName( target, "a" ) && targetType === "click",
2187 special = jQuery.event.special[ targetType ] || {};
2188
2189 if ( (!special._default || special._default.call( elem, event ) === false) &&
2190 !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
2191
2192 try {
2193 if ( target[ targetType ] ) {
2194 // Make sure that we don't accidentally re-trigger the onFOO events
2195 old = target[ "on" + targetType ];
2196
2197 if ( old ) {
2198 target[ "on" + targetType ] = null;
2199 }
2200
2201 jQuery.event.triggered = true;
2202 target[ targetType ]();
2203 }
2204
2205 // prevent IE from throwing an error for some elements with some event types, see #3533
2206 } catch (triggerError) {}
2207
2208 if ( old ) {
2209 target[ "on" + targetType ] = old;
2210 }
2211
2212 jQuery.event.triggered = false;
2213 }
2214 }
2215 },
2216
2217 handle: function( event ) {
2218 var all, handlers, namespaces, namespace_re, events,
2219 namespace_sort = [],
2220 args = jQuery.makeArray( arguments );
2221
2222 event = args[0] = jQuery.event.fix( event || window.event );
2223 event.currentTarget = this;
2224
2225 // Namespaced event handlers
2226 all = event.type.indexOf(".") < 0 && !event.exclusive;
2227
2228 if ( !all ) {
2229 namespaces = event.type.split(".");
2230 event.type = namespaces.shift();
2231 namespace_sort = namespaces.slice(0).sort();
2232 namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)");
2233 }
2234
2235 event.namespace = event.namespace || namespace_sort.join(".");
2236
2237 events = jQuery.data(this, this.nodeType ? "events" : "__events__");
2238
2239 if ( typeof events === "function" ) {
2240 events = events.events;
2241 }
2242
2243 handlers = (events || {})[ event.type ];
2244
2245 if ( events && handlers ) {
2246 // Clone the handlers to prevent manipulation
2247 handlers = handlers.slice(0);
2248
2249 for ( var j = 0, l = handlers.length; j < l; j++ ) {
2250 var handleObj = handlers[ j ];
2251
2252 // Filter the functions by class
2253 if ( all || namespace_re.test( handleObj.namespace ) ) {
2254 // Pass in a reference to the handler function itself
2255 // So that we can later remove it
2256 event.handler = handleObj.handler;
2257 event.data = handleObj.data;
2258 event.handleObj = handleObj;
2259
2260 var ret = handleObj.handler.apply( this, args );
2261
2262 if ( ret !== undefined ) {
2263 event.result = ret;
2264 if ( ret === false ) {
2265 event.preventDefault();
2266 event.stopPropagation();
2267 }
2268 }
2269
2270 if ( event.isImmediatePropagationStopped() ) {
2271 break;
2272 }
2273 }
2274 }
2275 }
2276
2277 return event.result;
2278 },
2279
2280 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(" "),
2281
2282 fix: function( event ) {
2283 if ( event[ jQuery.expando ] ) {
2284 return event;
2285 }
2286
2287 // store a copy of the original event object
2288 // and "clone" to set read-only properties
2289 var originalEvent = event;
2290 event = jQuery.Event( originalEvent );
2291
2292 for ( var i = this.props.length, prop; i; ) {
2293 prop = this.props[ --i ];
2294 event[ prop ] = originalEvent[ prop ];
2295 }
2296
2297 // Fix target property, if necessary
2298 if ( !event.target ) {
2299 // Fixes #1925 where srcElement might not be defined either
2300 event.target = event.srcElement || document;
2301 }
2302
2303 // check if target is a textnode (safari)
2304 if ( event.target.nodeType === 3 ) {
2305 event.target = event.target.parentNode;
2306 }
2307
2308 // Add relatedTarget, if necessary
2309 if ( !event.relatedTarget && event.fromElement ) {
2310 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
2311 }
2312
2313 // Calculate pageX/Y if missing and clientX/Y available
2314 if ( event.pageX == null && event.clientX != null ) {
2315 var doc = document.documentElement,
2316 body = document.body;
2317
2318 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
2319 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
2320 }
2321
2322 // Add which for key events
2323 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
2324 event.which = event.charCode != null ? event.charCode : event.keyCode;
2325 }
2326
2327 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2328 if ( !event.metaKey && event.ctrlKey ) {
2329 event.metaKey = event.ctrlKey;
2330 }
2331
2332 // Add which for click: 1 === left; 2 === middle; 3 === right
2333 // Note: button is not normalized, so don't use it
2334 if ( !event.which && event.button !== undefined ) {
2335 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2336 }
2337
2338 return event;
2339 },
2340
2341 // Deprecated, use jQuery.guid instead
2342 guid: 1E8,
2343
2344 // Deprecated, use jQuery.proxy instead
2345 proxy: jQuery.proxy,
2346
2347 special: {
2348 ready: {
2349 // Make sure the ready event is setup
2350 setup: jQuery.bindReady,
2351 teardown: jQuery.noop
2352 },
2353
2354 live: {
2355 add: function( handleObj ) {
2356 jQuery.event.add( this,
2357 liveConvert( handleObj.origType, handleObj.selector ),
2358 jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
2359 },
2360
2361 remove: function( handleObj ) {
2362 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
2363 }
2364 },
2365
2366 beforeunload: {
2367 setup: function( data, namespaces, eventHandle ) {
2368 // We only want to do this special case on windows
2369 if ( jQuery.isWindow( this ) ) {
2370 this.onbeforeunload = eventHandle;
2371 }
2372 },
2373
2374 teardown: function( namespaces, eventHandle ) {
2375 if ( this.onbeforeunload === eventHandle ) {
2376 this.onbeforeunload = null;
2377 }
2378 }
2379 }
2380 }
2381 };
2382
2383 jQuery.removeEvent = document.removeEventListener ?
2384 function( elem, type, handle ) {
2385 if ( elem.removeEventListener ) {
2386 elem.removeEventListener( type, handle, false );
2387 }
2388 } :
2389 function( elem, type, handle ) {
2390 if ( elem.detachEvent ) {
2391 elem.detachEvent( "on" + type, handle );
2392 }
2393 };
2394
2395 jQuery.Event = function( src ) {
2396 // Allow instantiation without the 'new' keyword
2397 if ( !this.preventDefault ) {
2398 return new jQuery.Event( src );
2399 }
2400
2401 // Event object
2402 if ( src && src.type ) {
2403 this.originalEvent = src;
2404 this.type = src.type;
2405 // Event type
2406 } else {
2407 this.type = src;
2408 }
2409
2410 // timeStamp is buggy for some events on Firefox(#3843)
2411 // So we won't rely on the native value
2412 this.timeStamp = jQuery.now();
2413
2414 // Mark it as fixed
2415 this[ jQuery.expando ] = true;
2416 };
2417
2418 function returnFalse() {
2419 return false;
2420 }
2421 function returnTrue() {
2422 return true;
2423 }
2424
2425 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2426 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2427 jQuery.Event.prototype = {
2428 preventDefault: function() {
2429 this.isDefaultPrevented = returnTrue;
2430
2431 var e = this.originalEvent;
2432 if ( !e ) {
2433 return;
2434 }
2435
2436 // if preventDefault exists run it on the original event
2437 if ( e.preventDefault ) {
2438 e.preventDefault();
2439
2440 // otherwise set the returnValue property of the original event to false (IE)
2441 } else {
2442 e.returnValue = false;
2443 }
2444 },
2445 stopPropagation: function() {
2446 this.isPropagationStopped = returnTrue;
2447
2448 var e = this.originalEvent;
2449 if ( !e ) {
2450 return;
2451 }
2452 // if stopPropagation exists run it on the original event
2453 if ( e.stopPropagation ) {
2454 e.stopPropagation();
2455 }
2456 // otherwise set the cancelBubble property of the original event to true (IE)
2457 e.cancelBubble = true;
2458 },
2459 stopImmediatePropagation: function() {
2460 this.isImmediatePropagationStopped = returnTrue;
2461 this.stopPropagation();
2462 },
2463 isDefaultPrevented: returnFalse,
2464 isPropagationStopped: returnFalse,
2465 isImmediatePropagationStopped: returnFalse
2466 };
2467
2468 // Checks if an event happened on an element within another element
2469 // Used in jQuery.event.special.mouseenter and mouseleave handlers
2470 var withinElement = function( event ) {
2471 // Check if mouse(over|out) are still within the same parent element
2472 var parent = event.relatedTarget;
2473
2474 // Firefox sometimes assigns relatedTarget a XUL element
2475 // which we cannot access the parentNode property of
2476 try {
2477 // Traverse up the tree
2478 while ( parent && parent !== this ) {
2479 parent = parent.parentNode;
2480 }
2481
2482 if ( parent !== this ) {
2483 // set the correct event type
2484 event.type = event.data;
2485
2486 // handle event if we actually just moused on to a non sub-element
2487 jQuery.event.handle.apply( this, arguments );
2488 }
2489
2490 // assuming we've left the element since we most likely mousedover a xul element
2491 } catch(e) { }
2492 },
2493
2494 // In case of event delegation, we only need to rename the event.type,
2495 // liveHandler will take care of the rest.
2496 delegate = function( event ) {
2497 event.type = event.data;
2498 jQuery.event.handle.apply( this, arguments );
2499 };
2500
2501 // Create mouseenter and mouseleave events
2502 jQuery.each({
2503 mouseenter: "mouseover",
2504 mouseleave: "mouseout"
2505 }, function( orig, fix ) {
2506 jQuery.event.special[ orig ] = {
2507 setup: function( data ) {
2508 jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
2509 },
2510 teardown: function( data ) {
2511 jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
2512 }
2513 };
2514 });
2515
2516 // submit delegation
2517 if ( !jQuery.support.submitBubbles ) {
2518
2519 jQuery.event.special.submit = {
2520 setup: function( data, namespaces ) {
2521 if ( this.nodeName.toLowerCase() !== "form" ) {
2522 jQuery.event.add(this, "click.specialSubmit", function( e ) {
2523 var elem = e.target,
2524 type = elem.type;
2525
2526 if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
2527 e.liveFired = undefined;
2528 return trigger( "submit", this, arguments );
2529 }
2530 });
2531
2532 jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
2533 var elem = e.target,
2534 type = elem.type;
2535
2536 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2537 e.liveFired = undefined;
2538 return trigger( "submit", this, arguments );
2539 }
2540 });
2541
2542 } else {
2543 return false;
2544 }
2545 },
2546
2547 teardown: function( namespaces ) {
2548 jQuery.event.remove( this, ".specialSubmit" );
2549 }
2550 };
2551
2552 }
2553
2554 // change delegation, happens here so we have bind.
2555 if ( !jQuery.support.changeBubbles ) {
2556
2557 var changeFilters,
2558
2559 getVal = function( elem ) {
2560 var type = elem.type, val = elem.value;
2561
2562 if ( type === "radio" || type === "checkbox" ) {
2563 val = elem.checked;
2564
2565 } else if ( type === "select-multiple" ) {
2566 val = elem.selectedIndex > -1 ?
2567 jQuery.map( elem.options, function( elem ) {
2568 return elem.selected;
2569 }).join("-") :
2570 "";
2571
2572 } else if ( elem.nodeName.toLowerCase() === "select" ) {
2573 val = elem.selectedIndex;
2574 }
2575
2576 return val;
2577 },
2578
2579 testChange = function testChange( e ) {
2580 var elem = e.target, data, val;
2581
2582 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
2583 return;
2584 }
2585
2586 data = jQuery.data( elem, "_change_data" );
2587 val = getVal(elem);
2588
2589 // the current data will be also retrieved by beforeactivate
2590 if ( e.type !== "focusout" || elem.type !== "radio" ) {
2591 jQuery.data( elem, "_change_data", val );
2592 }
2593
2594 if ( data === undefined || val === data ) {
2595 return;
2596 }
2597
2598 if ( data != null || val ) {
2599 e.type = "change";
2600 e.liveFired = undefined;
2601 return jQuery.event.trigger( e, arguments[1], elem );
2602 }
2603 };
2604
2605 jQuery.event.special.change = {
2606 filters: {
2607 focusout: testChange,
2608
2609 beforedeactivate: testChange,
2610
2611 click: function( e ) {
2612 var elem = e.target, type = elem.type;
2613
2614 if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
2615 return testChange.call( this, e );
2616 }
2617 },
2618
2619 // Change has to be called before submit
2620 // Keydown will be called before keypress, which is used in submit-event delegation
2621 keydown: function( e ) {
2622 var elem = e.target, type = elem.type;
2623
2624 if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
2625 (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
2626 type === "select-multiple" ) {
2627 return testChange.call( this, e );
2628 }
2629 },
2630
2631 // Beforeactivate happens also before the previous element is blurred
2632 // with this event you can't trigger a change event, but you can store
2633 // information
2634 beforeactivate: function( e ) {
2635 var elem = e.target;
2636 jQuery.data( elem, "_change_data", getVal(elem) );
2637 }
2638 },
2639
2640 setup: function( data, namespaces ) {
2641 if ( this.type === "file" ) {
2642 return false;
2643 }
2644
2645 for ( var type in changeFilters ) {
2646 jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
2647 }
2648
2649 return rformElems.test( this.nodeName );
2650 },
2651
2652 teardown: function( namespaces ) {
2653 jQuery.event.remove( this, ".specialChange" );
2654
2655 return rformElems.test( this.nodeName );
2656 }
2657 };
2658
2659 changeFilters = jQuery.event.special.change.filters;
2660
2661 // Handle when the input is .focus()'d
2662 changeFilters.focus = changeFilters.beforeactivate;
2663 }
2664
2665 function trigger( type, elem, args ) {
2666 args[0].type = type;
2667 return jQuery.event.handle.apply( elem, args );
2668 }
2669
2670 // Create "bubbling" focus and blur events
2671 if ( document.addEventListener ) {
2672 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
2673 jQuery.event.special[ fix ] = {
2674 setup: function() {
2675 if ( focusCounts[fix]++ === 0 ) {
2676 document.addEventListener( orig, handler, true );
2677 }
2678 },
2679 teardown: function() {
2680 if ( --focusCounts[fix] === 0 ) {
2681 document.removeEventListener( orig, handler, true );
2682 }
2683 }
2684 };
2685
2686 function handler( e ) {
2687 e = jQuery.event.fix( e );
2688 e.type = fix;
2689 return jQuery.event.trigger( e, null, e.target );
2690 }
2691 });
2692 }
2693
2694 jQuery.each(["bind", "one"], function( i, name ) {
2695 jQuery.fn[ name ] = function( type, data, fn ) {
2696 // Handle object literals
2697 if ( typeof type === "object" ) {
2698 for ( var key in type ) {
2699 this[ name ](key, data, type[key], fn);
2700 }
2701 return this;
2702 }
2703
2704 if ( jQuery.isFunction( data ) || data === false ) {
2705 fn = data;
2706 data = undefined;
2707 }
2708
2709 var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
2710 jQuery( this ).unbind( event, handler );
2711 return fn.apply( this, arguments );
2712 }) : fn;
2713
2714 if ( type === "unload" && name !== "one" ) {
2715 this.one( type, data, fn );
2716
2717 } else {
2718 for ( var i = 0, l = this.length; i < l; i++ ) {
2719 jQuery.event.add( this[i], type, handler, data );
2720 }
2721 }
2722
2723 return this;
2724 };
2725 });
2726
2727 jQuery.fn.extend({
2728 unbind: function( type, fn ) {
2729 // Handle object literals
2730 if ( typeof type === "object" && !type.preventDefault ) {
2731 for ( var key in type ) {
2732 this.unbind(key, type[key]);
2733 }
2734
2735 } else {
2736 for ( var i = 0, l = this.length; i < l; i++ ) {
2737 jQuery.event.remove( this[i], type, fn );
2738 }
2739 }
2740
2741 return this;
2742 },
2743
2744 delegate: function( selector, types, data, fn ) {
2745 return this.live( types, data, fn, selector );
2746 },
2747
2748 undelegate: function( selector, types, fn ) {
2749 if ( arguments.length === 0 ) {
2750 return this.unbind( "live" );
2751
2752 } else {
2753 return this.die( types, null, fn, selector );
2754 }
2755 },
2756
2757 trigger: function( type, data ) {
2758 return this.each(function() {
2759 jQuery.event.trigger( type, data, this );
2760 });
2761 },
2762
2763 triggerHandler: function( type, data ) {
2764 if ( this[0] ) {
2765 var event = jQuery.Event( type );
2766 event.preventDefault();
2767 event.stopPropagation();
2768 jQuery.event.trigger( event, data, this[0] );
2769 return event.result;
2770 }
2771 },
2772
2773 toggle: function( fn ) {
2774 // Save reference to arguments for access in closure
2775 var args = arguments,
2776 i = 1;
2777
2778 // link all the functions, so any of them can unbind this click handler
2779 while ( i < args.length ) {
2780 jQuery.proxy( fn, args[ i++ ] );
2781 }
2782
2783 return this.click( jQuery.proxy( fn, function( event ) {
2784 // Figure out which function to execute
2785 var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
2786 jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
2787
2788 // Make sure that clicks stop
2789 event.preventDefault();
2790
2791 // and execute the function
2792 return args[ lastToggle ].apply( this, arguments ) || false;
2793 }));
2794 },
2795
2796 hover: function( fnOver, fnOut ) {
2797 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
2798 }
2799 });
2800
2801 var liveMap = {
2802 focus: "focusin",
2803 blur: "focusout",
2804 mouseenter: "mouseover",
2805 mouseleave: "mouseout"
2806 };
2807
2808 jQuery.each(["live", "die"], function( i, name ) {
2809 jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
2810 var type, i = 0, match, namespaces, preType,
2811 selector = origSelector || this.selector,
2812 context = origSelector ? this : jQuery( this.context );
2813
2814 if ( typeof types === "object" && !types.preventDefault ) {
2815 for ( var key in types ) {
2816 context[ name ]( key, data, types[key], selector );
2817 }
2818
2819 return this;
2820 }
2821
2822 if ( jQuery.isFunction( data ) ) {
2823 fn = data;
2824 data = undefined;
2825 }
2826
2827 types = (types || "").split(" ");
2828
2829 while ( (type = types[ i++ ]) != null ) {
2830 match = rnamespaces.exec( type );
2831 namespaces = "";
2832
2833 if ( match ) {
2834 namespaces = match[0];
2835 type = type.replace( rnamespaces, "" );
2836 }
2837
2838 if ( type === "hover" ) {
2839 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
2840 continue;
2841 }
2842
2843 preType = type;
2844
2845 if ( type === "focus" || type === "blur" ) {
2846 types.push( liveMap[ type ] + namespaces );
2847 type = type + namespaces;
2848
2849 } else {
2850 type = (liveMap[ type ] || type) + namespaces;
2851 }
2852
2853 if ( name === "live" ) {
2854 // bind live handler
2855 for ( var j = 0, l = context.length; j < l; j++ ) {
2856 jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
2857 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
2858 }
2859
2860 } else {
2861 // unbind live handler
2862 context.unbind( "live." + liveConvert( type, selector ), fn );
2863 }
2864 }
2865
2866 return this;
2867 };
2868 });
2869
2870 function liveHandler( event ) {
2871 var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
2872 elems = [],
2873 selectors = [],
2874 events = jQuery.data( this, this.nodeType ? "events" : "__events__" );
2875
2876 if ( typeof events === "function" ) {
2877 events = events.events;
2878 }
2879
2880 // Make sure we avoid non-left-click bubbling in Firefox (#3861)
2881 if ( event.liveFired === this || !events || !events.live || event.button && event.type === "click" ) {
2882 return;
2883 }
2884
2885 if ( event.namespace ) {
2886 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
2887 }
2888
2889 event.liveFired = this;
2890
2891 var live = events.live.slice(0);
2892
2893 for ( j = 0; j < live.length; j++ ) {
2894 handleObj = live[j];
2895
2896 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
2897 selectors.push( handleObj.selector );
2898
2899 } else {
2900 live.splice( j--, 1 );
2901 }
2902 }
2903
2904 match = jQuery( event.target ).closest( selectors, event.currentTarget );
2905
2906 for ( i = 0, l = match.length; i < l; i++ ) {
2907 close = match[i];
2908
2909 for ( j = 0; j < live.length; j++ ) {
2910 handleObj = live[j];
2911
2912 if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) ) {
2913 elem = close.elem;
2914 related = null;
2915
2916 // Those two events require additional checking
2917 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
2918 event.type = handleObj.preType;
2919 related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
2920 }
2921
2922 if ( !related || related !== elem ) {
2923 elems.push({ elem: elem, handleObj: handleObj, level: close.level });
2924 }
2925 }
2926 }
2927 }
2928
2929 for ( i = 0, l = elems.length; i < l; i++ ) {
2930 match = elems[i];
2931
2932 if ( maxLevel && match.level > maxLevel ) {
2933 break;
2934 }
2935
2936 event.currentTarget = match.elem;
2937 event.data = match.handleObj.data;
2938 event.handleObj = match.handleObj;
2939
2940 ret = match.handleObj.origHandler.apply( match.elem, arguments );
2941
2942 if ( ret === false || event.isPropagationStopped() ) {
2943 maxLevel = match.level;
2944
2945 if ( ret === false ) {
2946 stop = false;
2947 }
2948 if ( event.isImmediatePropagationStopped() ) {
2949 break;
2950 }
2951 }
2952 }
2953
2954 return stop;
2955 }
2956
2957 function liveConvert( type, selector ) {
2958 return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&");
2959 }
2960
2961 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
2962 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
2963 "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
2964
2965 // Handle event binding
2966 jQuery.fn[ name ] = function( data, fn ) {
2967 if ( fn == null ) {
2968 fn = data;
2969 data = null;
2970 }
2971
2972 return arguments.length > 0 ?
2973 this.bind( name, data, fn ) :
2974 this.trigger( name );
2975 };
2976
2977 if ( jQuery.attrFn ) {
2978 jQuery.attrFn[ name ] = true;
2979 }
2980 });
2981
2982 // Prevent memory leaks in IE
2983 // Window isn't included so as not to unbind existing unload events
2984 // More info:
2985 // - http://isaacschlueter.com/2006/10/msie-memory-leaks/
2986 if ( window.attachEvent && !window.addEventListener ) {
2987 jQuery(window).bind("unload", function() {
2988 for ( var id in jQuery.cache ) {
2989 if ( jQuery.cache[ id ].handle ) {
2990 // Try/Catch is to handle iframes being unloaded, see #4280
2991 try {
2992 jQuery.event.remove( jQuery.cache[ id ].handle.elem );
2993 } catch(e) {}
2994 }
2995 }
2996 });
2997 }
2998
2999
3000 /*!
3001 * Sizzle CSS Selector Engine - v1.0
3002 * Copyright 2009, The Dojo Foundation
3003 * Released under the MIT, BSD, and GPL Licenses.
3004 * More information: http://sizzlejs.com/
3005 */
3006 (function(){
3007
3008 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3009 done = 0,
3010 toString = Object.prototype.toString,
3011 hasDuplicate = false,
3012 baseHasDuplicate = true;
3013
3014 // Here we check if the JavaScript engine is using some sort of
3015 // optimization where it does not always call our comparision
3016 // function. If that is the case, discard the hasDuplicate value.
3017 // Thus far that includes Google Chrome.
3018 [0, 0].sort(function() {
3019 baseHasDuplicate = false;
3020 return 0;
3021 });
3022
3023 var Sizzle = function( selector, context, results, seed ) {
3024 results = results || [];
3025 context = context || document;
3026
3027 var origContext = context;
3028
3029 if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3030 return [];
3031 }
3032
3033 if ( !selector || typeof selector !== "string" ) {
3034 return results;
3035 }
3036
3037 var m, set, checkSet, extra, ret, cur, pop, i,
3038 prune = true,
3039 contextXML = Sizzle.isXML( context ),
3040 parts = [],
3041 soFar = selector;
3042
3043 // Reset the position of the chunker regexp (start from head)
3044 do {
3045 chunker.exec( "" );
3046 m = chunker.exec( soFar );
3047
3048 if ( m ) {
3049 soFar = m[3];
3050
3051 parts.push( m[1] );
3052
3053 if ( m[2] ) {
3054 extra = m[3];
3055 break;
3056 }
3057 }
3058 } while ( m );
3059
3060 if ( parts.length > 1 && origPOS.exec( selector ) ) {
3061
3062 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3063 set = posProcess( parts[0] + parts[1], context );
3064
3065 } else {
3066 set = Expr.relative[ parts[0] ] ?
3067 [ context ] :
3068 Sizzle( parts.shift(), context );
3069
3070 while ( parts.length ) {
3071 selector = parts.shift();
3072
3073 if ( Expr.relative[ selector ] ) {
3074 selector += parts.shift();
3075 }
3076
3077 set = posProcess( selector, set );
3078 }
3079 }
3080
3081 } else {
3082 // Take a shortcut and set the context if the root selector is an ID
3083 // (but not if it'll be faster if the inner selector is an ID)
3084 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3085 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3086
3087 ret = Sizzle.find( parts.shift(), context, contextXML );
3088 context = ret.expr ?
3089 Sizzle.filter( ret.expr, ret.set )[0] :
3090 ret.set[0];
3091 }
3092
3093 if ( context ) {
3094 ret = seed ?
3095 { expr: parts.pop(), set: makeArray(seed) } :
3096 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3097
3098 set = ret.expr ?
3099 Sizzle.filter( ret.expr, ret.set ) :
3100 ret.set;
3101
3102 if ( parts.length > 0 ) {
3103 checkSet = makeArray( set );
3104
3105 } else {
3106 prune = false;
3107 }
3108
3109 while ( parts.length ) {
3110 cur = parts.pop();
3111 pop = cur;
3112
3113 if ( !Expr.relative[ cur ] ) {
3114 cur = "";
3115 } else {
3116 pop = parts.pop();
3117 }
3118
3119 if ( pop == null ) {
3120 pop = context;
3121 }
3122
3123 Expr.relative[ cur ]( checkSet, pop, contextXML );
3124 }
3125
3126 } else {
3127 checkSet = parts = [];
3128 }
3129 }
3130
3131 if ( !checkSet ) {
3132 checkSet = set;
3133 }
3134
3135 if ( !checkSet ) {
3136 Sizzle.error( cur || selector );
3137 }
3138
3139 if ( toString.call(checkSet) === "[object Array]" ) {
3140 if ( !prune ) {
3141 results.push.apply( results, checkSet );
3142
3143 } else if ( context && context.nodeType === 1 ) {
3144 for ( i = 0; checkSet[i] != null; i++ ) {
3145 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
3146 results.push( set[i] );
3147 }
3148 }
3149
3150 } else {
3151 for ( i = 0; checkSet[i] != null; i++ ) {
3152 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
3153 results.push( set[i] );
3154 }
3155 }
3156 }
3157
3158 } else {
3159 makeArray( checkSet, results );
3160 }
3161
3162 if ( extra ) {
3163 Sizzle( extra, origContext, results, seed );
3164 Sizzle.uniqueSort( results );
3165 }
3166
3167 return results;
3168 };
3169
3170 Sizzle.uniqueSort = function( results ) {
3171 if ( sortOrder ) {
3172 hasDuplicate = baseHasDuplicate;
3173 results.sort( sortOrder );
3174
3175 if ( hasDuplicate ) {
3176 for ( var i = 1; i < results.length; i++ ) {
3177 if ( results[i] === results[ i - 1 ] ) {
3178 results.splice( i--, 1 );
3179 }
3180 }
3181 }
3182 }
3183
3184 return results;
3185 };
3186
3187 Sizzle.matches = function( expr, set ) {
3188 return Sizzle( expr, null, null, set );
3189 };
3190
3191 Sizzle.matchesSelector = function( node, expr ) {
3192 return Sizzle( expr, null, null, [node] ).length > 0;
3193 };
3194
3195 Sizzle.find = function( expr, context, isXML ) {
3196 var set;
3197
3198 if ( !expr ) {
3199 return [];
3200 }
3201
3202 for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
3203 var match,
3204 type = Expr.order[i];
3205
3206 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
3207 var left = match[1];
3208 match.splice( 1, 1 );
3209
3210 if ( left.substr( left.length - 1 ) !== "\\" ) {
3211 match[1] = (match[1] || "").replace(/\\/g, "");
3212 set = Expr.find[ type ]( match, context, isXML );
3213
3214 if ( set != null ) {
3215 expr = expr.replace( Expr.match[ type ], "" );
3216 break;
3217 }
3218 }
3219 }
3220 }
3221
3222 if ( !set ) {
3223 set = context.getElementsByTagName( "*" );
3224 }
3225
3226 return { set: set, expr: expr };
3227 };
3228
3229 Sizzle.filter = function( expr, set, inplace, not ) {
3230 var match, anyFound,
3231 old = expr,
3232 result = [],
3233 curLoop = set,
3234 isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
3235
3236 while ( expr && set.length ) {
3237 for ( var type in Expr.filter ) {
3238 if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
3239 var found, item,
3240 filter = Expr.filter[ type ],
3241 left = match[1];
3242
3243 anyFound = false;
3244
3245 match.splice(1,1);
3246
3247 if ( left.substr( left.length - 1 ) === "\\" ) {
3248 continue;
3249 }
3250
3251 if ( curLoop === result ) {
3252 result = [];
3253 }
3254
3255 if ( Expr.preFilter[ type ] ) {
3256 match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
3257
3258 if ( !match ) {
3259 anyFound = found = true;
3260
3261 } else if ( match === true ) {
3262 continue;
3263 }
3264 }
3265
3266 if ( match ) {
3267 for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
3268 if ( item ) {
3269 found = filter( item, match, i, curLoop );
3270 var pass = not ^ !!found;
3271
3272 if ( inplace && found != null ) {
3273 if ( pass ) {
3274 anyFound = true;
3275
3276 } else {
3277 curLoop[i] = false;
3278 }
3279
3280 } else if ( pass ) {
3281 result.push( item );
3282 anyFound = true;
3283 }
3284 }
3285 }
3286 }
3287
3288 if ( found !== undefined ) {
3289 if ( !inplace ) {
3290 curLoop = result;
3291 }
3292
3293 expr = expr.replace( Expr.match[ type ], "" );
3294
3295 if ( !anyFound ) {
3296 return [];
3297 }
3298
3299 break;
3300 }
3301 }
3302 }
3303
3304 // Improper expression
3305 if ( expr === old ) {
3306 if ( anyFound == null ) {
3307 Sizzle.error( expr );
3308
3309 } else {
3310 break;
3311 }
3312 }
3313
3314 old = expr;
3315 }
3316
3317 return curLoop;
3318 };
3319
3320 Sizzle.error = function( msg ) {
3321 throw "Syntax error, unrecognized expression: " + msg;
3322 };
3323
3324 var Expr = Sizzle.selectors = {
3325 order: [ "ID", "NAME", "TAG" ],
3326
3327 match: {
3328 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
3329 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
3330 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
3331 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
3332 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
3333 CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+\-]*)\))?/,
3334 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
3335 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
3336 },
3337
3338 leftMatch: {},
3339
3340 attrMap: {
3341 "class": "className",
3342 "for": "htmlFor"
3343 },
3344
3345 attrHandle: {
3346 href: function( elem ) {
3347 return elem.getAttribute( "href" );
3348 }
3349 },
3350
3351 relative: {
3352 "+": function(checkSet, part){
3353 var isPartStr = typeof part === "string",
3354 isTag = isPartStr && !/\W/.test( part ),
3355 isPartStrNotTag = isPartStr && !isTag;
3356
3357 if ( isTag ) {
3358 part = part.toLowerCase();
3359 }
3360
3361 for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
3362 if ( (elem = checkSet[i]) ) {
3363 while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
3364
3365 checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
3366 elem || false :
3367 elem === part;
3368 }
3369 }
3370
3371 if ( isPartStrNotTag ) {
3372 Sizzle.filter( part, checkSet, true );
3373 }
3374 },
3375
3376 ">": function( checkSet, part ) {
3377 var elem,
3378 isPartStr = typeof part === "string",
3379 i = 0,
3380 l = checkSet.length;
3381
3382 if ( isPartStr && !/\W/.test( part ) ) {
3383 part = part.toLowerCase();
3384
3385 for ( ; i < l; i++ ) {
3386 elem = checkSet[i];
3387
3388 if ( elem ) {
3389 var parent = elem.parentNode;
3390 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
3391 }
3392 }
3393
3394 } else {
3395 for ( ; i < l; i++ ) {
3396 elem = checkSet[i];
3397
3398 if ( elem ) {
3399 checkSet[i] = isPartStr ?
3400 elem.parentNode :
3401 elem.parentNode === part;
3402 }
3403 }
3404
3405 if ( isPartStr ) {
3406 Sizzle.filter( part, checkSet, true );
3407 }
3408 }
3409 },
3410
3411 "": function(checkSet, part, isXML){
3412 var nodeCheck,
3413 doneName = done++,
3414 checkFn = dirCheck;
3415
3416 if ( typeof part === "string" && !/\W/.test(part) ) {
3417 part = part.toLowerCase();
3418 nodeCheck = part;
3419 checkFn = dirNodeCheck;
3420 }
3421
3422 checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
3423 },
3424
3425 "~": function( checkSet, part, isXML ) {
3426 var nodeCheck,
3427 doneName = done++,
3428 checkFn = dirCheck;
3429
3430 if ( typeof part === "string" && !/\W/.test( part ) ) {
3431 part = part.toLowerCase();
3432 nodeCheck = part;
3433 checkFn = dirNodeCheck;
3434 }
3435
3436 checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
3437 }
3438 },
3439
3440 find: {
3441 ID: function( match, context, isXML ) {
3442 if ( typeof context.getElementById !== "undefined" && !isXML ) {
3443 var m = context.getElementById(match[1]);
3444 // Check parentNode to catch when Blackberry 4.6 returns
3445 // nodes that are no longer in the document #6963
3446 return m && m.parentNode ? [m] : [];
3447 }
3448 },
3449
3450 NAME: function( match, context ) {
3451 if ( typeof context.getElementsByName !== "undefined" ) {
3452 var ret = [],
3453 results = context.getElementsByName( match[1] );
3454
3455 for ( var i = 0, l = results.length; i < l; i++ ) {
3456 if ( results[i].getAttribute("name") === match[1] ) {
3457 ret.push( results[i] );
3458 }
3459 }
3460
3461 return ret.length === 0 ? null : ret;
3462 }
3463 },
3464
3465 TAG: function( match, context ) {
3466 return context.getElementsByTagName( match[1] );
3467 }
3468 },
3469 preFilter: {
3470 CLASS: function( match, curLoop, inplace, result, not, isXML ) {
3471 match = " " + match[1].replace(/\\/g, "") + " ";
3472
3473 if ( isXML ) {
3474 return match;
3475 }
3476
3477 for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
3478 if ( elem ) {
3479 if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
3480 if ( !inplace ) {
3481 result.push( elem );
3482 }
3483
3484 } else if ( inplace ) {
3485 curLoop[i] = false;
3486 }
3487 }
3488 }
3489
3490 return false;
3491 },
3492
3493 ID: function( match ) {
3494 return match[1].replace(/\\/g, "");
3495 },
3496
3497 TAG: function( match, curLoop ) {
3498 return match[1].toLowerCase();
3499 },
3500
3501 CHILD: function( match ) {
3502 if ( match[1] === "nth" ) {
3503 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
3504 var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
3505 match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
3506 !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
3507
3508 // calculate the numbers (first)n+(last) including if they are negative
3509 match[2] = (test[1] + (test[2] || 1)) - 0;
3510 match[3] = test[3] - 0;
3511 }
3512
3513 // TODO: Move to normal caching system
3514 match[0] = done++;
3515
3516 return match;
3517 },
3518
3519 ATTR: function( match, curLoop, inplace, result, not, isXML ) {
3520 var name = match[1].replace(/\\/g, "");
3521
3522 if ( !isXML && Expr.attrMap[name] ) {
3523 match[1] = Expr.attrMap[name];
3524 }
3525
3526 if ( match[2] === "~=" ) {
3527 match[4] = " " + match[4] + " ";
3528 }
3529
3530 return match;
3531 },
3532
3533 PSEUDO: function( match, curLoop, inplace, result, not ) {
3534 if ( match[1] === "not" ) {
3535 // If we're dealing with a complex expression, or a simple one
3536 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
3537 match[3] = Sizzle(match[3], null, null, curLoop);
3538
3539 } else {
3540 var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
3541
3542 if ( !inplace ) {
3543 result.push.apply( result, ret );
3544 }
3545
3546 return false;
3547 }
3548
3549 } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
3550 return true;
3551 }
3552
3553 return match;
3554 },
3555
3556 POS: function( match ) {
3557 match.unshift( true );
3558
3559 return match;
3560 }
3561 },
3562
3563 filters: {
3564 enabled: function( elem ) {
3565 return elem.disabled === false && elem.type !== "hidden";
3566 },
3567
3568 disabled: function( elem ) {
3569 return elem.disabled === true;
3570 },
3571
3572 checked: function( elem ) {
3573 return elem.checked === true;
3574 },
3575
3576 selected: function( elem ) {
3577 // Accessing this property makes selected-by-default
3578 // options in Safari work properly
3579 elem.parentNode.selectedIndex;
3580
3581 return elem.selected === true;
3582 },
3583
3584 parent: function( elem ) {
3585 return !!elem.firstChild;
3586 },
3587
3588 empty: function( elem ) {
3589 return !elem.firstChild;
3590 },
3591
3592 has: function( elem, i, match ) {
3593 return !!Sizzle( match[3], elem ).length;
3594 },
3595
3596 header: function( elem ) {
3597 return (/h\d/i).test( elem.nodeName );
3598 },
3599
3600 text: function( elem ) {
3601 return "text" === elem.type;
3602 },
3603 radio: function( elem ) {
3604 return "radio" === elem.type;
3605 },
3606
3607 checkbox: function( elem ) {
3608 return "checkbox" === elem.type;
3609 },
3610
3611 file: function( elem ) {
3612 return "file" === elem.type;
3613 },
3614 password: function( elem ) {
3615 return "password" === elem.type;
3616 },
3617
3618 submit: function( elem ) {
3619 return "submit" === elem.type;
3620 },
3621
3622 image: function( elem ) {
3623 return "image" === elem.type;
3624 },
3625
3626 reset: function( elem ) {
3627 return "reset" === elem.type;
3628 },
3629
3630 button: function( elem ) {
3631 return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
3632 },
3633
3634 input: function( elem ) {
3635 return (/input|select|textarea|button/i).test( elem.nodeName );
3636 }
3637 },
3638 setFilters: {
3639 first: function( elem, i ) {
3640 return i === 0;
3641 },
3642
3643 last: function( elem, i, match, array ) {
3644 return i === array.length - 1;
3645 },
3646
3647 even: function( elem, i ) {
3648 return i % 2 === 0;
3649 },
3650
3651 odd: function( elem, i ) {
3652 return i % 2 === 1;
3653 },
3654
3655 lt: function( elem, i, match ) {
3656 return i < match[3] - 0;
3657 },
3658
3659 gt: function( elem, i, match ) {
3660 return i > match[3] - 0;
3661 },
3662
3663 nth: function( elem, i, match ) {
3664 return match[3] - 0 === i;
3665 },
3666
3667 eq: function( elem, i, match ) {
3668 return match[3] - 0 === i;
3669 }
3670 },
3671 filter: {
3672 PSEUDO: function( elem, match, i, array ) {
3673 var name = match[1],
3674 filter = Expr.filters[ name ];
3675
3676 if ( filter ) {
3677 return filter( elem, i, match, array );
3678
3679 } else if ( name === "contains" ) {
3680 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
3681
3682 } else if ( name === "not" ) {
3683 var not = match[3];
3684
3685 for ( var j = 0, l = not.length; j < l; j++ ) {
3686 if ( not[j] === elem ) {
3687 return false;
3688 }
3689 }
3690
3691 return true;
3692
3693 } else {
3694 Sizzle.error( "Syntax error, unrecognized expression: " + name );
3695 }
3696 },
3697
3698 CHILD: function( elem, match ) {
3699 var type = match[1],
3700 node = elem;
3701
3702 switch ( type ) {
3703 case "only":
3704 case "first":
3705 while ( (node = node.previousSibling) ) {
3706 if ( node.nodeType === 1 ) {
3707 return false;
3708 }
3709 }
3710
3711 if ( type === "first" ) {
3712 return true;
3713 }
3714
3715 node = elem;
3716
3717 case "last":
3718 while ( (node = node.nextSibling) ) {
3719 if ( node.nodeType === 1 ) {
3720 return false;
3721 }
3722 }
3723
3724 return true;
3725
3726 case "nth":
3727 var first = match[2],
3728 last = match[3];
3729
3730 if ( first === 1 && last === 0 ) {
3731 return true;
3732 }
3733
3734 var doneName = match[0],
3735 parent = elem.parentNode;
3736
3737 if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
3738 var count = 0;
3739
3740 for ( node = parent.firstChild; node; node = node.nextSibling ) {
3741 if ( node.nodeType === 1 ) {
3742 node.nodeIndex = ++count;
3743 }
3744 }
3745
3746 parent.sizcache = doneName;
3747 }
3748
3749 var diff = elem.nodeIndex - last;
3750
3751 if ( first === 0 ) {
3752 return diff === 0;
3753
3754 } else {
3755 return ( diff % first === 0 && diff / first >= 0 );
3756 }
3757 }
3758 },
3759
3760 ID: function( elem, match ) {
3761 return elem.nodeType === 1 && elem.getAttribute("id") === match;
3762 },
3763
3764 TAG: function( elem, match ) {
3765 return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
3766 },
3767
3768 CLASS: function( elem, match ) {
3769 return (" " + (elem.className || elem.getAttribute("class")) + " ")
3770 .indexOf( match ) > -1;
3771 },
3772
3773 ATTR: function( elem, match ) {
3774 var name = match[1],
3775 result = Expr.attrHandle[ name ] ?
3776 Expr.attrHandle[ name ]( elem ) :
3777 elem[ name ] != null ?
3778 elem[ name ] :
3779 elem.getAttribute( name ),
3780 value = result + "",
3781 type = match[2],
3782 check = match[4];
3783
3784 return result == null ?
3785 type === "!=" :
3786 type === "=" ?
3787 value === check :
3788 type === "*=" ?
3789 value.indexOf(check) >= 0 :
3790 type === "~=" ?
3791 (" " + value + " ").indexOf(check) >= 0 :
3792 !check ?
3793 value && result !== false :
3794 type === "!=" ?
3795 value !== check :
3796 type === "^=" ?
3797 value.indexOf(check) === 0 :
3798 type === "$=" ?
3799 value.substr(value.length - check.length) === check :
3800 type === "|=" ?
3801 value === check || value.substr(0, check.length + 1) === check + "-" :
3802 false;
3803 },
3804
3805 POS: function( elem, match, i, array ) {
3806 var name = match[2],
3807 filter = Expr.setFilters[ name ];
3808
3809 if ( filter ) {
3810 return filter( elem, i, match, array );
3811 }
3812 }
3813 }
3814 };
3815
3816 var origPOS = Expr.match.POS,
3817 fescape = function(all, num){
3818 return "\\" + (num - 0 + 1);
3819 };
3820
3821 for ( var type in Expr.match ) {
3822 Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
3823 Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
3824 }
3825
3826 var makeArray = function( array, results ) {
3827 array = Array.prototype.slice.call( array, 0 );
3828
3829 if ( results ) {
3830 results.push.apply( results, array );
3831 return results;
3832 }
3833
3834 return array;
3835 };
3836
3837 // Perform a simple check to determine if the browser is capable of
3838 // converting a NodeList to an array using builtin methods.
3839 // Also verifies that the returned array holds DOM nodes
3840 // (which is not the case in the Blackberry browser)
3841 try {
3842 Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
3843
3844 // Provide a fallback method if it does not work
3845 } catch( e ) {
3846 makeArray = function( array, results ) {
3847 var i = 0,
3848 ret = results || [];
3849
3850 if ( toString.call(array) === "[object Array]" ) {
3851 Array.prototype.push.apply( ret, array );
3852
3853 } else {
3854 if ( typeof array.length === "number" ) {
3855 for ( var l = array.length; i < l; i++ ) {
3856 ret.push( array[i] );
3857 }
3858
3859 } else {
3860 for ( ; array[i]; i++ ) {
3861 ret.push( array[i] );
3862 }
3863 }
3864 }
3865
3866 return ret;
3867 };
3868 }
3869
3870 var sortOrder, siblingCheck;
3871
3872 if ( document.documentElement.compareDocumentPosition ) {
3873 sortOrder = function( a, b ) {
3874 if ( a === b ) {
3875 hasDuplicate = true;
3876 return 0;
3877 }
3878
3879 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
3880 return a.compareDocumentPosition ? -1 : 1;
3881 }
3882
3883 return a.compareDocumentPosition(b) & 4 ? -1 : 1;
3884 };
3885
3886 } else {
3887 sortOrder = function( a, b ) {
3888 var al, bl,
3889 ap = [],
3890 bp = [],
3891 aup = a.parentNode,
3892 bup = b.parentNode,
3893 cur = aup;
3894
3895 // The nodes are identical, we can exit early
3896 if ( a === b ) {
3897 hasDuplicate = true;
3898 return 0;
3899
3900 // If the nodes are siblings (or identical) we can do a quick check
3901 } else if ( aup === bup ) {
3902 return siblingCheck( a, b );
3903
3904 // If no parents were found then the nodes are disconnected
3905 } else if ( !aup ) {
3906 return -1;
3907
3908 } else if ( !bup ) {
3909 return 1;
3910 }
3911
3912 // Otherwise they're somewhere else in the tree so we need
3913 // to build up a full list of the parentNodes for comparison
3914 while ( cur ) {
3915 ap.unshift( cur );
3916 cur = cur.parentNode;
3917 }
3918
3919 cur = bup;
3920
3921 while ( cur ) {
3922 bp.unshift( cur );
3923 cur = cur.parentNode;
3924 }
3925
3926 al = ap.length;
3927 bl = bp.length;
3928
3929 // Start walking down the tree looking for a discrepancy
3930 for ( var i = 0; i < al && i < bl; i++ ) {
3931 if ( ap[i] !== bp[i] ) {
3932 return siblingCheck( ap[i], bp[i] );
3933 }
3934 }
3935
3936 // We ended someplace up the tree so do a sibling check
3937 return i === al ?
3938 siblingCheck( a, bp[i], -1 ) :
3939 siblingCheck( ap[i], b, 1 );
3940 };
3941
3942 siblingCheck = function( a, b, ret ) {
3943 if ( a === b ) {
3944 return ret;
3945 }
3946
3947 var cur = a.nextSibling;
3948
3949 while ( cur ) {
3950 if ( cur === b ) {
3951 return -1;
3952 }
3953
3954 cur = cur.nextSibling;
3955 }
3956
3957 return 1;
3958 };
3959 }
3960
3961 // Utility function for retreiving the text value of an array of DOM nodes
3962 Sizzle.getText = function( elems ) {
3963 var ret = "", elem;
3964
3965 for ( var i = 0; elems[i]; i++ ) {
3966 elem = elems[i];
3967
3968 // Get the text from text nodes and CDATA nodes
3969 if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
3970 ret += elem.nodeValue;
3971
3972 // Traverse everything else, except comment nodes
3973 } else if ( elem.nodeType !== 8 ) {
3974 ret += Sizzle.getText( elem.childNodes );
3975 }
3976 }
3977
3978 return ret;
3979 };
3980
3981 // Check to see if the browser returns elements by name when
3982 // querying by getElementById (and provide a workaround)
3983 (function(){
3984 // We're going to inject a fake input element with a specified name
3985 var form = document.createElement("div"),
3986 id = "script" + (new Date()).getTime(),
3987 root = document.documentElement;
3988
3989 form.innerHTML = "<a name='" + id + "'/>";
3990
3991 // Inject it into the root element, check its status, and remove it quickly
3992 root.insertBefore( form, root.firstChild );
3993
3994 // The workaround has to do additional checks after a getElementById
3995 // Which slows things down for other browsers (hence the branching)
3996 if ( document.getElementById( id ) ) {
3997 Expr.find.ID = function( match, context, isXML ) {
3998 if ( typeof context.getElementById !== "undefined" && !isXML ) {
3999 var m = context.getElementById(match[1]);
4000
4001 return m ?
4002 m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4003 [m] :
4004 undefined :
4005 [];
4006 }
4007 };
4008
4009 Expr.filter.ID = function( elem, match ) {
4010 var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4011
4012 return elem.nodeType === 1 && node && node.nodeValue === match;
4013 };
4014 }
4015
4016 root.removeChild( form );
4017
4018 // release memory in IE
4019 root = form = null;
4020 })();
4021
4022 (function(){
4023 // Check to see if the browser returns only elements
4024 // when doing getElementsByTagName("*")
4025
4026 // Create a fake element
4027 var div = document.createElement("div");
4028 div.appendChild( document.createComment("") );
4029
4030 // Make sure no comments are found
4031 if ( div.getElementsByTagName("*").length > 0 ) {
4032 Expr.find.TAG = function( match, context ) {
4033 var results = context.getElementsByTagName( match[1] );
4034
4035 // Filter out possible comments
4036 if ( match[1] === "*" ) {
4037 var tmp = [];
4038
4039 for ( var i = 0; results[i]; i++ ) {
4040 if ( results[i].nodeType === 1 ) {
4041 tmp.push( results[i] );
4042 }
4043 }
4044
4045 results = tmp;
4046 }
4047
4048 return results;
4049 };
4050 }
4051
4052 // Check to see if an attribute returns normalized href attributes
4053 div.innerHTML = "<a href='#'></a>";
4054
4055 if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4056 div.firstChild.getAttribute("href") !== "#" ) {
4057
4058 Expr.attrHandle.href = function( elem ) {
4059 return elem.getAttribute( "href", 2 );
4060 };
4061 }
4062
4063 // release memory in IE
4064 div = null;
4065 })();
4066
4067 if ( document.querySelectorAll ) {
4068 (function(){
4069 var oldSizzle = Sizzle,
4070 div = document.createElement("div"),
4071 id = "__sizzle__";
4072
4073 div.innerHTML = "<p class='TEST'></p>";
4074
4075 // Safari can't handle uppercase or unicode characters when
4076 // in quirks mode.
4077 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4078 return;
4079 }
4080
4081 Sizzle = function( query, context, extra, seed ) {
4082 context = context || document;
4083
4084 // Make sure that attribute selectors are quoted
4085 query = query.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
4086
4087 // Only use querySelectorAll on non-XML documents
4088 // (ID selectors don't work in non-HTML documents)
4089 if ( !seed && !Sizzle.isXML(context) ) {
4090 if ( context.nodeType === 9 ) {
4091 try {
4092 return makeArray( context.querySelectorAll(query), extra );
4093 } catch(qsaError) {}
4094
4095 // qSA works strangely on Element-rooted queries
4096 // We can work around this by specifying an extra ID on the root
4097 // and working up from there (Thanks to Andrew Dupont for the technique)
4098 // IE 8 doesn't work on object elements
4099 } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
4100 var old = context.getAttribute( "id" ),
4101 nid = old || id;
4102
4103 if ( !old ) {
4104 context.setAttribute( "id", nid );
4105 }
4106
4107 try {
4108 return makeArray( context.querySelectorAll( "#" + nid + " " + query ), extra );
4109
4110 } catch(pseudoError) {
4111 } finally {
4112 if ( !old ) {
4113 context.removeAttribute( "id" );
4114 }
4115 }
4116 }
4117 }
4118
4119 return oldSizzle(query, context, extra, seed);
4120 };
4121
4122 for ( var prop in oldSizzle ) {
4123 Sizzle[ prop ] = oldSizzle[ prop ];
4124 }
4125
4126 // release memory in IE
4127 div = null;
4128 })();
4129 }
4130
4131 (function(){
4132 var html = document.documentElement,
4133 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector,
4134 pseudoWorks = false;
4135
4136 try {
4137 // This should fail with an exception
4138 // Gecko does not error, returns false instead
4139 matches.call( document.documentElement, "[test!='']:sizzle" );
4140
4141 } catch( pseudoError ) {
4142 pseudoWorks = true;
4143 }
4144
4145 if ( matches ) {
4146 Sizzle.matchesSelector = function( node, expr ) {
4147 // Make sure that attribute selectors are quoted
4148 expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
4149
4150 if ( !Sizzle.isXML( node ) ) {
4151 try {
4152 if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
4153 return matches.call( node, expr );
4154 }
4155 } catch(e) {}
4156 }
4157
4158 return Sizzle(expr, null, null, [node]).length > 0;
4159 };
4160 }
4161 })();
4162
4163 (function(){
4164 var div = document.createElement("div");
4165
4166 div.innerHTML = "<div class='test e'></div><div class='test'></div>";
4167
4168 // Opera can't find a second classname (in 9.6)
4169 // Also, make sure that getElementsByClassName actually exists
4170 if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
4171 return;
4172 }
4173
4174 // Safari caches class attributes, doesn't catch changes (in 3.2)
4175 div.lastChild.className = "e";
4176
4177 if ( div.getElementsByClassName("e").length === 1 ) {
4178 return;
4179 }
4180
4181 Expr.order.splice(1, 0, "CLASS");
4182 Expr.find.CLASS = function( match, context, isXML ) {
4183 if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
4184 return context.getElementsByClassName(match[1]);
4185 }
4186 };
4187
4188 // release memory in IE
4189 div = null;
4190 })();
4191
4192 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
4193 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
4194 var elem = checkSet[i];
4195
4196 if ( elem ) {
4197 var match = false;
4198
4199 elem = elem[dir];
4200
4201 while ( elem ) {
4202 if ( elem.sizcache === doneName ) {
4203 match = checkSet[elem.sizset];
4204 break;
4205 }
4206
4207 if ( elem.nodeType === 1 && !isXML ){
4208 elem.sizcache = doneName;
4209 elem.sizset = i;
4210 }
4211
4212 if ( elem.nodeName.toLowerCase() === cur ) {
4213 match = elem;
4214 break;
4215 }
4216
4217 elem = elem[dir];
4218 }
4219
4220 checkSet[i] = match;
4221 }
4222 }
4223 }
4224
4225 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
4226 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
4227 var elem = checkSet[i];
4228
4229 if ( elem ) {
4230 var match = false;
4231
4232 elem = elem[dir];
4233
4234 while ( elem ) {
4235 if ( elem.sizcache === doneName ) {
4236 match = checkSet[elem.sizset];
4237 break;
4238 }
4239
4240 if ( elem.nodeType === 1 ) {
4241 if ( !isXML ) {
4242 elem.sizcache = doneName;
4243 elem.sizset = i;
4244 }
4245
4246 if ( typeof cur !== "string" ) {
4247 if ( elem === cur ) {
4248 match = true;
4249 break;
4250 }
4251
4252 } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
4253 match = elem;
4254 break;
4255 }
4256 }
4257
4258 elem = elem[dir];
4259 }
4260
4261 checkSet[i] = match;
4262 }
4263 }
4264 }
4265
4266 if ( document.documentElement.contains ) {
4267 Sizzle.contains = function( a, b ) {
4268 return a !== b && (a.contains ? a.contains(b) : true);
4269 };
4270
4271 } else if ( document.documentElement.compareDocumentPosition ) {
4272 Sizzle.contains = function( a, b ) {
4273 return !!(a.compareDocumentPosition(b) & 16);
4274 };
4275
4276 } else {
4277 Sizzle.contains = function() {
4278 return false;
4279 };
4280 }
4281
4282 Sizzle.isXML = function( elem ) {
4283 // documentElement is verified for cases where it doesn't yet exist
4284 // (such as loading iframes in IE - #4833)
4285 var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
4286
4287 return documentElement ? documentElement.nodeName !== "HTML" : false;
4288 };
4289
4290 var posProcess = function( selector, context ) {
4291 var match,
4292 tmpSet = [],
4293 later = "",
4294 root = context.nodeType ? [context] : context;
4295
4296 // Position selectors must be done after the filter
4297 // And so must :not(positional) so we move all PSEUDOs to the end
4298 while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
4299 later += match[0];
4300 selector = selector.replace( Expr.match.PSEUDO, "" );
4301 }
4302
4303 selector = Expr.relative[selector] ? selector + "*" : selector;
4304
4305 for ( var i = 0, l = root.length; i < l; i++ ) {
4306 Sizzle( selector, root[i], tmpSet );
4307 }
4308
4309 return Sizzle.filter( later, tmpSet );
4310 };
4311
4312 // EXPOSE
4313 jQuery.find = Sizzle;
4314 jQuery.expr = Sizzle.selectors;
4315 jQuery.expr[":"] = jQuery.expr.filters;
4316 jQuery.unique = Sizzle.uniqueSort;
4317 jQuery.text = Sizzle.getText;
4318 jQuery.isXMLDoc = Sizzle.isXML;
4319 jQuery.contains = Sizzle.contains;
4320
4321
4322 })();
4323
4324
4325 var runtil = /Until$/,
4326 rparentsprev = /^(?:parents|prevUntil|prevAll)/,
4327 // Note: This RegExp should be improved, or likely pulled from Sizzle
4328 rmultiselector = /,/,
4329 isSimple = /^.[^:#\[\.,]*$/,
4330 slice = Array.prototype.slice,
4331 POS = jQuery.expr.match.POS;
4332
4333 jQuery.fn.extend({
4334 find: function( selector ) {
4335 var ret = this.pushStack( "", "find", selector ),
4336 length = 0;
4337
4338 for ( var i = 0, l = this.length; i < l; i++ ) {
4339 length = ret.length;
4340 jQuery.find( selector, this[i], ret );
4341
4342 if ( i > 0 ) {
4343 // Make sure that the results are unique
4344 for ( var n = length; n < ret.length; n++ ) {
4345 for ( var r = 0; r < length; r++ ) {
4346 if ( ret[r] === ret[n] ) {
4347 ret.splice(n--, 1);
4348 break;
4349 }
4350 }
4351 }
4352 }
4353 }
4354
4355 return ret;
4356 },
4357
4358 has: function( target ) {
4359 var targets = jQuery( target );
4360 return this.filter(function() {
4361 for ( var i = 0, l = targets.length; i < l; i++ ) {
4362 if ( jQuery.contains( this, targets[i] ) ) {
4363 return true;
4364 }
4365 }
4366 });
4367 },
4368
4369 not: function( selector ) {
4370 return this.pushStack( winnow(this, selector, false), "not", selector);
4371 },
4372
4373 filter: function( selector ) {
4374 return this.pushStack( winnow(this, selector, true), "filter", selector );
4375 },
4376
4377 is: function( selector ) {
4378 return !!selector && jQuery.filter( selector, this ).length > 0;
4379 },
4380
4381 closest: function( selectors, context ) {
4382 var ret = [], i, l, cur = this[0];
4383
4384 if ( jQuery.isArray( selectors ) ) {
4385 var match, selector,
4386 matches = {},
4387 level = 1;
4388
4389 if ( cur && selectors.length ) {
4390 for ( i = 0, l = selectors.length; i < l; i++ ) {
4391 selector = selectors[i];
4392
4393 if ( !matches[selector] ) {
4394 matches[selector] = jQuery.expr.match.POS.test( selector ) ?
4395 jQuery( selector, context || this.context ) :
4396 selector;
4397 }
4398 }
4399
4400 while ( cur && cur.ownerDocument && cur !== context ) {
4401 for ( selector in matches ) {
4402 match = matches[selector];
4403
4404 if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
4405 ret.push({ selector: selector, elem: cur, level: level });
4406 }
4407 }
4408
4409 cur = cur.parentNode;
4410 level++;
4411 }
4412 }
4413
4414 return ret;
4415 }
4416
4417 var pos = POS.test( selectors ) ?
4418 jQuery( selectors, context || this.context ) : null;
4419
4420 for ( i = 0, l = this.length; i < l; i++ ) {
4421 cur = this[i];
4422
4423 while ( cur ) {
4424 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
4425 ret.push( cur );
4426 break;
4427
4428 } else {
4429 cur = cur.parentNode;
4430 if ( !cur || !cur.ownerDocument || cur === context ) {
4431 break;
4432 }
4433 }
4434 }
4435 }
4436
4437 ret = ret.length > 1 ? jQuery.unique(ret) : ret;
4438
4439 return this.pushStack( ret, "closest", selectors );
4440 },
4441
4442 // Determine the position of an element within
4443 // the matched set of elements
4444 index: function( elem ) {
4445 if ( !elem || typeof elem === "string" ) {
4446 return jQuery.inArray( this[0],
4447 // If it receives a string, the selector is used
4448 // If it receives nothing, the siblings are used
4449 elem ? jQuery( elem ) : this.parent().children() );
4450 }
4451 // Locate the position of the desired element
4452 return jQuery.inArray(
4453 // If it receives a jQuery object, the first element is used
4454 elem.jquery ? elem[0] : elem, this );
4455 },
4456
4457 add: function( selector, context ) {
4458 var set = typeof selector === "string" ?
4459 jQuery( selector, context || this.context ) :
4460 jQuery.makeArray( selector ),
4461 all = jQuery.merge( this.get(), set );
4462
4463 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
4464 all :
4465 jQuery.unique( all ) );
4466 },
4467
4468 andSelf: function() {
4469 return this.add( this.prevObject );
4470 }
4471 });
4472
4473 // A painfully simple check to see if an element is disconnected
4474 // from a document (should be improved, where feasible).
4475 function isDisconnected( node ) {
4476 return !node || !node.parentNode || node.parentNode.nodeType === 11;
4477 }
4478
4479 jQuery.each({
4480 parent: function( elem ) {
4481 var parent = elem.parentNode;
4482 return parent && parent.nodeType !== 11 ? parent : null;
4483 },
4484 parents: function( elem ) {
4485 return jQuery.dir( elem, "parentNode" );
4486 },
4487 parentsUntil: function( elem, i, until ) {
4488 return jQuery.dir( elem, "parentNode", until );
4489 },
4490 next: function( elem ) {
4491 return jQuery.nth( elem, 2, "nextSibling" );
4492 },
4493 prev: function( elem ) {
4494 return jQuery.nth( elem, 2, "previousSibling" );
4495 },
4496 nextAll: function( elem ) {
4497 return jQuery.dir( elem, "nextSibling" );
4498 },
4499 prevAll: function( elem ) {
4500 return jQuery.dir( elem, "previousSibling" );
4501 },
4502 nextUntil: function( elem, i, until ) {
4503 return jQuery.dir( elem, "nextSibling", until );
4504 },
4505 prevUntil: function( elem, i, until ) {
4506 return jQuery.dir( elem, "previousSibling", until );
4507 },
4508 siblings: function( elem ) {
4509 return jQuery.sibling( elem.parentNode.firstChild, elem );
4510 },
4511 children: function( elem ) {
4512 return jQuery.sibling( elem.firstChild );
4513 },
4514 contents: function( elem ) {
4515 return jQuery.nodeName( elem, "iframe" ) ?
4516 elem.contentDocument || elem.contentWindow.document :
4517 jQuery.makeArray( elem.childNodes );
4518 }
4519 }, function( name, fn ) {
4520 jQuery.fn[ name ] = function( until, selector ) {
4521 var ret = jQuery.map( this, fn, until );
4522
4523 if ( !runtil.test( name ) ) {
4524 selector = until;
4525 }
4526
4527 if ( selector && typeof selector === "string" ) {
4528 ret = jQuery.filter( selector, ret );
4529 }
4530
4531 ret = this.length > 1 ? jQuery.unique( ret ) : ret;
4532
4533 if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
4534 ret = ret.reverse();
4535 }
4536
4537 return this.pushStack( ret, name, slice.call(arguments).join(",") );
4538 };
4539 });
4540
4541 jQuery.extend({
4542 filter: function( expr, elems, not ) {
4543 if ( not ) {
4544 expr = ":not(" + expr + ")";
4545 }
4546
4547 return elems.length === 1 ?
4548 jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
4549 jQuery.find.matches(expr, elems);
4550 },
4551
4552 dir: function( elem, dir, until ) {
4553 var matched = [],
4554 cur = elem[ dir ];
4555
4556 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
4557 if ( cur.nodeType === 1 ) {
4558 matched.push( cur );
4559 }
4560 cur = cur[dir];
4561 }
4562 return matched;
4563 },
4564
4565 nth: function( cur, result, dir, elem ) {
4566 result = result || 1;
4567 var num = 0;
4568
4569 for ( ; cur; cur = cur[dir] ) {
4570 if ( cur.nodeType === 1 && ++num === result ) {
4571 break;
4572 }
4573 }
4574
4575 return cur;
4576 },
4577
4578 sibling: function( n, elem ) {
4579 var r = [];
4580
4581 for ( ; n; n = n.nextSibling ) {
4582 if ( n.nodeType === 1 && n !== elem ) {
4583 r.push( n );
4584 }
4585 }
4586
4587 return r;
4588 }
4589 });
4590
4591 // Implement the identical functionality for filter and not
4592 function winnow( elements, qualifier, keep ) {
4593 if ( jQuery.isFunction( qualifier ) ) {
4594 return jQuery.grep(elements, function( elem, i ) {
4595 var retVal = !!qualifier.call( elem, i, elem );
4596 return retVal === keep;
4597 });
4598
4599 } else if ( qualifier.nodeType ) {
4600 return jQuery.grep(elements, function( elem, i ) {
4601 return (elem === qualifier) === keep;
4602 });
4603
4604 } else if ( typeof qualifier === "string" ) {
4605 var filtered = jQuery.grep(elements, function( elem ) {
4606 return elem.nodeType === 1;
4607 });
4608
4609 if ( isSimple.test( qualifier ) ) {
4610 return jQuery.filter(qualifier, filtered, !keep);
4611 } else {
4612 qualifier = jQuery.filter( qualifier, filtered );
4613 }
4614 }
4615
4616 return jQuery.grep(elements, function( elem, i ) {
4617 return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
4618 });
4619 }
4620
4621
4622
4623
4624 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
4625 rleadingWhitespace = /^\s+/,
4626 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
4627 rtagName = /<([\w:]+)/,
4628 rtbody = /<tbody/i,
4629 rhtml = /<|&#?\w+;/,
4630 rnocache = /<(?:script|object|embed|option|style)/i,
4631 // checked="checked" or checked (html5)
4632 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
4633 raction = /\=([^="'>\s]+\/)>/g,
4634 wrapMap = {
4635 option: [ 1, "<select multiple='multiple'>", "</select>" ],
4636 legend: [ 1, "<fieldset>", "</fieldset>" ],
4637 thead: [ 1, "<table>", "</table>" ],
4638 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4639 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4640 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
4641 area: [ 1, "<map>", "</map>" ],
4642 _default: [ 0, "", "" ]
4643 };
4644
4645 wrapMap.optgroup = wrapMap.option;
4646 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4647 wrapMap.th = wrapMap.td;
4648
4649 // IE can't serialize <link> and <script> tags normally
4650 if ( !jQuery.support.htmlSerialize ) {
4651 wrapMap._default = [ 1, "div<div>", "</div>" ];
4652 }
4653
4654 jQuery.fn.extend({
4655 text: function( text ) {
4656 if ( jQuery.isFunction(text) ) {
4657 return this.each(function(i) {
4658 var self = jQuery( this );
4659
4660 self.text( text.call(this, i, self.text()) );
4661 });
4662 }
4663
4664 if ( typeof text !== "object" && text !== undefined ) {
4665 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
4666 }
4667
4668 return jQuery.text( this );
4669 },
4670
4671 wrapAll: function( html ) {
4672 if ( jQuery.isFunction( html ) ) {
4673 return this.each(function(i) {
4674 jQuery(this).wrapAll( html.call(this, i) );
4675 });
4676 }
4677
4678 if ( this[0] ) {
4679 // The elements to wrap the target around
4680 var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
4681
4682 if ( this[0].parentNode ) {
4683 wrap.insertBefore( this[0] );
4684 }
4685
4686 wrap.map(function() {
4687 var elem = this;
4688
4689 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
4690 elem = elem.firstChild;
4691 }
4692
4693 return elem;
4694 }).append(this);
4695 }
4696
4697 return this;
4698 },
4699
4700 wrapInner: function( html ) {
4701 if ( jQuery.isFunction( html ) ) {
4702 return this.each(function(i) {
4703 jQuery(this).wrapInner( html.call(this, i) );
4704 });
4705 }
4706
4707 return this.each(function() {
4708 var self = jQuery( this ),
4709 contents = self.contents();
4710
4711 if ( contents.length ) {
4712 contents.wrapAll( html );
4713
4714 } else {
4715 self.append( html );
4716 }
4717 });
4718 },
4719
4720 wrap: function( html ) {
4721 return this.each(function() {
4722 jQuery( this ).wrapAll( html );
4723 });
4724 },
4725
4726 unwrap: function() {
4727 return this.parent().each(function() {
4728 if ( !jQuery.nodeName( this, "body" ) ) {
4729 jQuery( this ).replaceWith( this.childNodes );
4730 }
4731 }).end();
4732 },
4733
4734 append: function() {
4735 return this.domManip(arguments, true, function( elem ) {
4736 if ( this.nodeType === 1 ) {
4737 this.appendChild( elem );
4738 }
4739 });
4740 },
4741
4742 prepend: function() {
4743 return this.domManip(arguments, true, function( elem ) {
4744 if ( this.nodeType === 1 ) {
4745 this.insertBefore( elem, this.firstChild );
4746 }
4747 });
4748 },
4749
4750 before: function() {
4751 if ( this[0] && this[0].parentNode ) {
4752 return this.domManip(arguments, false, function( elem ) {
4753 this.parentNode.insertBefore( elem, this );
4754 });
4755 } else if ( arguments.length ) {
4756 var set = jQuery(arguments[0]);
4757 set.push.apply( set, this.toArray() );
4758 return this.pushStack( set, "before", arguments );
4759 }
4760 },
4761
4762 after: function() {
4763 if ( this[0] && this[0].parentNode ) {
4764 return this.domManip(arguments, false, function( elem ) {
4765 this.parentNode.insertBefore( elem, this.nextSibling );
4766 });
4767 } else if ( arguments.length ) {
4768 var set = this.pushStack( this, "after", arguments );
4769 set.push.apply( set, jQuery(arguments[0]).toArray() );
4770 return set;
4771 }
4772 },
4773
4774 // keepData is for internal use only--do not document
4775 remove: function( selector, keepData ) {
4776 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4777 if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
4778 if ( !keepData && elem.nodeType === 1 ) {
4779 jQuery.cleanData( elem.getElementsByTagName("*") );
4780 jQuery.cleanData( [ elem ] );
4781 }
4782
4783 if ( elem.parentNode ) {
4784 elem.parentNode.removeChild( elem );
4785 }
4786 }
4787 }
4788
4789 return this;
4790 },
4791
4792 empty: function() {
4793 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4794 // Remove element nodes and prevent memory leaks
4795 if ( elem.nodeType === 1 ) {
4796 jQuery.cleanData( elem.getElementsByTagName("*") );
4797 }
4798
4799 // Remove any remaining nodes
4800 while ( elem.firstChild ) {
4801 elem.removeChild( elem.firstChild );
4802 }
4803 }
4804
4805 return this;
4806 },
4807
4808 clone: function( events ) {
4809 // Do the clone
4810 var ret = this.map(function() {
4811 if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
4812 // IE copies events bound via attachEvent when
4813 // using cloneNode. Calling detachEvent on the
4814 // clone will also remove the events from the orignal
4815 // In order to get around this, we use innerHTML.
4816 // Unfortunately, this means some modifications to
4817 // attributes in IE that are actually only stored
4818 // as properties will not be copied (such as the
4819 // the name attribute on an input).
4820 var html = this.outerHTML,
4821 ownerDocument = this.ownerDocument;
4822
4823 if ( !html ) {
4824 var div = ownerDocument.createElement("div");
4825 div.appendChild( this.cloneNode(true) );
4826 html = div.innerHTML;
4827 }
4828
4829 return jQuery.clean([html.replace(rinlinejQuery, "")
4830 // Handle the case in IE 8 where action=/test/> self-closes a tag
4831 .replace(raction, '="$1">')
4832 .replace(rleadingWhitespace, "")], ownerDocument)[0];
4833 } else {
4834 return this.cloneNode(true);
4835 }
4836 });
4837
4838 // Copy the events from the original to the clone
4839 if ( events === true ) {
4840 cloneCopyEvent( this, ret );
4841 cloneCopyEvent( this.find("*"), ret.find("*") );
4842 }
4843
4844 // Return the cloned set
4845 return ret;
4846 },
4847
4848 html: function( value ) {
4849 if ( value === undefined ) {
4850 return this[0] && this[0].nodeType === 1 ?
4851 this[0].innerHTML.replace(rinlinejQuery, "") :
4852 null;
4853
4854 // See if we can take a shortcut and just use innerHTML
4855 } else if ( typeof value === "string" && !rnocache.test( value ) &&
4856 (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
4857 !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
4858
4859 value = value.replace(rxhtmlTag, "<$1></$2>");
4860
4861 try {
4862 for ( var i = 0, l = this.length; i < l; i++ ) {
4863 // Remove element nodes and prevent memory leaks
4864 if ( this[i].nodeType === 1 ) {
4865 jQuery.cleanData( this[i].getElementsByTagName("*") );
4866 this[i].innerHTML = value;
4867 }
4868 }
4869
4870 // If using innerHTML throws an exception, use the fallback method
4871 } catch(e) {
4872 this.empty().append( value );
4873 }
4874
4875 } else if ( jQuery.isFunction( value ) ) {
4876 this.each(function(i){
4877 var self = jQuery( this );
4878
4879 self.html( value.call(this, i, self.html()) );
4880 });
4881
4882 } else {
4883 this.empty().append( value );
4884 }
4885
4886 return this;
4887 },
4888
4889 replaceWith: function( value ) {
4890 if ( this[0] && this[0].parentNode ) {
4891 // Make sure that the elements are removed from the DOM before they are inserted
4892 // this can help fix replacing a parent with child elements
4893 if ( jQuery.isFunction( value ) ) {
4894 return this.each(function(i) {
4895 var self = jQuery(this), old = self.html();
4896 self.replaceWith( value.call( this, i, old ) );
4897 });
4898 }
4899
4900 if ( typeof value !== "string" ) {
4901 value = jQuery( value ).detach();
4902 }
4903
4904 return this.each(function() {
4905 var next = this.nextSibling,
4906 parent = this.parentNode;
4907
4908 jQuery( this ).remove();
4909
4910 if ( next ) {
4911 jQuery(next).before( value );
4912 } else {
4913 jQuery(parent).append( value );
4914 }
4915 });
4916 } else {
4917 return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
4918 }
4919 },
4920
4921 detach: function( selector ) {
4922 return this.remove( selector, true );
4923 },
4924
4925 domManip: function( args, table, callback ) {
4926 var results, first, fragment, parent,
4927 value = args[0],
4928 scripts = [];
4929
4930 // We can't cloneNode fragments that contain checked, in WebKit
4931 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
4932 return this.each(function() {
4933 jQuery(this).domManip( args, table, callback, true );
4934 });
4935 }
4936
4937 if ( jQuery.isFunction(value) ) {
4938 return this.each(function(i) {
4939 var self = jQuery(this);
4940 args[0] = value.call(this, i, table ? self.html() : undefined);
4941 self.domManip( args, table, callback );
4942 });
4943 }
4944
4945 if ( this[0] ) {
4946 parent = value && value.parentNode;
4947
4948 // If we're in a fragment, just use that instead of building a new one
4949 if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
4950 results = { fragment: parent };
4951
4952 } else {
4953 results = jQuery.buildFragment( args, this, scripts );
4954 }
4955
4956 fragment = results.fragment;
4957
4958 if ( fragment.childNodes.length === 1 ) {
4959 first = fragment = fragment.firstChild;
4960 } else {
4961 first = fragment.firstChild;
4962 }
4963
4964 if ( first ) {
4965 table = table && jQuery.nodeName( first, "tr" );
4966
4967 for ( var i = 0, l = this.length; i < l; i++ ) {
4968 callback.call(
4969 table ?
4970 root(this[i], first) :
4971 this[i],
4972 i > 0 || results.cacheable || this.length > 1 ?
4973 fragment.cloneNode(true) :
4974 fragment
4975 );
4976 }
4977 }
4978
4979 if ( scripts.length ) {
4980 jQuery.each( scripts, evalScript );
4981 }
4982 }
4983
4984 return this;
4985 }
4986 });
4987
4988 function root( elem, cur ) {
4989 return jQuery.nodeName(elem, "table") ?
4990 (elem.getElementsByTagName("tbody")[0] ||
4991 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
4992 elem;
4993 }
4994
4995 function cloneCopyEvent(orig, ret) {
4996 var i = 0;
4997
4998 ret.each(function() {
4999 if ( this.nodeName !== (orig[i] && orig[i].nodeName) ) {
5000 return;
5001 }
5002
5003 var oldData = jQuery.data( orig[i++] ),
5004 curData = jQuery.data( this, oldData ),
5005 events = oldData && oldData.events;
5006
5007 if ( events ) {
5008 delete curData.handle;
5009 curData.events = {};
5010
5011 for ( var type in events ) {
5012 for ( var handler in events[ type ] ) {
5013 jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
5014 }
5015 }
5016 }
5017 });
5018 }
5019
5020 jQuery.buildFragment = function( args, nodes, scripts ) {
5021 var fragment, cacheable, cacheresults,
5022 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
5023
5024 // Only cache "small" (1/2 KB) strings that are associated with the main document
5025 // Cloning options loses the selected state, so don't cache them
5026 // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
5027 // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
5028 if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
5029 !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
5030
5031 cacheable = true;
5032 cacheresults = jQuery.fragments[ args[0] ];
5033 if ( cacheresults ) {
5034 if ( cacheresults !== 1 ) {
5035 fragment = cacheresults;
5036 }
5037 }
5038 }
5039
5040 if ( !fragment ) {
5041 fragment = doc.createDocumentFragment();
5042 jQuery.clean( args, doc, fragment, scripts );
5043 }
5044
5045 if ( cacheable ) {
5046 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
5047 }
5048
5049 return { fragment: fragment, cacheable: cacheable };
5050 };
5051
5052 jQuery.fragments = {};
5053
5054 jQuery.each({
5055 appendTo: "append",
5056 prependTo: "prepend",
5057 insertBefore: "before",
5058 insertAfter: "after",
5059 replaceAll: "replaceWith"
5060 }, function( name, original ) {
5061 jQuery.fn[ name ] = function( selector ) {
5062 var ret = [],
5063 insert = jQuery( selector ),
5064 parent = this.length === 1 && this[0].parentNode;
5065
5066 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
5067 insert[ original ]( this[0] );
5068 return this;
5069
5070 } else {
5071 for ( var i = 0, l = insert.length; i < l; i++ ) {
5072 var elems = (i > 0 ? this.clone(true) : this).get();
5073 jQuery( insert[i] )[ original ]( elems );
5074 ret = ret.concat( elems );
5075 }
5076
5077 return this.pushStack( ret, name, insert.selector );
5078 }
5079 };
5080 });
5081
5082 jQuery.extend({
5083 clean: function( elems, context, fragment, scripts ) {
5084 context = context || document;
5085
5086 // !context.createElement fails in IE with an error but returns typeof 'object'
5087 if ( typeof context.createElement === "undefined" ) {
5088 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
5089 }
5090
5091 var ret = [];
5092
5093 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
5094 if ( typeof elem === "number" ) {
5095 elem += "";
5096 }
5097
5098 if ( !elem ) {
5099 continue;
5100 }
5101
5102 // Convert html string into DOM nodes
5103 if ( typeof elem === "string" && !rhtml.test( elem ) ) {
5104 elem = context.createTextNode( elem );
5105
5106 } else if ( typeof elem === "string" ) {
5107 // Fix "XHTML"-style tags in all browsers
5108 elem = elem.replace(rxhtmlTag, "<$1></$2>");
5109
5110 // Trim whitespace, otherwise indexOf won't work as expected
5111 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
5112 wrap = wrapMap[ tag ] || wrapMap._default,
5113 depth = wrap[0],
5114 div = context.createElement("div");
5115
5116 // Go to html and back, then peel off extra wrappers
5117 div.innerHTML = wrap[1] + elem + wrap[2];
5118
5119 // Move to the right depth
5120 while ( depth-- ) {
5121 div = div.lastChild;
5122 }
5123
5124 // Remove IE's autoinserted <tbody> from table fragments
5125 if ( !jQuery.support.tbody ) {
5126
5127 // String was a <table>, *may* have spurious <tbody>
5128 var hasBody = rtbody.test(elem),
5129 tbody = tag === "table" && !hasBody ?
5130 div.firstChild && div.firstChild.childNodes :
5131
5132 // String was a bare <thead> or <tfoot>
5133 wrap[1] === "<table>" && !hasBody ?
5134 div.childNodes :
5135 [];
5136
5137 for ( var j = tbody.length - 1; j >= 0 ; --j ) {
5138 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
5139 tbody[ j ].parentNode.removeChild( tbody[ j ] );
5140 }
5141 }
5142
5143 }
5144
5145 // IE completely kills leading whitespace when innerHTML is used
5146 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
5147 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
5148 }
5149
5150 elem = div.childNodes;
5151 }
5152
5153 if ( elem.nodeType ) {
5154 ret.push( elem );
5155 } else {
5156 ret = jQuery.merge( ret, elem );
5157 }
5158 }
5159
5160 if ( fragment ) {
5161 for ( i = 0; ret[i]; i++ ) {
5162 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
5163 scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
5164
5165 } else {
5166 if ( ret[i].nodeType === 1 ) {
5167 ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
5168 }
5169 fragment.appendChild( ret[i] );
5170 }
5171 }
5172 }
5173
5174 return ret;
5175 },
5176
5177 cleanData: function( elems ) {
5178 var data, id, cache = jQuery.cache,
5179 special = jQuery.event.special,
5180 deleteExpando = jQuery.support.deleteExpando;
5181
5182 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
5183 if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
5184 continue;
5185 }
5186
5187 id = elem[ jQuery.expando ];
5188
5189 if ( id ) {
5190 data = cache[ id ];
5191
5192 if ( data && data.events ) {
5193 for ( var type in data.events ) {
5194 if ( special[ type ] ) {
5195 jQuery.event.remove( elem, type );
5196
5197 } else {
5198 jQuery.removeEvent( elem, type, data.handle );
5199 }
5200 }
5201 }
5202
5203 if ( deleteExpando ) {
5204 delete elem[ jQuery.expando ];
5205
5206 } else if ( elem.removeAttribute ) {
5207 elem.removeAttribute( jQuery.expando );
5208 }
5209
5210 delete cache[ id ];
5211 }
5212 }
5213 }
5214 });
5215
5216 function evalScript( i, elem ) {
5217 if ( elem.src ) {
5218 jQuery.ajax({
5219 url: elem.src,
5220 async: false,
5221 dataType: "script"
5222 });
5223 } else {
5224 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
5225 }
5226
5227 if ( elem.parentNode ) {
5228 elem.parentNode.removeChild( elem );
5229 }
5230 }
5231
5232
5233
5234
5235 var ralpha = /alpha\([^)]*\)/i,
5236 ropacity = /opacity=([^)]*)/,
5237 rdashAlpha = /-([a-z])/ig,
5238 rupper = /([A-Z])/g,
5239 rnumpx = /^-?\d+(?:px)?$/i,
5240 rnum = /^-?\d/,
5241
5242 cssShow = { position: "absolute", visibility: "hidden", display: "block" },
5243 cssWidth = [ "Left", "Right" ],
5244 cssHeight = [ "Top", "Bottom" ],
5245 curCSS,
5246
5247 getComputedStyle,
5248 currentStyle,
5249
5250 fcamelCase = function( all, letter ) {
5251 return letter.toUpperCase();
5252 };
5253
5254 jQuery.fn.css = function( name, value ) {
5255 // Setting 'undefined' is a no-op
5256 if ( arguments.length === 2 && value === undefined ) {
5257 return this;
5258 }
5259
5260 return jQuery.access( this, name, value, true, function( elem, name, value ) {
5261 return value !== undefined ?
5262 jQuery.style( elem, name, value ) :
5263 jQuery.css( elem, name );
5264 });
5265 };
5266
5267 jQuery.extend({
5268 // Add in style property hooks for overriding the default
5269 // behavior of getting and setting a style property
5270 cssHooks: {
5271 opacity: {
5272 get: function( elem, computed ) {
5273 if ( computed ) {
5274 // We should always get a number back from opacity
5275 var ret = curCSS( elem, "opacity", "opacity" );
5276 return ret === "" ? "1" : ret;
5277
5278 } else {
5279 return elem.style.opacity;
5280 }
5281 }
5282 }
5283 },
5284
5285 // Exclude the following css properties to add px
5286 cssNumber: {
5287 "zIndex": true,
5288 "fontWeight": true,
5289 "opacity": true,
5290 "zoom": true,
5291 "lineHeight": true
5292 },
5293
5294 // Add in properties whose names you wish to fix before
5295 // setting or getting the value
5296 cssProps: {
5297 // normalize float css property
5298 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
5299 },
5300
5301 // Get and set the style property on a DOM Node
5302 style: function( elem, name, value, extra ) {
5303 // Don't set styles on text and comment nodes
5304 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
5305 return;
5306 }
5307
5308 // Make sure that we're working with the right name
5309 var ret, origName = jQuery.camelCase( name ),
5310 style = elem.style, hooks = jQuery.cssHooks[ origName ];
5311
5312 name = jQuery.cssProps[ origName ] || origName;
5313
5314 // Check if we're setting a value
5315 if ( value !== undefined ) {
5316 // Make sure that NaN and null values aren't set. See: #7116
5317 if ( typeof value === "number" && isNaN( value ) || value == null ) {
5318 return;
5319 }
5320
5321 // If a number was passed in, add 'px' to the (except for certain CSS properties)
5322 if ( typeof value === "number" && !jQuery.cssNumber[ origName ] ) {
5323 value += "px";
5324 }
5325
5326 // If a hook was provided, use that value, otherwise just set the specified value
5327 if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
5328 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
5329 // Fixes bug #5509
5330 try {
5331 style[ name ] = value;
5332 } catch(e) {}
5333 }
5334
5335 } else {
5336 // If a hook was provided get the non-computed value from there
5337 if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
5338 return ret;
5339 }
5340
5341 // Otherwise just get the value from the style object
5342 return style[ name ];
5343 }
5344 },
5345
5346 css: function( elem, name, extra ) {
5347 // Make sure that we're working with the right name
5348 var ret, origName = jQuery.camelCase( name ),
5349 hooks = jQuery.cssHooks[ origName ];
5350
5351 name = jQuery.cssProps[ origName ] || origName;
5352
5353 // If a hook was provided get the computed value from there
5354 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
5355 return ret;
5356
5357 // Otherwise, if a way to get the computed value exists, use that
5358 } else if ( curCSS ) {
5359 return curCSS( elem, name, origName );
5360 }
5361 },
5362
5363 // A method for quickly swapping in/out CSS properties to get correct calculations
5364 swap: function( elem, options, callback ) {
5365 var old = {};
5366
5367 // Remember the old values, and insert the new ones
5368 for ( var name in options ) {
5369 old[ name ] = elem.style[ name ];
5370 elem.style[ name ] = options[ name ];
5371 }
5372
5373 callback.call( elem );
5374
5375 // Revert the old values
5376 for ( name in options ) {
5377 elem.style[ name ] = old[ name ];
5378 }
5379 },
5380
5381 camelCase: function( string ) {
5382 return string.replace( rdashAlpha, fcamelCase );
5383 }
5384 });
5385
5386 // DEPRECATED, Use jQuery.css() instead
5387 jQuery.curCSS = jQuery.css;
5388
5389 jQuery.each(["height", "width"], function( i, name ) {
5390 jQuery.cssHooks[ name ] = {
5391 get: function( elem, computed, extra ) {
5392 var val;
5393
5394 if ( computed ) {
5395 if ( elem.offsetWidth !== 0 ) {
5396 val = getWH( elem, name, extra );
5397
5398 } else {
5399 jQuery.swap( elem, cssShow, function() {
5400 val = getWH( elem, name, extra );
5401 });
5402 }
5403
5404 if ( val <= 0 ) {
5405 val = curCSS( elem, name, name );
5406
5407 if ( val === "0px" && currentStyle ) {
5408 val = currentStyle( elem, name, name );
5409 }
5410
5411 if ( val != null ) {
5412 // Should return "auto" instead of 0, use 0 for
5413 // temporary backwards-compat
5414 return val === "" || val === "auto" ? "0px" : val;
5415 }
5416 }
5417
5418 if ( val < 0 || val == null ) {
5419 val = elem.style[ name ];
5420
5421 // Should return "auto" instead of 0, use 0 for
5422 // temporary backwards-compat
5423 return val === "" || val === "auto" ? "0px" : val;
5424 }
5425
5426 return typeof val === "string" ? val : val + "px";
5427 }
5428 },
5429
5430 set: function( elem, value ) {
5431 if ( rnumpx.test( value ) ) {
5432 // ignore negative width and height values #1599
5433 value = parseFloat(value);
5434
5435 if ( value >= 0 ) {
5436 return value + "px";
5437 }
5438
5439 } else {
5440 return value;
5441 }
5442 }
5443 };
5444 });
5445
5446 if ( !jQuery.support.opacity ) {
5447 jQuery.cssHooks.opacity = {
5448 get: function( elem, computed ) {
5449 // IE uses filters for opacity
5450 return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
5451 (parseFloat(RegExp.$1) / 100) + "" :
5452 computed ? "1" : "";
5453 },
5454
5455 set: function( elem, value ) {
5456 var style = elem.style;
5457
5458 // IE has trouble with opacity if it does not have layout
5459 // Force it by setting the zoom level
5460 style.zoom = 1;
5461
5462 // Set the alpha filter to set the opacity
5463 var opacity = jQuery.isNaN(value) ?
5464 "" :
5465 "alpha(opacity=" + value * 100 + ")",
5466 filter = style.filter || "";
5467
5468 style.filter = ralpha.test(filter) ?
5469 filter.replace(ralpha, opacity) :
5470 style.filter + ' ' + opacity;
5471 }
5472 };
5473 }
5474
5475 if ( document.defaultView && document.defaultView.getComputedStyle ) {
5476 getComputedStyle = function( elem, newName, name ) {
5477 var ret, defaultView, computedStyle;
5478
5479 name = name.replace( rupper, "-$1" ).toLowerCase();
5480
5481 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
5482 return undefined;
5483 }
5484
5485 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
5486 ret = computedStyle.getPropertyValue( name );
5487 if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
5488 ret = jQuery.style( elem, name );
5489 }
5490 }
5491
5492 return ret;
5493 };
5494 }
5495
5496 if ( document.documentElement.currentStyle ) {
5497 currentStyle = function( elem, name ) {
5498 var left, rsLeft,
5499 ret = elem.currentStyle && elem.currentStyle[ name ],
5500 style = elem.style;
5501
5502 // From the awesome hack by Dean Edwards
5503 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
5504
5505 // If we're not dealing with a regular pixel number
5506 // but a number that has a weird ending, we need to convert it to pixels
5507 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
5508 // Remember the original values
5509 left = style.left;
5510 rsLeft = elem.runtimeStyle.left;
5511
5512 // Put in the new values to get a computed value out
5513 elem.runtimeStyle.left = elem.currentStyle.left;
5514 style.left = name === "fontSize" ? "1em" : (ret || 0);
5515 ret = style.pixelLeft + "px";
5516
5517 // Revert the changed values
5518 style.left = left;
5519 elem.runtimeStyle.left = rsLeft;
5520 }
5521
5522 return ret === "" ? "auto" : ret;
5523 };
5524 }
5525
5526 curCSS = getComputedStyle || currentStyle;
5527
5528 function getWH( elem, name, extra ) {
5529 var which = name === "width" ? cssWidth : cssHeight,
5530 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
5531
5532 if ( extra === "border" ) {
5533 return val;
5534 }
5535
5536 jQuery.each( which, function() {
5537 if ( !extra ) {
5538 val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
5539 }
5540
5541 if ( extra === "margin" ) {
5542 val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
5543
5544 } else {
5545 val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
5546 }
5547 });
5548
5549 return val;
5550 }
5551
5552 if ( jQuery.expr && jQuery.expr.filters ) {
5553 jQuery.expr.filters.hidden = function( elem ) {
5554 var width = elem.offsetWidth,
5555 height = elem.offsetHeight;
5556
5557 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
5558 };
5559
5560 jQuery.expr.filters.visible = function( elem ) {
5561 return !jQuery.expr.filters.hidden( elem );
5562 };
5563 }
5564
5565
5566
5567
5568 var jsc = jQuery.now(),
5569 rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
5570 rselectTextarea = /^(?:select|textarea)/i,
5571 rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
5572 rnoContent = /^(?:GET|HEAD)$/,
5573 rbracket = /\[\]$/,
5574 jsre = /\=\?(&|$)/,
5575 rquery = /\?/,
5576 rts = /([?&])_=[^&]*/,
5577 rurl = /^(\w+:)?\/\/([^\/?#]+)/,
5578 r20 = /%20/g,
5579 rhash = /#.*$/,
5580
5581 // Keep a copy of the old load method
5582 _load = jQuery.fn.load;
5583
5584 jQuery.fn.extend({
5585 load: function( url, params, callback ) {
5586 if ( typeof url !== "string" && _load ) {
5587 return _load.apply( this, arguments );
5588
5589 // Don't do a request if no elements are being requested
5590 } else if ( !this.length ) {
5591 return this;
5592 }
5593
5594 var off = url.indexOf(" ");
5595 if ( off >= 0 ) {
5596 var selector = url.slice(off, url.length);
5597 url = url.slice(0, off);
5598 }
5599
5600 // Default to a GET request
5601 var type = "GET";
5602
5603 // If the second parameter was provided
5604 if ( params ) {
5605 // If it's a function
5606 if ( jQuery.isFunction( params ) ) {
5607 // We assume that it's the callback
5608 callback = params;
5609 params = null;
5610
5611 // Otherwise, build a param string
5612 } else if ( typeof params === "object" ) {
5613 params = jQuery.param( params, jQuery.ajaxSettings.traditional );
5614 type = "POST";
5615 }
5616 }
5617
5618 var self = this;
5619
5620 // Request the remote document
5621 jQuery.ajax({
5622 url: url,
5623 type: type,
5624 dataType: "html",
5625 data: params,
5626 complete: function( res, status ) {
5627 // If successful, inject the HTML into all the matched elements
5628 if ( status === "success" || status === "notmodified" ) {
5629 // See if a selector was specified
5630 self.html( selector ?
5631 // Create a dummy div to hold the results
5632 jQuery("<div>")
5633 // inject the contents of the document in, removing the scripts
5634 // to avoid any 'Permission Denied' errors in IE
5635 .append(res.responseText.replace(rscript, ""))
5636
5637 // Locate the specified elements
5638 .find(selector) :
5639
5640 // If not, just inject the full result
5641 res.responseText );
5642 }
5643
5644 if ( callback ) {
5645 self.each( callback, [res.responseText, status, res] );
5646 }
5647 }
5648 });
5649
5650 return this;
5651 },
5652
5653 serialize: function() {
5654 return jQuery.param(this.serializeArray());
5655 },
5656
5657 serializeArray: function() {
5658 return this.map(function() {
5659 return this.elements ? jQuery.makeArray(this.elements) : this;
5660 })
5661 .filter(function() {
5662 return this.name && !this.disabled &&
5663 (this.checked || rselectTextarea.test(this.nodeName) ||
5664 rinput.test(this.type));
5665 })
5666 .map(function( i, elem ) {
5667 var val = jQuery(this).val();
5668
5669 return val == null ?
5670 null :
5671 jQuery.isArray(val) ?
5672 jQuery.map( val, function( val, i ) {
5673 return { name: elem.name, value: val };
5674 }) :
5675 { name: elem.name, value: val };
5676 }).get();
5677 }
5678 });
5679
5680 // Attach a bunch of functions for handling common AJAX events
5681 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
5682 jQuery.fn[o] = function( f ) {
5683 return this.bind(o, f);
5684 };
5685 });
5686
5687 jQuery.extend({
5688 get: function( url, data, callback, type ) {
5689 // shift arguments if data argument was omited
5690 if ( jQuery.isFunction( data ) ) {
5691 type = type || callback;
5692 callback = data;
5693 data = null;
5694 }
5695
5696 return jQuery.ajax({
5697 type: "GET",
5698 url: url,
5699 data: data,
5700 success: callback,
5701 dataType: type
5702 });
5703 },
5704
5705 getScript: function( url, callback ) {
5706 return jQuery.get(url, null, callback, "script");
5707 },
5708
5709 getJSON: function( url, data, callback ) {
5710 return jQuery.get(url, data, callback, "json");
5711 },
5712
5713 post: function( url, data, callback, type ) {
5714 // shift arguments if data argument was omited
5715 if ( jQuery.isFunction( data ) ) {
5716 type = type || callback;
5717 callback = data;
5718 data = {};
5719 }
5720
5721 return jQuery.ajax({
5722 type: "POST",
5723 url: url,
5724 data: data,
5725 success: callback,
5726 dataType: type
5727 });
5728 },
5729
5730 ajaxSetup: function( settings ) {
5731 jQuery.extend( jQuery.ajaxSettings, settings );
5732 },
5733
5734 ajaxSettings: {
5735 url: location.href,
5736 global: true,
5737 type: "GET",
5738 contentType: "application/x-www-form-urlencoded",
5739 processData: true,
5740 async: true,
5741 /*
5742 timeout: 0,
5743 data: null,
5744 username: null,
5745 password: null,
5746 traditional: false,
5747 */
5748 // This function can be overriden by calling jQuery.ajaxSetup
5749 xhr: function() {
5750 return new window.XMLHttpRequest();
5751 },
5752 accepts: {
5753 xml: "application/xml, text/xml",
5754 html: "text/html",
5755 script: "text/javascript, application/javascript",
5756 json: "application/json, text/javascript",
5757 text: "text/plain",
5758 _default: "*/*"
5759 }
5760 },
5761
5762 ajax: function( origSettings ) {
5763 var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings),
5764 jsonp, status, data, type = s.type.toUpperCase(), noContent = rnoContent.test(type);
5765
5766 s.url = s.url.replace( rhash, "" );
5767
5768 // Use original (not extended) context object if it was provided
5769 s.context = origSettings && origSettings.context != null ? origSettings.context : s;
5770
5771 // convert data if not already a string
5772 if ( s.data && s.processData && typeof s.data !== "string" ) {
5773 s.data = jQuery.param( s.data, s.traditional );
5774 }
5775
5776 // Handle JSONP Parameter Callbacks
5777 if ( s.dataType === "jsonp" ) {
5778 if ( type === "GET" ) {
5779 if ( !jsre.test( s.url ) ) {
5780 s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
5781 }
5782 } else if ( !s.data || !jsre.test(s.data) ) {
5783 s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
5784 }
5785 s.dataType = "json";
5786 }
5787
5788 // Build temporary JSONP function
5789 if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
5790 jsonp = s.jsonpCallback || ("jsonp" + jsc++);
5791
5792 // Replace the =? sequence both in the query string and the data
5793 if ( s.data ) {
5794 s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
5795 }
5796
5797 s.url = s.url.replace(jsre, "=" + jsonp + "$1");
5798
5799 // We need to make sure
5800 // that a JSONP style response is executed properly
5801 s.dataType = "script";
5802
5803 // Handle JSONP-style loading
5804 var customJsonp = window[ jsonp ];
5805
5806 window[ jsonp ] = function( tmp ) {
5807 if ( jQuery.isFunction( customJsonp ) ) {
5808 customJsonp( tmp );
5809
5810 } else {
5811 // Garbage collect
5812 window[ jsonp ] = undefined;
5813
5814 try {
5815 delete window[ jsonp ];
5816 } catch( jsonpError ) {}
5817 }
5818
5819 data = tmp;
5820 jQuery.handleSuccess( s, xhr, status, data );
5821 jQuery.handleComplete( s, xhr, status, data );
5822
5823 if ( head ) {
5824 head.removeChild( script );
5825 }
5826 };
5827 }
5828
5829 if ( s.dataType === "script" && s.cache === null ) {
5830 s.cache = false;
5831 }
5832
5833 if ( s.cache === false && noContent ) {
5834 var ts = jQuery.now();
5835
5836 // try replacing _= if it is there
5837 var ret = s.url.replace(rts, "$1_=" + ts);
5838
5839 // if nothing was replaced, add timestamp to the end
5840 s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
5841 }
5842
5843 // If data is available, append data to url for GET/HEAD requests
5844 if ( s.data && noContent ) {
5845 s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
5846 }
5847
5848 // Watch for a new set of requests
5849 if ( s.global && jQuery.active++ === 0 ) {
5850 jQuery.event.trigger( "ajaxStart" );
5851 }
5852
5853 // Matches an absolute URL, and saves the domain
5854 var parts = rurl.exec( s.url ),
5855 remote = parts && (parts[1] && parts[1].toLowerCase() !== location.protocol || parts[2].toLowerCase() !== location.host);
5856
5857 // If we're requesting a remote document
5858 // and trying to load JSON or Script with a GET
5859 if ( s.dataType === "script" && type === "GET" && remote ) {
5860 var head = document.getElementsByTagName("head")[0] || document.documentElement;
5861 var script = document.createElement("script");
5862 if ( s.scriptCharset ) {
5863 script.charset = s.scriptCharset;
5864 }
5865 script.src = s.url;
5866
5867 // Handle Script loading
5868 if ( !jsonp ) {
5869 var done = false;
5870
5871 // Attach handlers for all browsers
5872 script.onload = script.onreadystatechange = function() {
5873 if ( !done && (!this.readyState ||
5874 this.readyState === "loaded" || this.readyState === "complete") ) {
5875 done = true;
5876 jQuery.handleSuccess( s, xhr, status, data );
5877 jQuery.handleComplete( s, xhr, status, data );
5878
5879 // Handle memory leak in IE
5880 script.onload = script.onreadystatechange = null;
5881 if ( head && script.parentNode ) {
5882 head.removeChild( script );
5883 }
5884 }
5885 };
5886 }
5887
5888 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
5889 // This arises when a base node is used (#2709 and #4378).
5890 head.insertBefore( script, head.firstChild );
5891
5892 // We handle everything using the script element injection
5893 return undefined;
5894 }
5895
5896 var requestDone = false;
5897
5898 // Create the request object
5899 var xhr = s.xhr();
5900
5901 if ( !xhr ) {
5902 return;
5903 }
5904
5905 // Open the socket
5906 // Passing null username, generates a login popup on Opera (#2865)
5907 if ( s.username ) {
5908 xhr.open(type, s.url, s.async, s.username, s.password);
5909 } else {
5910 xhr.open(type, s.url, s.async);
5911 }
5912
5913 // Need an extra try/catch for cross domain requests in Firefox 3
5914 try {
5915 // Set content-type if data specified and content-body is valid for this type
5916 if ( (s.data != null && !noContent) || (origSettings && origSettings.contentType) ) {
5917 xhr.setRequestHeader("Content-Type", s.contentType);
5918 }
5919
5920 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
5921 if ( s.ifModified ) {
5922 if ( jQuery.lastModified[s.url] ) {
5923 xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);
5924 }
5925
5926 if ( jQuery.etag[s.url] ) {
5927 xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);
5928 }
5929 }
5930
5931 // Set header so the called script knows that it's an XMLHttpRequest
5932 // Only send the header if it's not a remote XHR
5933 if ( !remote ) {
5934 xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
5935 }
5936
5937 // Set the Accepts header for the server, depending on the dataType
5938 xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
5939 s.accepts[ s.dataType ] + ", */*; q=0.01" :
5940 s.accepts._default );
5941 } catch( headerError ) {}
5942
5943 // Allow custom headers/mimetypes and early abort
5944 if ( s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false ) {
5945 // Handle the global AJAX counter
5946 if ( s.global && jQuery.active-- === 1 ) {
5947 jQuery.event.trigger( "ajaxStop" );
5948 }
5949
5950 // close opended socket
5951 xhr.abort();
5952 return false;
5953 }
5954
5955 if ( s.global ) {
5956 jQuery.triggerGlobal( s, "ajaxSend", [xhr, s] );
5957 }
5958
5959 // Wait for a response to come back
5960 var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) {
5961 // The request was aborted
5962 if ( !xhr || xhr.readyState === 0 || isTimeout === "abort" ) {
5963 // Opera doesn't call onreadystatechange before this point
5964 // so we simulate the call
5965 if ( !requestDone ) {
5966 jQuery.handleComplete( s, xhr, status, data );
5967 }
5968
5969 requestDone = true;
5970 if ( xhr ) {
5971 xhr.onreadystatechange = jQuery.noop;
5972 }
5973
5974 // The transfer is complete and the data is available, or the request timed out
5975 } else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) {
5976 requestDone = true;
5977 xhr.onreadystatechange = jQuery.noop;
5978
5979 status = isTimeout === "timeout" ?
5980 "timeout" :
5981 !jQuery.httpSuccess( xhr ) ?
5982 "error" :
5983 s.ifModified && jQuery.httpNotModified( xhr, s.url ) ?
5984 "notmodified" :
5985 "success";
5986
5987 var errMsg;
5988
5989 if ( status === "success" ) {
5990 // Watch for, and catch, XML document parse errors
5991 try {
5992 // process the data (runs the xml through httpData regardless of callback)
5993 data = jQuery.httpData( xhr, s.dataType, s );
5994 } catch( parserError ) {
5995 status = "parsererror";
5996 errMsg = parserError;
5997 }
5998 }
5999
6000 // Make sure that the request was successful or notmodified
6001 if ( status === "success" || status === "notmodified" ) {
6002 // JSONP handles its own success callback
6003 if ( !jsonp ) {
6004 jQuery.handleSuccess( s, xhr, status, data );
6005 }
6006 } else {
6007 jQuery.handleError( s, xhr, status, errMsg );
6008 }
6009
6010 // Fire the complete handlers
6011 if ( !jsonp ) {
6012 jQuery.handleComplete( s, xhr, status, data );
6013 }
6014
6015 if ( isTimeout === "timeout" ) {
6016 xhr.abort();
6017 }
6018
6019 // Stop memory leaks
6020 if ( s.async ) {
6021 xhr = null;
6022 }
6023 }
6024 };
6025
6026 // Override the abort handler, if we can (IE 6 doesn't allow it, but that's OK)
6027 // Opera doesn't fire onreadystatechange at all on abort
6028 try {
6029 var oldAbort = xhr.abort;
6030 xhr.abort = function() {
6031 if ( xhr ) {
6032 // oldAbort has no call property in IE7 so
6033 // just do it this way, which works in all
6034 // browsers
6035 Function.prototype.call.call( oldAbort, xhr );
6036 }
6037
6038 onreadystatechange( "abort" );
6039 };
6040 } catch( abortError ) {}
6041
6042 // Timeout checker
6043 if ( s.async && s.timeout > 0 ) {
6044 setTimeout(function() {
6045 // Check to see if the request is still happening
6046 if ( xhr && !requestDone ) {
6047 onreadystatechange( "timeout" );
6048 }
6049 }, s.timeout);
6050 }
6051
6052 // Send the data
6053 try {
6054 xhr.send( noContent || s.data == null ? null : s.data );
6055
6056 } catch( sendError ) {
6057 jQuery.handleError( s, xhr, null, sendError );
6058
6059 // Fire the complete handlers
6060 jQuery.handleComplete( s, xhr, status, data );
6061 }
6062
6063 // firefox 1.5 doesn't fire statechange for sync requests
6064 if ( !s.async ) {
6065 onreadystatechange();
6066 }
6067
6068 // return XMLHttpRequest to allow aborting the request etc.
6069 return xhr;
6070 },
6071
6072 // Serialize an array of form elements or a set of
6073 // key/values into a query string
6074 param: function( a, traditional ) {
6075 var s = [],
6076 add = function( key, value ) {
6077 // If value is a function, invoke it and return its value
6078 value = jQuery.isFunction(value) ? value() : value;
6079 s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
6080 };
6081
6082 // Set traditional to true for jQuery <= 1.3.2 behavior.
6083 if ( traditional === undefined ) {
6084 traditional = jQuery.ajaxSettings.traditional;
6085 }
6086
6087 // If an array was passed in, assume that it is an array of form elements.
6088 if ( jQuery.isArray(a) || a.jquery ) {
6089 // Serialize the form elements
6090 jQuery.each( a, function() {
6091 add( this.name, this.value );
6092 });
6093
6094 } else {
6095 // If traditional, encode the "old" way (the way 1.3.2 or older
6096 // did it), otherwise encode params recursively.
6097 for ( var prefix in a ) {
6098 buildParams( prefix, a[prefix], traditional, add );
6099 }
6100 }
6101
6102 // Return the resulting serialization
6103 return s.join("&").replace(r20, "+");
6104 }
6105 });
6106
6107 function buildParams( prefix, obj, traditional, add ) {
6108 if ( jQuery.isArray(obj) && obj.length ) {
6109 // Serialize array item.
6110 jQuery.each( obj, function( i, v ) {
6111 if ( traditional || rbracket.test( prefix ) ) {
6112 // Treat each array item as a scalar.
6113 add( prefix, v );
6114
6115 } else {
6116 // If array item is non-scalar (array or object), encode its
6117 // numeric index to resolve deserialization ambiguity issues.
6118 // Note that rack (as of 1.0.0) can't currently deserialize
6119 // nested arrays properly, and attempting to do so may cause
6120 // a server error. Possible fixes are to modify rack's
6121 // deserialization algorithm or to provide an option or flag
6122 // to force array serialization to be shallow.
6123 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
6124 }
6125 });
6126
6127 } else if ( !traditional && obj != null && typeof obj === "object" ) {
6128 if ( jQuery.isEmptyObject( obj ) ) {
6129 add( prefix, "" );
6130
6131 // Serialize object item.
6132 } else {
6133 jQuery.each( obj, function( k, v ) {
6134 buildParams( prefix + "[" + k + "]", v, traditional, add );
6135 });
6136 }
6137
6138 } else {
6139 // Serialize scalar item.
6140 add( prefix, obj );
6141 }
6142 }
6143
6144 // This is still on the jQuery object... for now
6145 // Want to move this to jQuery.ajax some day
6146 jQuery.extend({
6147
6148 // Counter for holding the number of active queries
6149 active: 0,
6150
6151 // Last-Modified header cache for next request
6152 lastModified: {},
6153 etag: {},
6154
6155 handleError: function( s, xhr, status, e ) {
6156 // If a local callback was specified, fire it
6157 if ( s.error ) {
6158 s.error.call( s.context, xhr, status, e );
6159 }
6160
6161 // Fire the global callback
6162 if ( s.global ) {
6163 jQuery.triggerGlobal( s, "ajaxError", [xhr, s, e] );
6164 }
6165 },
6166
6167 handleSuccess: function( s, xhr, status, data ) {
6168 // If a local callback was specified, fire it and pass it the data
6169 if ( s.success ) {
6170 s.success.call( s.context, data, status, xhr );
6171 }
6172
6173 // Fire the global callback
6174 if ( s.global ) {
6175 jQuery.triggerGlobal( s, "ajaxSuccess", [xhr, s] );
6176 }
6177 },
6178
6179 handleComplete: function( s, xhr, status ) {
6180 // Process result
6181 if ( s.complete ) {
6182 s.complete.call( s.context, xhr, status );
6183 }
6184
6185 // The request was completed
6186 if ( s.global ) {
6187 jQuery.triggerGlobal( s, "ajaxComplete", [xhr, s] );
6188 }
6189
6190 // Handle the global AJAX counter
6191 if ( s.global && jQuery.active-- === 1 ) {
6192 jQuery.event.trigger( "ajaxStop" );
6193 }
6194 },
6195
6196 triggerGlobal: function( s, type, args ) {
6197 (s.context && s.context.url == null ? jQuery(s.context) : jQuery.event).trigger(type, args);
6198 },
6199
6200 // Determines if an XMLHttpRequest was successful or not
6201 httpSuccess: function( xhr ) {
6202 try {
6203 // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
6204 return !xhr.status && location.protocol === "file:" ||
6205 xhr.status >= 200 && xhr.status < 300 ||
6206 xhr.status === 304 || xhr.status === 1223;
6207 } catch(e) {}
6208
6209 return false;
6210 },
6211
6212 // Determines if an XMLHttpRequest returns NotModified
6213 httpNotModified: function( xhr, url ) {
6214 var lastModified = xhr.getResponseHeader("Last-Modified"),
6215 etag = xhr.getResponseHeader("Etag");
6216
6217 if ( lastModified ) {
6218 jQuery.lastModified[url] = lastModified;
6219 }
6220
6221 if ( etag ) {
6222 jQuery.etag[url] = etag;
6223 }
6224
6225 return xhr.status === 304;
6226 },
6227
6228 httpData: function( xhr, type, s ) {
6229 var ct = xhr.getResponseHeader("content-type") || "",
6230 xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
6231 data = xml ? xhr.responseXML : xhr.responseText;
6232
6233 if ( xml && data.documentElement.nodeName === "parsererror" ) {
6234 jQuery.error( "parsererror" );
6235 }
6236
6237 // Allow a pre-filtering function to sanitize the response
6238 // s is checked to keep backwards compatibility
6239 if ( s && s.dataFilter ) {
6240 data = s.dataFilter( data, type );
6241 }
6242
6243 // The filter can actually parse the response
6244 if ( typeof data === "string" ) {
6245 // Get the JavaScript object, if JSON is used.
6246 if ( type === "json" || !type && ct.indexOf("json") >= 0 ) {
6247 data = jQuery.parseJSON( data );
6248
6249 // If the type is "script", eval it in global context
6250 } else if ( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
6251 jQuery.globalEval( data );
6252 }
6253 }
6254
6255 return data;
6256 }
6257
6258 });
6259
6260 /*
6261 * Create the request object; Microsoft failed to properly
6262 * implement the XMLHttpRequest in IE7 (can't request local files),
6263 * so we use the ActiveXObject when it is available
6264 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
6265 * we need a fallback.
6266 */
6267 if ( window.ActiveXObject ) {
6268 jQuery.ajaxSettings.xhr = function() {
6269 if ( window.location.protocol !== "file:" ) {
6270 try {
6271 return new window.XMLHttpRequest();
6272 } catch(xhrError) {}
6273 }
6274
6275 try {
6276 return new window.ActiveXObject("Microsoft.XMLHTTP");
6277 } catch(activeError) {}
6278 };
6279 }
6280
6281 // Does this browser support XHR requests?
6282 jQuery.support.ajax = !!jQuery.ajaxSettings.xhr();
6283
6284
6285
6286
6287 var elemdisplay = {},
6288 rfxtypes = /^(?:toggle|show|hide)$/,
6289 rfxnum = /^([+\-]=)?([\d+.\-]+)(.*)$/,
6290 timerId,
6291 fxAttrs = [
6292 // height animations
6293 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
6294 // width animations
6295 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
6296 // opacity animations
6297 [ "opacity" ]
6298 ];
6299
6300 jQuery.fn.extend({
6301 show: function( speed, easing, callback ) {
6302 var elem, display;
6303
6304 if ( speed || speed === 0 ) {
6305 return this.animate( genFx("show", 3), speed, easing, callback);
6306
6307 } else {
6308 for ( var i = 0, j = this.length; i < j; i++ ) {
6309 elem = this[i];
6310 display = elem.style.display;
6311
6312 // Reset the inline display of this element to learn if it is
6313 // being hidden by cascaded rules or not
6314 if ( !jQuery.data(elem, "olddisplay") && display === "none" ) {
6315 display = elem.style.display = "";
6316 }
6317
6318 // Set elements which have been overridden with display: none
6319 // in a stylesheet to whatever the default browser style is
6320 // for such an element
6321 if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
6322 jQuery.data(elem, "olddisplay", defaultDisplay(elem.nodeName));
6323 }
6324 }
6325
6326 // Set the display of most of the elements in a second loop
6327 // to avoid the constant reflow
6328 for ( i = 0; i < j; i++ ) {
6329 elem = this[i];
6330 display = elem.style.display;
6331
6332 if ( display === "" || display === "none" ) {
6333 elem.style.display = jQuery.data(elem, "olddisplay") || "";
6334 }
6335 }
6336
6337 return this;
6338 }
6339 },
6340
6341 hide: function( speed, easing, callback ) {
6342 if ( speed || speed === 0 ) {
6343 return this.animate( genFx("hide", 3), speed, easing, callback);
6344
6345 } else {
6346 for ( var i = 0, j = this.length; i < j; i++ ) {
6347 var display = jQuery.css( this[i], "display" );
6348
6349 if ( display !== "none" ) {
6350 jQuery.data( this[i], "olddisplay", display );
6351 }
6352 }
6353
6354 // Set the display of the elements in a second loop
6355 // to avoid the constant reflow
6356 for ( i = 0; i < j; i++ ) {
6357 this[i].style.display = "none";
6358 }
6359
6360 return this;
6361 }
6362 },
6363
6364 // Save the old toggle function
6365 _toggle: jQuery.fn.toggle,
6366
6367 toggle: function( fn, fn2, callback ) {
6368 var bool = typeof fn === "boolean";
6369
6370 if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
6371 this._toggle.apply( this, arguments );
6372
6373 } else if ( fn == null || bool ) {
6374 this.each(function() {
6375 var state = bool ? fn : jQuery(this).is(":hidden");
6376 jQuery(this)[ state ? "show" : "hide" ]();
6377 });
6378
6379 } else {
6380 this.animate(genFx("toggle", 3), fn, fn2, callback);
6381 }
6382
6383 return this;
6384 },
6385
6386 fadeTo: function( speed, to, easing, callback ) {
6387 return this.filter(":hidden").css("opacity", 0).show().end()
6388 .animate({opacity: to}, speed, easing, callback);
6389 },
6390
6391 animate: function( prop, speed, easing, callback ) {
6392 var optall = jQuery.speed(speed, easing, callback);
6393
6394 if ( jQuery.isEmptyObject( prop ) ) {
6395 return this.each( optall.complete );
6396 }
6397
6398 return this[ optall.queue === false ? "each" : "queue" ](function() {
6399 // XXX 'this' does not always have a nodeName when running the
6400 // test suite
6401
6402 var opt = jQuery.extend({}, optall), p,
6403 isElement = this.nodeType === 1,
6404 hidden = isElement && jQuery(this).is(":hidden"),
6405 self = this;
6406
6407 for ( p in prop ) {
6408 var name = jQuery.camelCase( p );
6409
6410 if ( p !== name ) {
6411 prop[ name ] = prop[ p ];
6412 delete prop[ p ];
6413 p = name;
6414 }
6415
6416 if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
6417 return opt.complete.call(this);
6418 }
6419
6420 if ( isElement && ( p === "height" || p === "width" ) ) {
6421 // Make sure that nothing sneaks out
6422 // Record all 3 overflow attributes because IE does not
6423 // change the overflow attribute when overflowX and
6424 // overflowY are set to the same value
6425 opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
6426
6427 // Set display property to inline-block for height/width
6428 // animations on inline elements that are having width/height
6429 // animated
6430 if ( jQuery.css( this, "display" ) === "inline" &&
6431 jQuery.css( this, "float" ) === "none" ) {
6432 if ( !jQuery.support.inlineBlockNeedsLayout ) {
6433 this.style.display = "inline-block";
6434
6435 } else {
6436 var display = defaultDisplay(this.nodeName);
6437
6438 // inline-level elements accept inline-block;
6439 // block-level elements need to be inline with layout
6440 if ( display === "inline" ) {
6441 this.style.display = "inline-block";
6442
6443 } else {
6444 this.style.display = "inline";
6445 this.style.zoom = 1;
6446 }
6447 }
6448 }
6449 }
6450
6451 if ( jQuery.isArray( prop[p] ) ) {
6452 // Create (if needed) and add to specialEasing
6453 (opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
6454 prop[p] = prop[p][0];
6455 }
6456 }
6457
6458 if ( opt.overflow != null ) {
6459 this.style.overflow = "hidden";
6460 }
6461
6462 opt.curAnim = jQuery.extend({}, prop);
6463
6464 jQuery.each( prop, function( name, val ) {
6465 var e = new jQuery.fx( self, opt, name );
6466
6467 if ( rfxtypes.test(val) ) {
6468 e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );
6469
6470 } else {
6471 var parts = rfxnum.exec(val),
6472 start = e.cur() || 0;
6473
6474 if ( parts ) {
6475 var end = parseFloat( parts[2] ),
6476 unit = parts[3] || "px";
6477
6478 // We need to compute starting value
6479 if ( unit !== "px" ) {
6480 jQuery.style( self, name, (end || 1) + unit);
6481 start = ((end || 1) / e.cur()) * start;
6482 jQuery.style( self, name, start + unit);
6483 }
6484
6485 // If a +=/-= token was provided, we're doing a relative animation
6486 if ( parts[1] ) {
6487 end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
6488 }
6489
6490 e.custom( start, end, unit );
6491
6492 } else {
6493 e.custom( start, val, "" );
6494 }
6495 }
6496 });
6497
6498 // For JS strict compliance
6499 return true;
6500 });
6501 },
6502
6503 stop: function( clearQueue, gotoEnd ) {
6504 var timers = jQuery.timers;
6505
6506 if ( clearQueue ) {
6507 this.queue([]);
6508 }
6509
6510 this.each(function() {
6511 // go in reverse order so anything added to the queue during the loop is ignored
6512 for ( var i = timers.length - 1; i >= 0; i-- ) {
6513 if ( timers[i].elem === this ) {
6514 if (gotoEnd) {
6515 // force the next step to be the last
6516 timers[i](true);
6517 }
6518
6519 timers.splice(i, 1);
6520 }
6521 }
6522 });
6523
6524 // start the next in the queue if the last step wasn't forced
6525 if ( !gotoEnd ) {
6526 this.dequeue();
6527 }
6528
6529 return this;
6530 }
6531
6532 });
6533
6534 function genFx( type, num ) {
6535 var obj = {};
6536
6537 jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
6538 obj[ this ] = type;
6539 });
6540
6541 return obj;
6542 }
6543
6544 // Generate shortcuts for custom animations
6545 jQuery.each({
6546 slideDown: genFx("show", 1),
6547 slideUp: genFx("hide", 1),
6548 slideToggle: genFx("toggle", 1),
6549 fadeIn: { opacity: "show" },
6550 fadeOut: { opacity: "hide" },
6551 fadeToggle: { opacity: "toggle" }
6552 }, function( name, props ) {
6553 jQuery.fn[ name ] = function( speed, easing, callback ) {
6554 return this.animate( props, speed, easing, callback );
6555 };
6556 });
6557
6558 jQuery.extend({
6559 speed: function( speed, easing, fn ) {
6560 var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
6561 complete: fn || !fn && easing ||
6562 jQuery.isFunction( speed ) && speed,
6563 duration: speed,
6564 easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
6565 };
6566
6567 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
6568 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
6569
6570 // Queueing
6571 opt.old = opt.complete;
6572 opt.complete = function() {
6573 if ( opt.queue !== false ) {
6574 jQuery(this).dequeue();
6575 }
6576 if ( jQuery.isFunction( opt.old ) ) {
6577 opt.old.call( this );
6578 }
6579 };
6580
6581 return opt;
6582 },
6583
6584 easing: {
6585 linear: function( p, n, firstNum, diff ) {
6586 return firstNum + diff * p;
6587 },
6588 swing: function( p, n, firstNum, diff ) {
6589 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
6590 }
6591 },
6592
6593 timers: [],
6594
6595 fx: function( elem, options, prop ) {
6596 this.options = options;
6597 this.elem = elem;
6598 this.prop = prop;
6599
6600 if ( !options.orig ) {
6601 options.orig = {};
6602 }
6603 }
6604
6605 });
6606
6607 jQuery.fx.prototype = {
6608 // Simple function for setting a style value
6609 update: function() {
6610 if ( this.options.step ) {
6611 this.options.step.call( this.elem, this.now, this );
6612 }
6613
6614 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
6615 },
6616
6617 // Get the current size
6618 cur: function() {
6619 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
6620 return this.elem[ this.prop ];
6621 }
6622
6623 var r = parseFloat( jQuery.css( this.elem, this.prop ) );
6624 return r && r > -10000 ? r : 0;
6625 },
6626
6627 // Start an animation from one number to another
6628 custom: function( from, to, unit ) {
6629 var self = this,
6630 fx = jQuery.fx;
6631
6632 this.startTime = jQuery.now();
6633 this.start = from;
6634 this.end = to;
6635 this.unit = unit || this.unit || "px";
6636 this.now = this.start;
6637 this.pos = this.state = 0;
6638
6639 function t( gotoEnd ) {
6640 return self.step(gotoEnd);
6641 }
6642
6643 t.elem = this.elem;
6644
6645 if ( t() && jQuery.timers.push(t) && !timerId ) {
6646 timerId = setInterval(fx.tick, fx.interval);
6647 }
6648 },
6649
6650 // Simple 'show' function
6651 show: function() {
6652 // Remember where we started, so that we can go back to it later
6653 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
6654 this.options.show = true;
6655
6656 // Begin the animation
6657 // Make sure that we start at a small width/height to avoid any
6658 // flash of content
6659 this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
6660
6661 // Start by showing the element
6662 jQuery( this.elem ).show();
6663 },
6664
6665 // Simple 'hide' function
6666 hide: function() {
6667 // Remember where we started, so that we can go back to it later
6668 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
6669 this.options.hide = true;
6670
6671 // Begin the animation
6672 this.custom(this.cur(), 0);
6673 },
6674
6675 // Each step of an animation
6676 step: function( gotoEnd ) {
6677 var t = jQuery.now(), done = true;
6678
6679 if ( gotoEnd || t >= this.options.duration + this.startTime ) {
6680 this.now = this.end;
6681 this.pos = this.state = 1;
6682 this.update();
6683
6684 this.options.curAnim[ this.prop ] = true;
6685
6686 for ( var i in this.options.curAnim ) {
6687 if ( this.options.curAnim[i] !== true ) {
6688 done = false;
6689 }
6690 }
6691
6692 if ( done ) {
6693 // Reset the overflow
6694 if ( this.options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
6695 var elem = this.elem,
6696 options = this.options;
6697
6698 jQuery.each( [ "", "X", "Y" ], function (index, value) {
6699 elem.style[ "overflow" + value ] = options.overflow[index];
6700 } );
6701 }
6702
6703 // Hide the element if the "hide" operation was done
6704 if ( this.options.hide ) {
6705 jQuery(this.elem).hide();
6706 }
6707
6708 // Reset the properties, if the item has been hidden or shown
6709 if ( this.options.hide || this.options.show ) {
6710 for ( var p in this.options.curAnim ) {
6711 jQuery.style( this.elem, p, this.options.orig[p] );
6712 }
6713 }
6714
6715 // Execute the complete function
6716 this.options.complete.call( this.elem );
6717 }
6718
6719 return false;
6720
6721 } else {
6722 var n = t - this.startTime;
6723 this.state = n / this.options.duration;
6724
6725 // Perform the easing function, defaults to swing
6726 var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop];
6727 var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear");
6728 this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
6729 this.now = this.start + ((this.end - this.start) * this.pos);
6730
6731 // Perform the next step of the animation
6732 this.update();
6733 }
6734
6735 return true;
6736 }
6737 };
6738
6739 jQuery.extend( jQuery.fx, {
6740 tick: function() {
6741 var timers = jQuery.timers;
6742
6743 for ( var i = 0; i < timers.length; i++ ) {
6744 if ( !timers[i]() ) {
6745 timers.splice(i--, 1);
6746 }
6747 }
6748
6749 if ( !timers.length ) {
6750 jQuery.fx.stop();
6751 }
6752 },
6753
6754 interval: 13,
6755
6756 stop: function() {
6757 clearInterval( timerId );
6758 timerId = null;
6759 },
6760
6761 speeds: {
6762 slow: 600,
6763 fast: 200,
6764 // Default speed
6765 _default: 400
6766 },
6767
6768 step: {
6769 opacity: function( fx ) {
6770 jQuery.style( fx.elem, "opacity", fx.now );
6771 },
6772
6773 _default: function( fx ) {
6774 if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
6775 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
6776 } else {
6777 fx.elem[ fx.prop ] = fx.now;
6778 }
6779 }
6780 }
6781 });
6782
6783 if ( jQuery.expr && jQuery.expr.filters ) {
6784 jQuery.expr.filters.animated = function( elem ) {
6785 return jQuery.grep(jQuery.timers, function( fn ) {
6786 return elem === fn.elem;
6787 }).length;
6788 };
6789 }
6790
6791 function defaultDisplay( nodeName ) {
6792 if ( !elemdisplay[ nodeName ] ) {
6793 var elem = jQuery("<" + nodeName + ">").appendTo("body"),
6794 display = elem.css("display");
6795
6796 elem.remove();
6797
6798 if ( display === "none" || display === "" ) {
6799 display = "block";
6800 }
6801
6802 elemdisplay[ nodeName ] = display;
6803 }
6804
6805 return elemdisplay[ nodeName ];
6806 }
6807
6808
6809
6810
6811 var rtable = /^t(?:able|d|h)$/i,
6812 rroot = /^(?:body|html)$/i;
6813
6814 if ( "getBoundingClientRect" in document.documentElement ) {
6815 jQuery.fn.offset = function( options ) {
6816 var elem = this[0], box;
6817
6818 if ( options ) {
6819 return this.each(function( i ) {
6820 jQuery.offset.setOffset( this, options, i );
6821 });
6822 }
6823
6824 if ( !elem || !elem.ownerDocument ) {
6825 return null;
6826 }
6827
6828 if ( elem === elem.ownerDocument.body ) {
6829 return jQuery.offset.bodyOffset( elem );
6830 }
6831
6832 try {
6833 box = elem.getBoundingClientRect();
6834 } catch(e) {}
6835
6836 var doc = elem.ownerDocument,
6837 docElem = doc.documentElement;
6838
6839 // Make sure we're not dealing with a disconnected DOM node
6840 if ( !box || !jQuery.contains( docElem, elem ) ) {
6841 return box || { top: 0, left: 0 };
6842 }
6843
6844 var body = doc.body,
6845 win = getWindow(doc),
6846 clientTop = docElem.clientTop || body.clientTop || 0,
6847 clientLeft = docElem.clientLeft || body.clientLeft || 0,
6848 scrollTop = (win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop ),
6849 scrollLeft = (win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft),
6850 top = box.top + scrollTop - clientTop,
6851 left = box.left + scrollLeft - clientLeft;
6852
6853 return { top: top, left: left };
6854 };
6855
6856 } else {
6857 jQuery.fn.offset = function( options ) {
6858 var elem = this[0];
6859
6860 if ( options ) {
6861 return this.each(function( i ) {
6862 jQuery.offset.setOffset( this, options, i );
6863 });
6864 }
6865
6866 if ( !elem || !elem.ownerDocument ) {
6867 return null;
6868 }
6869
6870 if ( elem === elem.ownerDocument.body ) {
6871 return jQuery.offset.bodyOffset( elem );
6872 }
6873
6874 jQuery.offset.initialize();
6875
6876 var computedStyle,
6877 offsetParent = elem.offsetParent,
6878 prevOffsetParent = elem,
6879 doc = elem.ownerDocument,
6880 docElem = doc.documentElement,
6881 body = doc.body,
6882 defaultView = doc.defaultView,
6883 prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
6884 top = elem.offsetTop,
6885 left = elem.offsetLeft;
6886
6887 while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
6888 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
6889 break;
6890 }
6891
6892 computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
6893 top -= elem.scrollTop;
6894 left -= elem.scrollLeft;
6895
6896 if ( elem === offsetParent ) {
6897 top += elem.offsetTop;
6898 left += elem.offsetLeft;
6899
6900 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
6901 top += parseFloat( computedStyle.borderTopWidth ) || 0;
6902 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
6903 }
6904
6905 prevOffsetParent = offsetParent;
6906 offsetParent = elem.offsetParent;
6907 }
6908
6909 if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
6910 top += parseFloat( computedStyle.borderTopWidth ) || 0;
6911 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
6912 }
6913
6914 prevComputedStyle = computedStyle;
6915 }
6916
6917 if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
6918 top += body.offsetTop;
6919 left += body.offsetLeft;
6920 }
6921
6922 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
6923 top += Math.max( docElem.scrollTop, body.scrollTop );
6924 left += Math.max( docElem.scrollLeft, body.scrollLeft );
6925 }
6926
6927 return { top: top, left: left };
6928 };
6929 }
6930
6931 jQuery.offset = {
6932 initialize: function() {
6933 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
6934 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>";
6935
6936 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
6937
6938 container.innerHTML = html;
6939 body.insertBefore( container, body.firstChild );
6940 innerDiv = container.firstChild;
6941 checkDiv = innerDiv.firstChild;
6942 td = innerDiv.nextSibling.firstChild.firstChild;
6943
6944 this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
6945 this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
6946
6947 checkDiv.style.position = "fixed";
6948 checkDiv.style.top = "20px";
6949
6950 // safari subtracts parent border width here which is 5px
6951 this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
6952 checkDiv.style.position = checkDiv.style.top = "";
6953
6954 innerDiv.style.overflow = "hidden";
6955 innerDiv.style.position = "relative";
6956
6957 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
6958
6959 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
6960
6961 body.removeChild( container );
6962 body = container = innerDiv = checkDiv = table = td = null;
6963 jQuery.offset.initialize = jQuery.noop;
6964 },
6965
6966 bodyOffset: function( body ) {
6967 var top = body.offsetTop,
6968 left = body.offsetLeft;
6969
6970 jQuery.offset.initialize();
6971
6972 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
6973 top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
6974 left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
6975 }
6976
6977 return { top: top, left: left };
6978 },
6979
6980 setOffset: function( elem, options, i ) {
6981 var position = jQuery.css( elem, "position" );
6982
6983 // set position first, in-case top/left are set even on static elem
6984 if ( position === "static" ) {
6985 elem.style.position = "relative";
6986 }
6987
6988 var curElem = jQuery( elem ),
6989 curOffset = curElem.offset(),
6990 curCSSTop = jQuery.css( elem, "top" ),
6991 curCSSLeft = jQuery.css( elem, "left" ),
6992 calculatePosition = (position === "absolute" && jQuery.inArray('auto', [curCSSTop, curCSSLeft]) > -1),
6993 props = {}, curPosition = {}, curTop, curLeft;
6994
6995 // need to be able to calculate position if either top or left is auto and position is absolute
6996 if ( calculatePosition ) {
6997 curPosition = curElem.position();
6998 }
6999
7000 curTop = calculatePosition ? curPosition.top : parseInt( curCSSTop, 10 ) || 0;
7001 curLeft = calculatePosition ? curPosition.left : parseInt( curCSSLeft, 10 ) || 0;
7002
7003 if ( jQuery.isFunction( options ) ) {
7004 options = options.call( elem, i, curOffset );
7005 }
7006
7007 if (options.top != null) {
7008 props.top = (options.top - curOffset.top) + curTop;
7009 }
7010 if (options.left != null) {
7011 props.left = (options.left - curOffset.left) + curLeft;
7012 }
7013
7014 if ( "using" in options ) {
7015 options.using.call( elem, props );
7016 } else {
7017 curElem.css( props );
7018 }
7019 }
7020 };
7021
7022
7023 jQuery.fn.extend({
7024 position: function() {
7025 if ( !this[0] ) {
7026 return null;
7027 }
7028
7029 var elem = this[0],
7030
7031 // Get *real* offsetParent
7032 offsetParent = this.offsetParent(),
7033
7034 // Get correct offsets
7035 offset = this.offset(),
7036 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
7037
7038 // Subtract element margins
7039 // note: when an element has margin: auto the offsetLeft and marginLeft
7040 // are the same in Safari causing offset.left to incorrectly be 0
7041 offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
7042 offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
7043
7044 // Add offsetParent borders
7045 parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
7046 parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
7047
7048 // Subtract the two offsets
7049 return {
7050 top: offset.top - parentOffset.top,
7051 left: offset.left - parentOffset.left
7052 };
7053 },
7054
7055 offsetParent: function() {
7056 return this.map(function() {
7057 var offsetParent = this.offsetParent || document.body;
7058 while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
7059 offsetParent = offsetParent.offsetParent;
7060 }
7061 return offsetParent;
7062 });
7063 }
7064 });
7065
7066
7067 // Create scrollLeft and scrollTop methods
7068 jQuery.each( ["Left", "Top"], function( i, name ) {
7069 var method = "scroll" + name;
7070
7071 jQuery.fn[ method ] = function(val) {
7072 var elem = this[0], win;
7073
7074 if ( !elem ) {
7075 return null;
7076 }
7077
7078 if ( val !== undefined ) {
7079 // Set the scroll offset
7080 return this.each(function() {
7081 win = getWindow( this );
7082
7083 if ( win ) {
7084 win.scrollTo(
7085 !i ? val : jQuery(win).scrollLeft(),
7086 i ? val : jQuery(win).scrollTop()
7087 );
7088
7089 } else {
7090 this[ method ] = val;
7091 }
7092 });
7093 } else {
7094 win = getWindow( elem );
7095
7096 // Return the scroll offset
7097 return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
7098 jQuery.support.boxModel && win.document.documentElement[ method ] ||
7099 win.document.body[ method ] :
7100 elem[ method ];
7101 }
7102 };
7103 });
7104
7105 function getWindow( elem ) {
7106 return jQuery.isWindow( elem ) ?
7107 elem :
7108 elem.nodeType === 9 ?
7109 elem.defaultView || elem.parentWindow :
7110 false;
7111 }
7112
7113
7114
7115
7116 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
7117 jQuery.each([ "Height", "Width" ], function( i, name ) {
7118
7119 var type = name.toLowerCase();
7120
7121 // innerHeight and innerWidth
7122 jQuery.fn["inner" + name] = function() {
7123 return this[0] ?
7124 parseFloat( jQuery.css( this[0], type, "padding" ) ) :
7125 null;
7126 };
7127
7128 // outerHeight and outerWidth
7129 jQuery.fn["outer" + name] = function( margin ) {
7130 return this[0] ?
7131 parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
7132 null;
7133 };
7134
7135 jQuery.fn[ type ] = function( size ) {
7136 // Get window width or height
7137 var elem = this[0];
7138 if ( !elem ) {
7139 return size == null ? null : this;
7140 }
7141
7142 if ( jQuery.isFunction( size ) ) {
7143 return this.each(function( i ) {
7144 var self = jQuery( this );
7145 self[ type ]( size.call( this, i, self[ type ]() ) );
7146 });
7147 }
7148
7149 if ( jQuery.isWindow( elem ) ) {
7150 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
7151 return elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
7152 elem.document.body[ "client" + name ];
7153
7154 // Get document width or height
7155 } else if ( elem.nodeType === 9 ) {
7156 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
7157 return Math.max(
7158 elem.documentElement["client" + name],
7159 elem.body["scroll" + name], elem.documentElement["scroll" + name],
7160 elem.body["offset" + name], elem.documentElement["offset" + name]
7161 );
7162
7163 // Get or set width or height on the element
7164 } else if ( size === undefined ) {
7165 var orig = jQuery.css( elem, type ),
7166 ret = parseFloat( orig );
7167
7168 return jQuery.isNaN( ret ) ? orig : ret;
7169
7170 // Set the width or height on the element (default to pixels if value is unitless)
7171 } else {
7172 return this.css( type, typeof size === "string" ? size : size + "px" );
7173 }
7174 };
7175
7176 });
7177
7178
7179 })(window);| 联系我们 |
|---|
| 文章看不懂？联系我们为您免费解答！免费助力个人，小企站点！ |
| ① 电话：020-2206-9892 |
| ② QQ咨询：1025174874 |
| ③ 邮件：info@361sale.com |
| ④ 工作时间：周一至周五，9:30-18:30，节假日休息 |
发布者：光子波动，转转请注明出处：https://www.361sale.com/11961/
