WordPress.org

Make WordPress Core

Changeset 16318


Ignore:
Timestamp:
11/12/2010 07:13:11 AM (8 years ago)
Author:
nacin
Message:

jQuery 1.4.4. props demetris, fixes #15201, #15227.

Location:
trunk/wp-includes
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/wp-includes/js/jquery/jquery.js

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