| blob | 5c99a8d4a8889f15947dc465a69c6fa286dfddee |
1 /*!
2 * jQuery JavaScript Library v1.5
3 * http://jquery.com/
4 *
5 * Copyright 2011, John Resig
6 * Dual licensed under the MIT or GPL Version 2 licenses.
7 * http://jquery.org/license
8 *
9 * Includes Sizzle.js
10 * http://sizzlejs.com/
11 * Copyright 2011, The Dojo Foundation
12 * Released under the MIT, BSD, and GPL Licenses.
13 *
14 * Date: Mon Jan 31 08:31:29 2011 -0500
15 */
16 (function( window, undefined ) {
18 // Use the correct document accordingly with window argument (sandbox)
19 var document = window.document;
20 var jQuery = (function() {
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, rootjQuery );
26 },
28 // Map over jQuery in case of overwrite
29 _jQuery = window.jQuery,
31 // Map over the $ in case of overwrite
32 _$ = window.$,
34 // A central reference to the root jQuery(document)
35 rootjQuery,
37 // A simple way to check for HTML strings or ID strings
38 // (both of which we optimize for)
39 quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,
41 // Check if a string has a non-whitespace character in it
42 rnotwhite = /\S/,
44 // Used for trimming whitespace
45 trimLeft = /^\s+/,
46 trimRight = /\s+$/,
48 // Check for digits
49 rdigit = /\d/,
51 // Match a standalone tag
52 rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
54 // JSON RegExp
55 rvalidchars = /^[\],:{}\s]*$/,
56 rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
57 rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
58 rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
60 // Useragent RegExp
61 rwebkit = /(webkit)[ \/]([\w.]+)/,
62 ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
63 rmsie = /(msie) ([\w.]+)/,
64 rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
66 // Keep a UserAgent string for use with jQuery.browser
67 userAgent = navigator.userAgent,
69 // For matching the engine and version of the browser
70 browserMatch,
72 // Has the ready events already been bound?
73 readyBound = false,
75 // The deferred used on DOM ready
76 readyList,
78 // Promise methods
79 promiseMethods = "then done fail isResolved isRejected promise".split( " " ),
81 // The ready event handler
82 DOMContentLoaded,
84 // Save a reference to some core methods
85 toString = Object.prototype.toString,
86 hasOwn = Object.prototype.hasOwnProperty,
87 push = Array.prototype.push,
88 slice = Array.prototype.slice,
89 trim = String.prototype.trim,
90 indexOf = Array.prototype.indexOf,
92 // [[Class]] -> type pairs
93 class2type = {};
95 jQuery.fn = jQuery.prototype = {
96 constructor: jQuery,
97 init: function( selector, context, rootjQuery ) {
98 var match, elem, ret, doc;
100 // Handle $(""), $(null), or $(undefined)
101 if ( !selector ) {
102 return this;
103 }
105 // Handle $(DOMElement)
106 if ( selector.nodeType ) {
107 this.context = this[0] = selector;
108 this.length = 1;
109 return this;
110 }
112 // The body element only exists once, optimize finding it
113 if ( selector === "body" && !context && document.body ) {
114 this.context = document;
115 this[0] = document.body;
116 this.selector = "body";
117 this.length = 1;
118 return this;
119 }
121 // Handle HTML strings
122 if ( typeof selector === "string" ) {
123 // Are we dealing with HTML string or an ID?
124 match = quickExpr.exec( selector );
126 // Verify a match, and that no context was specified for #id
127 if ( match && (match[1] || !context) ) {
129 // HANDLE: $(html) -> $(array)
130 if ( match[1] ) {
131 context = context instanceof jQuery ? context[0] : context;
132 doc = (context ? context.ownerDocument || context : document);
134 // If a single string is passed in and it's a single tag
135 // just do a createElement and skip the rest
136 ret = rsingleTag.exec( selector );
138 if ( ret ) {
139 if ( jQuery.isPlainObject( context ) ) {
140 selector = [ document.createElement( ret[1] ) ];
141 jQuery.fn.attr.call( selector, context, true );
143 } else {
144 selector = [ doc.createElement( ret[1] ) ];
145 }
147 } else {
148 ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
149 selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
150 }
152 return jQuery.merge( this, selector );
154 // HANDLE: $("#id")
155 } else {
156 elem = document.getElementById( match[2] );
158 // Check parentNode to catch when Blackberry 4.6 returns
159 // nodes that are no longer in the document #6963
160 if ( elem && elem.parentNode ) {
161 // Handle the case where IE and Opera return items
162 // by name instead of ID
163 if ( elem.id !== match[2] ) {
164 return rootjQuery.find( selector );
165 }
167 // Otherwise, we inject the element directly into the jQuery object
168 this.length = 1;
169 this[0] = elem;
170 }
172 this.context = document;
173 this.selector = selector;
174 return this;
175 }
177 // HANDLE: $(expr, $(...))
178 } else if ( !context || context.jquery ) {
179 return (context || rootjQuery).find( selector );
181 // HANDLE: $(expr, context)
182 // (which is just equivalent to: $(context).find(expr)
183 } else {
184 return this.constructor( context ).find( selector );
185 }
187 // HANDLE: $(function)
188 // Shortcut for document ready
189 } else if ( jQuery.isFunction( selector ) ) {
190 return rootjQuery.ready( selector );
191 }
193 if (selector.selector !== undefined) {
194 this.selector = selector.selector;
195 this.context = selector.context;
196 }
198 return jQuery.makeArray( selector, this );
199 },
201 // Start with an empty selector
202 selector: "",
204 // The current version of jQuery being used
205 jquery: "1.5",
207 // The default length of a jQuery object is 0
208 length: 0,
210 // The number of elements contained in the matched element set
211 size: function() {
212 return this.length;
213 },
215 toArray: function() {
216 return slice.call( this, 0 );
217 },
219 // Get the Nth element in the matched element set OR
220 // Get the whole matched element set as a clean array
221 get: function( num ) {
222 return num == null ?
224 // Return a 'clean' array
225 this.toArray() :
227 // Return just the object
228 ( num < 0 ? this[ this.length + num ] : this[ num ] );
229 },
231 // Take an array of elements and push it onto the stack
232 // (returning the new matched element set)
233 pushStack: function( elems, name, selector ) {
234 // Build a new jQuery matched element set
235 var ret = this.constructor();
237 if ( jQuery.isArray( elems ) ) {
238 push.apply( ret, elems );
240 } else {
241 jQuery.merge( ret, elems );
242 }
244 // Add the old object onto the stack (as a reference)
245 ret.prevObject = this;
247 ret.context = this.context;
249 if ( name === "find" ) {
250 ret.selector = this.selector + (this.selector ? " " : "") + selector;
251 } else if ( name ) {
252 ret.selector = this.selector + "." + name + "(" + selector + ")";
253 }
255 // Return the newly-formed element set
256 return ret;
257 },
259 // Execute a callback for every element in the matched set.
260 // (You can seed the arguments with an array of args, but this is
261 // only used internally.)
262 each: function( callback, args ) {
263 return jQuery.each( this, callback, args );
264 },
266 ready: function( fn ) {
267 // Attach the listeners
268 jQuery.bindReady();
270 // Add the callback
271 readyList.done( fn );
273 return this;
274 },
276 eq: function( i ) {
277 return i === -1 ?
278 this.slice( i ) :
279 this.slice( i, +i + 1 );
280 },
282 first: function() {
283 return this.eq( 0 );
284 },
286 last: function() {
287 return this.eq( -1 );
288 },
290 slice: function() {
291 return this.pushStack( slice.apply( this, arguments ),
292 "slice", slice.call(arguments).join(",") );
293 },
295 map: function( callback ) {
296 return this.pushStack( jQuery.map(this, function( elem, i ) {
297 return callback.call( elem, i, elem );
298 }));
299 },
301 end: function() {
302 return this.prevObject || this.constructor(null);
303 },
305 // For internal use only.
306 // Behaves like an Array's method, not like a jQuery method.
307 push: push,
308 sort: [].sort,
309 splice: [].splice
310 };
312 // Give the init function the jQuery prototype for later instantiation
313 jQuery.fn.init.prototype = jQuery.fn;
315 jQuery.extend = jQuery.fn.extend = function() {
316 var options, name, src, copy, copyIsArray, clone,
317 target = arguments[0] || {},
318 i = 1,
319 length = arguments.length,
320 deep = false;
322 // Handle a deep copy situation
323 if ( typeof target === "boolean" ) {
324 deep = target;
325 target = arguments[1] || {};
326 // skip the boolean and the target
327 i = 2;
328 }
330 // Handle case when target is a string or something (possible in deep copy)
331 if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
332 target = {};
333 }
335 // extend jQuery itself if only one argument is passed
336 if ( length === i ) {
337 target = this;
338 --i;
339 }
341 for ( ; i < length; i++ ) {
342 // Only deal with non-null/undefined values
343 if ( (options = arguments[ i ]) != null ) {
344 // Extend the base object
345 for ( name in options ) {
346 src = target[ name ];
347 copy = options[ name ];
349 // Prevent never-ending loop
350 if ( target === copy ) {
351 continue;
352 }
354 // Recurse if we're merging plain objects or arrays
355 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
356 if ( copyIsArray ) {
357 copyIsArray = false;
358 clone = src && jQuery.isArray(src) ? src : [];
360 } else {
361 clone = src && jQuery.isPlainObject(src) ? src : {};
362 }
364 // Never move original objects, clone them
365 target[ name ] = jQuery.extend( deep, clone, copy );
367 // Don't bring in undefined values
368 } else if ( copy !== undefined ) {
369 target[ name ] = copy;
370 }
371 }
372 }
373 }
375 // Return the modified object
376 return target;
377 };
379 jQuery.extend({
380 noConflict: function( deep ) {
381 window.$ = _$;
383 if ( deep ) {
384 window.jQuery = _jQuery;
385 }
387 return jQuery;
388 },
390 // Is the DOM ready to be used? Set to true once it occurs.
391 isReady: false,
393 // A counter to track how many items to wait for before
394 // the ready event fires. See #6781
395 readyWait: 1,
397 // Handle when the DOM is ready
398 ready: function( wait ) {
399 // A third-party is pushing the ready event forwards
400 if ( wait === true ) {
401 jQuery.readyWait--;
402 }
404 // Make sure that the DOM is not already loaded
405 if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) {
406 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
407 if ( !document.body ) {
408 return setTimeout( jQuery.ready, 1 );
409 }
411 // Remember that the DOM is ready
412 jQuery.isReady = true;
414 // If a normal DOM Ready event fired, decrement, and wait if need be
415 if ( wait !== true && --jQuery.readyWait > 0 ) {
416 return;
417 }
419 // If there are functions bound, to execute
420 readyList.resolveWith( document, [ jQuery ] );
422 // Trigger any bound ready events
423 if ( jQuery.fn.trigger ) {
424 jQuery( document ).trigger( "ready" ).unbind( "ready" );
425 }
426 }
427 },
429 bindReady: function() {
430 if ( readyBound ) {
431 return;
432 }
434 readyBound = true;
436 // Catch cases where $(document).ready() is called after the
437 // browser event has already occurred.
438 if ( document.readyState === "complete" ) {
439 // Handle it asynchronously to allow scripts the opportunity to delay ready
440 return setTimeout( jQuery.ready, 1 );
441 }
443 // Mozilla, Opera and webkit nightlies currently support this event
444 if ( document.addEventListener ) {
445 // Use the handy event callback
446 document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
448 // A fallback to window.onload, that will always work
449 window.addEventListener( "load", jQuery.ready, false );
451 // If IE event model is used
452 } else if ( document.attachEvent ) {
453 // ensure firing before onload,
454 // maybe late but safe also for iframes
455 document.attachEvent("onreadystatechange", DOMContentLoaded);
457 // A fallback to window.onload, that will always work
458 window.attachEvent( "onload", jQuery.ready );
460 // If IE and not a frame
461 // continually check to see if the document is ready
462 var toplevel = false;
464 try {
465 toplevel = window.frameElement == null;
466 } catch(e) {}
468 if ( document.documentElement.doScroll && toplevel ) {
469 doScrollCheck();
470 }
471 }
472 },
474 // See test/unit/core.js for details concerning isFunction.
475 // Since version 1.3, DOM methods and functions like alert
476 // aren't supported. They return false on IE (#2968).
477 isFunction: function( obj ) {
478 return jQuery.type(obj) === "function";
479 },
481 isArray: Array.isArray || function( obj ) {
482 return jQuery.type(obj) === "array";
483 },
485 // A crude way of determining if an object is a window
486 isWindow: function( obj ) {
487 return obj && typeof obj === "object" && "setInterval" in obj;
488 },
490 isNaN: function( obj ) {
491 return obj == null || !rdigit.test( obj ) || isNaN( obj );
492 },
494 type: function( obj ) {
495 return obj == null ?
496 String( obj ) :
497 class2type[ toString.call(obj) ] || "object";
498 },
500 isPlainObject: function( obj ) {
501 // Must be an Object.
502 // Because of IE, we also have to check the presence of the constructor property.
503 // Make sure that DOM nodes and window objects don't pass through, as well
504 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
505 return false;
506 }
508 // Not own constructor property must be Object
509 if ( obj.constructor &&
510 !hasOwn.call(obj, "constructor") &&
511 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
512 return false;
513 }
515 // Own properties are enumerated firstly, so to speed up,
516 // if last one is own, then all properties are own.
518 var key;
519 for ( key in obj ) {}
521 return key === undefined || hasOwn.call( obj, key );
522 },
524 isEmptyObject: function( obj ) {
525 for ( var name in obj ) {
526 return false;
527 }
528 return true;
529 },
531 error: function( msg ) {
532 throw msg;
533 },
535 parseJSON: function( data ) {
536 if ( typeof data !== "string" || !data ) {
537 return null;
538 }
540 // Make sure leading/trailing whitespace is removed (IE can't handle it)
541 data = jQuery.trim( data );
543 // Make sure the incoming data is actual JSON
544 // Logic borrowed from http://json.org/json2.js
545 if ( rvalidchars.test(data.replace(rvalidescape, "@")
546 .replace(rvalidtokens, "]")
547 .replace(rvalidbraces, "")) ) {
549 // Try to use the native JSON parser first
550 return window.JSON && window.JSON.parse ?
551 window.JSON.parse( data ) :
552 (new Function("return " + data))();
554 } else {
555 jQuery.error( "Invalid JSON: " + data );
556 }
557 },
559 // Cross-browser xml parsing
560 // (xml & tmp used internally)
561 parseXML: function( data , xml , tmp ) {
563 if ( window.DOMParser ) { // Standard
564 tmp = new DOMParser();
565 xml = tmp.parseFromString( data , "text/xml" );
566 } else { // IE
567 xml = new ActiveXObject( "Microsoft.XMLDOM" );
568 xml.async = "false";
569 xml.loadXML( data );
570 }
572 tmp = xml.documentElement;
574 if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
575 jQuery.error( "Invalid XML: " + data );
576 }
578 return xml;
579 },
581 noop: function() {},
583 // Evalulates a script in a global context
584 globalEval: function( data ) {
585 if ( data && rnotwhite.test(data) ) {
586 // Inspired by code by Andrea Giammarchi
587 // http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
588 var head = document.getElementsByTagName("head")[0] || document.documentElement,
589 script = document.createElement("script");
591 script.type = "text/javascript";
593 if ( jQuery.support.scriptEval() ) {
594 script.appendChild( document.createTextNode( data ) );
595 } else {
596 script.text = data;
597 }
599 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
600 // This arises when a base node is used (#2709).
601 head.insertBefore( script, head.firstChild );
602 head.removeChild( script );
603 }
604 },
606 nodeName: function( elem, name ) {
607 return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
608 },
610 // args is for internal usage only
611 each: function( object, callback, args ) {
612 var name, i = 0,
613 length = object.length,
614 isObj = length === undefined || jQuery.isFunction(object);
616 if ( args ) {
617 if ( isObj ) {
618 for ( name in object ) {
619 if ( callback.apply( object[ name ], args ) === false ) {
620 break;
621 }
622 }
623 } else {
624 for ( ; i < length; ) {
625 if ( callback.apply( object[ i++ ], args ) === false ) {
626 break;
627 }
628 }
629 }
631 // A special, fast, case for the most common use of each
632 } else {
633 if ( isObj ) {
634 for ( name in object ) {
635 if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
636 break;
637 }
638 }
639 } else {
640 for ( var value = object[0];
641 i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
642 }
643 }
645 return object;
646 },
648 // Use native String.trim function wherever possible
649 trim: trim ?
650 function( text ) {
651 return text == null ?
652 "" :
653 trim.call( text );
654 } :
656 // Otherwise use our own trimming functionality
657 function( text ) {
658 return text == null ?
659 "" :
660 text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
661 },
663 // results is for internal usage only
664 makeArray: function( array, results ) {
665 var ret = results || [];
667 if ( array != null ) {
668 // The window, strings (and functions) also have 'length'
669 // The extra typeof function check is to prevent crashes
670 // in Safari 2 (See: #3039)
671 // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
672 var type = jQuery.type(array);
674 if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
675 push.call( ret, array );
676 } else {
677 jQuery.merge( ret, array );
678 }
679 }
681 return ret;
682 },
684 inArray: function( elem, array ) {
685 if ( array.indexOf ) {
686 return array.indexOf( elem );
687 }
689 for ( var i = 0, length = array.length; i < length; i++ ) {
690 if ( array[ i ] === elem ) {
691 return i;
692 }
693 }
695 return -1;
696 },
698 merge: function( first, second ) {
699 var i = first.length,
700 j = 0;
702 if ( typeof second.length === "number" ) {
703 for ( var l = second.length; j < l; j++ ) {
704 first[ i++ ] = second[ j ];
705 }
707 } else {
708 while ( second[j] !== undefined ) {
709 first[ i++ ] = second[ j++ ];
710 }
711 }
713 first.length = i;
715 return first;
716 },
718 grep: function( elems, callback, inv ) {
719 var ret = [], retVal;
720 inv = !!inv;
722 // Go through the array, only saving the items
723 // that pass the validator function
724 for ( var i = 0, length = elems.length; i < length; i++ ) {
725 retVal = !!callback( elems[ i ], i );
726 if ( inv !== retVal ) {
727 ret.push( elems[ i ] );
728 }
729 }
731 return ret;
732 },
734 // arg is for internal usage only
735 map: function( elems, callback, arg ) {
736 var ret = [], value;
738 // Go through the array, translating each of the items to their
739 // new value (or values).
740 for ( var i = 0, length = elems.length; i < length; i++ ) {
741 value = callback( elems[ i ], i, arg );
743 if ( value != null ) {
744 ret[ ret.length ] = value;
745 }
746 }
748 // Flatten any nested arrays
749 return ret.concat.apply( [], ret );
750 },
752 // A global GUID counter for objects
753 guid: 1,
755 proxy: function( fn, proxy, thisObject ) {
756 if ( arguments.length === 2 ) {
757 if ( typeof proxy === "string" ) {
758 thisObject = fn;
759 fn = thisObject[ proxy ];
760 proxy = undefined;
762 } else if ( proxy && !jQuery.isFunction( proxy ) ) {
763 thisObject = proxy;
764 proxy = undefined;
765 }
766 }
768 if ( !proxy && fn ) {
769 proxy = function() {
770 return fn.apply( thisObject || this, arguments );
771 };
772 }
774 // Set the guid of unique handler to the same of original handler, so it can be removed
775 if ( fn ) {
776 proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
777 }
779 // So proxy can be declared as an argument
780 return proxy;
781 },
783 // Mutifunctional method to get and set values to a collection
784 // The value/s can be optionally by executed if its a function
785 access: function( elems, key, value, exec, fn, pass ) {
786 var length = elems.length;
788 // Setting many attributes
789 if ( typeof key === "object" ) {
790 for ( var k in key ) {
791 jQuery.access( elems, k, key[k], exec, fn, value );
792 }
793 return elems;
794 }
796 // Setting one attribute
797 if ( value !== undefined ) {
798 // Optionally, function values get executed if exec is true
799 exec = !pass && exec && jQuery.isFunction(value);
801 for ( var i = 0; i < length; i++ ) {
802 fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
803 }
805 return elems;
806 }
808 // Getting an attribute
809 return length ? fn( elems[0], key ) : undefined;
810 },
812 now: function() {
813 return (new Date()).getTime();
814 },
816 // Create a simple deferred (one callbacks list)
817 _Deferred: function() {
818 var // callbacks list
819 callbacks = [],
820 // stored [ context , args ]
821 fired,
822 // to avoid firing when already doing so
823 firing,
824 // flag to know if the deferred has been cancelled
825 cancelled,
826 // the deferred itself
827 deferred = {
829 // done( f1, f2, ...)
830 done: function() {
831 if ( !cancelled ) {
832 var args = arguments,
833 i,
834 length,
835 elem,
836 type,
837 _fired;
838 if ( fired ) {
839 _fired = fired;
840 fired = 0;
841 }
842 for ( i = 0, length = args.length; i < length; i++ ) {
843 elem = args[ i ];
844 type = jQuery.type( elem );
845 if ( type === "array" ) {
846 deferred.done.apply( deferred, elem );
847 } else if ( type === "function" ) {
848 callbacks.push( elem );
849 }
850 }
851 if ( _fired ) {
852 deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
853 }
854 }
855 return this;
856 },
858 // resolve with given context and args
859 resolveWith: function( context, args ) {
860 if ( !cancelled && !fired && !firing ) {
861 firing = 1;
862 try {
863 while( callbacks[ 0 ] ) {
864 callbacks.shift().apply( context, args );
865 }
866 }
867 finally {
868 fired = [ context, args ];
869 firing = 0;
870 }
871 }
872 return this;
873 },
875 // resolve with this as context and given arguments
876 resolve: function() {
877 deferred.resolveWith( jQuery.isFunction( this.promise ) ? this.promise() : this, arguments );
878 return this;
879 },
881 // Has this deferred been resolved?
882 isResolved: function() {
883 return !!( firing || fired );
884 },
886 // Cancel
887 cancel: function() {
888 cancelled = 1;
889 callbacks = [];
890 return this;
891 }
892 };
894 return deferred;
895 },
897 // Full fledged deferred (two callbacks list)
898 Deferred: function( func ) {
899 var deferred = jQuery._Deferred(),
900 failDeferred = jQuery._Deferred(),
901 promise;
902 // Add errorDeferred methods, then and promise
903 jQuery.extend( deferred, {
904 then: function( doneCallbacks, failCallbacks ) {
905 deferred.done( doneCallbacks ).fail( failCallbacks );
906 return this;
907 },
908 fail: failDeferred.done,
909 rejectWith: failDeferred.resolveWith,
910 reject: failDeferred.resolve,
911 isRejected: failDeferred.isResolved,
912 // Get a promise for this deferred
913 // If obj is provided, the promise aspect is added to the object
914 promise: function( obj , i /* internal */ ) {
915 if ( obj == null ) {
916 if ( promise ) {
917 return promise;
918 }
919 promise = obj = {};
920 }
921 i = promiseMethods.length;
922 while( i-- ) {
923 obj[ promiseMethods[ i ] ] = deferred[ promiseMethods[ i ] ];
924 }
925 return obj;
926 }
927 } );
928 // Make sure only one callback list will be used
929 deferred.then( failDeferred.cancel, deferred.cancel );
930 // Unexpose cancel
931 delete deferred.cancel;
932 // Call given func if any
933 if ( func ) {
934 func.call( deferred, deferred );
935 }
936 return deferred;
937 },
939 // Deferred helper
940 when: function( object ) {
941 var args = arguments,
942 length = args.length,
943 deferred = length <= 1 && object && jQuery.isFunction( object.promise ) ?
944 object :
945 jQuery.Deferred(),
946 promise = deferred.promise(),
947 resolveArray;
949 if ( length > 1 ) {
950 resolveArray = new Array( length );
951 jQuery.each( args, function( index, element ) {
952 jQuery.when( element ).then( function( value ) {
953 resolveArray[ index ] = arguments.length > 1 ? slice.call( arguments, 0 ) : value;
954 if( ! --length ) {
955 deferred.resolveWith( promise, resolveArray );
956 }
957 }, deferred.reject );
958 } );
959 } else if ( deferred !== object ) {
960 deferred.resolve( object );
961 }
962 return promise;
963 },
965 // Use of jQuery.browser is frowned upon.
966 // More details: http://docs.jquery.com/Utilities/jQuery.browser
967 uaMatch: function( ua ) {
968 ua = ua.toLowerCase();
970 var match = rwebkit.exec( ua ) ||
971 ropera.exec( ua ) ||
972 rmsie.exec( ua ) ||
973 ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
974 [];
976 return { browser: match[1] || "", version: match[2] || "0" };
977 },
979 sub: function() {
980 function jQuerySubclass( selector, context ) {
981 return new jQuerySubclass.fn.init( selector, context );
982 }
983 jQuery.extend( true, jQuerySubclass, this );
984 jQuerySubclass.superclass = this;
985 jQuerySubclass.fn = jQuerySubclass.prototype = this();
986 jQuerySubclass.fn.constructor = jQuerySubclass;
987 jQuerySubclass.subclass = this.subclass;
988 jQuerySubclass.fn.init = function init( selector, context ) {
989 if ( context && context instanceof jQuery && !(context instanceof jQuerySubclass) ) {
990 context = jQuerySubclass(context);
991 }
993 return jQuery.fn.init.call( this, selector, context, rootjQuerySubclass );
994 };
995 jQuerySubclass.fn.init.prototype = jQuerySubclass.fn;
996 var rootjQuerySubclass = jQuerySubclass(document);
997 return jQuerySubclass;
998 },
1000 browser: {}
1001 });
1003 // Create readyList deferred
1004 readyList = jQuery._Deferred();
1006 // Populate the class2type map
1007 jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
1008 class2type[ "[object " + name + "]" ] = name.toLowerCase();
1009 });
1011 browserMatch = jQuery.uaMatch( userAgent );
1012 if ( browserMatch.browser ) {
1013 jQuery.browser[ browserMatch.browser ] = true;
1014 jQuery.browser.version = browserMatch.version;
1015 }
1017 // Deprecated, use jQuery.browser.webkit instead
1018 if ( jQuery.browser.webkit ) {
1019 jQuery.browser.safari = true;
1020 }
1022 if ( indexOf ) {
1023 jQuery.inArray = function( elem, array ) {
1024 return indexOf.call( array, elem );
1025 };
1026 }
1028 // IE doesn't match non-breaking spaces with \s
1029 if ( rnotwhite.test( "\xA0" ) ) {
1030 trimLeft = /^[\s\xA0]+/;
1031 trimRight = /[\s\xA0]+$/;
1032 }
1034 // All jQuery objects should point back to these
1035 rootjQuery = jQuery(document);
1037 // Cleanup functions for the document ready method
1038 if ( document.addEventListener ) {
1039 DOMContentLoaded = function() {
1040 document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
1041 jQuery.ready();
1042 };
1044 } else if ( document.attachEvent ) {
1045 DOMContentLoaded = function() {
1046 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
1047 if ( document.readyState === "complete" ) {
1048 document.detachEvent( "onreadystatechange", DOMContentLoaded );
1049 jQuery.ready();
1050 }
1051 };
1052 }
1054 // The DOM ready check for Internet Explorer
1055 function doScrollCheck() {
1056 if ( jQuery.isReady ) {
1057 return;
1058 }
1060 try {
1061 // If IE is used, use the trick by Diego Perini
1062 // http://javascript.nwbox.com/IEContentLoaded/
1063 document.documentElement.doScroll("left");
1064 } catch(e) {
1065 setTimeout( doScrollCheck, 1 );
1066 return;
1067 }
1069 // and execute any waiting functions
1070 jQuery.ready();
1071 }
1073 // Expose jQuery to the global object
1074 return (window.jQuery = window.$ = jQuery);
1076 })();
1079 (function() {
1081 jQuery.support = {};
1083 var div = document.createElement("div");
1085 div.style.display = "none";
1086 div.innerHTML = " <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
1088 var all = div.getElementsByTagName("*"),
1089 a = div.getElementsByTagName("a")[0],
1090 select = document.createElement("select"),
1091 opt = select.appendChild( document.createElement("option") );
1093 // Can't get basic test support
1094 if ( !all || !all.length || !a ) {
1095 return;
1096 }
1098 jQuery.support = {
1099 // IE strips leading whitespace when .innerHTML is used
1100 leadingWhitespace: div.firstChild.nodeType === 3,
1102 // Make sure that tbody elements aren't automatically inserted
1103 // IE will insert them into empty tables
1104 tbody: !div.getElementsByTagName("tbody").length,
1106 // Make sure that link elements get serialized correctly by innerHTML
1107 // This requires a wrapper element in IE
1108 htmlSerialize: !!div.getElementsByTagName("link").length,
1110 // Get the style information from getAttribute
1111 // (IE uses .cssText insted)
1112 style: /red/.test( a.getAttribute("style") ),
1114 // Make sure that URLs aren't manipulated
1115 // (IE normalizes it by default)
1116 hrefNormalized: a.getAttribute("href") === "/a",
1118 // Make sure that element opacity exists
1119 // (IE uses filter instead)
1120 // Use a regex to work around a WebKit issue. See #5145
1121 opacity: /^0.55$/.test( a.style.opacity ),
1123 // Verify style float existence
1124 // (IE uses styleFloat instead of cssFloat)
1125 cssFloat: !!a.style.cssFloat,
1127 // Make sure that if no value is specified for a checkbox
1128 // that it defaults to "on".
1129 // (WebKit defaults to "" instead)
1130 checkOn: div.getElementsByTagName("input")[0].value === "on",
1132 // Make sure that a selected-by-default option has a working selected property.
1133 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
1134 optSelected: opt.selected,
1136 // Will be defined later
1137 deleteExpando: true,
1138 optDisabled: false,
1139 checkClone: false,
1140 _scriptEval: null,
1141 noCloneEvent: true,
1142 boxModel: null,
1143 inlineBlockNeedsLayout: false,
1144 shrinkWrapBlocks: false,
1145 reliableHiddenOffsets: true
1146 };
1148 // Make sure that the options inside disabled selects aren't marked as disabled
1149 // (WebKit marks them as diabled)
1150 select.disabled = true;
1151 jQuery.support.optDisabled = !opt.disabled;
1153 jQuery.support.scriptEval = function() {
1154 if ( jQuery.support._scriptEval === null ) {
1155 var root = document.documentElement,
1156 script = document.createElement("script"),
1157 id = "script" + jQuery.now();
1159 script.type = "text/javascript";
1160 try {
1161 script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
1162 } catch(e) {}
1164 root.insertBefore( script, root.firstChild );
1166 // Make sure that the execution of code works by injecting a script
1167 // tag with appendChild/createTextNode
1168 // (IE doesn't support this, fails, and uses .text instead)
1169 if ( window[ id ] ) {
1170 jQuery.support._scriptEval = true;
1171 delete window[ id ];
1172 } else {
1173 jQuery.support._scriptEval = false;
1174 }
1176 root.removeChild( script );
1177 // release memory in IE
1178 root = script = id = null;
1179 }
1181 return jQuery.support._scriptEval;
1182 };
1184 // Test to see if it's possible to delete an expando from an element
1185 // Fails in Internet Explorer
1186 try {
1187 delete div.test;
1189 } catch(e) {
1190 jQuery.support.deleteExpando = false;
1191 }
1193 if ( div.attachEvent && div.fireEvent ) {
1194 div.attachEvent("onclick", function click() {
1195 // Cloning a node shouldn't copy over any
1196 // bound event handlers (IE does this)
1197 jQuery.support.noCloneEvent = false;
1198 div.detachEvent("onclick", click);
1199 });
1200 div.cloneNode(true).fireEvent("onclick");
1201 }
1203 div = document.createElement("div");
1204 div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
1206 var fragment = document.createDocumentFragment();
1207 fragment.appendChild( div.firstChild );
1209 // WebKit doesn't clone checked state correctly in fragments
1210 jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
1212 // Figure out if the W3C box model works as expected
1213 // document.body must exist before we can do this
1214 jQuery(function() {
1215 var div = document.createElement("div"),
1216 body = document.getElementsByTagName("body")[0];
1218 // Frameset documents with no body should not run this code
1219 if ( !body ) {
1220 return;
1221 }
1223 div.style.width = div.style.paddingLeft = "1px";
1224 body.appendChild( div );
1225 jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
1227 if ( "zoom" in div.style ) {
1228 // Check if natively block-level elements act like inline-block
1229 // elements when setting their display to 'inline' and giving
1230 // them layout
1231 // (IE < 8 does this)
1232 div.style.display = "inline";
1233 div.style.zoom = 1;
1234 jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2;
1236 // Check if elements with layout shrink-wrap their children
1237 // (IE 6 does this)
1238 div.style.display = "";
1239 div.innerHTML = "<div style='width:4px;'></div>";
1240 jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2;
1241 }
1243 div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
1244 var tds = div.getElementsByTagName("td");
1246 // Check if table cells still have offsetWidth/Height when they are set
1247 // to display:none and there are still other visible table cells in a
1248 // table row; if so, offsetWidth/Height are not reliable for use when
1249 // determining if an element has been hidden directly using
1250 // display:none (it is still safe to use offsets if a parent element is
1251 // hidden; don safety goggles and see bug #4512 for more information).
1252 // (only IE 8 fails this test)
1253 jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0;
1255 tds[0].style.display = "";
1256 tds[1].style.display = "none";
1258 // Check if empty table cells still have offsetWidth/Height
1259 // (IE < 8 fail this test)
1260 jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
1261 div.innerHTML = "";
1263 body.removeChild( div ).style.display = "none";
1264 div = tds = null;
1265 });
1267 // Technique from Juriy Zaytsev
1268 // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1269 var eventSupported = function( eventName ) {
1270 var el = document.createElement("div");
1271 eventName = "on" + eventName;
1273 // We only care about the case where non-standard event systems
1274 // are used, namely in IE. Short-circuiting here helps us to
1275 // avoid an eval call (in setAttribute) which can cause CSP
1276 // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
1277 if ( !el.attachEvent ) {
1278 return true;
1279 }
1281 var isSupported = (eventName in el);
1282 if ( !isSupported ) {
1283 el.setAttribute(eventName, "return;");
1284 isSupported = typeof el[eventName] === "function";
1285 }
1286 el = null;
1288 return isSupported;
1289 };
1291 jQuery.support.submitBubbles = eventSupported("submit");
1292 jQuery.support.changeBubbles = eventSupported("change");
1294 // release memory in IE
1295 div = all = a = null;
1296 })();
1300 var rbrace = /^(?:\{.*\}|\[.*\])$/;
1302 jQuery.extend({
1303 cache: {},
1305 // Please use with caution
1306 uuid: 0,
1308 // Unique for each copy of jQuery on the page
1309 // Non-digits removed to match rinlinejQuery
1310 expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
1312 // The following elements throw uncatchable exceptions if you
1313 // attempt to add expando properties to them.
1314 noData: {
1315 "embed": true,
1316 // Ban all objects except for Flash (which handle expandos)
1317 "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1318 "applet": true
1319 },
1321 hasData: function( elem ) {
1322 elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
1324 return !!elem && !jQuery.isEmptyObject(elem);
1325 },
1327 data: function( elem, name, data, pvt /* Internal Use Only */ ) {
1328 if ( !jQuery.acceptData( elem ) ) {
1329 return;
1330 }
1332 var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
1334 // We have to handle DOM nodes and JS objects differently because IE6-7
1335 // can't GC object references properly across the DOM-JS boundary
1336 isNode = elem.nodeType,
1338 // Only DOM nodes need the global jQuery cache; JS object data is
1339 // attached directly to the object so GC can occur automatically
1340 cache = isNode ? jQuery.cache : elem,
1342 // Only defining an ID for JS objects if its cache already exists allows
1343 // the code to shortcut on the same path as a DOM node with no cache
1344 id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
1346 // Avoid doing any more work than we need to when trying to get data on an
1347 // object that has no data at all
1348 if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
1349 return;
1350 }
1352 if ( !id ) {
1353 // Only DOM nodes need a new unique ID for each element since their data
1354 // ends up in the global cache
1355 if ( isNode ) {
1356 elem[ jQuery.expando ] = id = ++jQuery.uuid;
1357 } else {
1358 id = jQuery.expando;
1359 }
1360 }
1362 if ( !cache[ id ] ) {
1363 cache[ id ] = {};
1364 }
1366 // An object can be passed to jQuery.data instead of a key/value pair; this gets
1367 // shallow copied over onto the existing cache
1368 if ( typeof name === "object" ) {
1369 if ( pvt ) {
1370 cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
1371 } else {
1372 cache[ id ] = jQuery.extend(cache[ id ], name);
1373 }
1374 }
1376 thisCache = cache[ id ];
1378 // Internal jQuery data is stored in a separate object inside the object's data
1379 // cache in order to avoid key collisions between internal data and user-defined
1380 // data
1381 if ( pvt ) {
1382 if ( !thisCache[ internalKey ] ) {
1383 thisCache[ internalKey ] = {};
1384 }
1386 thisCache = thisCache[ internalKey ];
1387 }
1389 if ( data !== undefined ) {
1390 thisCache[ name ] = data;
1391 }
1393 // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
1394 // not attempt to inspect the internal events object using jQuery.data, as this
1395 // internal data object is undocumented and subject to change.
1396 if ( name === "events" && !thisCache[name] ) {
1397 return thisCache[ internalKey ] && thisCache[ internalKey ].events;
1398 }
1400 return getByName ? thisCache[ name ] : thisCache;
1401 },
1403 removeData: function( elem, name, pvt /* Internal Use Only */ ) {
1404 if ( !jQuery.acceptData( elem ) ) {
1405 return;
1406 }
1408 var internalKey = jQuery.expando, isNode = elem.nodeType,
1410 // See jQuery.data for more information
1411 cache = isNode ? jQuery.cache : elem,
1413 // See jQuery.data for more information
1414 id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
1416 // If there is already no cache entry for this object, there is no
1417 // purpose in continuing
1418 if ( !cache[ id ] ) {
1419 return;
1420 }
1422 if ( name ) {
1423 var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
1425 if ( thisCache ) {
1426 delete thisCache[ name ];
1428 // If there is no data left in the cache, we want to continue
1429 // and let the cache object itself get destroyed
1430 if ( !jQuery.isEmptyObject(thisCache) ) {
1431 return;
1432 }
1433 }
1434 }
1436 // See jQuery.data for more information
1437 if ( pvt ) {
1438 delete cache[ id ][ internalKey ];
1440 // Don't destroy the parent cache unless the internal data object
1441 // had been the only thing left in it
1442 if ( !jQuery.isEmptyObject(cache[ id ]) ) {
1443 return;
1444 }
1445 }
1447 var internalCache = cache[ id ][ internalKey ];
1449 // Browsers that fail expando deletion also refuse to delete expandos on
1450 // the window, but it will allow it on all other JS objects; other browsers
1451 // don't care
1452 if ( jQuery.support.deleteExpando || cache != window ) {
1453 delete cache[ id ];
1454 } else {
1455 cache[ id ] = null;
1456 }
1458 // We destroyed the entire user cache at once because it's faster than
1459 // iterating through each key, but we need to continue to persist internal
1460 // data if it existed
1461 if ( internalCache ) {
1462 cache[ id ] = {};
1463 cache[ id ][ internalKey ] = internalCache;
1465 // Otherwise, we need to eliminate the expando on the node to avoid
1466 // false lookups in the cache for entries that no longer exist
1467 } else if ( isNode ) {
1468 // IE does not allow us to delete expando properties from nodes,
1469 // nor does it have a removeAttribute function on Document nodes;
1470 // we must handle all of these cases
1471 if ( jQuery.support.deleteExpando ) {
1472 delete elem[ jQuery.expando ];
1473 } else if ( elem.removeAttribute ) {
1474 elem.removeAttribute( jQuery.expando );
1475 } else {
1476 elem[ jQuery.expando ] = null;
1477 }
1478 }
1479 },
1481 // For internal use only.
1482 _data: function( elem, name, data ) {
1483 return jQuery.data( elem, name, data, true );
1484 },
1486 // A method for determining if a DOM node can handle the data expando
1487 acceptData: function( elem ) {
1488 if ( elem.nodeName ) {
1489 var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1491 if ( match ) {
1492 return !(match === true || elem.getAttribute("classid") !== match);
1493 }
1494 }
1496 return true;
1497 }
1498 });
1500 jQuery.fn.extend({
1501 data: function( key, value ) {
1502 var data = null;
1504 if ( typeof key === "undefined" ) {
1505 if ( this.length ) {
1506 data = jQuery.data( this[0] );
1508 if ( this[0].nodeType === 1 ) {
1509 var attr = this[0].attributes, name;
1510 for ( var i = 0, l = attr.length; i < l; i++ ) {
1511 name = attr[i].name;
1513 if ( name.indexOf( "data-" ) === 0 ) {
1514 name = name.substr( 5 );
1515 dataAttr( this[0], name, data[ name ] );
1516 }
1517 }
1518 }
1519 }
1521 return data;
1523 } else if ( typeof key === "object" ) {
1524 return this.each(function() {
1525 jQuery.data( this, key );
1526 });
1527 }
1529 var parts = key.split(".");
1530 parts[1] = parts[1] ? "." + parts[1] : "";
1532 if ( value === undefined ) {
1533 data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1535 // Try to fetch any internally stored data first
1536 if ( data === undefined && this.length ) {
1537 data = jQuery.data( this[0], key );
1538 data = dataAttr( this[0], key, data );
1539 }
1541 return data === undefined && parts[1] ?
1542 this.data( parts[0] ) :
1543 data;
1545 } else {
1546 return this.each(function() {
1547 var $this = jQuery( this ),
1548 args = [ parts[0], value ];
1550 $this.triggerHandler( "setData" + parts[1] + "!", args );
1551 jQuery.data( this, key, value );
1552 $this.triggerHandler( "changeData" + parts[1] + "!", args );
1553 });
1554 }
1555 },
1557 removeData: function( key ) {
1558 return this.each(function() {
1559 jQuery.removeData( this, key );
1560 });
1561 }
1562 });
1564 function dataAttr( elem, key, data ) {
1565 // If nothing was found internally, try to fetch any
1566 // data from the HTML5 data-* attribute
1567 if ( data === undefined && elem.nodeType === 1 ) {
1568 data = elem.getAttribute( "data-" + key );
1570 if ( typeof data === "string" ) {
1571 try {
1572 data = data === "true" ? true :
1573 data === "false" ? false :
1574 data === "null" ? null :
1575 !jQuery.isNaN( data ) ? parseFloat( data ) :
1576 rbrace.test( data ) ? jQuery.parseJSON( data ) :
1577 data;
1578 } catch( e ) {}
1580 // Make sure we set the data so it isn't changed later
1581 jQuery.data( elem, key, data );
1583 } else {
1584 data = undefined;
1585 }
1586 }
1588 return data;
1589 }
1594 jQuery.extend({
1595 queue: function( elem, type, data ) {
1596 if ( !elem ) {
1597 return;
1598 }
1600 type = (type || "fx") + "queue";
1601 var q = jQuery._data( elem, type );
1603 // Speed up dequeue by getting out quickly if this is just a lookup
1604 if ( !data ) {
1605 return q || [];
1606 }
1608 if ( !q || jQuery.isArray(data) ) {
1609 q = jQuery._data( elem, type, jQuery.makeArray(data) );
1611 } else {
1612 q.push( data );
1613 }
1615 return q;
1616 },
1618 dequeue: function( elem, type ) {
1619 type = type || "fx";
1621 var queue = jQuery.queue( elem, type ),
1622 fn = queue.shift();
1624 // If the fx queue is dequeued, always remove the progress sentinel
1625 if ( fn === "inprogress" ) {
1626 fn = queue.shift();
1627 }
1629 if ( fn ) {
1630 // Add a progress sentinel to prevent the fx queue from being
1631 // automatically dequeued
1632 if ( type === "fx" ) {
1633 queue.unshift("inprogress");
1634 }
1636 fn.call(elem, function() {
1637 jQuery.dequeue(elem, type);
1638 });
1639 }
1641 if ( !queue.length ) {
1642 jQuery.removeData( elem, type + "queue", true );
1643 }
1644 }
1645 });
1647 jQuery.fn.extend({
1648 queue: function( type, data ) {
1649 if ( typeof type !== "string" ) {
1650 data = type;
1651 type = "fx";
1652 }
1654 if ( data === undefined ) {
1655 return jQuery.queue( this[0], type );
1656 }
1657 return this.each(function( i ) {
1658 var queue = jQuery.queue( this, type, data );
1660 if ( type === "fx" && queue[0] !== "inprogress" ) {
1661 jQuery.dequeue( this, type );
1662 }
1663 });
1664 },
1665 dequeue: function( type ) {
1666 return this.each(function() {
1667 jQuery.dequeue( this, type );
1668 });
1669 },
1671 // Based off of the plugin by Clint Helfers, with permission.
1672 // http://blindsignals.com/index.php/2009/07/jquery-delay/
1673 delay: function( time, type ) {
1674 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1675 type = type || "fx";
1677 return this.queue( type, function() {
1678 var elem = this;
1679 setTimeout(function() {
1680 jQuery.dequeue( elem, type );
1681 }, time );
1682 });
1683 },
1685 clearQueue: function( type ) {
1686 return this.queue( type || "fx", [] );
1687 }
1688 });
1693 var rclass = /[\n\t\r]/g,
1694 rspaces = /\s+/,
1695 rreturn = /\r/g,
1696 rspecialurl = /^(?:href|src|style)$/,
1697 rtype = /^(?:button|input)$/i,
1698 rfocusable = /^(?:button|input|object|select|textarea)$/i,
1699 rclickable = /^a(?:rea)?$/i,
1700 rradiocheck = /^(?:radio|checkbox)$/i;
1702 jQuery.props = {
1703 "for": "htmlFor",
1704 "class": "className",
1705 readonly: "readOnly",
1706 maxlength: "maxLength",
1707 cellspacing: "cellSpacing",
1708 rowspan: "rowSpan",
1709 colspan: "colSpan",
1710 tabindex: "tabIndex",
1711 usemap: "useMap",
1712 frameborder: "frameBorder"
1713 };
1715 jQuery.fn.extend({
1716 attr: function( name, value ) {
1717 return jQuery.access( this, name, value, true, jQuery.attr );
1718 },
1720 removeAttr: function( name, fn ) {
1721 return this.each(function(){
1722 jQuery.attr( this, name, "" );
1723 if ( this.nodeType === 1 ) {
1724 this.removeAttribute( name );
1725 }
1726 });
1727 },
1729 addClass: function( value ) {
1730 if ( jQuery.isFunction(value) ) {
1731 return this.each(function(i) {
1732 var self = jQuery(this);
1733 self.addClass( value.call(this, i, self.attr("class")) );
1734 });
1735 }
1737 if ( value && typeof value === "string" ) {
1738 var classNames = (value || "").split( rspaces );
1740 for ( var i = 0, l = this.length; i < l; i++ ) {
1741 var elem = this[i];
1743 if ( elem.nodeType === 1 ) {
1744 if ( !elem.className ) {
1745 elem.className = value;
1747 } else {
1748 var className = " " + elem.className + " ",
1749 setClass = elem.className;
1751 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1752 if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1753 setClass += " " + classNames[c];
1754 }
1755 }
1756 elem.className = jQuery.trim( setClass );
1757 }
1758 }
1759 }
1760 }
1762 return this;
1763 },
1765 removeClass: function( value ) {
1766 if ( jQuery.isFunction(value) ) {
1767 return this.each(function(i) {
1768 var self = jQuery(this);
1769 self.removeClass( value.call(this, i, self.attr("class")) );
1770 });
1771 }
1773 if ( (value && typeof value === "string") || value === undefined ) {
1774 var classNames = (value || "").split( rspaces );
1776 for ( var i = 0, l = this.length; i < l; i++ ) {
1777 var elem = this[i];
1779 if ( elem.nodeType === 1 && elem.className ) {
1780 if ( value ) {
1781 var className = (" " + elem.className + " ").replace(rclass, " ");
1782 for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1783 className = className.replace(" " + classNames[c] + " ", " ");
1784 }
1785 elem.className = jQuery.trim( className );
1787 } else {
1788 elem.className = "";
1789 }
1790 }
1791 }
1792 }
1794 return this;
1795 },
1797 toggleClass: function( value, stateVal ) {
1798 var type = typeof value,
1799 isBool = typeof stateVal === "boolean";
1801 if ( jQuery.isFunction( value ) ) {
1802 return this.each(function(i) {
1803 var self = jQuery(this);
1804 self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1805 });
1806 }
1808 return this.each(function() {
1809 if ( type === "string" ) {
1810 // toggle individual class names
1811 var className,
1812 i = 0,
1813 self = jQuery( this ),
1814 state = stateVal,
1815 classNames = value.split( rspaces );
1817 while ( (className = classNames[ i++ ]) ) {
1818 // check each className given, space seperated list
1819 state = isBool ? state : !self.hasClass( className );
1820 self[ state ? "addClass" : "removeClass" ]( className );
1821 }
1823 } else if ( type === "undefined" || type === "boolean" ) {
1824 if ( this.className ) {
1825 // store className if set
1826 jQuery._data( this, "__className__", this.className );
1827 }
1829 // toggle whole className
1830 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
1831 }
1832 });
1833 },
1835 hasClass: function( selector ) {
1836 var className = " " + selector + " ";
1837 for ( var i = 0, l = this.length; i < l; i++ ) {
1838 if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1839 return true;
1840 }
1841 }
1843 return false;
1844 },
1846 val: function( value ) {
1847 if ( !arguments.length ) {
1848 var elem = this[0];
1850 if ( elem ) {
1851 if ( jQuery.nodeName( elem, "option" ) ) {
1852 // attributes.value is undefined in Blackberry 4.7 but
1853 // uses .value. See #6932
1854 var val = elem.attributes.value;
1855 return !val || val.specified ? elem.value : elem.text;
1856 }
1858 // We need to handle select boxes special
1859 if ( jQuery.nodeName( elem, "select" ) ) {
1860 var index = elem.selectedIndex,
1861 values = [],
1862 options = elem.options,
1863 one = elem.type === "select-one";
1865 // Nothing was selected
1866 if ( index < 0 ) {
1867 return null;
1868 }
1870 // Loop through all the selected options
1871 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1872 var option = options[ i ];
1874 // Don't return options that are disabled or in a disabled optgroup
1875 if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
1876 (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
1878 // Get the specific value for the option
1879 value = jQuery(option).val();
1881 // We don't need an array for one selects
1882 if ( one ) {
1883 return value;
1884 }
1886 // Multi-Selects return an array
1887 values.push( value );
1888 }
1889 }
1891 return values;
1892 }
1894 // Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1895 if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1896 return elem.getAttribute("value") === null ? "on" : elem.value;
1897 }
1899 // Everything else, we just grab the value
1900 return (elem.value || "").replace(rreturn, "");
1902 }
1904 return undefined;
1905 }
1907 var isFunction = jQuery.isFunction(value);
1909 return this.each(function(i) {
1910 var self = jQuery(this), val = value;
1912 if ( this.nodeType !== 1 ) {
1913 return;
1914 }
1916 if ( isFunction ) {
1917 val = value.call(this, i, self.val());
1918 }
1920 // Treat null/undefined as ""; convert numbers to string
1921 if ( val == null ) {
1922 val = "";
1923 } else if ( typeof val === "number" ) {
1924 val += "";
1925 } else if ( jQuery.isArray(val) ) {
1926 val = jQuery.map(val, function (value) {
1927 return value == null ? "" : value + "";
1928 });
1929 }
1931 if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1932 this.checked = jQuery.inArray( self.val(), val ) >= 0;
1934 } else if ( jQuery.nodeName( this, "select" ) ) {
1935 var values = jQuery.makeArray(val);
1937 jQuery( "option", this ).each(function() {
1938 this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1939 });
1941 if ( !values.length ) {
1942 this.selectedIndex = -1;
1943 }
1945 } else {
1946 this.value = val;
1947 }
1948 });
1949 }
1950 });
1952 jQuery.extend({
1953 attrFn: {
1954 val: true,
1955 css: true,
1956 html: true,
1957 text: true,
1958 data: true,
1959 width: true,
1960 height: true,
1961 offset: true
1962 },
1964 attr: function( elem, name, value, pass ) {
1965 // don't get/set attributes on text, comment and attribute nodes
1966 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || elem.nodeType === 2 ) {
1967 return undefined;
1968 }
1970 if ( pass && name in jQuery.attrFn ) {
1971 return jQuery(elem)[name](value);
1972 }
1974 var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
1975 // Whether we are setting (or getting)
1976 set = value !== undefined;
1978 // Try to normalize/fix the name
1979 name = notxml && jQuery.props[ name ] || name;
1981 // Only do all the following if this is a node (faster for style)
1982 if ( elem.nodeType === 1 ) {
1983 // These attributes require special treatment
1984 var special = rspecialurl.test( name );
1986 // Safari mis-reports the default selected property of an option
1987 // Accessing the parent's selectedIndex property fixes it
1988 if ( name === "selected" && !jQuery.support.optSelected ) {
1989 var parent = elem.parentNode;
1990 if ( parent ) {
1991 parent.selectedIndex;
1993 // Make sure that it also works with optgroups, see #5701
1994 if ( parent.parentNode ) {
1995 parent.parentNode.selectedIndex;
1996 }
1997 }
1998 }
2000 // If applicable, access the attribute via the DOM 0 way
2001 // 'in' checks fail in Blackberry 4.7 #6931
2002 if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
2003 if ( set ) {
2004 // We can't allow the type property to be changed (since it causes problems in IE)
2005 if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
2006 jQuery.error( "type property can't be changed" );
2007 }
2009 if ( value === null ) {
2010 if ( elem.nodeType === 1 ) {
2011 elem.removeAttribute( name );
2012 }
2014 } else {
2015 elem[ name ] = value;
2016 }
2017 }
2019 // browsers index elements by id/name on forms, give priority to attributes.
2020 if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
2021 return elem.getAttributeNode( name ).nodeValue;
2022 }
2024 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
2025 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
2026 if ( name === "tabIndex" ) {
2027 var attributeNode = elem.getAttributeNode( "tabIndex" );
2029 return attributeNode && attributeNode.specified ?
2030 attributeNode.value :
2031 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
2032 0 :
2033 undefined;
2034 }
2036 return elem[ name ];
2037 }
2039 if ( !jQuery.support.style && notxml && name === "style" ) {
2040 if ( set ) {
2041 elem.style.cssText = "" + value;
2042 }
2044 return elem.style.cssText;
2045 }
2047 if ( set ) {
2048 // convert the value to a string (all browsers do this but IE) see #1070
2049 elem.setAttribute( name, "" + value );
2050 }
2052 // Ensure that missing attributes return undefined
2053 // Blackberry 4.7 returns "" from getAttribute #6938
2054 if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
2055 return undefined;
2056 }
2058 var attr = !jQuery.support.hrefNormalized && notxml && special ?
2059 // Some attributes require a special call on IE
2060 elem.getAttribute( name, 2 ) :
2061 elem.getAttribute( name );
2063 // Non-existent attributes return null, we normalize to undefined
2064 return attr === null ? undefined : attr;
2065 }
2066 // Handle everything which isn't a DOM element node
2067 if ( set ) {
2068 elem[ name ] = value;
2069 }
2070 return elem[ name ];
2071 }
2072 });
2077 var rnamespaces = /\.(.*)$/,
2078 rformElems = /^(?:textarea|input|select)$/i,
2079 rperiod = /\./g,
2080 rspace = / /g,
2081 rescape = /[^\w\s.|`]/g,
2082 fcleanup = function( nm ) {
2083 return nm.replace(rescape, "\\$&");
2084 },
2085 eventKey = "events";
2087 /*
2088 * A number of helper functions used for managing events.
2089 * Many of the ideas behind this code originated from
2090 * Dean Edwards' addEvent library.
2091 */
2092 jQuery.event = {
2094 // Bind an event to an element
2095 // Original by Dean Edwards
2096 add: function( elem, types, handler, data ) {
2097 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2098 return;
2099 }
2101 // For whatever reason, IE has trouble passing the window object
2102 // around, causing it to be cloned in the process
2103 if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
2104 elem = window;
2105 }
2107 if ( handler === false ) {
2108 handler = returnFalse;
2109 } else if ( !handler ) {
2110 // Fixes bug #7229. Fix recommended by jdalton
2111 return;
2112 }
2114 var handleObjIn, handleObj;
2116 if ( handler.handler ) {
2117 handleObjIn = handler;
2118 handler = handleObjIn.handler;
2119 }
2121 // Make sure that the function being executed has a unique ID
2122 if ( !handler.guid ) {
2123 handler.guid = jQuery.guid++;
2124 }
2126 // Init the element's event structure
2127 var elemData = jQuery._data( elem );
2129 // If no elemData is found then we must be trying to bind to one of the
2130 // banned noData elements
2131 if ( !elemData ) {
2132 return;
2133 }
2135 var events = elemData[ eventKey ],
2136 eventHandle = elemData.handle;
2138 if ( typeof events === "function" ) {
2139 // On plain objects events is a fn that holds the the data
2140 // which prevents this data from being JSON serialized
2141 // the function does not need to be called, it just contains the data
2142 eventHandle = events.handle;
2143 events = events.events;
2145 } else if ( !events ) {
2146 if ( !elem.nodeType ) {
2147 // On plain objects, create a fn that acts as the holder
2148 // of the values to avoid JSON serialization of event data
2149 elemData[ eventKey ] = elemData = function(){};
2150 }
2152 elemData.events = events = {};
2153 }
2155 if ( !eventHandle ) {
2156 elemData.handle = eventHandle = function() {
2157 // Handle the second event of a trigger and when
2158 // an event is called after a page has unloaded
2159 return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
2160 jQuery.event.handle.apply( eventHandle.elem, arguments ) :
2161 undefined;
2162 };
2163 }
2165 // Add elem as a property of the handle function
2166 // This is to prevent a memory leak with non-native events in IE.
2167 eventHandle.elem = elem;
2169 // Handle multiple events separated by a space
2170 // jQuery(...).bind("mouseover mouseout", fn);
2171 types = types.split(" ");
2173 var type, i = 0, namespaces;
2175 while ( (type = types[ i++ ]) ) {
2176 handleObj = handleObjIn ?
2177 jQuery.extend({}, handleObjIn) :
2178 { handler: handler, data: data };
2180 // Namespaced event handlers
2181 if ( type.indexOf(".") > -1 ) {
2182 namespaces = type.split(".");
2183 type = namespaces.shift();
2184 handleObj.namespace = namespaces.slice(0).sort().join(".");
2186 } else {
2187 namespaces = [];
2188 handleObj.namespace = "";
2189 }
2191 handleObj.type = type;
2192 if ( !handleObj.guid ) {
2193 handleObj.guid = handler.guid;
2194 }
2196 // Get the current list of functions bound to this event
2197 var handlers = events[ type ],
2198 special = jQuery.event.special[ type ] || {};
2200 // Init the event handler queue
2201 if ( !handlers ) {
2202 handlers = events[ type ] = [];
2204 // Check for a special event handler
2205 // Only use addEventListener/attachEvent if the special
2206 // events handler returns false
2207 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
2208 // Bind the global event handler to the element
2209 if ( elem.addEventListener ) {
2210 elem.addEventListener( type, eventHandle, false );
2212 } else if ( elem.attachEvent ) {
2213 elem.attachEvent( "on" + type, eventHandle );
2214 }
2215 }
2216 }
2218 if ( special.add ) {
2219 special.add.call( elem, handleObj );
2221 if ( !handleObj.handler.guid ) {
2222 handleObj.handler.guid = handler.guid;
2223 }
2224 }
2226 // Add the function to the element's handler list
2227 handlers.push( handleObj );
2229 // Keep track of which events have been used, for global triggering
2230 jQuery.event.global[ type ] = true;
2231 }
2233 // Nullify elem to prevent memory leaks in IE
2234 elem = null;
2235 },
2237 global: {},
2239 // Detach an event or set of events from an element
2240 remove: function( elem, types, handler, pos ) {
2241 // don't do events on text and comment nodes
2242 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
2243 return;
2244 }
2246 if ( handler === false ) {
2247 handler = returnFalse;
2248 }
2250 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
2251 elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
2252 events = elemData && elemData[ eventKey ];
2254 if ( !elemData || !events ) {
2255 return;
2256 }
2258 if ( typeof events === "function" ) {
2259 elemData = events;
2260 events = events.events;
2261 }
2263 // types is actually an event object here
2264 if ( types && types.type ) {
2265 handler = types.handler;
2266 types = types.type;
2267 }
2269 // Unbind all events for the element
2270 if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
2271 types = types || "";
2273 for ( type in events ) {
2274 jQuery.event.remove( elem, type + types );
2275 }
2277 return;
2278 }
2280 // Handle multiple events separated by a space
2281 // jQuery(...).unbind("mouseover mouseout", fn);
2282 types = types.split(" ");
2284 while ( (type = types[ i++ ]) ) {
2285 origType = type;
2286 handleObj = null;
2287 all = type.indexOf(".") < 0;
2288 namespaces = [];
2290 if ( !all ) {
2291 // Namespaced event handlers
2292 namespaces = type.split(".");
2293 type = namespaces.shift();
2295 namespace = new RegExp("(^|\\.)" +
2296 jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
2297 }
2299 eventType = events[ type ];
2301 if ( !eventType ) {
2302 continue;
2303 }
2305 if ( !handler ) {
2306 for ( j = 0; j < eventType.length; j++ ) {
2307 handleObj = eventType[ j ];
2309 if ( all || namespace.test( handleObj.namespace ) ) {
2310 jQuery.event.remove( elem, origType, handleObj.handler, j );
2311 eventType.splice( j--, 1 );
2312 }
2313 }
2315 continue;
2316 }
2318 special = jQuery.event.special[ type ] || {};
2320 for ( j = pos || 0; j < eventType.length; j++ ) {
2321 handleObj = eventType[ j ];
2323 if ( handler.guid === handleObj.guid ) {
2324 // remove the given handler for the given type
2325 if ( all || namespace.test( handleObj.namespace ) ) {
2326 if ( pos == null ) {
2327 eventType.splice( j--, 1 );
2328 }
2330 if ( special.remove ) {
2331 special.remove.call( elem, handleObj );
2332 }
2333 }
2335 if ( pos != null ) {
2336 break;
2337 }
2338 }
2339 }
2341 // remove generic event handler if no more handlers exist
2342 if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
2343 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2344 jQuery.removeEvent( elem, type, elemData.handle );
2345 }
2347 ret = null;
2348 delete events[ type ];
2349 }
2350 }
2352 // Remove the expando if it's no longer used
2353 if ( jQuery.isEmptyObject( events ) ) {
2354 var handle = elemData.handle;
2355 if ( handle ) {
2356 handle.elem = null;
2357 }
2359 delete elemData.events;
2360 delete elemData.handle;
2362 if ( typeof elemData === "function" ) {
2363 jQuery.removeData( elem, eventKey, true );
2365 } else if ( jQuery.isEmptyObject( elemData ) ) {
2366 jQuery.removeData( elem, undefined, true );
2367 }
2368 }
2369 },
2371 // bubbling is internal
2372 trigger: function( event, data, elem /*, bubbling */ ) {
2373 // Event object or event type
2374 var type = event.type || event,
2375 bubbling = arguments[3];
2377 if ( !bubbling ) {
2378 event = typeof event === "object" ?
2379 // jQuery.Event object
2380 event[ jQuery.expando ] ? event :
2381 // Object literal
2382 jQuery.extend( jQuery.Event(type), event ) :
2383 // Just the event type (string)
2384 jQuery.Event(type);
2386 if ( type.indexOf("!") >= 0 ) {
2387 event.type = type = type.slice(0, -1);
2388 event.exclusive = true;
2389 }
2391 // Handle a global trigger
2392 if ( !elem ) {
2393 // Don't bubble custom events when global (to avoid too much overhead)
2394 event.stopPropagation();
2396 // Only trigger if we've ever bound an event for it
2397 if ( jQuery.event.global[ type ] ) {
2398 // XXX This code smells terrible. event.js should not be directly
2399 // inspecting the data cache
2400 jQuery.each( jQuery.cache, function() {
2401 // internalKey variable is just used to make it easier to find
2402 // and potentially change this stuff later; currently it just
2403 // points to jQuery.expando
2404 var internalKey = jQuery.expando,
2405 internalCache = this[ internalKey ];
2406 if ( internalCache && internalCache.events && internalCache.events[type] ) {
2407 jQuery.event.trigger( event, data, internalCache.handle.elem );
2408 }
2409 });
2410 }
2411 }
2413 // Handle triggering a single element
2415 // don't do events on text and comment nodes
2416 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
2417 return undefined;
2418 }
2420 // Clean up in case it is reused
2421 event.result = undefined;
2422 event.target = elem;
2424 // Clone the incoming data, if any
2425 data = jQuery.makeArray( data );
2426 data.unshift( event );
2427 }
2429 event.currentTarget = elem;
2431 // Trigger the event, it is assumed that "handle" is a function
2432 var handle = elem.nodeType ?
2433 jQuery._data( elem, "handle" ) :
2434 (jQuery._data( elem, eventKey ) || {}).handle;
2436 if ( handle ) {
2437 handle.apply( elem, data );
2438 }
2440 var parent = elem.parentNode || elem.ownerDocument;
2442 // Trigger an inline bound script
2443 try {
2444 if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
2445 if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
2446 event.result = false;
2447 event.preventDefault();
2448 }
2449 }
2451 // prevent IE from throwing an error for some elements with some event types, see #3533
2452 } catch (inlineError) {}
2454 if ( !event.isPropagationStopped() && parent ) {
2455 jQuery.event.trigger( event, data, parent, true );
2457 } else if ( !event.isDefaultPrevented() ) {
2458 var old,
2459 target = event.target,
2460 targetType = type.replace( rnamespaces, "" ),
2461 isClick = jQuery.nodeName( target, "a" ) && targetType === "click",
2462 special = jQuery.event.special[ targetType ] || {};
2464 if ( (!special._default || special._default.call( elem, event ) === false) &&
2465 !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
2467 try {
2468 if ( target[ targetType ] ) {
2469 // Make sure that we don't accidentally re-trigger the onFOO events
2470 old = target[ "on" + targetType ];
2472 if ( old ) {
2473 target[ "on" + targetType ] = null;
2474 }
2476 jQuery.event.triggered = true;
2477 target[ targetType ]();
2478 }
2480 // prevent IE from throwing an error for some elements with some event types, see #3533
2481 } catch (triggerError) {}
2483 if ( old ) {
2484 target[ "on" + targetType ] = old;
2485 }
2487 jQuery.event.triggered = false;
2488 }
2489 }
2490 },
2492 handle: function( event ) {
2493 var all, handlers, namespaces, namespace_re, events,
2494 namespace_sort = [],
2495 args = jQuery.makeArray( arguments );
2497 event = args[0] = jQuery.event.fix( event || window.event );
2498 event.currentTarget = this;
2500 // Namespaced event handlers
2501 all = event.type.indexOf(".") < 0 && !event.exclusive;
2503 if ( !all ) {
2504 namespaces = event.type.split(".");
2505 event.type = namespaces.shift();
2506 namespace_sort = namespaces.slice(0).sort();
2507 namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)");
2508 }
2510 event.namespace = event.namespace || namespace_sort.join(".");
2512 events = jQuery._data(this, eventKey);
2514 if ( typeof events === "function" ) {
2515 events = events.events;
2516 }
2518 handlers = (events || {})[ event.type ];
2520 if ( events && handlers ) {
2521 // Clone the handlers to prevent manipulation
2522 handlers = handlers.slice(0);
2524 for ( var j = 0, l = handlers.length; j < l; j++ ) {
2525 var handleObj = handlers[ j ];
2527 // Filter the functions by class
2528 if ( all || namespace_re.test( handleObj.namespace ) ) {
2529 // Pass in a reference to the handler function itself
2530 // So that we can later remove it
2531 event.handler = handleObj.handler;
2532 event.data = handleObj.data;
2533 event.handleObj = handleObj;
2535 var ret = handleObj.handler.apply( this, args );
2537 if ( ret !== undefined ) {
2538 event.result = ret;
2539 if ( ret === false ) {
2540 event.preventDefault();
2541 event.stopPropagation();
2542 }
2543 }
2545 if ( event.isImmediatePropagationStopped() ) {
2546 break;
2547 }
2548 }
2549 }
2550 }
2552 return event.result;
2553 },
2555 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(" "),
2557 fix: function( event ) {
2558 if ( event[ jQuery.expando ] ) {
2559 return event;
2560 }
2562 // store a copy of the original event object
2563 // and "clone" to set read-only properties
2564 var originalEvent = event;
2565 event = jQuery.Event( originalEvent );
2567 for ( var i = this.props.length, prop; i; ) {
2568 prop = this.props[ --i ];
2569 event[ prop ] = originalEvent[ prop ];
2570 }
2572 // Fix target property, if necessary
2573 if ( !event.target ) {
2574 // Fixes #1925 where srcElement might not be defined either
2575 event.target = event.srcElement || document;
2576 }
2578 // check if target is a textnode (safari)
2579 if ( event.target.nodeType === 3 ) {
2580 event.target = event.target.parentNode;
2581 }
2583 // Add relatedTarget, if necessary
2584 if ( !event.relatedTarget && event.fromElement ) {
2585 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
2586 }
2588 // Calculate pageX/Y if missing and clientX/Y available
2589 if ( event.pageX == null && event.clientX != null ) {
2590 var doc = document.documentElement,
2591 body = document.body;
2593 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
2594 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
2595 }
2597 // Add which for key events
2598 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
2599 event.which = event.charCode != null ? event.charCode : event.keyCode;
2600 }
2602 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2603 if ( !event.metaKey && event.ctrlKey ) {
2604 event.metaKey = event.ctrlKey;
2605 }
2607 // Add which for click: 1 === left; 2 === middle; 3 === right
2608 // Note: button is not normalized, so don't use it
2609 if ( !event.which && event.button !== undefined ) {
2610 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2611 }
2613 return event;
2614 },
2616 // Deprecated, use jQuery.guid instead
2617 guid: 1E8,
2619 // Deprecated, use jQuery.proxy instead
2620 proxy: jQuery.proxy,
2622 special: {
2623 ready: {
2624 // Make sure the ready event is setup
2625 setup: jQuery.bindReady,
2626 teardown: jQuery.noop
2627 },
2629 live: {
2630 add: function( handleObj ) {
2631 jQuery.event.add( this,
2632 liveConvert( handleObj.origType, handleObj.selector ),
2633 jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
2634 },
2636 remove: function( handleObj ) {
2637 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
2638 }
2639 },
2641 beforeunload: {
2642 setup: function( data, namespaces, eventHandle ) {
2643 // We only want to do this special case on windows
2644 if ( jQuery.isWindow( this ) ) {
2645 this.onbeforeunload = eventHandle;
2646 }
2647 },
2649 teardown: function( namespaces, eventHandle ) {
2650 if ( this.onbeforeunload === eventHandle ) {
2651 this.onbeforeunload = null;
2652 }
2653 }
2654 }
2655 }
2656 };
2658 jQuery.removeEvent = document.removeEventListener ?
2659 function( elem, type, handle ) {
2660 if ( elem.removeEventListener ) {
2661 elem.removeEventListener( type, handle, false );
2662 }
2663 } :
2664 function( elem, type, handle ) {
2665 if ( elem.detachEvent ) {
2666 elem.detachEvent( "on" + type, handle );
2667 }
2668 };
2670 jQuery.Event = function( src ) {
2671 // Allow instantiation without the 'new' keyword
2672 if ( !this.preventDefault ) {
2673 return new jQuery.Event( src );
2674 }
2676 // Event object
2677 if ( src && src.type ) {
2678 this.originalEvent = src;
2679 this.type = src.type;
2681 // Events bubbling up the document may have been marked as prevented
2682 // by a handler lower down the tree; reflect the correct value.
2683 this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
2684 src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
2686 // Event type
2687 } else {
2688 this.type = src;
2689 }
2691 // timeStamp is buggy for some events on Firefox(#3843)
2692 // So we won't rely on the native value
2693 this.timeStamp = jQuery.now();
2695 // Mark it as fixed
2696 this[ jQuery.expando ] = true;
2697 };
2699 function returnFalse() {
2700 return false;
2701 }
2702 function returnTrue() {
2703 return true;
2704 }
2706 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2707 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2708 jQuery.Event.prototype = {
2709 preventDefault: function() {
2710 this.isDefaultPrevented = returnTrue;
2712 var e = this.originalEvent;
2713 if ( !e ) {
2714 return;
2715 }
2717 // if preventDefault exists run it on the original event
2718 if ( e.preventDefault ) {
2719 e.preventDefault();
2721 // otherwise set the returnValue property of the original event to false (IE)
2722 } else {
2723 e.returnValue = false;
2724 }
2725 },
2726 stopPropagation: function() {
2727 this.isPropagationStopped = returnTrue;
2729 var e = this.originalEvent;
2730 if ( !e ) {
2731 return;
2732 }
2733 // if stopPropagation exists run it on the original event
2734 if ( e.stopPropagation ) {
2735 e.stopPropagation();
2736 }
2737 // otherwise set the cancelBubble property of the original event to true (IE)
2738 e.cancelBubble = true;
2739 },
2740 stopImmediatePropagation: function() {
2741 this.isImmediatePropagationStopped = returnTrue;
2742 this.stopPropagation();
2743 },
2744 isDefaultPrevented: returnFalse,
2745 isPropagationStopped: returnFalse,
2746 isImmediatePropagationStopped: returnFalse
2747 };
2749 // Checks if an event happened on an element within another element
2750 // Used in jQuery.event.special.mouseenter and mouseleave handlers
2751 var withinElement = function( event ) {
2752 // Check if mouse(over|out) are still within the same parent element
2753 var parent = event.relatedTarget;
2755 // Firefox sometimes assigns relatedTarget a XUL element
2756 // which we cannot access the parentNode property of
2757 try {
2758 // Traverse up the tree
2759 while ( parent && parent !== this ) {
2760 parent = parent.parentNode;
2761 }
2763 if ( parent !== this ) {
2764 // set the correct event type
2765 event.type = event.data;
2767 // handle event if we actually just moused on to a non sub-element
2768 jQuery.event.handle.apply( this, arguments );
2769 }
2771 // assuming we've left the element since we most likely mousedover a xul element
2772 } catch(e) { }
2773 },
2775 // In case of event delegation, we only need to rename the event.type,
2776 // liveHandler will take care of the rest.
2777 delegate = function( event ) {
2778 event.type = event.data;
2779 jQuery.event.handle.apply( this, arguments );
2780 };
2782 // Create mouseenter and mouseleave events
2783 jQuery.each({
2784 mouseenter: "mouseover",
2785 mouseleave: "mouseout"
2786 }, function( orig, fix ) {
2787 jQuery.event.special[ orig ] = {
2788 setup: function( data ) {
2789 jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
2790 },
2791 teardown: function( data ) {
2792 jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
2793 }
2794 };
2795 });
2797 // submit delegation
2798 if ( !jQuery.support.submitBubbles ) {
2800 jQuery.event.special.submit = {
2801 setup: function( data, namespaces ) {
2802 if ( this.nodeName && this.nodeName.toLowerCase() !== "form" ) {
2803 jQuery.event.add(this, "click.specialSubmit", function( e ) {
2804 var elem = e.target,
2805 type = elem.type;
2807 if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
2808 e.liveFired = undefined;
2809 return trigger( "submit", this, arguments );
2810 }
2811 });
2813 jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
2814 var elem = e.target,
2815 type = elem.type;
2817 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2818 e.liveFired = undefined;
2819 return trigger( "submit", this, arguments );
2820 }
2821 });
2823 } else {
2824 return false;
2825 }
2826 },
2828 teardown: function( namespaces ) {
2829 jQuery.event.remove( this, ".specialSubmit" );
2830 }
2831 };
2833 }
2835 // change delegation, happens here so we have bind.
2836 if ( !jQuery.support.changeBubbles ) {
2838 var changeFilters,
2840 getVal = function( elem ) {
2841 var type = elem.type, val = elem.value;
2843 if ( type === "radio" || type === "checkbox" ) {
2844 val = elem.checked;
2846 } else if ( type === "select-multiple" ) {
2847 val = elem.selectedIndex > -1 ?
2848 jQuery.map( elem.options, function( elem ) {
2849 return elem.selected;
2850 }).join("-") :
2851 "";
2853 } else if ( elem.nodeName.toLowerCase() === "select" ) {
2854 val = elem.selectedIndex;
2855 }
2857 return val;
2858 },
2860 testChange = function testChange( e ) {
2861 var elem = e.target, data, val;
2863 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
2864 return;
2865 }
2867 data = jQuery._data( elem, "_change_data" );
2868 val = getVal(elem);
2870 // the current data will be also retrieved by beforeactivate
2871 if ( e.type !== "focusout" || elem.type !== "radio" ) {
2872 jQuery._data( elem, "_change_data", val );
2873 }
2875 if ( data === undefined || val === data ) {
2876 return;
2877 }
2879 if ( data != null || val ) {
2880 e.type = "change";
2881 e.liveFired = undefined;
2882 return jQuery.event.trigger( e, arguments[1], elem );
2883 }
2884 };
2886 jQuery.event.special.change = {
2887 filters: {
2888 focusout: testChange,
2890 beforedeactivate: testChange,
2892 click: function( e ) {
2893 var elem = e.target, type = elem.type;
2895 if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
2896 return testChange.call( this, e );
2897 }
2898 },
2900 // Change has to be called before submit
2901 // Keydown will be called before keypress, which is used in submit-event delegation
2902 keydown: function( e ) {
2903 var elem = e.target, type = elem.type;
2905 if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
2906 (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
2907 type === "select-multiple" ) {
2908 return testChange.call( this, e );
2909 }
2910 },
2912 // Beforeactivate happens also before the previous element is blurred
2913 // with this event you can't trigger a change event, but you can store
2914 // information
2915 beforeactivate: function( e ) {
2916 var elem = e.target;
2917 jQuery._data( elem, "_change_data", getVal(elem) );
2918 }
2919 },
2921 setup: function( data, namespaces ) {
2922 if ( this.type === "file" ) {
2923 return false;
2924 }
2926 for ( var type in changeFilters ) {
2927 jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
2928 }
2930 return rformElems.test( this.nodeName );
2931 },
2933 teardown: function( namespaces ) {
2934 jQuery.event.remove( this, ".specialChange" );
2936 return rformElems.test( this.nodeName );
2937 }
2938 };
2940 changeFilters = jQuery.event.special.change.filters;
2942 // Handle when the input is .focus()'d
2943 changeFilters.focus = changeFilters.beforeactivate;
2944 }
2946 function trigger( type, elem, args ) {
2947 args[0].type = type;
2948 return jQuery.event.handle.apply( elem, args );
2949 }
2951 // Create "bubbling" focus and blur events
2952 if ( document.addEventListener ) {
2953 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
2954 jQuery.event.special[ fix ] = {
2955 setup: function() {
2956 this.addEventListener( orig, handler, true );
2957 },
2958 teardown: function() {
2959 this.removeEventListener( orig, handler, true );
2960 }
2961 };
2963 function handler( e ) {
2964 e = jQuery.event.fix( e );
2965 e.type = fix;
2966 return jQuery.event.handle.call( this, e );
2967 }
2968 });
2969 }
2971 jQuery.each(["bind", "one"], function( i, name ) {
2972 jQuery.fn[ name ] = function( type, data, fn ) {
2973 // Handle object literals
2974 if ( typeof type === "object" ) {
2975 for ( var key in type ) {
2976 this[ name ](key, data, type[key], fn);
2977 }
2978 return this;
2979 }
2981 if ( jQuery.isFunction( data ) || data === false ) {
2982 fn = data;
2983 data = undefined;
2984 }
2986 var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
2987 jQuery( this ).unbind( event, handler );
2988 return fn.apply( this, arguments );
2989 }) : fn;
2991 if ( type === "unload" && name !== "one" ) {
2992 this.one( type, data, fn );
2994 } else {
2995 for ( var i = 0, l = this.length; i < l; i++ ) {
2996 jQuery.event.add( this[i], type, handler, data );
2997 }
2998 }
3000 return this;
3001 };
3002 });
3004 jQuery.fn.extend({
3005 unbind: function( type, fn ) {
3006 // Handle object literals
3007 if ( typeof type === "object" && !type.preventDefault ) {
3008 for ( var key in type ) {
3009 this.unbind(key, type[key]);
3010 }
3012 } else {
3013 for ( var i = 0, l = this.length; i < l; i++ ) {
3014 jQuery.event.remove( this[i], type, fn );
3015 }
3016 }
3018 return this;
3019 },
3021 delegate: function( selector, types, data, fn ) {
3022 return this.live( types, data, fn, selector );
3023 },
3025 undelegate: function( selector, types, fn ) {
3026 if ( arguments.length === 0 ) {
3027 return this.unbind( "live" );
3029 } else {
3030 return this.die( types, null, fn, selector );
3031 }
3032 },
3034 trigger: function( type, data ) {
3035 return this.each(function() {
3036 jQuery.event.trigger( type, data, this );
3037 });
3038 },
3040 triggerHandler: function( type, data ) {
3041 if ( this[0] ) {
3042 var event = jQuery.Event( type );
3043 event.preventDefault();
3044 event.stopPropagation();
3045 jQuery.event.trigger( event, data, this[0] );
3046 return event.result;
3047 }
3048 },
3050 toggle: function( fn ) {
3051 // Save reference to arguments for access in closure
3052 var args = arguments,
3053 i = 1;
3055 // link all the functions, so any of them can unbind this click handler
3056 while ( i < args.length ) {
3057 jQuery.proxy( fn, args[ i++ ] );
3058 }
3060 return this.click( jQuery.proxy( fn, function( event ) {
3061 // Figure out which function to execute
3062 var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
3063 jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
3065 // Make sure that clicks stop
3066 event.preventDefault();
3068 // and execute the function
3069 return args[ lastToggle ].apply( this, arguments ) || false;
3070 }));
3071 },
3073 hover: function( fnOver, fnOut ) {
3074 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
3075 }
3076 });
3078 var liveMap = {
3079 focus: "focusin",
3080 blur: "focusout",
3081 mouseenter: "mouseover",
3082 mouseleave: "mouseout"
3083 };
3085 jQuery.each(["live", "die"], function( i, name ) {
3086 jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
3087 var type, i = 0, match, namespaces, preType,
3088 selector = origSelector || this.selector,
3089 context = origSelector ? this : jQuery( this.context );
3091 if ( typeof types === "object" && !types.preventDefault ) {
3092 for ( var key in types ) {
3093 context[ name ]( key, data, types[key], selector );
3094 }
3096 return this;
3097 }
3099 if ( jQuery.isFunction( data ) ) {
3100 fn = data;
3101 data = undefined;
3102 }
3104 types = (types || "").split(" ");
3106 while ( (type = types[ i++ ]) != null ) {
3107 match = rnamespaces.exec( type );
3108 namespaces = "";
3110 if ( match ) {
3111 namespaces = match[0];
3112 type = type.replace( rnamespaces, "" );
3113 }
3115 if ( type === "hover" ) {
3116 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
3117 continue;
3118 }
3120 preType = type;
3122 if ( type === "focus" || type === "blur" ) {
3123 types.push( liveMap[ type ] + namespaces );
3124 type = type + namespaces;
3126 } else {
3127 type = (liveMap[ type ] || type) + namespaces;
3128 }
3130 if ( name === "live" ) {
3131 // bind live handler
3132 for ( var j = 0, l = context.length; j < l; j++ ) {
3133 jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
3134 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
3135 }
3137 } else {
3138 // unbind live handler
3139 context.unbind( "live." + liveConvert( type, selector ), fn );
3140 }
3141 }
3143 return this;
3144 };
3145 });
3147 function liveHandler( event ) {
3148 var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
3149 elems = [],
3150 selectors = [],
3151 events = jQuery._data( this, eventKey );
3153 if ( typeof events === "function" ) {
3154 events = events.events;
3155 }
3157 // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
3158 if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
3159 return;
3160 }
3162 if ( event.namespace ) {
3163 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
3164 }
3166 event.liveFired = this;
3168 var live = events.live.slice(0);
3170 for ( j = 0; j < live.length; j++ ) {
3171 handleObj = live[j];
3173 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
3174 selectors.push( handleObj.selector );
3176 } else {
3177 live.splice( j--, 1 );
3178 }
3179 }
3181 match = jQuery( event.target ).closest( selectors, event.currentTarget );
3183 for ( i = 0, l = match.length; i < l; i++ ) {
3184 close = match[i];
3186 for ( j = 0; j < live.length; j++ ) {
3187 handleObj = live[j];
3189 if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) ) {
3190 elem = close.elem;
3191 related = null;
3193 // Those two events require additional checking
3194 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
3195 event.type = handleObj.preType;
3196 related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
3197 }
3199 if ( !related || related !== elem ) {
3200 elems.push({ elem: elem, handleObj: handleObj, level: close.level });
3201 }
3202 }
3203 }
3204 }
3206 for ( i = 0, l = elems.length; i < l; i++ ) {
3207 match = elems[i];
3209 if ( maxLevel && match.level > maxLevel ) {
3210 break;
3211 }
3213 event.currentTarget = match.elem;
3214 event.data = match.handleObj.data;
3215 event.handleObj = match.handleObj;
3217 ret = match.handleObj.origHandler.apply( match.elem, arguments );
3219 if ( ret === false || event.isPropagationStopped() ) {
3220 maxLevel = match.level;
3222 if ( ret === false ) {
3223 stop = false;
3224 }
3225 if ( event.isImmediatePropagationStopped() ) {
3226 break;
3227 }
3228 }
3229 }
3231 return stop;
3232 }
3234 function liveConvert( type, selector ) {
3235 return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&");
3236 }
3238 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
3239 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
3240 "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
3242 // Handle event binding
3243 jQuery.fn[ name ] = function( data, fn ) {
3244 if ( fn == null ) {
3245 fn = data;
3246 data = null;
3247 }
3249 return arguments.length > 0 ?
3250 this.bind( name, data, fn ) :
3251 this.trigger( name );
3252 };
3254 if ( jQuery.attrFn ) {
3255 jQuery.attrFn[ name ] = true;
3256 }
3257 });
3260 /*!
3261 * Sizzle CSS Selector Engine
3262 * Copyright 2011, The Dojo Foundation
3263 * Released under the MIT, BSD, and GPL Licenses.
3264 * More information: http://sizzlejs.com/
3265 */
3266 (function(){
3268 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
3269 done = 0,
3270 toString = Object.prototype.toString,
3271 hasDuplicate = false,
3272 baseHasDuplicate = true;
3274 // Here we check if the JavaScript engine is using some sort of
3275 // optimization where it does not always call our comparision
3276 // function. If that is the case, discard the hasDuplicate value.
3277 // Thus far that includes Google Chrome.
3278 [0, 0].sort(function() {
3279 baseHasDuplicate = false;
3280 return 0;
3281 });
3283 var Sizzle = function( selector, context, results, seed ) {
3284 results = results || [];
3285 context = context || document;
3287 var origContext = context;
3289 if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
3290 return [];
3291 }
3293 if ( !selector || typeof selector !== "string" ) {
3294 return results;
3295 }
3297 var m, set, checkSet, extra, ret, cur, pop, i,
3298 prune = true,
3299 contextXML = Sizzle.isXML( context ),
3300 parts = [],
3301 soFar = selector;
3303 // Reset the position of the chunker regexp (start from head)
3304 do {
3305 chunker.exec( "" );
3306 m = chunker.exec( soFar );
3308 if ( m ) {
3309 soFar = m[3];
3311 parts.push( m[1] );
3313 if ( m[2] ) {
3314 extra = m[3];
3315 break;
3316 }
3317 }
3318 } while ( m );
3320 if ( parts.length > 1 && origPOS.exec( selector ) ) {
3322 if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
3323 set = posProcess( parts[0] + parts[1], context );
3325 } else {
3326 set = Expr.relative[ parts[0] ] ?
3327 [ context ] :
3328 Sizzle( parts.shift(), context );
3330 while ( parts.length ) {
3331 selector = parts.shift();
3333 if ( Expr.relative[ selector ] ) {
3334 selector += parts.shift();
3335 }
3337 set = posProcess( selector, set );
3338 }
3339 }
3341 } else {
3342 // Take a shortcut and set the context if the root selector is an ID
3343 // (but not if it'll be faster if the inner selector is an ID)
3344 if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3345 Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3347 ret = Sizzle.find( parts.shift(), context, contextXML );
3348 context = ret.expr ?
3349 Sizzle.filter( ret.expr, ret.set )[0] :
3350 ret.set[0];
3351 }
3353 if ( context ) {
3354 ret = seed ?
3355 { expr: parts.pop(), set: makeArray(seed) } :
3356 Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3358 set = ret.expr ?
3359 Sizzle.filter( ret.expr, ret.set ) :
3360 ret.set;
3362 if ( parts.length > 0 ) {
3363 checkSet = makeArray( set );
3365 } else {
3366 prune = false;
3367 }
3369 while ( parts.length ) {
3370 cur = parts.pop();
3371 pop = cur;
3373 if ( !Expr.relative[ cur ] ) {
3374 cur = "";
3375 } else {
3376 pop = parts.pop();
3377 }
3379 if ( pop == null ) {
3380 pop = context;
3381 }
3383 Expr.relative[ cur ]( checkSet, pop, contextXML );
3384 }
3386 } else {
3387 checkSet = parts = [];
3388 }
3389 }
3391 if ( !checkSet ) {
3392 checkSet = set;
3393 }
3395 if ( !checkSet ) {
3396 Sizzle.error( cur || selector );
3397 }
3399 if ( toString.call(checkSet) === "[object Array]" ) {
3400 if ( !prune ) {
3401 results.push.apply( results, checkSet );
3403 } else if ( context && context.nodeType === 1 ) {
3404 for ( i = 0; checkSet[i] != null; i++ ) {
3405 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
3406 results.push( set[i] );
3407 }
3408 }
3410 } else {
3411 for ( i = 0; checkSet[i] != null; i++ ) {
3412 if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
3413 results.push( set[i] );
3414 }
3415 }
3416 }
3418 } else {
3419 makeArray( checkSet, results );
3420 }
3422 if ( extra ) {
3423 Sizzle( extra, origContext, results, seed );
3424 Sizzle.uniqueSort( results );
3425 }
3427 return results;
3428 };
3430 Sizzle.uniqueSort = function( results ) {
3431 if ( sortOrder ) {
3432 hasDuplicate = baseHasDuplicate;
3433 results.sort( sortOrder );
3435 if ( hasDuplicate ) {
3436 for ( var i = 1; i < results.length; i++ ) {
3437 if ( results[i] === results[ i - 1 ] ) {
3438 results.splice( i--, 1 );
3439 }
3440 }
3441 }
3442 }
3444 return results;
3445 };
3447 Sizzle.matches = function( expr, set ) {
3448 return Sizzle( expr, null, null, set );
3449 };
3451 Sizzle.matchesSelector = function( node, expr ) {
3452 return Sizzle( expr, null, null, [node] ).length > 0;
3453 };
3455 Sizzle.find = function( expr, context, isXML ) {
3456 var set;
3458 if ( !expr ) {
3459 return [];
3460 }
3462 for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
3463 var match,
3464 type = Expr.order[i];
3466 if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
3467 var left = match[1];
3468 match.splice( 1, 1 );
3470 if ( left.substr( left.length - 1 ) !== "\\" ) {
3471 match[1] = (match[1] || "").replace(/\\/g, "");
3472 set = Expr.find[ type ]( match, context, isXML );
3474 if ( set != null ) {
3475 expr = expr.replace( Expr.match[ type ], "" );
3476 break;
3477 }
3478 }
3479 }
3480 }
3482 if ( !set ) {
3483 set = typeof context.getElementsByTagName !== "undefined" ?
3484 context.getElementsByTagName( "*" ) :
3485 [];
3486 }
3488 return { set: set, expr: expr };
3489 };
3491 Sizzle.filter = function( expr, set, inplace, not ) {
3492 var match, anyFound,
3493 old = expr,
3494 result = [],
3495 curLoop = set,
3496 isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
3498 while ( expr && set.length ) {
3499 for ( var type in Expr.filter ) {
3500 if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
3501 var found, item,
3502 filter = Expr.filter[ type ],
3503 left = match[1];
3505 anyFound = false;
3507 match.splice(1,1);
3509 if ( left.substr( left.length - 1 ) === "\\" ) {
3510 continue;
3511 }
3513 if ( curLoop === result ) {
3514 result = [];
3515 }
3517 if ( Expr.preFilter[ type ] ) {
3518 match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
3520 if ( !match ) {
3521 anyFound = found = true;
3523 } else if ( match === true ) {
3524 continue;
3525 }
3526 }
3528 if ( match ) {
3529 for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
3530 if ( item ) {
3531 found = filter( item, match, i, curLoop );
3532 var pass = not ^ !!found;
3534 if ( inplace && found != null ) {
3535 if ( pass ) {
3536 anyFound = true;
3538 } else {
3539 curLoop[i] = false;
3540 }
3542 } else if ( pass ) {
3543 result.push( item );
3544 anyFound = true;
3545 }
3546 }
3547 }
3548 }
3550 if ( found !== undefined ) {
3551 if ( !inplace ) {
3552 curLoop = result;
3553 }
3555 expr = expr.replace( Expr.match[ type ], "" );
3557 if ( !anyFound ) {
3558 return [];
3559 }
3561 break;
3562 }
3563 }
3564 }
3566 // Improper expression
3567 if ( expr === old ) {
3568 if ( anyFound == null ) {
3569 Sizzle.error( expr );
3571 } else {
3572 break;
3573 }
3574 }
3576 old = expr;
3577 }
3579 return curLoop;
3580 };
3582 Sizzle.error = function( msg ) {
3583 throw "Syntax error, unrecognized expression: " + msg;
3584 };
3586 var Expr = Sizzle.selectors = {
3587 order: [ "ID", "NAME", "TAG" ],
3589 match: {
3590 ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
3591 CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
3592 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
3593 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
3594 TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
3595 CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
3596 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
3597 PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
3598 },
3600 leftMatch: {},
3602 attrMap: {
3603 "class": "className",
3604 "for": "htmlFor"
3605 },
3607 attrHandle: {
3608 href: function( elem ) {
3609 return elem.getAttribute( "href" );
3610 }
3611 },
3613 relative: {
3614 "+": function(checkSet, part){
3615 var isPartStr = typeof part === "string",
3616 isTag = isPartStr && !/\W/.test( part ),
3617 isPartStrNotTag = isPartStr && !isTag;
3619 if ( isTag ) {
3620 part = part.toLowerCase();
3621 }
3623 for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
3624 if ( (elem = checkSet[i]) ) {
3625 while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
3627 checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
3628 elem || false :
3629 elem === part;
3630 }
3631 }
3633 if ( isPartStrNotTag ) {
3634 Sizzle.filter( part, checkSet, true );
3635 }
3636 },
3638 ">": function( checkSet, part ) {
3639 var elem,
3640 isPartStr = typeof part === "string",
3641 i = 0,
3642 l = checkSet.length;
3644 if ( isPartStr && !/\W/.test( part ) ) {
3645 part = part.toLowerCase();
3647 for ( ; i < l; i++ ) {
3648 elem = checkSet[i];
3650 if ( elem ) {
3651 var parent = elem.parentNode;
3652 checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
3653 }
3654 }
3656 } else {
3657 for ( ; i < l; i++ ) {
3658 elem = checkSet[i];
3660 if ( elem ) {
3661 checkSet[i] = isPartStr ?
3662 elem.parentNode :
3663 elem.parentNode === part;
3664 }
3665 }
3667 if ( isPartStr ) {
3668 Sizzle.filter( part, checkSet, true );
3669 }
3670 }
3671 },
3673 "": function(checkSet, part, isXML){
3674 var nodeCheck,
3675 doneName = done++,
3676 checkFn = dirCheck;
3678 if ( typeof part === "string" && !/\W/.test(part) ) {
3679 part = part.toLowerCase();
3680 nodeCheck = part;
3681 checkFn = dirNodeCheck;
3682 }
3684 checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
3685 },
3687 "~": function( checkSet, part, isXML ) {
3688 var nodeCheck,
3689 doneName = done++,
3690 checkFn = dirCheck;
3692 if ( typeof part === "string" && !/\W/.test( part ) ) {
3693 part = part.toLowerCase();
3694 nodeCheck = part;
3695 checkFn = dirNodeCheck;
3696 }
3698 checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
3699 }
3700 },
3702 find: {
3703 ID: function( match, context, isXML ) {
3704 if ( typeof context.getElementById !== "undefined" && !isXML ) {
3705 var m = context.getElementById(match[1]);
3706 // Check parentNode to catch when Blackberry 4.6 returns
3707 // nodes that are no longer in the document #6963
3708 return m && m.parentNode ? [m] : [];
3709 }
3710 },
3712 NAME: function( match, context ) {
3713 if ( typeof context.getElementsByName !== "undefined" ) {
3714 var ret = [],
3715 results = context.getElementsByName( match[1] );
3717 for ( var i = 0, l = results.length; i < l; i++ ) {
3718 if ( results[i].getAttribute("name") === match[1] ) {
3719 ret.push( results[i] );
3720 }
3721 }
3723 return ret.length === 0 ? null : ret;
3724 }
3725 },
3727 TAG: function( match, context ) {
3728 if ( typeof context.getElementsByTagName !== "undefined" ) {
3729 return context.getElementsByTagName( match[1] );
3730 }
3731 }
3732 },
3733 preFilter: {
3734 CLASS: function( match, curLoop, inplace, result, not, isXML ) {
3735 match = " " + match[1].replace(/\\/g, "") + " ";
3737 if ( isXML ) {
3738 return match;
3739 }
3741 for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
3742 if ( elem ) {
3743 if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
3744 if ( !inplace ) {
3745 result.push( elem );
3746 }
3748 } else if ( inplace ) {
3749 curLoop[i] = false;
3750 }
3751 }
3752 }
3754 return false;
3755 },
3757 ID: function( match ) {
3758 return match[1].replace(/\\/g, "");
3759 },
3761 TAG: function( match, curLoop ) {
3762 return match[1].toLowerCase();
3763 },
3765 CHILD: function( match ) {
3766 if ( match[1] === "nth" ) {
3767 if ( !match[2] ) {
3768 Sizzle.error( match[0] );
3769 }
3771 match[2] = match[2].replace(/^\+|\s*/g, '');
3773 // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
3774 var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
3775 match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
3776 !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
3778 // calculate the numbers (first)n+(last) including if they are negative
3779 match[2] = (test[1] + (test[2] || 1)) - 0;
3780 match[3] = test[3] - 0;
3781 }
3782 else if ( match[2] ) {
3783 Sizzle.error( match[0] );
3784 }
3786 // TODO: Move to normal caching system
3787 match[0] = done++;
3789 return match;
3790 },
3792 ATTR: function( match, curLoop, inplace, result, not, isXML ) {
3793 var name = match[1] = match[1].replace(/\\/g, "");
3795 if ( !isXML && Expr.attrMap[name] ) {
3796 match[1] = Expr.attrMap[name];
3797 }
3799 // Handle if an un-quoted value was used
3800 match[4] = ( match[4] || match[5] || "" ).replace(/\\/g, "");
3802 if ( match[2] === "~=" ) {
3803 match[4] = " " + match[4] + " ";
3804 }
3806 return match;
3807 },
3809 PSEUDO: function( match, curLoop, inplace, result, not ) {
3810 if ( match[1] === "not" ) {
3811 // If we're dealing with a complex expression, or a simple one
3812 if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
3813 match[3] = Sizzle(match[3], null, null, curLoop);
3815 } else {
3816 var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
3818 if ( !inplace ) {
3819 result.push.apply( result, ret );
3820 }
3822 return false;
3823 }
3825 } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
3826 return true;
3827 }
3829 return match;
3830 },
3832 POS: function( match ) {
3833 match.unshift( true );
3835 return match;
3836 }
3837 },
3839 filters: {
3840 enabled: function( elem ) {
3841 return elem.disabled === false && elem.type !== "hidden";
3842 },
3844 disabled: function( elem ) {
3845 return elem.disabled === true;
3846 },
3848 checked: function( elem ) {
3849 return elem.checked === true;
3850 },
3852 selected: function( elem ) {
3853 // Accessing this property makes selected-by-default
3854 // options in Safari work properly
3855 elem.parentNode.selectedIndex;
3857 return elem.selected === true;
3858 },
3860 parent: function( elem ) {
3861 return !!elem.firstChild;
3862 },
3864 empty: function( elem ) {
3865 return !elem.firstChild;
3866 },
3868 has: function( elem, i, match ) {
3869 return !!Sizzle( match[3], elem ).length;
3870 },
3872 header: function( elem ) {
3873 return (/h\d/i).test( elem.nodeName );
3874 },
3876 text: function( elem ) {
3877 return "text" === elem.type;
3878 },
3879 radio: function( elem ) {
3880 return "radio" === elem.type;
3881 },
3883 checkbox: function( elem ) {
3884 return "checkbox" === elem.type;
3885 },
3887 file: function( elem ) {
3888 return "file" === elem.type;
3889 },
3890 password: function( elem ) {
3891 return "password" === elem.type;
3892 },
3894 submit: function( elem ) {
3895 return "submit" === elem.type;
3896 },
3898 image: function( elem ) {
3899 return "image" === elem.type;
3900 },
3902 reset: function( elem ) {
3903 return "reset" === elem.type;
3904 },
3906 button: function( elem ) {
3907 return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
3908 },
3910 input: function( elem ) {
3911 return (/input|select|textarea|button/i).test( elem.nodeName );
3912 }
3913 },
3914 setFilters: {
3915 first: function( elem, i ) {
3916 return i === 0;
3917 },
3919 last: function( elem, i, match, array ) {
3920 return i === array.length - 1;
3921 },
3923 even: function( elem, i ) {
3924 return i % 2 === 0;
3925 },
3927 odd: function( elem, i ) {
3928 return i % 2 === 1;
3929 },
3931 lt: function( elem, i, match ) {
3932 return i < match[3] - 0;
3933 },
3935 gt: function( elem, i, match ) {
3936 return i > match[3] - 0;
3937 },
3939 nth: function( elem, i, match ) {
3940 return match[3] - 0 === i;
3941 },
3943 eq: function( elem, i, match ) {
3944 return match[3] - 0 === i;
3945 }
3946 },
3947 filter: {
3948 PSEUDO: function( elem, match, i, array ) {
3949 var name = match[1],
3950 filter = Expr.filters[ name ];
3952 if ( filter ) {
3953 return filter( elem, i, match, array );
3955 } else if ( name === "contains" ) {
3956 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
3958 } else if ( name === "not" ) {
3959 var not = match[3];
3961 for ( var j = 0, l = not.length; j < l; j++ ) {
3962 if ( not[j] === elem ) {
3963 return false;
3964 }
3965 }
3967 return true;
3969 } else {
3970 Sizzle.error( name );
3971 }
3972 },
3974 CHILD: function( elem, match ) {
3975 var type = match[1],
3976 node = elem;
3978 switch ( type ) {
3979 case "only":
3980 case "first":
3981 while ( (node = node.previousSibling) ) {
3982 if ( node.nodeType === 1 ) {
3983 return false;
3984 }
3985 }
3987 if ( type === "first" ) {
3988 return true;
3989 }
3991 node = elem;
3993 case "last":
3994 while ( (node = node.nextSibling) ) {
3995 if ( node.nodeType === 1 ) {
3996 return false;
3997 }
3998 }
4000 return true;
4002 case "nth":
4003 var first = match[2],
4004 last = match[3];
4006 if ( first === 1 && last === 0 ) {
4007 return true;
4008 }
4010 var doneName = match[0],
4011 parent = elem.parentNode;
4013 if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
4014 var count = 0;
4016 for ( node = parent.firstChild; node; node = node.nextSibling ) {
4017 if ( node.nodeType === 1 ) {
4018 node.nodeIndex = ++count;
4019 }
4020 }
4022 parent.sizcache = doneName;
4023 }
4025 var diff = elem.nodeIndex - last;
4027 if ( first === 0 ) {
4028 return diff === 0;
4030 } else {
4031 return ( diff % first === 0 && diff / first >= 0 );
4032 }
4033 }
4034 },
4036 ID: function( elem, match ) {
4037 return elem.nodeType === 1 && elem.getAttribute("id") === match;
4038 },
4040 TAG: function( elem, match ) {
4041 return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
4042 },
4044 CLASS: function( elem, match ) {
4045 return (" " + (elem.className || elem.getAttribute("class")) + " ")
4046 .indexOf( match ) > -1;
4047 },
4049 ATTR: function( elem, match ) {
4050 var name = match[1],
4051 result = Expr.attrHandle[ name ] ?
4052 Expr.attrHandle[ name ]( elem ) :
4053 elem[ name ] != null ?
4054 elem[ name ] :
4055 elem.getAttribute( name ),
4056 value = result + "",
4057 type = match[2],
4058 check = match[4];
4060 return result == null ?
4061 type === "!=" :
4062 type === "=" ?
4063 value === check :
4064 type === "*=" ?
4065 value.indexOf(check) >= 0 :
4066 type === "~=" ?
4067 (" " + value + " ").indexOf(check) >= 0 :
4068 !check ?
4069 value && result !== false :
4070 type === "!=" ?
4071 value !== check :
4072 type === "^=" ?
4073 value.indexOf(check) === 0 :
4074 type === "$=" ?
4075 value.substr(value.length - check.length) === check :
4076 type === "|=" ?
4077 value === check || value.substr(0, check.length + 1) === check + "-" :
4078 false;
4079 },
4081 POS: function( elem, match, i, array ) {
4082 var name = match[2],
4083 filter = Expr.setFilters[ name ];
4085 if ( filter ) {
4086 return filter( elem, i, match, array );
4087 }
4088 }
4089 }
4090 };
4092 var origPOS = Expr.match.POS,
4093 fescape = function(all, num){
4094 return "\\" + (num - 0 + 1);
4095 };
4097 for ( var type in Expr.match ) {
4098 Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
4099 Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
4100 }
4102 var makeArray = function( array, results ) {
4103 array = Array.prototype.slice.call( array, 0 );
4105 if ( results ) {
4106 results.push.apply( results, array );
4107 return results;
4108 }
4110 return array;
4111 };
4113 // Perform a simple check to determine if the browser is capable of
4114 // converting a NodeList to an array using builtin methods.
4115 // Also verifies that the returned array holds DOM nodes
4116 // (which is not the case in the Blackberry browser)
4117 try {
4118 Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
4120 // Provide a fallback method if it does not work
4121 } catch( e ) {
4122 makeArray = function( array, results ) {
4123 var i = 0,
4124 ret = results || [];
4126 if ( toString.call(array) === "[object Array]" ) {
4127 Array.prototype.push.apply( ret, array );
4129 } else {
4130 if ( typeof array.length === "number" ) {
4131 for ( var l = array.length; i < l; i++ ) {
4132 ret.push( array[i] );
4133 }
4135 } else {
4136 for ( ; array[i]; i++ ) {
4137 ret.push( array[i] );
4138 }
4139 }
4140 }
4142 return ret;
4143 };
4144 }
4146 var sortOrder, siblingCheck;
4148 if ( document.documentElement.compareDocumentPosition ) {
4149 sortOrder = function( a, b ) {
4150 if ( a === b ) {
4151 hasDuplicate = true;
4152 return 0;
4153 }
4155 if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
4156 return a.compareDocumentPosition ? -1 : 1;
4157 }
4159 return a.compareDocumentPosition(b) & 4 ? -1 : 1;
4160 };
4162 } else {
4163 sortOrder = function( a, b ) {
4164 var al, bl,
4165 ap = [],
4166 bp = [],
4167 aup = a.parentNode,
4168 bup = b.parentNode,
4169 cur = aup;
4171 // The nodes are identical, we can exit early
4172 if ( a === b ) {
4173 hasDuplicate = true;
4174 return 0;
4176 // If the nodes are siblings (or identical) we can do a quick check
4177 } else if ( aup === bup ) {
4178 return siblingCheck( a, b );
4180 // If no parents were found then the nodes are disconnected
4181 } else if ( !aup ) {
4182 return -1;
4184 } else if ( !bup ) {
4185 return 1;
4186 }
4188 // Otherwise they're somewhere else in the tree so we need
4189 // to build up a full list of the parentNodes for comparison
4190 while ( cur ) {
4191 ap.unshift( cur );
4192 cur = cur.parentNode;
4193 }
4195 cur = bup;
4197 while ( cur ) {
4198 bp.unshift( cur );
4199 cur = cur.parentNode;
4200 }
4202 al = ap.length;
4203 bl = bp.length;
4205 // Start walking down the tree looking for a discrepancy
4206 for ( var i = 0; i < al && i < bl; i++ ) {
4207 if ( ap[i] !== bp[i] ) {
4208 return siblingCheck( ap[i], bp[i] );
4209 }
4210 }
4212 // We ended someplace up the tree so do a sibling check
4213 return i === al ?
4214 siblingCheck( a, bp[i], -1 ) :
4215 siblingCheck( ap[i], b, 1 );
4216 };
4218 siblingCheck = function( a, b, ret ) {
4219 if ( a === b ) {
4220 return ret;
4221 }
4223 var cur = a.nextSibling;
4225 while ( cur ) {
4226 if ( cur === b ) {
4227 return -1;
4228 }
4230 cur = cur.nextSibling;
4231 }
4233 return 1;
4234 };
4235 }
4237 // Utility function for retreiving the text value of an array of DOM nodes
4238 Sizzle.getText = function( elems ) {
4239 var ret = "", elem;
4241 for ( var i = 0; elems[i]; i++ ) {
4242 elem = elems[i];
4244 // Get the text from text nodes and CDATA nodes
4245 if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
4246 ret += elem.nodeValue;
4248 // Traverse everything else, except comment nodes
4249 } else if ( elem.nodeType !== 8 ) {
4250 ret += Sizzle.getText( elem.childNodes );
4251 }
4252 }
4254 return ret;
4255 };
4257 // Check to see if the browser returns elements by name when
4258 // querying by getElementById (and provide a workaround)
4259 (function(){
4260 // We're going to inject a fake input element with a specified name
4261 var form = document.createElement("div"),
4262 id = "script" + (new Date()).getTime(),
4263 root = document.documentElement;
4265 form.innerHTML = "<a name='" + id + "'/>";
4267 // Inject it into the root element, check its status, and remove it quickly
4268 root.insertBefore( form, root.firstChild );
4270 // The workaround has to do additional checks after a getElementById
4271 // Which slows things down for other browsers (hence the branching)
4272 if ( document.getElementById( id ) ) {
4273 Expr.find.ID = function( match, context, isXML ) {
4274 if ( typeof context.getElementById !== "undefined" && !isXML ) {
4275 var m = context.getElementById(match[1]);
4277 return m ?
4278 m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
4279 [m] :
4280 undefined :
4281 [];
4282 }
4283 };
4285 Expr.filter.ID = function( elem, match ) {
4286 var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
4288 return elem.nodeType === 1 && node && node.nodeValue === match;
4289 };
4290 }
4292 root.removeChild( form );
4294 // release memory in IE
4295 root = form = null;
4296 })();
4298 (function(){
4299 // Check to see if the browser returns only elements
4300 // when doing getElementsByTagName("*")
4302 // Create a fake element
4303 var div = document.createElement("div");
4304 div.appendChild( document.createComment("") );
4306 // Make sure no comments are found
4307 if ( div.getElementsByTagName("*").length > 0 ) {
4308 Expr.find.TAG = function( match, context ) {
4309 var results = context.getElementsByTagName( match[1] );
4311 // Filter out possible comments
4312 if ( match[1] === "*" ) {
4313 var tmp = [];
4315 for ( var i = 0; results[i]; i++ ) {
4316 if ( results[i].nodeType === 1 ) {
4317 tmp.push( results[i] );
4318 }
4319 }
4321 results = tmp;
4322 }
4324 return results;
4325 };
4326 }
4328 // Check to see if an attribute returns normalized href attributes
4329 div.innerHTML = "<a href='#'></a>";
4331 if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
4332 div.firstChild.getAttribute("href") !== "#" ) {
4334 Expr.attrHandle.href = function( elem ) {
4335 return elem.getAttribute( "href", 2 );
4336 };
4337 }
4339 // release memory in IE
4340 div = null;
4341 })();
4343 if ( document.querySelectorAll ) {
4344 (function(){
4345 var oldSizzle = Sizzle,
4346 div = document.createElement("div"),
4347 id = "__sizzle__";
4349 div.innerHTML = "<p class='TEST'></p>";
4351 // Safari can't handle uppercase or unicode characters when
4352 // in quirks mode.
4353 if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
4354 return;
4355 }
4357 Sizzle = function( query, context, extra, seed ) {
4358 context = context || document;
4360 // Only use querySelectorAll on non-XML documents
4361 // (ID selectors don't work in non-HTML documents)
4362 if ( !seed && !Sizzle.isXML(context) ) {
4363 // See if we find a selector to speed up
4364 var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
4366 if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
4367 // Speed-up: Sizzle("TAG")
4368 if ( match[1] ) {
4369 return makeArray( context.getElementsByTagName( query ), extra );
4371 // Speed-up: Sizzle(".CLASS")
4372 } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
4373 return makeArray( context.getElementsByClassName( match[2] ), extra );
4374 }
4375 }
4377 if ( context.nodeType === 9 ) {
4378 // Speed-up: Sizzle("body")
4379 // The body element only exists once, optimize finding it
4380 if ( query === "body" && context.body ) {
4381 return makeArray( [ context.body ], extra );
4383 // Speed-up: Sizzle("#ID")
4384 } else if ( match && match[3] ) {
4385 var elem = context.getElementById( match[3] );
4387 // Check parentNode to catch when Blackberry 4.6 returns
4388 // nodes that are no longer in the document #6963
4389 if ( elem && elem.parentNode ) {
4390 // Handle the case where IE and Opera return items
4391 // by name instead of ID
4392 if ( elem.id === match[3] ) {
4393 return makeArray( [ elem ], extra );
4394 }
4396 } else {
4397 return makeArray( [], extra );
4398 }
4399 }
4401 try {
4402 return makeArray( context.querySelectorAll(query), extra );
4403 } catch(qsaError) {}
4405 // qSA works strangely on Element-rooted queries
4406 // We can work around this by specifying an extra ID on the root
4407 // and working up from there (Thanks to Andrew Dupont for the technique)
4408 // IE 8 doesn't work on object elements
4409 } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
4410 var old = context.getAttribute( "id" ),
4411 nid = old || id,
4412 hasParent = context.parentNode,
4413 relativeHierarchySelector = /^\s*[+~]/.test( query );
4415 if ( !old ) {
4416 context.setAttribute( "id", nid );
4417 } else {
4418 nid = nid.replace( /'/g, "\\$&" );
4419 }
4420 if ( relativeHierarchySelector && hasParent ) {
4421 context = context.parentNode;
4422 }
4424 try {
4425 if ( !relativeHierarchySelector || hasParent ) {
4426 return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
4427 }
4429 } catch(pseudoError) {
4430 } finally {
4431 if ( !old ) {
4432 context.removeAttribute( "id" );
4433 }
4434 }
4435 }
4436 }
4438 return oldSizzle(query, context, extra, seed);
4439 };
4441 for ( var prop in oldSizzle ) {
4442 Sizzle[ prop ] = oldSizzle[ prop ];
4443 }
4445 // release memory in IE
4446 div = null;
4447 })();
4448 }
4450 (function(){
4451 var html = document.documentElement,
4452 matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector,
4453 pseudoWorks = false;
4455 try {
4456 // This should fail with an exception
4457 // Gecko does not error, returns false instead
4458 matches.call( document.documentElement, "[test!='']:sizzle" );
4460 } catch( pseudoError ) {
4461 pseudoWorks = true;
4462 }
4464 if ( matches ) {
4465 Sizzle.matchesSelector = function( node, expr ) {
4466 // Make sure that attribute selectors are quoted
4467 expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
4469 if ( !Sizzle.isXML( node ) ) {
4470 try {
4471 if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
4472 return matches.call( node, expr );
4473 }
4474 } catch(e) {}
4475 }
4477 return Sizzle(expr, null, null, [node]).length > 0;
4478 };
4479 }
4480 })();
4482 (function(){
4483 var div = document.createElement("div");
4485 div.innerHTML = "<div class='test e'></div><div class='test'></div>";
4487 // Opera can't find a second classname (in 9.6)
4488 // Also, make sure that getElementsByClassName actually exists
4489 if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
4490 return;
4491 }
4493 // Safari caches class attributes, doesn't catch changes (in 3.2)
4494 div.lastChild.className = "e";
4496 if ( div.getElementsByClassName("e").length === 1 ) {
4497 return;
4498 }
4500 Expr.order.splice(1, 0, "CLASS");
4501 Expr.find.CLASS = function( match, context, isXML ) {
4502 if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
4503 return context.getElementsByClassName(match[1]);
4504 }
4505 };
4507 // release memory in IE
4508 div = null;
4509 })();
4511 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
4512 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
4513 var elem = checkSet[i];
4515 if ( elem ) {
4516 var match = false;
4518 elem = elem[dir];
4520 while ( elem ) {
4521 if ( elem.sizcache === doneName ) {
4522 match = checkSet[elem.sizset];
4523 break;
4524 }
4526 if ( elem.nodeType === 1 && !isXML ){
4527 elem.sizcache = doneName;
4528 elem.sizset = i;
4529 }
4531 if ( elem.nodeName.toLowerCase() === cur ) {
4532 match = elem;
4533 break;
4534 }
4536 elem = elem[dir];
4537 }
4539 checkSet[i] = match;
4540 }
4541 }
4542 }
4544 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
4545 for ( var i = 0, l = checkSet.length; i < l; i++ ) {
4546 var elem = checkSet[i];
4548 if ( elem ) {
4549 var match = false;
4551 elem = elem[dir];
4553 while ( elem ) {
4554 if ( elem.sizcache === doneName ) {
4555 match = checkSet[elem.sizset];
4556 break;
4557 }
4559 if ( elem.nodeType === 1 ) {
4560 if ( !isXML ) {
4561 elem.sizcache = doneName;
4562 elem.sizset = i;
4563 }
4565 if ( typeof cur !== "string" ) {
4566 if ( elem === cur ) {
4567 match = true;
4568 break;
4569 }
4571 } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
4572 match = elem;
4573 break;
4574 }
4575 }
4577 elem = elem[dir];
4578 }
4580 checkSet[i] = match;
4581 }
4582 }
4583 }
4585 if ( document.documentElement.contains ) {
4586 Sizzle.contains = function( a, b ) {
4587 return a !== b && (a.contains ? a.contains(b) : true);
4588 };
4590 } else if ( document.documentElement.compareDocumentPosition ) {
4591 Sizzle.contains = function( a, b ) {
4592 return !!(a.compareDocumentPosition(b) & 16);
4593 };
4595 } else {
4596 Sizzle.contains = function() {
4597 return false;
4598 };
4599 }
4601 Sizzle.isXML = function( elem ) {
4602 // documentElement is verified for cases where it doesn't yet exist
4603 // (such as loading iframes in IE - #4833)
4604 var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
4606 return documentElement ? documentElement.nodeName !== "HTML" : false;
4607 };
4609 var posProcess = function( selector, context ) {
4610 var match,
4611 tmpSet = [],
4612 later = "",
4613 root = context.nodeType ? [context] : context;
4615 // Position selectors must be done after the filter
4616 // And so must :not(positional) so we move all PSEUDOs to the end
4617 while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
4618 later += match[0];
4619 selector = selector.replace( Expr.match.PSEUDO, "" );
4620 }
4622 selector = Expr.relative[selector] ? selector + "*" : selector;
4624 for ( var i = 0, l = root.length; i < l; i++ ) {
4625 Sizzle( selector, root[i], tmpSet );
4626 }
4628 return Sizzle.filter( later, tmpSet );
4629 };
4631 // EXPOSE
4632 jQuery.find = Sizzle;
4633 jQuery.expr = Sizzle.selectors;
4634 jQuery.expr[":"] = jQuery.expr.filters;
4635 jQuery.unique = Sizzle.uniqueSort;
4636 jQuery.text = Sizzle.getText;
4637 jQuery.isXMLDoc = Sizzle.isXML;
4638 jQuery.contains = Sizzle.contains;
4641 })();
4644 var runtil = /Until$/,
4645 rparentsprev = /^(?:parents|prevUntil|prevAll)/,
4646 // Note: This RegExp should be improved, or likely pulled from Sizzle
4647 rmultiselector = /,/,
4648 isSimple = /^.[^:#\[\.,]*$/,
4649 slice = Array.prototype.slice,
4650 POS = jQuery.expr.match.POS,
4651 // methods guaranteed to produce a unique set when starting from a unique set
4652 guaranteedUnique = {
4653 children: true,
4654 contents: true,
4655 next: true,
4656 prev: true
4657 };
4659 jQuery.fn.extend({
4660 find: function( selector ) {
4661 var ret = this.pushStack( "", "find", selector ),
4662 length = 0;
4664 for ( var i = 0, l = this.length; i < l; i++ ) {
4665 length = ret.length;
4666 jQuery.find( selector, this[i], ret );
4668 if ( i > 0 ) {
4669 // Make sure that the results are unique
4670 for ( var n = length; n < ret.length; n++ ) {
4671 for ( var r = 0; r < length; r++ ) {
4672 if ( ret[r] === ret[n] ) {
4673 ret.splice(n--, 1);
4674 break;
4675 }
4676 }
4677 }
4678 }
4679 }
4681 return ret;
4682 },
4684 has: function( target ) {
4685 var targets = jQuery( target );
4686 return this.filter(function() {
4687 for ( var i = 0, l = targets.length; i < l; i++ ) {
4688 if ( jQuery.contains( this, targets[i] ) ) {
4689 return true;
4690 }
4691 }
4692 });
4693 },
4695 not: function( selector ) {
4696 return this.pushStack( winnow(this, selector, false), "not", selector);
4697 },
4699 filter: function( selector ) {
4700 return this.pushStack( winnow(this, selector, true), "filter", selector );
4701 },
4703 is: function( selector ) {
4704 return !!selector && jQuery.filter( selector, this ).length > 0;
4705 },
4707 closest: function( selectors, context ) {
4708 var ret = [], i, l, cur = this[0];
4710 if ( jQuery.isArray( selectors ) ) {
4711 var match, selector,
4712 matches = {},
4713 level = 1;
4715 if ( cur && selectors.length ) {
4716 for ( i = 0, l = selectors.length; i < l; i++ ) {
4717 selector = selectors[i];
4719 if ( !matches[selector] ) {
4720 matches[selector] = jQuery.expr.match.POS.test( selector ) ?
4721 jQuery( selector, context || this.context ) :
4722 selector;
4723 }
4724 }
4726 while ( cur && cur.ownerDocument && cur !== context ) {
4727 for ( selector in matches ) {
4728 match = matches[selector];
4730 if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
4731 ret.push({ selector: selector, elem: cur, level: level });
4732 }
4733 }
4735 cur = cur.parentNode;
4736 level++;
4737 }
4738 }
4740 return ret;
4741 }
4743 var pos = POS.test( selectors ) ?
4744 jQuery( selectors, context || this.context ) : null;
4746 for ( i = 0, l = this.length; i < l; i++ ) {
4747 cur = this[i];
4749 while ( cur ) {
4750 if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
4751 ret.push( cur );
4752 break;
4754 } else {
4755 cur = cur.parentNode;
4756 if ( !cur || !cur.ownerDocument || cur === context ) {
4757 break;
4758 }
4759 }
4760 }
4761 }
4763 ret = ret.length > 1 ? jQuery.unique(ret) : ret;
4765 return this.pushStack( ret, "closest", selectors );
4766 },
4768 // Determine the position of an element within
4769 // the matched set of elements
4770 index: function( elem ) {
4771 if ( !elem || typeof elem === "string" ) {
4772 return jQuery.inArray( this[0],
4773 // If it receives a string, the selector is used
4774 // If it receives nothing, the siblings are used
4775 elem ? jQuery( elem ) : this.parent().children() );
4776 }
4777 // Locate the position of the desired element
4778 return jQuery.inArray(
4779 // If it receives a jQuery object, the first element is used
4780 elem.jquery ? elem[0] : elem, this );
4781 },
4783 add: function( selector, context ) {
4784 var set = typeof selector === "string" ?
4785 jQuery( selector, context ) :
4786 jQuery.makeArray( selector ),
4787 all = jQuery.merge( this.get(), set );
4789 return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
4790 all :
4791 jQuery.unique( all ) );
4792 },
4794 andSelf: function() {
4795 return this.add( this.prevObject );
4796 }
4797 });
4799 // A painfully simple check to see if an element is disconnected
4800 // from a document (should be improved, where feasible).
4801 function isDisconnected( node ) {
4802 return !node || !node.parentNode || node.parentNode.nodeType === 11;
4803 }
4805 jQuery.each({
4806 parent: function( elem ) {
4807 var parent = elem.parentNode;
4808 return parent && parent.nodeType !== 11 ? parent : null;
4809 },
4810 parents: function( elem ) {
4811 return jQuery.dir( elem, "parentNode" );
4812 },
4813 parentsUntil: function( elem, i, until ) {
4814 return jQuery.dir( elem, "parentNode", until );
4815 },
4816 next: function( elem ) {
4817 return jQuery.nth( elem, 2, "nextSibling" );
4818 },
4819 prev: function( elem ) {
4820 return jQuery.nth( elem, 2, "previousSibling" );
4821 },
4822 nextAll: function( elem ) {
4823 return jQuery.dir( elem, "nextSibling" );
4824 },
4825 prevAll: function( elem ) {
4826 return jQuery.dir( elem, "previousSibling" );
4827 },
4828 nextUntil: function( elem, i, until ) {
4829 return jQuery.dir( elem, "nextSibling", until );
4830 },
4831 prevUntil: function( elem, i, until ) {
4832 return jQuery.dir( elem, "previousSibling", until );
4833 },
4834 siblings: function( elem ) {
4835 return jQuery.sibling( elem.parentNode.firstChild, elem );
4836 },
4837 children: function( elem ) {
4838 return jQuery.sibling( elem.firstChild );
4839 },
4840 contents: function( elem ) {
4841 return jQuery.nodeName( elem, "iframe" ) ?
4842 elem.contentDocument || elem.contentWindow.document :
4843 jQuery.makeArray( elem.childNodes );
4844 }
4845 }, function( name, fn ) {
4846 jQuery.fn[ name ] = function( until, selector ) {
4847 var ret = jQuery.map( this, fn, until ),
4848 // The variable 'args' was introduced in
4849 // https://github.com/jquery/jquery/commit/52a0238
4850 // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
4851 // http://code.google.com/p/v8/issues/detail?id=1050
4852 args = slice.call(arguments);
4854 if ( !runtil.test( name ) ) {
4855 selector = until;
4856 }
4858 if ( selector && typeof selector === "string" ) {
4859 ret = jQuery.filter( selector, ret );
4860 }
4862 ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
4864 if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
4865 ret = ret.reverse();
4866 }
4868 return this.pushStack( ret, name, args.join(",") );
4869 };
4870 });
4872 jQuery.extend({
4873 filter: function( expr, elems, not ) {
4874 if ( not ) {
4875 expr = ":not(" + expr + ")";
4876 }
4878 return elems.length === 1 ?
4879 jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
4880 jQuery.find.matches(expr, elems);
4881 },
4883 dir: function( elem, dir, until ) {
4884 var matched = [],
4885 cur = elem[ dir ];
4887 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
4888 if ( cur.nodeType === 1 ) {
4889 matched.push( cur );
4890 }
4891 cur = cur[dir];
4892 }
4893 return matched;
4894 },
4896 nth: function( cur, result, dir, elem ) {
4897 result = result || 1;
4898 var num = 0;
4900 for ( ; cur; cur = cur[dir] ) {
4901 if ( cur.nodeType === 1 && ++num === result ) {
4902 break;
4903 }
4904 }
4906 return cur;
4907 },
4909 sibling: function( n, elem ) {
4910 var r = [];
4912 for ( ; n; n = n.nextSibling ) {
4913 if ( n.nodeType === 1 && n !== elem ) {
4914 r.push( n );
4915 }
4916 }
4918 return r;
4919 }
4920 });
4922 // Implement the identical functionality for filter and not
4923 function winnow( elements, qualifier, keep ) {
4924 if ( jQuery.isFunction( qualifier ) ) {
4925 return jQuery.grep(elements, function( elem, i ) {
4926 var retVal = !!qualifier.call( elem, i, elem );
4927 return retVal === keep;
4928 });
4930 } else if ( qualifier.nodeType ) {
4931 return jQuery.grep(elements, function( elem, i ) {
4932 return (elem === qualifier) === keep;
4933 });
4935 } else if ( typeof qualifier === "string" ) {
4936 var filtered = jQuery.grep(elements, function( elem ) {
4937 return elem.nodeType === 1;
4938 });
4940 if ( isSimple.test( qualifier ) ) {
4941 return jQuery.filter(qualifier, filtered, !keep);
4942 } else {
4943 qualifier = jQuery.filter( qualifier, filtered );
4944 }
4945 }
4947 return jQuery.grep(elements, function( elem, i ) {
4948 return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
4949 });
4950 }
4955 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
4956 rleadingWhitespace = /^\s+/,
4957 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
4958 rtagName = /<([\w:]+)/,
4959 rtbody = /<tbody/i,
4960 rhtml = /<|&#?\w+;/,
4961 rnocache = /<(?:script|object|embed|option|style)/i,
4962 // checked="checked" or checked (html5)
4963 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
4964 wrapMap = {
4965 option: [ 1, "<select multiple='multiple'>", "</select>" ],
4966 legend: [ 1, "<fieldset>", "</fieldset>" ],
4967 thead: [ 1, "<table>", "</table>" ],
4968 tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4969 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4970 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
4971 area: [ 1, "<map>", "</map>" ],
4972 _default: [ 0, "", "" ]
4973 };
4975 wrapMap.optgroup = wrapMap.option;
4976 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4977 wrapMap.th = wrapMap.td;
4979 // IE can't serialize <link> and <script> tags normally
4980 if ( !jQuery.support.htmlSerialize ) {
4981 wrapMap._default = [ 1, "div<div>", "</div>" ];
4982 }
4984 jQuery.fn.extend({
4985 text: function( text ) {
4986 if ( jQuery.isFunction(text) ) {
4987 return this.each(function(i) {
4988 var self = jQuery( this );
4990 self.text( text.call(this, i, self.text()) );
4991 });
4992 }
4994 if ( typeof text !== "object" && text !== undefined ) {
4995 return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
4996 }
4998 return jQuery.text( this );
4999 },
5001 wrapAll: function( html ) {
5002 if ( jQuery.isFunction( html ) ) {
5003 return this.each(function(i) {
5004 jQuery(this).wrapAll( html.call(this, i) );
5005 });
5006 }
5008 if ( this[0] ) {
5009 // The elements to wrap the target around
5010 var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
5012 if ( this[0].parentNode ) {
5013 wrap.insertBefore( this[0] );
5014 }
5016 wrap.map(function() {
5017 var elem = this;
5019 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
5020 elem = elem.firstChild;
5021 }
5023 return elem;
5024 }).append(this);
5025 }
5027 return this;
5028 },
5030 wrapInner: function( html ) {
5031 if ( jQuery.isFunction( html ) ) {
5032 return this.each(function(i) {
5033 jQuery(this).wrapInner( html.call(this, i) );
5034 });
5035 }
5037 return this.each(function() {
5038 var self = jQuery( this ),
5039 contents = self.contents();
5041 if ( contents.length ) {
5042 contents.wrapAll( html );
5044 } else {
5045 self.append( html );
5046 }
5047 });
5048 },
5050 wrap: function( html ) {
5051 return this.each(function() {
5052 jQuery( this ).wrapAll( html );
5053 });
5054 },
5056 unwrap: function() {
5057 return this.parent().each(function() {
5058 if ( !jQuery.nodeName( this, "body" ) ) {
5059 jQuery( this ).replaceWith( this.childNodes );
5060 }
5061 }).end();
5062 },
5064 append: function() {
5065 return this.domManip(arguments, true, function( elem ) {
5066 if ( this.nodeType === 1 ) {
5067 this.appendChild( elem );
5068 }
5069 });
5070 },
5072 prepend: function() {
5073 return this.domManip(arguments, true, function( elem ) {
5074 if ( this.nodeType === 1 ) {
5075 this.insertBefore( elem, this.firstChild );
5076 }
5077 });
5078 },
5080 before: function() {
5081 if ( this[0] && this[0].parentNode ) {
5082 return this.domManip(arguments, false, function( elem ) {
5083 this.parentNode.insertBefore( elem, this );
5084 });
5085 } else if ( arguments.length ) {
5086 var set = jQuery(arguments[0]);
5087 set.push.apply( set, this.toArray() );
5088 return this.pushStack( set, "before", arguments );
5089 }
5090 },
5092 after: function() {
5093 if ( this[0] && this[0].parentNode ) {
5094 return this.domManip(arguments, false, function( elem ) {
5095 this.parentNode.insertBefore( elem, this.nextSibling );
5096 });
5097 } else if ( arguments.length ) {
5098 var set = this.pushStack( this, "after", arguments );
5099 set.push.apply( set, jQuery(arguments[0]).toArray() );
5100 return set;
5101 }
5102 },
5104 // keepData is for internal use only--do not document
5105 remove: function( selector, keepData ) {
5106 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5107 if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
5108 if ( !keepData && elem.nodeType === 1 ) {
5109 jQuery.cleanData( elem.getElementsByTagName("*") );
5110 jQuery.cleanData( [ elem ] );
5111 }
5113 if ( elem.parentNode ) {
5114 elem.parentNode.removeChild( elem );
5115 }
5116 }
5117 }
5119 return this;
5120 },
5122 empty: function() {
5123 for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
5124 // Remove element nodes and prevent memory leaks
5125 if ( elem.nodeType === 1 ) {
5126 jQuery.cleanData( elem.getElementsByTagName("*") );
5127 }
5129 // Remove any remaining nodes
5130 while ( elem.firstChild ) {
5131 elem.removeChild( elem.firstChild );
5132 }
5133 }
5135 return this;
5136 },
5138 clone: function( dataAndEvents, deepDataAndEvents ) {
5139 dataAndEvents = dataAndEvents == null ? true : dataAndEvents;
5140 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
5142 return this.map( function () {
5143 return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
5144 });
5145 },
5147 html: function( value ) {
5148 if ( value === undefined ) {
5149 return this[0] && this[0].nodeType === 1 ?
5150 this[0].innerHTML.replace(rinlinejQuery, "") :
5151 null;
5153 // See if we can take a shortcut and just use innerHTML
5154 } else if ( typeof value === "string" && !rnocache.test( value ) &&
5155 (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
5156 !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
5158 value = value.replace(rxhtmlTag, "<$1></$2>");
5160 try {
5161 for ( var i = 0, l = this.length; i < l; i++ ) {
5162 // Remove element nodes and prevent memory leaks
5163 if ( this[i].nodeType === 1 ) {
5164 jQuery.cleanData( this[i].getElementsByTagName("*") );
5165 this[i].innerHTML = value;
5166 }
5167 }
5169 // If using innerHTML throws an exception, use the fallback method
5170 } catch(e) {
5171 this.empty().append( value );
5172 }
5174 } else if ( jQuery.isFunction( value ) ) {
5175 this.each(function(i){
5176 var self = jQuery( this );
5178 self.html( value.call(this, i, self.html()) );
5179 });
5181 } else {
5182 this.empty().append( value );
5183 }
5185 return this;
5186 },
5188 replaceWith: function( value ) {
5189 if ( this[0] && this[0].parentNode ) {
5190 // Make sure that the elements are removed from the DOM before they are inserted
5191 // this can help fix replacing a parent with child elements
5192 if ( jQuery.isFunction( value ) ) {
5193 return this.each(function(i) {
5194 var self = jQuery(this), old = self.html();
5195 self.replaceWith( value.call( this, i, old ) );
5196 });
5197 }
5199 if ( typeof value !== "string" ) {
5200 value = jQuery( value ).detach();
5201 }
5203 return this.each(function() {
5204 var next = this.nextSibling,
5205 parent = this.parentNode;
5207 jQuery( this ).remove();
5209 if ( next ) {
5210 jQuery(next).before( value );
5211 } else {
5212 jQuery(parent).append( value );
5213 }
5214 });
5215 } else {
5216 return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
5217 }
5218 },
5220 detach: function( selector ) {
5221 return this.remove( selector, true );
5222 },
5224 domManip: function( args, table, callback ) {
5225 var results, first, fragment, parent,
5226 value = args[0],
5227 scripts = [];
5229 // We can't cloneNode fragments that contain checked, in WebKit
5230 if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
5231 return this.each(function() {
5232 jQuery(this).domManip( args, table, callback, true );
5233 });
5234 }
5236 if ( jQuery.isFunction(value) ) {
5237 return this.each(function(i) {
5238 var self = jQuery(this);
5239 args[0] = value.call(this, i, table ? self.html() : undefined);
5240 self.domManip( args, table, callback );
5241 });
5242 }
5244 if ( this[0] ) {
5245 parent = value && value.parentNode;
5247 // If we're in a fragment, just use that instead of building a new one
5248 if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
5249 results = { fragment: parent };
5251 } else {
5252 results = jQuery.buildFragment( args, this, scripts );
5253 }
5255 fragment = results.fragment;
5257 if ( fragment.childNodes.length === 1 ) {
5258 first = fragment = fragment.firstChild;
5259 } else {
5260 first = fragment.firstChild;
5261 }
5263 if ( first ) {
5264 table = table && jQuery.nodeName( first, "tr" );
5266 for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
5267 callback.call(
5268 table ?
5269 root(this[i], first) :
5270 this[i],
5271 // Make sure that we do not leak memory by inadvertently discarding
5272 // the original fragment (which might have attached data) instead of
5273 // using it; in addition, use the original fragment object for the last
5274 // item instead of first because it can end up being emptied incorrectly
5275 // in certain situations (Bug #8070).
5276 // Fragments from the fragment cache must always be cloned and never used
5277 // in place.
5278 results.cacheable || (l > 1 && i < lastIndex) ?
5279 jQuery.clone( fragment, true, true ) :
5280 fragment
5281 );
5282 }
5283 }
5285 if ( scripts.length ) {
5286 jQuery.each( scripts, evalScript );
5287 }
5288 }
5290 return this;
5291 }
5292 });
5294 function root( elem, cur ) {
5295 return jQuery.nodeName(elem, "table") ?
5296 (elem.getElementsByTagName("tbody")[0] ||
5297 elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
5298 elem;
5299 }
5301 function cloneCopyEvent( src, dest ) {
5303 if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
5304 return;
5305 }
5307 var internalKey = jQuery.expando,
5308 oldData = jQuery.data( src ),
5309 curData = jQuery.data( dest, oldData );
5311 // Switch to use the internal data object, if it exists, for the next
5312 // stage of data copying
5313 if ( (oldData = oldData[ internalKey ]) ) {
5314 var events = oldData.events;
5315 curData = curData[ internalKey ] = jQuery.extend({}, oldData);
5317 if ( events ) {
5318 delete curData.handle;
5319 curData.events = {};
5321 for ( var type in events ) {
5322 for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
5323 jQuery.event.add( dest, type, events[ type ][ i ], events[ type ][ i ].data );
5324 }
5325 }
5326 }
5327 }
5328 }
5330 function cloneFixAttributes(src, dest) {
5331 // We do not need to do anything for non-Elements
5332 if ( dest.nodeType !== 1 ) {
5333 return;
5334 }
5336 var nodeName = dest.nodeName.toLowerCase();
5338 // clearAttributes removes the attributes, which we don't want,
5339 // but also removes the attachEvent events, which we *do* want
5340 dest.clearAttributes();
5342 // mergeAttributes, in contrast, only merges back on the
5343 // original attributes, not the events
5344 dest.mergeAttributes(src);
5346 // IE6-8 fail to clone children inside object elements that use
5347 // the proprietary classid attribute value (rather than the type
5348 // attribute) to identify the type of content to display
5349 if ( nodeName === "object" ) {
5350 dest.outerHTML = src.outerHTML;
5352 } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
5353 // IE6-8 fails to persist the checked state of a cloned checkbox
5354 // or radio button. Worse, IE6-7 fail to give the cloned element
5355 // a checked appearance if the defaultChecked value isn't also set
5356 if ( src.checked ) {
5357 dest.defaultChecked = dest.checked = src.checked;
5358 }
5360 // IE6-7 get confused and end up setting the value of a cloned
5361 // checkbox/radio button to an empty string instead of "on"
5362 if ( dest.value !== src.value ) {
5363 dest.value = src.value;
5364 }
5366 // IE6-8 fails to return the selected option to the default selected
5367 // state when cloning options
5368 } else if ( nodeName === "option" ) {
5369 dest.selected = src.defaultSelected;
5371 // IE6-8 fails to set the defaultValue to the correct value when
5372 // cloning other types of input fields
5373 } else if ( nodeName === "input" || nodeName === "textarea" ) {
5374 dest.defaultValue = src.defaultValue;
5375 }
5377 // Event data gets referenced instead of copied if the expando
5378 // gets copied too
5379 dest.removeAttribute( jQuery.expando );
5380 }
5382 jQuery.buildFragment = function( args, nodes, scripts ) {
5383 var fragment, cacheable, cacheresults,
5384 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
5386 // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
5387 // Cloning options loses the selected state, so don't cache them
5388 // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
5389 // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
5390 if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
5391 args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
5393 cacheable = true;
5394 cacheresults = jQuery.fragments[ args[0] ];
5395 if ( cacheresults ) {
5396 if ( cacheresults !== 1 ) {
5397 fragment = cacheresults;
5398 }
5399 }
5400 }
5402 if ( !fragment ) {
5403 fragment = doc.createDocumentFragment();
5404 jQuery.clean( args, doc, fragment, scripts );
5405 }
5407 if ( cacheable ) {
5408 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
5409 }
5411 return { fragment: fragment, cacheable: cacheable };
5412 };
5414 jQuery.fragments = {};
5416 jQuery.each({
5417 appendTo: "append",
5418 prependTo: "prepend",
5419 insertBefore: "before",
5420 insertAfter: "after",
5421 replaceAll: "replaceWith"
5422 }, function( name, original ) {
5423 jQuery.fn[ name ] = function( selector ) {
5424 var ret = [],
5425 insert = jQuery( selector ),
5426 parent = this.length === 1 && this[0].parentNode;
5428 if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
5429 insert[ original ]( this[0] );
5430 return this;
5432 } else {
5433 for ( var i = 0, l = insert.length; i < l; i++ ) {
5434 var elems = (i > 0 ? this.clone(true) : this).get();
5435 jQuery( insert[i] )[ original ]( elems );
5436 ret = ret.concat( elems );
5437 }
5439 return this.pushStack( ret, name, insert.selector );
5440 }
5441 };
5442 });
5444 jQuery.extend({
5445 clone: function( elem, dataAndEvents, deepDataAndEvents ) {
5446 var clone = elem.cloneNode(true),
5447 srcElements,
5448 destElements,
5449 i;
5451 if ( !jQuery.support.noCloneEvent && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
5452 // IE copies events bound via attachEvent when using cloneNode.
5453 // Calling detachEvent on the clone will also remove the events
5454 // from the original. In order to get around this, we use some
5455 // proprietary methods to clear the events. Thanks to MooTools
5456 // guys for this hotness.
5458 // Using Sizzle here is crazy slow, so we use getElementsByTagName
5459 // instead
5460 srcElements = elem.getElementsByTagName("*");
5461 destElements = clone.getElementsByTagName("*");
5463 // Weird iteration because IE will replace the length property
5464 // with an element if you are cloning the body and one of the
5465 // elements on the page has a name or id of "length"
5466 for ( i = 0; srcElements[i]; ++i ) {
5467 cloneFixAttributes( srcElements[i], destElements[i] );
5468 }
5470 cloneFixAttributes( elem, clone );
5471 }
5473 // Copy the events from the original to the clone
5474 if ( dataAndEvents ) {
5476 cloneCopyEvent( elem, clone );
5478 if ( deepDataAndEvents && "getElementsByTagName" in elem ) {
5480 srcElements = elem.getElementsByTagName("*");
5481 destElements = clone.getElementsByTagName("*");
5483 if ( srcElements.length ) {
5484 for ( i = 0; srcElements[i]; ++i ) {
5485 cloneCopyEvent( srcElements[i], destElements[i] );
5486 }
5487 }
5488 }
5489 }
5490 // Return the cloned set
5491 return clone;
5492 },
5493 clean: function( elems, context, fragment, scripts ) {
5494 context = context || document;
5496 // !context.createElement fails in IE with an error but returns typeof 'object'
5497 if ( typeof context.createElement === "undefined" ) {
5498 context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
5499 }
5501 var ret = [];
5503 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
5504 if ( typeof elem === "number" ) {
5505 elem += "";
5506 }
5508 if ( !elem ) {
5509 continue;
5510 }
5512 // Convert html string into DOM nodes
5513 if ( typeof elem === "string" && !rhtml.test( elem ) ) {
5514 elem = context.createTextNode( elem );
5516 } else if ( typeof elem === "string" ) {
5517 // Fix "XHTML"-style tags in all browsers
5518 elem = elem.replace(rxhtmlTag, "<$1></$2>");
5520 // Trim whitespace, otherwise indexOf won't work as expected
5521 var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
5522 wrap = wrapMap[ tag ] || wrapMap._default,
5523 depth = wrap[0],
5524 div = context.createElement("div");
5526 // Go to html and back, then peel off extra wrappers
5527 div.innerHTML = wrap[1] + elem + wrap[2];
5529 // Move to the right depth
5530 while ( depth-- ) {
5531 div = div.lastChild;
5532 }
5534 // Remove IE's autoinserted <tbody> from table fragments
5535 if ( !jQuery.support.tbody ) {
5537 // String was a <table>, *may* have spurious <tbody>
5538 var hasBody = rtbody.test(elem),
5539 tbody = tag === "table" && !hasBody ?
5540 div.firstChild && div.firstChild.childNodes :
5542 // String was a bare <thead> or <tfoot>
5543 wrap[1] === "<table>" && !hasBody ?
5544 div.childNodes :
5545 [];
5547 for ( var j = tbody.length - 1; j >= 0 ; --j ) {
5548 if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
5549 tbody[ j ].parentNode.removeChild( tbody[ j ] );
5550 }
5551 }
5553 }
5555 // IE completely kills leading whitespace when innerHTML is used
5556 if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
5557 div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
5558 }
5560 elem = div.childNodes;
5561 }
5563 if ( elem.nodeType ) {
5564 ret.push( elem );
5565 } else {
5566 ret = jQuery.merge( ret, elem );
5567 }
5568 }
5570 if ( fragment ) {
5571 for ( i = 0; ret[i]; i++ ) {
5572 if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
5573 scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
5575 } else {
5576 if ( ret[i].nodeType === 1 ) {
5577 ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
5578 }
5579 fragment.appendChild( ret[i] );
5580 }
5581 }
5582 }
5584 return ret;
5585 },
5587 cleanData: function( elems ) {
5588 var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
5589 deleteExpando = jQuery.support.deleteExpando;
5591 for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
5592 if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
5593 continue;
5594 }
5596 id = elem[ jQuery.expando ];
5598 if ( id ) {
5599 data = cache[ id ] && cache[ id ][ internalKey ];
5601 if ( data && data.events ) {
5602 for ( var type in data.events ) {
5603 if ( special[ type ] ) {
5604 jQuery.event.remove( elem, type );
5606 // This is a shortcut to avoid jQuery.event.remove's overhead
5607 } else {
5608 jQuery.removeEvent( elem, type, data.handle );
5609 }
5610 }
5612 // Null the DOM reference to avoid IE6/7/8 leak (#7054)
5613 if ( data.handle ) {
5614 data.handle.elem = null;
5615 }
5616 }
5618 if ( deleteExpando ) {
5619 delete elem[ jQuery.expando ];
5621 } else if ( elem.removeAttribute ) {
5622 elem.removeAttribute( jQuery.expando );
5623 }
5625 delete cache[ id ];
5626 }
5627 }
5628 }
5629 });
5631 function evalScript( i, elem ) {
5632 if ( elem.src ) {
5633 jQuery.ajax({
5634 url: elem.src,
5635 async: false,
5636 dataType: "script"
5637 });
5638 } else {
5639 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
5640 }
5642 if ( elem.parentNode ) {
5643 elem.parentNode.removeChild( elem );
5644 }
5645 }
5650 var ralpha = /alpha\([^)]*\)/i,
5651 ropacity = /opacity=([^)]*)/,
5652 rdashAlpha = /-([a-z])/ig,
5653 rupper = /([A-Z])/g,
5654 rnumpx = /^-?\d+(?:px)?$/i,
5655 rnum = /^-?\d/,
5657 cssShow = { position: "absolute", visibility: "hidden", display: "block" },
5658 cssWidth = [ "Left", "Right" ],
5659 cssHeight = [ "Top", "Bottom" ],
5660 curCSS,
5662 getComputedStyle,
5663 currentStyle,
5665 fcamelCase = function( all, letter ) {
5666 return letter.toUpperCase();
5667 };
5669 jQuery.fn.css = function( name, value ) {
5670 // Setting 'undefined' is a no-op
5671 if ( arguments.length === 2 && value === undefined ) {
5672 return this;
5673 }
5675 return jQuery.access( this, name, value, true, function( elem, name, value ) {
5676 return value !== undefined ?
5677 jQuery.style( elem, name, value ) :
5678 jQuery.css( elem, name );
5679 });
5680 };
5682 jQuery.extend({
5683 // Add in style property hooks for overriding the default
5684 // behavior of getting and setting a style property
5685 cssHooks: {
5686 opacity: {
5687 get: function( elem, computed ) {
5688 if ( computed ) {
5689 // We should always get a number back from opacity
5690 var ret = curCSS( elem, "opacity", "opacity" );
5691 return ret === "" ? "1" : ret;
5693 } else {
5694 return elem.style.opacity;
5695 }
5696 }
5697 }
5698 },
5700 // Exclude the following css properties to add px
5701 cssNumber: {
5702 "zIndex": true,
5703 "fontWeight": true,
5704 "opacity": true,
5705 "zoom": true,
5706 "lineHeight": true
5707 },
5709 // Add in properties whose names you wish to fix before
5710 // setting or getting the value
5711 cssProps: {
5712 // normalize float css property
5713 "float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
5714 },
5716 // Get and set the style property on a DOM Node
5717 style: function( elem, name, value, extra ) {
5718 // Don't set styles on text and comment nodes
5719 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
5720 return;
5721 }
5723 // Make sure that we're working with the right name
5724 var ret, origName = jQuery.camelCase( name ),
5725 style = elem.style, hooks = jQuery.cssHooks[ origName ];
5727 name = jQuery.cssProps[ origName ] || origName;
5729 // Check if we're setting a value
5730 if ( value !== undefined ) {
5731 // Make sure that NaN and null values aren't set. See: #7116
5732 if ( typeof value === "number" && isNaN( value ) || value == null ) {
5733 return;
5734 }
5736 // If a number was passed in, add 'px' to the (except for certain CSS properties)
5737 if ( typeof value === "number" && !jQuery.cssNumber[ origName ] ) {
5738 value += "px";
5739 }
5741 // If a hook was provided, use that value, otherwise just set the specified value
5742 if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
5743 // Wrapped to prevent IE from throwing errors when 'invalid' values are provided
5744 // Fixes bug #5509
5745 try {
5746 style[ name ] = value;
5747 } catch(e) {}
5748 }
5750 } else {
5751 // If a hook was provided get the non-computed value from there
5752 if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
5753 return ret;
5754 }
5756 // Otherwise just get the value from the style object
5757 return style[ name ];
5758 }
5759 },
5761 css: function( elem, name, extra ) {
5762 // Make sure that we're working with the right name
5763 var ret, origName = jQuery.camelCase( name ),
5764 hooks = jQuery.cssHooks[ origName ];
5766 name = jQuery.cssProps[ origName ] || origName;
5768 // If a hook was provided get the computed value from there
5769 if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
5770 return ret;
5772 // Otherwise, if a way to get the computed value exists, use that
5773 } else if ( curCSS ) {
5774 return curCSS( elem, name, origName );
5775 }
5776 },
5778 // A method for quickly swapping in/out CSS properties to get correct calculations
5779 swap: function( elem, options, callback ) {
5780 var old = {};
5782 // Remember the old values, and insert the new ones
5783 for ( var name in options ) {
5784 old[ name ] = elem.style[ name ];
5785 elem.style[ name ] = options[ name ];
5786 }
5788 callback.call( elem );
5790 // Revert the old values
5791 for ( name in options ) {
5792 elem.style[ name ] = old[ name ];
5793 }
5794 },
5796 camelCase: function( string ) {
5797 return string.replace( rdashAlpha, fcamelCase );
5798 }
5799 });
5801 // DEPRECATED, Use jQuery.css() instead
5802 jQuery.curCSS = jQuery.css;
5804 jQuery.each(["height", "width"], function( i, name ) {
5805 jQuery.cssHooks[ name ] = {
5806 get: function( elem, computed, extra ) {
5807 var val;
5809 if ( computed ) {
5810 if ( elem.offsetWidth !== 0 ) {
5811 val = getWH( elem, name, extra );
5813 } else {
5814 jQuery.swap( elem, cssShow, function() {
5815 val = getWH( elem, name, extra );
5816 });
5817 }
5819 if ( val <= 0 ) {
5820 val = curCSS( elem, name, name );
5822 if ( val === "0px" && currentStyle ) {
5823 val = currentStyle( elem, name, name );
5824 }
5826 if ( val != null ) {
5827 // Should return "auto" instead of 0, use 0 for
5828 // temporary backwards-compat
5829 return val === "" || val === "auto" ? "0px" : val;
5830 }
5831 }
5833 if ( val < 0 || val == null ) {
5834 val = elem.style[ name ];
5836 // Should return "auto" instead of 0, use 0 for
5837 // temporary backwards-compat
5838 return val === "" || val === "auto" ? "0px" : val;
5839 }
5841 return typeof val === "string" ? val : val + "px";
5842 }
5843 },
5845 set: function( elem, value ) {
5846 if ( rnumpx.test( value ) ) {
5847 // ignore negative width and height values #1599
5848 value = parseFloat(value);
5850 if ( value >= 0 ) {
5851 return value + "px";
5852 }
5854 } else {
5855 return value;
5856 }
5857 }
5858 };
5859 });
5861 if ( !jQuery.support.opacity ) {
5862 jQuery.cssHooks.opacity = {
5863 get: function( elem, computed ) {
5864 // IE uses filters for opacity
5865 return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
5866 (parseFloat(RegExp.$1) / 100) + "" :
5867 computed ? "1" : "";
5868 },
5870 set: function( elem, value ) {
5871 var style = elem.style;
5873 // IE has trouble with opacity if it does not have layout
5874 // Force it by setting the zoom level
5875 style.zoom = 1;
5877 // Set the alpha filter to set the opacity
5878 var opacity = jQuery.isNaN(value) ?
5879 "" :
5880 "alpha(opacity=" + value * 100 + ")",
5881 filter = style.filter || "";
5883 style.filter = ralpha.test(filter) ?
5884 filter.replace(ralpha, opacity) :
5885 style.filter + ' ' + opacity;
5886 }
5887 };
5888 }
5890 if ( document.defaultView && document.defaultView.getComputedStyle ) {
5891 getComputedStyle = function( elem, newName, name ) {
5892 var ret, defaultView, computedStyle;
5894 name = name.replace( rupper, "-$1" ).toLowerCase();
5896 if ( !(defaultView = elem.ownerDocument.defaultView) ) {
5897 return undefined;
5898 }
5900 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
5901 ret = computedStyle.getPropertyValue( name );
5902 if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
5903 ret = jQuery.style( elem, name );
5904 }
5905 }
5907 return ret;
5908 };
5909 }
5911 if ( document.documentElement.currentStyle ) {
5912 currentStyle = function( elem, name ) {
5913 var left,
5914 ret = elem.currentStyle && elem.currentStyle[ name ],
5915 rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
5916 style = elem.style;
5918 // From the awesome hack by Dean Edwards
5919 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
5921 // If we're not dealing with a regular pixel number
5922 // but a number that has a weird ending, we need to convert it to pixels
5923 if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
5924 // Remember the original values
5925 left = style.left;
5927 // Put in the new values to get a computed value out
5928 if ( rsLeft ) {
5929 elem.runtimeStyle.left = elem.currentStyle.left;
5930 }
5931 style.left = name === "fontSize" ? "1em" : (ret || 0);
5932 ret = style.pixelLeft + "px";
5934 // Revert the changed values
5935 style.left = left;
5936 if ( rsLeft ) {
5937 elem.runtimeStyle.left = rsLeft;
5938 }
5939 }
5941 return ret === "" ? "auto" : ret;
5942 };
5943 }
5945 curCSS = getComputedStyle || currentStyle;
5947 function getWH( elem, name, extra ) {
5948 var which = name === "width" ? cssWidth : cssHeight,
5949 val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
5951 if ( extra === "border" ) {
5952 return val;
5953 }
5955 jQuery.each( which, function() {
5956 if ( !extra ) {
5957 val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
5958 }
5960 if ( extra === "margin" ) {
5961 val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
5963 } else {
5964 val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
5965 }
5966 });
5968 return val;
5969 }
5971 if ( jQuery.expr && jQuery.expr.filters ) {
5972 jQuery.expr.filters.hidden = function( elem ) {
5973 var width = elem.offsetWidth,
5974 height = elem.offsetHeight;
5976 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
5977 };
5979 jQuery.expr.filters.visible = function( elem ) {
5980 return !jQuery.expr.filters.hidden( elem );
5981 };
5982 }
5987 var r20 = /%20/g,
5988 rbracket = /\[\]$/,
5989 rCRLF = /\r?\n/g,
5990 rhash = /#.*$/,
5991 rheaders = /^(.*?):\s*(.*?)\r?$/mg, // IE leaves an \r character at EOL
5992 rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
5993 rnoContent = /^(?:GET|HEAD)$/,
5994 rprotocol = /^\/\//,
5995 rquery = /\?/,
5996 rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
5997 rselectTextarea = /^(?:select|textarea)/i,
5998 rspacesAjax = /\s+/,
5999 rts = /([?&])_=[^&]*/,
6000 rurl = /^(\w+:)\/\/([^\/?#:]+)(?::(\d+))?/,
6002 // Keep a copy of the old load method
6003 _load = jQuery.fn.load,
6005 /* Prefilters
6006 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
6007 * 2) These are called:
6008 * - BEFORE asking for a transport
6009 * - AFTER param serialization (s.data is a string if s.processData is true)
6010 * 3) key is the dataType
6011 * 4) the catchall symbol "*" can be used
6012 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
6013 */
6014 prefilters = {},
6016 /* Transports bindings
6017 * 1) key is the dataType
6018 * 2) the catchall symbol "*" can be used
6019 * 3) selection will start with transport dataType and THEN go to "*" if needed
6020 */
6021 transports = {};
6023 // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
6024 function addToPrefiltersOrTransports( structure ) {
6026 // dataTypeExpression is optional and defaults to "*"
6027 return function( dataTypeExpression, func ) {
6029 if ( typeof dataTypeExpression !== "string" ) {
6030 func = dataTypeExpression;
6031 dataTypeExpression = "*";
6032 }
6034 if ( jQuery.isFunction( func ) ) {
6035 var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
6036 i = 0,
6037 length = dataTypes.length,
6038 dataType,
6039 list,
6040 placeBefore;
6042 // For each dataType in the dataTypeExpression
6043 for(; i < length; i++ ) {
6044 dataType = dataTypes[ i ];
6045 // We control if we're asked to add before
6046 // any existing element
6047 placeBefore = /^\+/.test( dataType );
6048 if ( placeBefore ) {
6049 dataType = dataType.substr( 1 ) || "*";
6050 }
6051 list = structure[ dataType ] = structure[ dataType ] || [];
6052 // then we add to the structure accordingly
6053 list[ placeBefore ? "unshift" : "push" ]( func );
6054 }
6055 }
6056 };
6057 }
6059 //Base inspection function for prefilters and transports
6060 function inspectPrefiltersOrTransports( structure, options, originalOptions, jXHR,
6061 dataType /* internal */, inspected /* internal */ ) {
6063 dataType = dataType || options.dataTypes[ 0 ];
6064 inspected = inspected || {};
6066 inspected[ dataType ] = true;
6068 var list = structure[ dataType ],
6069 i = 0,
6070 length = list ? list.length : 0,
6071 executeOnly = ( structure === prefilters ),
6072 selection;
6074 for(; i < length && ( executeOnly || !selection ); i++ ) {
6075 selection = list[ i ]( options, originalOptions, jXHR );
6076 // If we got redirected to another dataType
6077 // we try there if not done already
6078 if ( typeof selection === "string" ) {
6079 if ( inspected[ selection ] ) {
6080 selection = undefined;
6081 } else {
6082 options.dataTypes.unshift( selection );
6083 selection = inspectPrefiltersOrTransports(
6084 structure, options, originalOptions, jXHR, selection, inspected );
6085 }
6086 }
6087 }
6088 // If we're only executing or nothing was selected
6089 // we try the catchall dataType if not done already
6090 if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
6091 selection = inspectPrefiltersOrTransports(
6092 structure, options, originalOptions, jXHR, "*", inspected );
6093 }
6094 // unnecessary when only executing (prefilters)
6095 // but it'll be ignored by the caller in that case
6096 return selection;
6097 }
6099 jQuery.fn.extend({
6100 load: function( url, params, callback ) {
6101 if ( typeof url !== "string" && _load ) {
6102 return _load.apply( this, arguments );
6104 // Don't do a request if no elements are being requested
6105 } else if ( !this.length ) {
6106 return this;
6107 }
6109 var off = url.indexOf( " " );
6110 if ( off >= 0 ) {
6111 var selector = url.slice( off, url.length );
6112 url = url.slice( 0, off );
6113 }
6115 // Default to a GET request
6116 var type = "GET";
6118 // If the second parameter was provided
6119 if ( params ) {
6120 // If it's a function
6121 if ( jQuery.isFunction( params ) ) {
6122 // We assume that it's the callback
6123 callback = params;
6124 params = null;
6126 // Otherwise, build a param string
6127 } else if ( typeof params === "object" ) {
6128 params = jQuery.param( params, jQuery.ajaxSettings.traditional );
6129 type = "POST";
6130 }
6131 }
6133 var self = this;
6135 // Request the remote document
6136 jQuery.ajax({
6137 url: url,
6138 type: type,
6139 dataType: "html",
6140 data: params,
6141 // Complete callback (responseText is used internally)
6142 complete: function( jXHR, status, responseText ) {
6143 // Store the response as specified by the jXHR object
6144 responseText = jXHR.responseText;
6145 // If successful, inject the HTML into all the matched elements
6146 if ( jXHR.isResolved() ) {
6147 // #4825: Get the actual response in case
6148 // a dataFilter is present in ajaxSettings
6149 jXHR.done(function( r ) {
6150 responseText = r;
6151 });
6152 // See if a selector was specified
6153 self.html( selector ?
6154 // Create a dummy div to hold the results
6155 jQuery("<div>")
6156 // inject the contents of the document in, removing the scripts
6157 // to avoid any 'Permission Denied' errors in IE
6158 .append(responseText.replace(rscript, ""))
6160 // Locate the specified elements
6161 .find(selector) :
6163 // If not, just inject the full result
6164 responseText );
6165 }
6167 if ( callback ) {
6168 self.each( callback, [ responseText, status, jXHR ] );
6169 }
6170 }
6171 });
6173 return this;
6174 },
6176 serialize: function() {
6177 return jQuery.param( this.serializeArray() );
6178 },
6180 serializeArray: function() {
6181 return this.map(function(){
6182 return this.elements ? jQuery.makeArray( this.elements ) : this;
6183 })
6184 .filter(function(){
6185 return this.name && !this.disabled &&
6186 ( this.checked || rselectTextarea.test( this.nodeName ) ||
6187 rinput.test( this.type ) );
6188 })
6189 .map(function( i, elem ){
6190 var val = jQuery( this ).val();
6192 return val == null ?
6193 null :
6194 jQuery.isArray( val ) ?
6195 jQuery.map( val, function( val, i ){
6196 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6197 }) :
6198 { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
6199 }).get();
6200 }
6201 });
6203 // Attach a bunch of functions for handling common AJAX events
6204 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
6205 jQuery.fn[ o ] = function( f ){
6206 return this.bind( o, f );
6207 };
6208 } );
6210 jQuery.each( [ "get", "post" ], function( i, method ) {
6211 jQuery[ method ] = function( url, data, callback, type ) {
6212 // shift arguments if data argument was omitted
6213 if ( jQuery.isFunction( data ) ) {
6214 type = type || callback;
6215 callback = data;
6216 data = null;
6217 }
6219 return jQuery.ajax({
6220 type: method,
6221 url: url,
6222 data: data,
6223 success: callback,
6224 dataType: type
6225 });
6226 };
6227 } );
6229 jQuery.extend({
6231 getScript: function( url, callback ) {
6232 return jQuery.get( url, null, callback, "script" );
6233 },
6235 getJSON: function( url, data, callback ) {
6236 return jQuery.get( url, data, callback, "json" );
6237 },
6239 ajaxSetup: function( settings ) {
6240 jQuery.extend( true, jQuery.ajaxSettings, settings );
6241 if ( settings.context ) {
6242 jQuery.ajaxSettings.context = settings.context;
6243 }
6244 },
6246 ajaxSettings: {
6247 url: location.href,
6248 global: true,
6249 type: "GET",
6250 contentType: "application/x-www-form-urlencoded",
6251 processData: true,
6252 async: true,
6253 /*
6254 timeout: 0,
6255 data: null,
6256 dataType: null,
6257 username: null,
6258 password: null,
6259 cache: null,
6260 traditional: false,
6261 headers: {},
6262 crossDomain: null,
6263 */
6265 accepts: {
6266 xml: "application/xml, text/xml",
6267 html: "text/html",
6268 text: "text/plain",
6269 json: "application/json, text/javascript",
6270 "*": "*/*"
6271 },
6273 contents: {
6274 xml: /xml/,
6275 html: /html/,
6276 json: /json/
6277 },
6279 responseFields: {
6280 xml: "responseXML",
6281 text: "responseText"
6282 },
6284 // List of data converters
6285 // 1) key format is "source_type destination_type" (a single space in-between)
6286 // 2) the catchall symbol "*" can be used for source_type
6287 converters: {
6289 // Convert anything to text
6290 "* text": window.String,
6292 // Text to html (true = no transformation)
6293 "text html": true,
6295 // Evaluate text as a json expression
6296 "text json": jQuery.parseJSON,
6298 // Parse text as xml
6299 "text xml": jQuery.parseXML
6300 }
6301 },
6303 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
6304 ajaxTransport: addToPrefiltersOrTransports( transports ),
6306 // Main method
6307 ajax: function( url, options ) {
6309 // If options is not an object,
6310 // we simulate pre-1.5 signature
6311 if ( typeof options !== "object" ) {
6312 options = url;
6313 url = undefined;
6314 }
6316 // Force options to be an object
6317 options = options || {};
6319 var // Create the final options object
6320 s = jQuery.extend( true, {}, jQuery.ajaxSettings, options ),
6321 // Callbacks contexts
6322 // We force the original context if it exists
6323 // or take it from jQuery.ajaxSettings otherwise
6324 // (plain objects used as context get extended)
6325 callbackContext =
6326 ( s.context = ( "context" in options ? options : jQuery.ajaxSettings ).context ) || s,
6327 globalEventContext = callbackContext === s ? jQuery.event : jQuery( callbackContext ),
6328 // Deferreds
6329 deferred = jQuery.Deferred(),
6330 completeDeferred = jQuery._Deferred(),
6331 // Status-dependent callbacks
6332 statusCode = s.statusCode || {},
6333 // Headers (they are sent all at once)
6334 requestHeaders = {},
6335 // Response headers
6336 responseHeadersString,
6337 responseHeaders,
6338 // transport
6339 transport,
6340 // timeout handle
6341 timeoutTimer,
6342 // Cross-domain detection vars
6343 loc = document.location,
6344 protocol = loc.protocol || "http:",
6345 parts,
6346 // The jXHR state
6347 state = 0,
6348 // Loop variable
6349 i,
6350 // Fake xhr
6351 jXHR = {
6353 readyState: 0,
6355 // Caches the header
6356 setRequestHeader: function( name, value ) {
6357 if ( state === 0 ) {
6358 requestHeaders[ name.toLowerCase() ] = value;
6359 }
6360 return this;
6361 },
6363 // Raw string
6364 getAllResponseHeaders: function() {
6365 return state === 2 ? responseHeadersString : null;
6366 },
6368 // Builds headers hashtable if needed
6369 getResponseHeader: function( key ) {
6370 var match;
6371 if ( state === 2 ) {
6372 if ( !responseHeaders ) {
6373 responseHeaders = {};
6374 while( ( match = rheaders.exec( responseHeadersString ) ) ) {
6375 responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
6376 }
6377 }
6378 match = responseHeaders[ key.toLowerCase() ];
6379 }
6380 return match || null;
6381 },
6383 // Cancel the request
6384 abort: function( statusText ) {
6385 statusText = statusText || "abort";
6386 if ( transport ) {
6387 transport.abort( statusText );
6388 }
6389 done( 0, statusText );
6390 return this;
6391 }
6392 };
6394 // Callback for when everything is done
6395 // It is defined here because jslint complains if it is declared
6396 // at the end of the function (which would be more logical and readable)
6397 function done( status, statusText, responses, headers) {
6399 // Called once
6400 if ( state === 2 ) {
6401 return;
6402 }
6404 // State is "done" now
6405 state = 2;
6407 // Clear timeout if it exists
6408 if ( timeoutTimer ) {
6409 clearTimeout( timeoutTimer );
6410 }
6412 // Dereference transport for early garbage collection
6413 // (no matter how long the jXHR object will be used)
6414 transport = undefined;
6416 // Cache response headers
6417 responseHeadersString = headers || "";
6419 // Set readyState
6420 jXHR.readyState = status ? 4 : 0;
6422 var isSuccess,
6423 success,
6424 error,
6425 response = responses ? ajaxHandleResponses( s, jXHR, responses ) : undefined,
6426 lastModified,
6427 etag;
6429 // If successful, handle type chaining
6430 if ( status >= 200 && status < 300 || status === 304 ) {
6432 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
6433 if ( s.ifModified ) {
6435 if ( ( lastModified = jXHR.getResponseHeader( "Last-Modified" ) ) ) {
6436 jQuery.lastModified[ s.url ] = lastModified;
6437 }
6438 if ( ( etag = jXHR.getResponseHeader( "Etag" ) ) ) {
6439 jQuery.etag[ s.url ] = etag;
6440 }
6441 }
6443 // If not modified
6444 if ( status === 304 ) {
6446 statusText = "notmodified";
6447 isSuccess = true;
6449 // If we have data
6450 } else {
6452 try {
6453 success = ajaxConvert( s, response );
6454 statusText = "success";
6455 isSuccess = true;
6456 } catch(e) {
6457 // We have a parsererror
6458 statusText = "parsererror";
6459 error = e;
6460 }
6461 }
6462 } else {
6463 // We extract error from statusText
6464 // then normalize statusText and status for non-aborts
6465 error = statusText;
6466 if( status ) {
6467 statusText = "error";
6468 if ( status < 0 ) {
6469 status = 0;
6470 }
6471 }
6472 }
6474 // Set data for the fake xhr object
6475 jXHR.status = status;
6476 jXHR.statusText = statusText;
6478 // Success/Error
6479 if ( isSuccess ) {
6480 deferred.resolveWith( callbackContext, [ success, statusText, jXHR ] );
6481 } else {
6482 deferred.rejectWith( callbackContext, [ jXHR, statusText, error ] );
6483 }
6485 // Status-dependent callbacks
6486 jXHR.statusCode( statusCode );
6487 statusCode = undefined;
6489 if ( s.global ) {
6490 globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
6491 [ jXHR, s, isSuccess ? success : error ] );
6492 }
6494 // Complete
6495 completeDeferred.resolveWith( callbackContext, [ jXHR, statusText ] );
6497 if ( s.global ) {
6498 globalEventContext.trigger( "ajaxComplete", [ jXHR, s] );
6499 // Handle the global AJAX counter
6500 if ( !( --jQuery.active ) ) {
6501 jQuery.event.trigger( "ajaxStop" );
6502 }
6503 }
6504 }
6506 // Attach deferreds
6507 deferred.promise( jXHR );
6508 jXHR.success = jXHR.done;
6509 jXHR.error = jXHR.fail;
6510 jXHR.complete = completeDeferred.done;
6512 // Status-dependent callbacks
6513 jXHR.statusCode = function( map ) {
6514 if ( map ) {
6515 var tmp;
6516 if ( state < 2 ) {
6517 for( tmp in map ) {
6518 statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
6519 }
6520 } else {
6521 tmp = map[ jXHR.status ];
6522 jXHR.then( tmp, tmp );
6523 }
6524 }
6525 return this;
6526 };
6528 // Remove hash character (#7531: and string promotion)
6529 // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
6530 // We also use the url parameter if available
6531 s.url = ( "" + ( url || s.url ) ).replace( rhash, "" ).replace( rprotocol, protocol + "//" );
6533 // Extract dataTypes list
6534 s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
6536 // Determine if a cross-domain request is in order
6537 if ( !s.crossDomain ) {
6538 parts = rurl.exec( s.url.toLowerCase() );
6539 s.crossDomain = !!( parts &&
6540 ( parts[ 1 ] != protocol || parts[ 2 ] != loc.hostname ||
6541 ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
6542 ( loc.port || ( protocol === "http:" ? 80 : 443 ) ) )
6543 );
6544 }
6546 // Convert data if not already a string
6547 if ( s.data && s.processData && typeof s.data !== "string" ) {
6548 s.data = jQuery.param( s.data, s.traditional );
6549 }
6551 // Apply prefilters
6552 inspectPrefiltersOrTransports( prefilters, s, options, jXHR );
6554 // Uppercase the type
6555 s.type = s.type.toUpperCase();
6557 // Determine if request has content
6558 s.hasContent = !rnoContent.test( s.type );
6560 // Watch for a new set of requests
6561 if ( s.global && jQuery.active++ === 0 ) {
6562 jQuery.event.trigger( "ajaxStart" );
6563 }
6565 // More options handling for requests with no content
6566 if ( !s.hasContent ) {
6568 // If data is available, append data to url
6569 if ( s.data ) {
6570 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
6571 }
6573 // Add anti-cache in url if needed
6574 if ( s.cache === false ) {
6576 var ts = jQuery.now(),
6577 // try replacing _= if it is there
6578 ret = s.url.replace( rts, "$1_=" + ts );
6580 // if nothing was replaced, add timestamp to the end
6581 s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
6582 }
6583 }
6585 // Set the correct header, if data is being sent
6586 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
6587 requestHeaders[ "content-type" ] = s.contentType;
6588 }
6590 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
6591 if ( s.ifModified ) {
6592 if ( jQuery.lastModified[ s.url ] ) {
6593 requestHeaders[ "if-modified-since" ] = jQuery.lastModified[ s.url ];
6594 }
6595 if ( jQuery.etag[ s.url ] ) {
6596 requestHeaders[ "if-none-match" ] = jQuery.etag[ s.url ];
6597 }
6598 }
6600 // Set the Accepts header for the server, depending on the dataType
6601 requestHeaders.accept = s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
6602 s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
6603 s.accepts[ "*" ];
6605 // Check for headers option
6606 for ( i in s.headers ) {
6607 requestHeaders[ i.toLowerCase() ] = s.headers[ i ];
6608 }
6610 // Allow custom headers/mimetypes and early abort
6611 if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jXHR, s ) === false || state === 2 ) ) {
6612 // Abort if not done already
6613 done( 0, "abort" );
6614 // Return false
6615 jXHR = false;
6617 } else {
6619 // Install callbacks on deferreds
6620 for ( i in { success: 1, error: 1, complete: 1 } ) {
6621 jXHR[ i ]( s[ i ] );
6622 }
6624 // Get transport
6625 transport = inspectPrefiltersOrTransports( transports, s, options, jXHR );
6627 // If no transport, we auto-abort
6628 if ( !transport ) {
6629 done( -1, "No Transport" );
6630 } else {
6631 // Set state as sending
6632 state = jXHR.readyState = 1;
6633 // Send global event
6634 if ( s.global ) {
6635 globalEventContext.trigger( "ajaxSend", [ jXHR, s ] );
6636 }
6637 // Timeout
6638 if ( s.async && s.timeout > 0 ) {
6639 timeoutTimer = setTimeout( function(){
6640 jXHR.abort( "timeout" );
6641 }, s.timeout );
6642 }
6644 try {
6645 transport.send( requestHeaders, done );
6646 } catch (e) {
6647 // Propagate exception as error if not done
6648 if ( status < 2 ) {
6649 done( -1, e );
6650 // Simply rethrow otherwise
6651 } else {
6652 jQuery.error( e );
6653 }
6654 }
6655 }
6656 }
6657 return jXHR;
6658 },
6660 // Serialize an array of form elements or a set of
6661 // key/values into a query string
6662 param: function( a, traditional ) {
6663 var s = [],
6664 add = function( key, value ) {
6665 // If value is a function, invoke it and return its value
6666 value = jQuery.isFunction( value ) ? value() : value;
6667 s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
6668 };
6670 // Set traditional to true for jQuery <= 1.3.2 behavior.
6671 if ( traditional === undefined ) {
6672 traditional = jQuery.ajaxSettings.traditional;
6673 }
6675 // If an array was passed in, assume that it is an array of form elements.
6676 if ( jQuery.isArray( a ) || a.jquery ) {
6677 // Serialize the form elements
6678 jQuery.each( a, function() {
6679 add( this.name, this.value );
6680 } );
6682 } else {
6683 // If traditional, encode the "old" way (the way 1.3.2 or older
6684 // did it), otherwise encode params recursively.
6685 for ( var prefix in a ) {
6686 buildParams( prefix, a[ prefix ], traditional, add );
6687 }
6688 }
6690 // Return the resulting serialization
6691 return s.join( "&" ).replace( r20, "+" );
6692 }
6693 });
6695 function buildParams( prefix, obj, traditional, add ) {
6696 if ( jQuery.isArray( obj ) && obj.length ) {
6697 // Serialize array item.
6698 jQuery.each( obj, function( i, v ) {
6699 if ( traditional || rbracket.test( prefix ) ) {
6700 // Treat each array item as a scalar.
6701 add( prefix, v );
6703 } else {
6704 // If array item is non-scalar (array or object), encode its
6705 // numeric index to resolve deserialization ambiguity issues.
6706 // Note that rack (as of 1.0.0) can't currently deserialize
6707 // nested arrays properly, and attempting to do so may cause
6708 // a server error. Possible fixes are to modify rack's
6709 // deserialization algorithm or to provide an option or flag
6710 // to force array serialization to be shallow.
6711 buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
6712 }
6713 });
6715 } else if ( !traditional && obj != null && typeof obj === "object" ) {
6716 // If we see an array here, it is empty and should be treated as an empty
6717 // object
6718 if ( jQuery.isArray( obj ) || jQuery.isEmptyObject( obj ) ) {
6719 add( prefix, "" );
6721 // Serialize object item.
6722 } else {
6723 jQuery.each( obj, function( k, v ) {
6724 buildParams( prefix + "[" + k + "]", v, traditional, add );
6725 });
6726 }
6728 } else {
6729 // Serialize scalar item.
6730 add( prefix, obj );
6731 }
6732 }
6734 // This is still on the jQuery object... for now
6735 // Want to move this to jQuery.ajax some day
6736 jQuery.extend({
6738 // Counter for holding the number of active queries
6739 active: 0,
6741 // Last-Modified header cache for next request
6742 lastModified: {},
6743 etag: {}
6745 });
6747 /* Handles responses to an ajax request:
6748 * - sets all responseXXX fields accordingly
6749 * - finds the right dataType (mediates between content-type and expected dataType)
6750 * - returns the corresponding response
6751 */
6752 function ajaxHandleResponses( s, jXHR, responses ) {
6754 var contents = s.contents,
6755 dataTypes = s.dataTypes,
6756 responseFields = s.responseFields,
6757 ct,
6758 type,
6759 finalDataType,
6760 firstDataType;
6762 // Fill responseXXX fields
6763 for( type in responseFields ) {
6764 if ( type in responses ) {
6765 jXHR[ responseFields[type] ] = responses[ type ];
6766 }
6767 }
6769 // Remove auto dataType and get content-type in the process
6770 while( dataTypes[ 0 ] === "*" ) {
6771 dataTypes.shift();
6772 if ( ct === undefined ) {
6773 ct = jXHR.getResponseHeader( "content-type" );
6774 }
6775 }
6777 // Check if we're dealing with a known content-type
6778 if ( ct ) {
6779 for ( type in contents ) {
6780 if ( contents[ type ] && contents[ type ].test( ct ) ) {
6781 dataTypes.unshift( type );
6782 break;
6783 }
6784 }
6785 }
6787 // Check to see if we have a response for the expected dataType
6788 if ( dataTypes[ 0 ] in responses ) {
6789 finalDataType = dataTypes[ 0 ];
6790 } else {
6791 // Try convertible dataTypes
6792 for ( type in responses ) {
6793 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
6794 finalDataType = type;
6795 break;
6796 }
6797 if ( !firstDataType ) {
6798 firstDataType = type;
6799 }
6800 }
6801 // Or just use first one
6802 finalDataType = finalDataType || firstDataType;
6803 }
6805 // If we found a dataType
6806 // We add the dataType to the list if needed
6807 // and return the corresponding response
6808 if ( finalDataType ) {
6809 if ( finalDataType !== dataTypes[ 0 ] ) {
6810 dataTypes.unshift( finalDataType );
6811 }
6812 return responses[ finalDataType ];
6813 }
6814 }
6816 // Chain conversions given the request and the original response
6817 function ajaxConvert( s, response ) {
6819 // Apply the dataFilter if provided
6820 if ( s.dataFilter ) {
6821 response = s.dataFilter( response, s.dataType );
6822 }
6824 var dataTypes = s.dataTypes,
6825 converters = s.converters,
6826 i,
6827 length = dataTypes.length,
6828 tmp,
6829 // Current and previous dataTypes
6830 current = dataTypes[ 0 ],
6831 prev,
6832 // Conversion expression
6833 conversion,
6834 // Conversion function
6835 conv,
6836 // Conversion functions (transitive conversion)
6837 conv1,
6838 conv2;
6840 // For each dataType in the chain
6841 for( i = 1; i < length; i++ ) {
6843 // Get the dataTypes
6844 prev = current;
6845 current = dataTypes[ i ];
6847 // If current is auto dataType, update it to prev
6848 if( current === "*" ) {
6849 current = prev;
6850 // If no auto and dataTypes are actually different
6851 } else if ( prev !== "*" && prev !== current ) {
6853 // Get the converter
6854 conversion = prev + " " + current;
6855 conv = converters[ conversion ] || converters[ "* " + current ];
6857 // If there is no direct converter, search transitively
6858 if ( !conv ) {
6859 conv2 = undefined;
6860 for( conv1 in converters ) {
6861 tmp = conv1.split( " " );
6862 if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
6863 conv2 = converters[ tmp[1] + " " + current ];
6864 if ( conv2 ) {
6865 conv1 = converters[ conv1 ];
6866 if ( conv1 === true ) {
6867 conv = conv2;
6868 } else if ( conv2 === true ) {
6869 conv = conv1;
6870 }
6871 break;
6872 }
6873 }
6874 }
6875 }
6876 // If we found no converter, dispatch an error
6877 if ( !( conv || conv2 ) ) {
6878 jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
6879 }
6880 // If found converter is not an equivalence
6881 if ( conv !== true ) {
6882 // Convert with 1 or 2 converters accordingly
6883 response = conv ? conv( response ) : conv2( conv1(response) );
6884 }
6885 }
6886 }
6887 return response;
6888 }
6893 var jsc = jQuery.now(),
6894 jsre = /(\=)\?(&|$)|()\?\?()/i;
6896 // Default jsonp settings
6897 jQuery.ajaxSetup({
6898 jsonp: "callback",
6899 jsonpCallback: function() {
6900 return jQuery.expando + "_" + ( jsc++ );
6901 }
6902 });
6904 // Detect, normalize options and install callbacks for jsonp requests
6905 jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, dataIsString /* internal */ ) {
6907 dataIsString = ( typeof s.data === "string" );
6909 if ( s.dataTypes[ 0 ] === "jsonp" ||
6910 originalSettings.jsonpCallback ||
6911 originalSettings.jsonp != null ||
6912 s.jsonp !== false && ( jsre.test( s.url ) ||
6913 dataIsString && jsre.test( s.data ) ) ) {
6915 var responseContainer,
6916 jsonpCallback = s.jsonpCallback =
6917 jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
6918 previous = window[ jsonpCallback ],
6919 url = s.url,
6920 data = s.data,
6921 replace = "$1" + jsonpCallback + "$2";
6923 if ( s.jsonp !== false ) {
6924 url = url.replace( jsre, replace );
6925 if ( s.url === url ) {
6926 if ( dataIsString ) {
6927 data = data.replace( jsre, replace );
6928 }
6929 if ( s.data === data ) {
6930 // Add callback manually
6931 url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
6932 }
6933 }
6934 }
6936 s.url = url;
6937 s.data = data;
6939 window[ jsonpCallback ] = function( response ) {
6940 responseContainer = [ response ];
6941 };
6943 s.complete = [ function() {
6945 // Set callback back to previous value
6946 window[ jsonpCallback ] = previous;
6948 // Call if it was a function and we have a response
6949 if ( previous) {
6950 if ( responseContainer && jQuery.isFunction( previous ) ) {
6951 window[ jsonpCallback ] ( responseContainer[ 0 ] );
6952 }
6953 } else {
6954 // else, more memory leak avoidance
6955 try{
6956 delete window[ jsonpCallback ];
6957 } catch( e ) {}
6958 }
6960 }, s.complete ];
6962 // Use data converter to retrieve json after script execution
6963 s.converters["script json"] = function() {
6964 if ( ! responseContainer ) {
6965 jQuery.error( jsonpCallback + " was not called" );
6966 }
6967 return responseContainer[ 0 ];
6968 };
6970 // force json dataType
6971 s.dataTypes[ 0 ] = "json";
6973 // Delegate to script
6974 return "script";
6975 }
6976 } );
6981 // Install script dataType
6982 jQuery.ajaxSetup({
6983 accepts: {
6984 script: "text/javascript, application/javascript"
6985 },
6986 contents: {
6987 script: /javascript/
6988 },
6989 converters: {
6990 "text script": function( text ) {
6991 jQuery.globalEval( text );
6992 return text;
6993 }
6994 }
6995 });
6997 // Handle cache's special case and global
6998 jQuery.ajaxPrefilter( "script", function( s ) {
6999 if ( s.cache === undefined ) {
7000 s.cache = false;
7001 }
7002 if ( s.crossDomain ) {
7003 s.type = "GET";
7004 s.global = false;
7005 }
7006 } );
7008 // Bind script tag hack transport
7009 jQuery.ajaxTransport( "script", function(s) {
7011 // This transport only deals with cross domain requests
7012 if ( s.crossDomain ) {
7014 var script,
7015 head = document.getElementsByTagName( "head" )[ 0 ] || document.documentElement;
7017 return {
7019 send: function( _, callback ) {
7021 script = document.createElement( "script" );
7023 script.async = "async";
7025 if ( s.scriptCharset ) {
7026 script.charset = s.scriptCharset;
7027 }
7029 script.src = s.url;
7031 // Attach handlers for all browsers
7032 script.onload = script.onreadystatechange = function( _, isAbort ) {
7034 if ( !script.readyState || /loaded|complete/.test( script.readyState ) ) {
7036 // Handle memory leak in IE
7037 script.onload = script.onreadystatechange = null;
7039 // Remove the script
7040 if ( head && script.parentNode ) {
7041 head.removeChild( script );
7042 }
7044 // Dereference the script
7045 script = undefined;
7047 // Callback if not abort
7048 if ( !isAbort ) {
7049 callback( 200, "success" );
7050 }
7051 }
7052 };
7053 // Use insertBefore instead of appendChild to circumvent an IE6 bug.
7054 // This arises when a base node is used (#2709 and #4378).
7055 head.insertBefore( script, head.firstChild );
7056 },
7058 abort: function() {
7059 if ( script ) {
7060 script.onload( 0, 1 );
7061 }
7062 }
7063 };
7064 }
7065 } );
7070 var // Next active xhr id
7071 xhrId = jQuery.now(),
7073 // active xhrs
7074 xhrs = {},
7076 // #5280: see below
7077 xhrUnloadAbortInstalled,
7079 // XHR used to determine supports properties
7080 testXHR;
7082 // Create the request object
7083 // (This is still attached to ajaxSettings for backward compatibility)
7084 jQuery.ajaxSettings.xhr = window.ActiveXObject ?
7085 /* Microsoft failed to properly
7086 * implement the XMLHttpRequest in IE7 (can't request local files),
7087 * so we use the ActiveXObject when it is available
7088 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
7089 * we need a fallback.
7090 */
7091 function() {
7092 if ( window.location.protocol !== "file:" ) {
7093 try {
7094 return new window.XMLHttpRequest();
7095 } catch( xhrError ) {}
7096 }
7098 try {
7099 return new window.ActiveXObject("Microsoft.XMLHTTP");
7100 } catch( activeError ) {}
7101 } :
7102 // For all other browsers, use the standard XMLHttpRequest object
7103 function() {
7104 return new window.XMLHttpRequest();
7105 };
7107 // Test if we can create an xhr object
7108 try {
7109 testXHR = jQuery.ajaxSettings.xhr();
7110 } catch( xhrCreationException ) {}
7112 //Does this browser support XHR requests?
7113 jQuery.support.ajax = !!testXHR;
7115 // Does this browser support crossDomain XHR requests
7116 jQuery.support.cors = testXHR && ( "withCredentials" in testXHR );
7118 // No need for the temporary xhr anymore
7119 testXHR = undefined;
7121 // Create transport if the browser can provide an xhr
7122 if ( jQuery.support.ajax ) {
7124 jQuery.ajaxTransport(function( s ) {
7125 // Cross domain only allowed if supported through XMLHttpRequest
7126 if ( !s.crossDomain || jQuery.support.cors ) {
7128 var callback;
7130 return {
7131 send: function( headers, complete ) {
7133 // #5280: we need to abort on unload or IE will keep connections alive
7134 if ( !xhrUnloadAbortInstalled ) {
7136 xhrUnloadAbortInstalled = 1;
7138 jQuery(window).bind( "unload", function() {
7140 // Abort all pending requests
7141 jQuery.each( xhrs, function( _, xhr ) {
7142 if ( xhr.onreadystatechange ) {
7143 xhr.onreadystatechange( 1 );
7144 }
7145 } );
7147 } );
7148 }
7150 // Get a new xhr
7151 var xhr = s.xhr(),
7152 handle;
7154 // Open the socket
7155 // Passing null username, generates a login popup on Opera (#2865)
7156 if ( s.username ) {
7157 xhr.open( s.type, s.url, s.async, s.username, s.password );
7158 } else {
7159 xhr.open( s.type, s.url, s.async );
7160 }
7162 // Requested-With header
7163 // Not set for crossDomain requests with no content
7164 // (see why at http://trac.dojotoolkit.org/ticket/9486)
7165 // Won't change header if already provided
7166 if ( !( s.crossDomain && !s.hasContent ) && !headers["x-requested-with"] ) {
7167 headers[ "x-requested-with" ] = "XMLHttpRequest";
7168 }
7170 // Need an extra try/catch for cross domain requests in Firefox 3
7171 try {
7172 jQuery.each( headers, function( key, value ) {
7173 xhr.setRequestHeader( key, value );
7174 } );
7175 } catch( _ ) {}
7177 // Do send the request
7178 // This may raise an exception which is actually
7179 // handled in jQuery.ajax (so no try/catch here)
7180 xhr.send( ( s.hasContent && s.data ) || null );
7182 // Listener
7183 callback = function( _, isAbort ) {
7185 // Was never called and is aborted or complete
7186 if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
7188 // Only called once
7189 callback = 0;
7191 // Do not keep as active anymore
7192 if ( handle ) {
7193 xhr.onreadystatechange = jQuery.noop;
7194 delete xhrs[ handle ];
7195 }
7197 // If it's an abort
7198 if ( isAbort ) {
7199 // Abort it manually if needed
7200 if ( xhr.readyState !== 4 ) {
7201 xhr.abort();
7202 }
7203 } else {
7204 // Get info
7205 var status = xhr.status,
7206 statusText,
7207 responseHeaders = xhr.getAllResponseHeaders(),
7208 responses = {},
7209 xml = xhr.responseXML;
7211 // Construct response list
7212 if ( xml && xml.documentElement /* #4958 */ ) {
7213 responses.xml = xml;
7214 }
7215 responses.text = xhr.responseText;
7217 // Firefox throws an exception when accessing
7218 // statusText for faulty cross-domain requests
7219 try {
7220 statusText = xhr.statusText;
7221 } catch( e ) {
7222 // We normalize with Webkit giving an empty statusText
7223 statusText = "";
7224 }
7226 // Filter status for non standard behaviours
7227 status =
7228 // Opera returns 0 when it should be 304
7229 // Webkit returns 0 for failing cross-domain no matter the real status
7230 status === 0 ?
7231 (
7232 // Webkit, Firefox: filter out faulty cross-domain requests
7233 !s.crossDomain || statusText ?
7234 (
7235 // Opera: filter out real aborts #6060
7236 responseHeaders ?
7237 304 :
7238 0
7239 ) :
7240 // We assume 302 but could be anything cross-domain related
7241 302
7242 ) :
7243 (
7244 // IE sometimes returns 1223 when it should be 204 (see #1450)
7245 status == 1223 ?
7246 204 :
7247 status
7248 );
7250 // Call complete
7251 complete( status, statusText, responses, responseHeaders );
7252 }
7253 }
7254 };
7256 // if we're in sync mode or it's in cache
7257 // and has been retrieved directly (IE6 & IE7)
7258 // we need to manually fire the callback
7259 if ( !s.async || xhr.readyState === 4 ) {
7260 callback();
7261 } else {
7262 // Add to list of active xhrs
7263 handle = xhrId++;
7264 xhrs[ handle ] = xhr;
7265 xhr.onreadystatechange = callback;
7266 }
7267 },
7269 abort: function() {
7270 if ( callback ) {
7271 callback(0,1);
7272 }
7273 }
7274 };
7275 }
7276 });
7277 }
7282 var elemdisplay = {},
7283 rfxtypes = /^(?:toggle|show|hide)$/,
7284 rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
7285 timerId,
7286 fxAttrs = [
7287 // height animations
7288 [ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
7289 // width animations
7290 [ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
7291 // opacity animations
7292 [ "opacity" ]
7293 ];
7295 jQuery.fn.extend({
7296 show: function( speed, easing, callback ) {
7297 var elem, display;
7299 if ( speed || speed === 0 ) {
7300 return this.animate( genFx("show", 3), speed, easing, callback);
7302 } else {
7303 for ( var i = 0, j = this.length; i < j; i++ ) {
7304 elem = this[i];
7305 display = elem.style.display;
7307 // Reset the inline display of this element to learn if it is
7308 // being hidden by cascaded rules or not
7309 if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
7310 display = elem.style.display = "";
7311 }
7313 // Set elements which have been overridden with display: none
7314 // in a stylesheet to whatever the default browser style is
7315 // for such an element
7316 if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
7317 jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
7318 }
7319 }
7321 // Set the display of most of the elements in a second loop
7322 // to avoid the constant reflow
7323 for ( i = 0; i < j; i++ ) {
7324 elem = this[i];
7325 display = elem.style.display;
7327 if ( display === "" || display === "none" ) {
7328 elem.style.display = jQuery._data(elem, "olddisplay") || "";
7329 }
7330 }
7332 return this;
7333 }
7334 },
7336 hide: function( speed, easing, callback ) {
7337 if ( speed || speed === 0 ) {
7338 return this.animate( genFx("hide", 3), speed, easing, callback);
7340 } else {
7341 for ( var i = 0, j = this.length; i < j; i++ ) {
7342 var display = jQuery.css( this[i], "display" );
7344 if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
7345 jQuery._data( this[i], "olddisplay", display );
7346 }
7347 }
7349 // Set the display of the elements in a second loop
7350 // to avoid the constant reflow
7351 for ( i = 0; i < j; i++ ) {
7352 this[i].style.display = "none";
7353 }
7355 return this;
7356 }
7357 },
7359 // Save the old toggle function
7360 _toggle: jQuery.fn.toggle,
7362 toggle: function( fn, fn2, callback ) {
7363 var bool = typeof fn === "boolean";
7365 if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
7366 this._toggle.apply( this, arguments );
7368 } else if ( fn == null || bool ) {
7369 this.each(function() {
7370 var state = bool ? fn : jQuery(this).is(":hidden");
7371 jQuery(this)[ state ? "show" : "hide" ]();
7372 });
7374 } else {
7375 this.animate(genFx("toggle", 3), fn, fn2, callback);
7376 }
7378 return this;
7379 },
7381 fadeTo: function( speed, to, easing, callback ) {
7382 return this.filter(":hidden").css("opacity", 0).show().end()
7383 .animate({opacity: to}, speed, easing, callback);
7384 },
7386 animate: function( prop, speed, easing, callback ) {
7387 var optall = jQuery.speed(speed, easing, callback);
7389 if ( jQuery.isEmptyObject( prop ) ) {
7390 return this.each( optall.complete );
7391 }
7393 return this[ optall.queue === false ? "each" : "queue" ](function() {
7394 // XXX 'this' does not always have a nodeName when running the
7395 // test suite
7397 var opt = jQuery.extend({}, optall), p,
7398 isElement = this.nodeType === 1,
7399 hidden = isElement && jQuery(this).is(":hidden"),
7400 self = this;
7402 for ( p in prop ) {
7403 var name = jQuery.camelCase( p );
7405 if ( p !== name ) {
7406 prop[ name ] = prop[ p ];
7407 delete prop[ p ];
7408 p = name;
7409 }
7411 if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
7412 return opt.complete.call(this);
7413 }
7415 if ( isElement && ( p === "height" || p === "width" ) ) {
7416 // Make sure that nothing sneaks out
7417 // Record all 3 overflow attributes because IE does not
7418 // change the overflow attribute when overflowX and
7419 // overflowY are set to the same value
7420 opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
7422 // Set display property to inline-block for height/width
7423 // animations on inline elements that are having width/height
7424 // animated
7425 if ( jQuery.css( this, "display" ) === "inline" &&
7426 jQuery.css( this, "float" ) === "none" ) {
7427 if ( !jQuery.support.inlineBlockNeedsLayout ) {
7428 this.style.display = "inline-block";
7430 } else {
7431 var display = defaultDisplay(this.nodeName);
7433 // inline-level elements accept inline-block;
7434 // block-level elements need to be inline with layout
7435 if ( display === "inline" ) {
7436 this.style.display = "inline-block";
7438 } else {
7439 this.style.display = "inline";
7440 this.style.zoom = 1;
7441 }
7442 }
7443 }
7444 }
7446 if ( jQuery.isArray( prop[p] ) ) {
7447 // Create (if needed) and add to specialEasing
7448 (opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
7449 prop[p] = prop[p][0];
7450 }
7451 }
7453 if ( opt.overflow != null ) {
7454 this.style.overflow = "hidden";
7455 }
7457 opt.curAnim = jQuery.extend({}, prop);
7459 jQuery.each( prop, function( name, val ) {
7460 var e = new jQuery.fx( self, opt, name );
7462 if ( rfxtypes.test(val) ) {
7463 e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );
7465 } else {
7466 var parts = rfxnum.exec(val),
7467 start = e.cur() || 0;
7469 if ( parts ) {
7470 var end = parseFloat( parts[2] ),
7471 unit = parts[3] || "px";
7473 // We need to compute starting value
7474 if ( unit !== "px" ) {
7475 jQuery.style( self, name, (end || 1) + unit);
7476 start = ((end || 1) / e.cur()) * start;
7477 jQuery.style( self, name, start + unit);
7478 }
7480 // If a +=/-= token was provided, we're doing a relative animation
7481 if ( parts[1] ) {
7482 end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
7483 }
7485 e.custom( start, end, unit );
7487 } else {
7488 e.custom( start, val, "" );
7489 }
7490 }
7491 });
7493 // For JS strict compliance
7494 return true;
7495 });
7496 },
7498 stop: function( clearQueue, gotoEnd ) {
7499 var timers = jQuery.timers;
7501 if ( clearQueue ) {
7502 this.queue([]);
7503 }
7505 this.each(function() {
7506 // go in reverse order so anything added to the queue during the loop is ignored
7507 for ( var i = timers.length - 1; i >= 0; i-- ) {
7508 if ( timers[i].elem === this ) {
7509 if (gotoEnd) {
7510 // force the next step to be the last
7511 timers[i](true);
7512 }
7514 timers.splice(i, 1);
7515 }
7516 }
7517 });
7519 // start the next in the queue if the last step wasn't forced
7520 if ( !gotoEnd ) {
7521 this.dequeue();
7522 }
7524 return this;
7525 }
7527 });
7529 function genFx( type, num ) {
7530 var obj = {};
7532 jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
7533 obj[ this ] = type;
7534 });
7536 return obj;
7537 }
7539 // Generate shortcuts for custom animations
7540 jQuery.each({
7541 slideDown: genFx("show", 1),
7542 slideUp: genFx("hide", 1),
7543 slideToggle: genFx("toggle", 1),
7544 fadeIn: { opacity: "show" },
7545 fadeOut: { opacity: "hide" },
7546 fadeToggle: { opacity: "toggle" }
7547 }, function( name, props ) {
7548 jQuery.fn[ name ] = function( speed, easing, callback ) {
7549 return this.animate( props, speed, easing, callback );
7550 };
7551 });
7553 jQuery.extend({
7554 speed: function( speed, easing, fn ) {
7555 var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
7556 complete: fn || !fn && easing ||
7557 jQuery.isFunction( speed ) && speed,
7558 duration: speed,
7559 easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
7560 };
7562 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
7563 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
7565 // Queueing
7566 opt.old = opt.complete;
7567 opt.complete = function() {
7568 if ( opt.queue !== false ) {
7569 jQuery(this).dequeue();
7570 }
7571 if ( jQuery.isFunction( opt.old ) ) {
7572 opt.old.call( this );
7573 }
7574 };
7576 return opt;
7577 },
7579 easing: {
7580 linear: function( p, n, firstNum, diff ) {
7581 return firstNum + diff * p;
7582 },
7583 swing: function( p, n, firstNum, diff ) {
7584 return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
7585 }
7586 },
7588 timers: [],
7590 fx: function( elem, options, prop ) {
7591 this.options = options;
7592 this.elem = elem;
7593 this.prop = prop;
7595 if ( !options.orig ) {
7596 options.orig = {};
7597 }
7598 }
7600 });
7602 jQuery.fx.prototype = {
7603 // Simple function for setting a style value
7604 update: function() {
7605 if ( this.options.step ) {
7606 this.options.step.call( this.elem, this.now, this );
7607 }
7609 (jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
7610 },
7612 // Get the current size
7613 cur: function() {
7614 if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
7615 return this.elem[ this.prop ];
7616 }
7618 var r = parseFloat( jQuery.css( this.elem, this.prop ) );
7619 return r || 0;
7620 },
7622 // Start an animation from one number to another
7623 custom: function( from, to, unit ) {
7624 var self = this,
7625 fx = jQuery.fx;
7627 this.startTime = jQuery.now();
7628 this.start = from;
7629 this.end = to;
7630 this.unit = unit || this.unit || "px";
7631 this.now = this.start;
7632 this.pos = this.state = 0;
7634 function t( gotoEnd ) {
7635 return self.step(gotoEnd);
7636 }
7638 t.elem = this.elem;
7640 if ( t() && jQuery.timers.push(t) && !timerId ) {
7641 timerId = setInterval(fx.tick, fx.interval);
7642 }
7643 },
7645 // Simple 'show' function
7646 show: function() {
7647 // Remember where we started, so that we can go back to it later
7648 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
7649 this.options.show = true;
7651 // Begin the animation
7652 // Make sure that we start at a small width/height to avoid any
7653 // flash of content
7654 this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
7656 // Start by showing the element
7657 jQuery( this.elem ).show();
7658 },
7660 // Simple 'hide' function
7661 hide: function() {
7662 // Remember where we started, so that we can go back to it later
7663 this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
7664 this.options.hide = true;
7666 // Begin the animation
7667 this.custom(this.cur(), 0);
7668 },
7670 // Each step of an animation
7671 step: function( gotoEnd ) {
7672 var t = jQuery.now(), done = true;
7674 if ( gotoEnd || t >= this.options.duration + this.startTime ) {
7675 this.now = this.end;
7676 this.pos = this.state = 1;
7677 this.update();
7679 this.options.curAnim[ this.prop ] = true;
7681 for ( var i in this.options.curAnim ) {
7682 if ( this.options.curAnim[i] !== true ) {
7683 done = false;
7684 }
7685 }
7687 if ( done ) {
7688 // Reset the overflow
7689 if ( this.options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
7690 var elem = this.elem,
7691 options = this.options;
7693 jQuery.each( [ "", "X", "Y" ], function (index, value) {
7694 elem.style[ "overflow" + value ] = options.overflow[index];
7695 } );
7696 }
7698 // Hide the element if the "hide" operation was done
7699 if ( this.options.hide ) {
7700 jQuery(this.elem).hide();
7701 }
7703 // Reset the properties, if the item has been hidden or shown
7704 if ( this.options.hide || this.options.show ) {
7705 for ( var p in this.options.curAnim ) {
7706 jQuery.style( this.elem, p, this.options.orig[p] );
7707 }
7708 }
7710 // Execute the complete function
7711 this.options.complete.call( this.elem );
7712 }
7714 return false;
7716 } else {
7717 var n = t - this.startTime;
7718 this.state = n / this.options.duration;
7720 // Perform the easing function, defaults to swing
7721 var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop];
7722 var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear");
7723 this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
7724 this.now = this.start + ((this.end - this.start) * this.pos);
7726 // Perform the next step of the animation
7727 this.update();
7728 }
7730 return true;
7731 }
7732 };
7734 jQuery.extend( jQuery.fx, {
7735 tick: function() {
7736 var timers = jQuery.timers;
7738 for ( var i = 0; i < timers.length; i++ ) {
7739 if ( !timers[i]() ) {
7740 timers.splice(i--, 1);
7741 }
7742 }
7744 if ( !timers.length ) {
7745 jQuery.fx.stop();
7746 }
7747 },
7749 interval: 13,
7751 stop: function() {
7752 clearInterval( timerId );
7753 timerId = null;
7754 },
7756 speeds: {
7757 slow: 600,
7758 fast: 200,
7759 // Default speed
7760 _default: 400
7761 },
7763 step: {
7764 opacity: function( fx ) {
7765 jQuery.style( fx.elem, "opacity", fx.now );
7766 },
7768 _default: function( fx ) {
7769 if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
7770 fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
7771 } else {
7772 fx.elem[ fx.prop ] = fx.now;
7773 }
7774 }
7775 }
7776 });
7778 if ( jQuery.expr && jQuery.expr.filters ) {
7779 jQuery.expr.filters.animated = function( elem ) {
7780 return jQuery.grep(jQuery.timers, function( fn ) {
7781 return elem === fn.elem;
7782 }).length;
7783 };
7784 }
7786 function defaultDisplay( nodeName ) {
7787 if ( !elemdisplay[ nodeName ] ) {
7788 var elem = jQuery("<" + nodeName + ">").appendTo("body"),
7789 display = elem.css("display");
7791 elem.remove();
7793 if ( display === "none" || display === "" ) {
7794 display = "block";
7795 }
7797 elemdisplay[ nodeName ] = display;
7798 }
7800 return elemdisplay[ nodeName ];
7801 }
7806 var rtable = /^t(?:able|d|h)$/i,
7807 rroot = /^(?:body|html)$/i;
7809 if ( "getBoundingClientRect" in document.documentElement ) {
7810 jQuery.fn.offset = function( options ) {
7811 var elem = this[0], box;
7813 if ( options ) {
7814 return this.each(function( i ) {
7815 jQuery.offset.setOffset( this, options, i );
7816 });
7817 }
7819 if ( !elem || !elem.ownerDocument ) {
7820 return null;
7821 }
7823 if ( elem === elem.ownerDocument.body ) {
7824 return jQuery.offset.bodyOffset( elem );
7825 }
7827 try {
7828 box = elem.getBoundingClientRect();
7829 } catch(e) {}
7831 var doc = elem.ownerDocument,
7832 docElem = doc.documentElement;
7834 // Make sure we're not dealing with a disconnected DOM node
7835 if ( !box || !jQuery.contains( docElem, elem ) ) {
7836 return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
7837 }
7839 var body = doc.body,
7840 win = getWindow(doc),
7841 clientTop = docElem.clientTop || body.clientTop || 0,
7842 clientLeft = docElem.clientLeft || body.clientLeft || 0,
7843 scrollTop = (win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop || body.scrollTop ),
7844 scrollLeft = (win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft),
7845 top = box.top + scrollTop - clientTop,
7846 left = box.left + scrollLeft - clientLeft;
7848 return { top: top, left: left };
7849 };
7851 } else {
7852 jQuery.fn.offset = function( options ) {
7853 var elem = this[0];
7855 if ( options ) {
7856 return this.each(function( i ) {
7857 jQuery.offset.setOffset( this, options, i );
7858 });
7859 }
7861 if ( !elem || !elem.ownerDocument ) {
7862 return null;
7863 }
7865 if ( elem === elem.ownerDocument.body ) {
7866 return jQuery.offset.bodyOffset( elem );
7867 }
7869 jQuery.offset.initialize();
7871 var computedStyle,
7872 offsetParent = elem.offsetParent,
7873 prevOffsetParent = elem,
7874 doc = elem.ownerDocument,
7875 docElem = doc.documentElement,
7876 body = doc.body,
7877 defaultView = doc.defaultView,
7878 prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
7879 top = elem.offsetTop,
7880 left = elem.offsetLeft;
7882 while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
7883 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
7884 break;
7885 }
7887 computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
7888 top -= elem.scrollTop;
7889 left -= elem.scrollLeft;
7891 if ( elem === offsetParent ) {
7892 top += elem.offsetTop;
7893 left += elem.offsetLeft;
7895 if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
7896 top += parseFloat( computedStyle.borderTopWidth ) || 0;
7897 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
7898 }
7900 prevOffsetParent = offsetParent;
7901 offsetParent = elem.offsetParent;
7902 }
7904 if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
7905 top += parseFloat( computedStyle.borderTopWidth ) || 0;
7906 left += parseFloat( computedStyle.borderLeftWidth ) || 0;
7907 }
7909 prevComputedStyle = computedStyle;
7910 }
7912 if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
7913 top += body.offsetTop;
7914 left += body.offsetLeft;
7915 }
7917 if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
7918 top += Math.max( docElem.scrollTop, body.scrollTop );
7919 left += Math.max( docElem.scrollLeft, body.scrollLeft );
7920 }
7922 return { top: top, left: left };
7923 };
7924 }
7926 jQuery.offset = {
7927 initialize: function() {
7928 var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
7929 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>";
7931 jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
7933 container.innerHTML = html;
7934 body.insertBefore( container, body.firstChild );
7935 innerDiv = container.firstChild;
7936 checkDiv = innerDiv.firstChild;
7937 td = innerDiv.nextSibling.firstChild.firstChild;
7939 this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
7940 this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
7942 checkDiv.style.position = "fixed";
7943 checkDiv.style.top = "20px";
7945 // safari subtracts parent border width here which is 5px
7946 this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
7947 checkDiv.style.position = checkDiv.style.top = "";
7949 innerDiv.style.overflow = "hidden";
7950 innerDiv.style.position = "relative";
7952 this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
7954 this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
7956 body.removeChild( container );
7957 body = container = innerDiv = checkDiv = table = td = null;
7958 jQuery.offset.initialize = jQuery.noop;
7959 },
7961 bodyOffset: function( body ) {
7962 var top = body.offsetTop,
7963 left = body.offsetLeft;
7965 jQuery.offset.initialize();
7967 if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
7968 top += parseFloat( jQuery.css(body, "marginTop") ) || 0;
7969 left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
7970 }
7972 return { top: top, left: left };
7973 },
7975 setOffset: function( elem, options, i ) {
7976 var position = jQuery.css( elem, "position" );
7978 // set position first, in-case top/left are set even on static elem
7979 if ( position === "static" ) {
7980 elem.style.position = "relative";
7981 }
7983 var curElem = jQuery( elem ),
7984 curOffset = curElem.offset(),
7985 curCSSTop = jQuery.css( elem, "top" ),
7986 curCSSLeft = jQuery.css( elem, "left" ),
7987 calculatePosition = (position === "absolute" && jQuery.inArray('auto', [curCSSTop, curCSSLeft]) > -1),
7988 props = {}, curPosition = {}, curTop, curLeft;
7990 // need to be able to calculate position if either top or left is auto and position is absolute
7991 if ( calculatePosition ) {
7992 curPosition = curElem.position();
7993 }
7995 curTop = calculatePosition ? curPosition.top : parseInt( curCSSTop, 10 ) || 0;
7996 curLeft = calculatePosition ? curPosition.left : parseInt( curCSSLeft, 10 ) || 0;
7998 if ( jQuery.isFunction( options ) ) {
7999 options = options.call( elem, i, curOffset );
8000 }
8002 if (options.top != null) {
8003 props.top = (options.top - curOffset.top) + curTop;
8004 }
8005 if (options.left != null) {
8006 props.left = (options.left - curOffset.left) + curLeft;
8007 }
8009 if ( "using" in options ) {
8010 options.using.call( elem, props );
8011 } else {
8012 curElem.css( props );
8013 }
8014 }
8015 };
8018 jQuery.fn.extend({
8019 position: function() {
8020 if ( !this[0] ) {
8021 return null;
8022 }
8024 var elem = this[0],
8026 // Get *real* offsetParent
8027 offsetParent = this.offsetParent(),
8029 // Get correct offsets
8030 offset = this.offset(),
8031 parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
8033 // Subtract element margins
8034 // note: when an element has margin: auto the offsetLeft and marginLeft
8035 // are the same in Safari causing offset.left to incorrectly be 0
8036 offset.top -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
8037 offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
8039 // Add offsetParent borders
8040 parentOffset.top += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
8041 parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
8043 // Subtract the two offsets
8044 return {
8045 top: offset.top - parentOffset.top,
8046 left: offset.left - parentOffset.left
8047 };
8048 },
8050 offsetParent: function() {
8051 return this.map(function() {
8052 var offsetParent = this.offsetParent || document.body;
8053 while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
8054 offsetParent = offsetParent.offsetParent;
8055 }
8056 return offsetParent;
8057 });
8058 }
8059 });
8062 // Create scrollLeft and scrollTop methods
8063 jQuery.each( ["Left", "Top"], function( i, name ) {
8064 var method = "scroll" + name;
8066 jQuery.fn[ method ] = function(val) {
8067 var elem = this[0], win;
8069 if ( !elem ) {
8070 return null;
8071 }
8073 if ( val !== undefined ) {
8074 // Set the scroll offset
8075 return this.each(function() {
8076 win = getWindow( this );
8078 if ( win ) {
8079 win.scrollTo(
8080 !i ? val : jQuery(win).scrollLeft(),
8081 i ? val : jQuery(win).scrollTop()
8082 );
8084 } else {
8085 this[ method ] = val;
8086 }
8087 });
8088 } else {
8089 win = getWindow( elem );
8091 // Return the scroll offset
8092 return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
8093 jQuery.support.boxModel && win.document.documentElement[ method ] ||
8094 win.document.body[ method ] :
8095 elem[ method ];
8096 }
8097 };
8098 });
8100 function getWindow( elem ) {
8101 return jQuery.isWindow( elem ) ?
8102 elem :
8103 elem.nodeType === 9 ?
8104 elem.defaultView || elem.parentWindow :
8105 false;
8106 }
8111 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
8112 jQuery.each([ "Height", "Width" ], function( i, name ) {
8114 var type = name.toLowerCase();
8116 // innerHeight and innerWidth
8117 jQuery.fn["inner" + name] = function() {
8118 return this[0] ?
8119 parseFloat( jQuery.css( this[0], type, "padding" ) ) :
8120 null;
8121 };
8123 // outerHeight and outerWidth
8124 jQuery.fn["outer" + name] = function( margin ) {
8125 return this[0] ?
8126 parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
8127 null;
8128 };
8130 jQuery.fn[ type ] = function( size ) {
8131 // Get window width or height
8132 var elem = this[0];
8133 if ( !elem ) {
8134 return size == null ? null : this;
8135 }
8137 if ( jQuery.isFunction( size ) ) {
8138 return this.each(function( i ) {
8139 var self = jQuery( this );
8140 self[ type ]( size.call( this, i, self[ type ]() ) );
8141 });
8142 }
8144 if ( jQuery.isWindow( elem ) ) {
8145 // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
8146 // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
8147 var docElemProp = elem.document.documentElement[ "client" + name ];
8148 return elem.document.compatMode === "CSS1Compat" && docElemProp ||
8149 elem.document.body[ "client" + name ] || docElemProp;
8151 // Get document width or height
8152 } else if ( elem.nodeType === 9 ) {
8153 // Either scroll[Width/Height] or offset[Width/Height], whichever is greater
8154 return Math.max(
8155 elem.documentElement["client" + name],
8156 elem.body["scroll" + name], elem.documentElement["scroll" + name],
8157 elem.body["offset" + name], elem.documentElement["offset" + name]
8158 );
8160 // Get or set width or height on the element
8161 } else if ( size === undefined ) {
8162 var orig = jQuery.css( elem, type ),
8163 ret = parseFloat( orig );
8165 return jQuery.isNaN( ret ) ? orig : ret;
8167 // Set the width or height on the element (default to pixels if value is unitless)
8168 } else {
8169 return this.css( type, typeof size === "string" ? size : size + "px" );
8170 }
8171 };
8173 });
8176 })(window);