WordPress.org

Make WordPress Core

Changeset 16318


Ignore:
Timestamp:
11/12/10 07:13:11 (6 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