Changeset 8162


Ignore:
Timestamp:
12/16/10 07:09:14 (9 years ago)
Author:
rvelices
Message:

jquery upgrade to 1.4.4

Location:
trunk
Files:
1 added
1 deleted
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/admin/themes/default/template/header.tpl

    r8008 r8162  
    2626<!-- END get_combined_scripts --> 
    2727 
    28 {combine_script id='jquery' path='themes/default/js/jquery.packed.js'} 
     28{combine_script id='jquery' path='themes/default/js/jquery.min.js'} 
    2929 
    3030<!--[if lt IE 7]> 
  • trunk/admin/themes/default/template/include/autosize.inc.tpl

    r7995 r8162  
    1 {combine_script id='jquery' load='async' path='themes/default/js/jquery.packed.js'} 
     1{combine_script id='jquery' load='async' path='themes/default/js/jquery.min.js'} 
    22{combine_script id='jquery.autogrow' load='async' require='jquery' path='themes/default/js/plugins/jquery.autogrow-textarea.js'} 
    33{* Auto size and auto grow textarea *} 
  • trunk/admin/themes/default/template/include/datepicker.inc.tpl

    r8076 r8162  
    1 {combine_script id='jquery' load='footer' path='themes/default/js/jquery.packed.js'} 
     1{combine_script id='jquery' load='footer' path='themes/default/js/jquery.min.js'} 
    22{combine_script id='jquery.ui' load='footer' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js'} 
    33{combine_script id='jquery.ui.datepicker' load='footer' require='jquery.ui' path='themes/default/js/ui/packed/ui.datepicker.packed.js'} 
  • trunk/admin/themes/default/template/include/dbselect.inc.tpl

    r7995 r8162  
    1 {combine_script id='jquery' load='async' path='themes/default/js/jquery.packed.js'} 
     1{combine_script id='jquery' load='async' path='themes/default/js/jquery.min.js'} 
    22{combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js' } 
    33{combine_script id='jquery.ui.resizable' load='async' require='jquery.ui' path='themes/default/js/ui/packed/ui.resizable.packed.js' } 
  • trunk/admin/themes/default/template/include/resize.inc.tpl

    r7995 r8162  
    1 {combine_script id='jquery' load='async' path='themes/default/js/jquery.packed.js'} 
     1{combine_script id='jquery' load='async' path='themes/default/js/jquery.min.js'} 
    22{combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js'} 
    33{combine_script id='jquery.ui.resizable' load='async' require='jquery.ui' path='themes/default/js/ui/packed/ui.resizable.packed.js'} 
  • trunk/admin/themes/default/template/install.tpl

    r6363 r8162  
    1313{/foreach} 
    1414 
    15 <script type="text/javascript" src="themes/default/js/jquery.packed.js"></script> 
     15<script type="text/javascript" src="themes/default/js/jquery.min.js"></script> 
    1616{literal} 
    1717<script type="text/javascript"> 
  • trunk/include/template.class.php

    r8128 r8162  
    524524    } 
    525525    $id = $params['id']; 
     526    trigger_error("known_script is deprecated $id ".@$params['src'], E_USER_WARNING); 
     527    if ('jquery'==$id) 
     528    { 
     529      $this->scriptLoader->add($id, 0, array(), null); 
     530      return; 
     531    } 
    526532    if (! isset( $this->known_scripts[$id] ) ) 
    527533    { 
  • trunk/themes/default/js/jquery.js

    r4918 r8162  
    11/*! 
    2  * jQuery JavaScript Library v1.4.1 
     2 * jQuery JavaScript Library v1.4.4 
    33 * http://jquery.com/ 
    44 * 
     
    1212 * Released under the MIT, BSD, and GPL Licenses. 
    1313 * 
    14  * Date: Mon Jan 25 19:43:33 2010 -0500 
     14 * Date: Thu Nov 11 19:04:53 2010 -0500 
    1515 */ 
    1616(function( window, undefined ) { 
     17 
     18// Use the correct document accordingly with window argument (sandbox) 
     19var document = window.document; 
     20var jQuery = (function() { 
    1721 
    1822// Define a local copy of jQuery 
     
    2832        _$ = window.$, 
    2933 
    30         // Use the correct document accordingly with window argument (sandbox) 
    31         document = window.document, 
    32  
    3334        // A central reference to the root jQuery(document) 
    3435        rootjQuery, 
     
    3637        // A simple way to check for HTML strings or ID strings 
    3738        // (both of which we optimize for) 
    38         quickExpr = /^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/, 
     39        quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/, 
    3940 
    4041        // Is it a simple selector 
     
    4344        // Check if a string has a non-whitespace character in it 
    4445        rnotwhite = /\S/, 
     46        rwhite = /\s/, 
    4547 
    4648        // Used for trimming whitespace 
    47         rtrim = /^(\s|\u00A0)+|(\s|\u00A0)+$/g, 
     49        trimLeft = /^\s+/, 
     50        trimRight = /\s+$/, 
     51 
     52        // Check for non-word characters 
     53        rnonword = /\W/, 
     54 
     55        // Check for digits 
     56        rdigit = /\d/, 
    4857 
    4958        // Match a standalone tag 
    5059        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.]+))?/, 
    5172 
    5273        // Keep a UserAgent string for use with jQuery.browser 
     
    6788        // Save a reference to some core methods 
    6889        toString = Object.prototype.toString, 
    69         hasOwnProperty = Object.prototype.hasOwnProperty, 
     90        hasOwn = Object.prototype.hasOwnProperty, 
    7091        push = Array.prototype.push, 
    7192        slice = Array.prototype.slice, 
    72         indexOf = Array.prototype.indexOf; 
     93        trim = String.prototype.trim, 
     94        indexOf = Array.prototype.indexOf, 
     95         
     96        // [[Class]] -> type pairs 
     97        class2type = {}; 
    7398 
    7499jQuery.fn = jQuery.prototype = { 
     
    87112                        return this; 
    88113                } 
     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                } 
    89123 
    90124                // Handle HTML strings 
     
    114148 
    115149                                        } else { 
    116                                                 ret = buildFragment( [ match[1] ], [ doc ] ); 
     150                                                ret = jQuery.buildFragment( [ match[1] ], [ doc ] ); 
    117151                                                selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes; 
    118152                                        } 
    119  
     153                                         
     154                                        return jQuery.merge( this, selector ); 
     155                                         
    120156                                // HANDLE: $("#id") 
    121157                                } else { 
    122158                                        elem = document.getElementById( match[2] ); 
    123159 
    124                                         if ( elem ) { 
     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 ) { 
    125163                                                // Handle the case where IE and Opera return items 
    126164                                                // by name instead of ID 
     
    140178 
    141179                        // HANDLE: $("TAG") 
    142                         } else if ( !context && /^\w+$/.test( selector ) ) { 
     180                        } else if ( !context && !rnonword.test( selector ) ) { 
    143181                                this.selector = selector; 
    144182                                this.context = document; 
    145183                                selector = document.getElementsByTagName( selector ); 
     184                                return jQuery.merge( this, selector ); 
    146185 
    147186                        // HANDLE: $(expr, $(...)) 
     
    166205                } 
    167206 
    168                 return jQuery.isArray( selector ) ? 
    169                         this.setArray( selector ) : 
    170                         jQuery.makeArray( selector, this ); 
     207                return jQuery.makeArray( selector, this ); 
    171208        }, 
    172209 
     
    175212 
    176213        // The current version of jQuery being used 
    177         jquery: "1.4.1", 
     214        jquery: "1.4.4", 
    178215 
    179216        // The default length of a jQuery object is 0 
     
    205242        pushStack: function( elems, name, selector ) { 
    206243                // Build a new jQuery matched element set 
    207                 var ret = jQuery( elems || null ); 
     244                var ret = jQuery(); 
     245 
     246                if ( jQuery.isArray( elems ) ) { 
     247                        push.apply( ret, elems ); 
     248                 
     249                } else { 
     250                        jQuery.merge( ret, elems ); 
     251                } 
    208252 
    209253                // Add the old object onto the stack (as a reference) 
     
    220264                // Return the newly-formed element set 
    221265                return ret; 
    222         }, 
    223  
    224         // Force the current matched set of elements to become 
    225         // the specified array of elements (destroying the stack in the process) 
    226         // You should use pushStack() in order to do this, but maintain the stack 
    227         setArray: function( elems ) { 
    228                 // Resetting the length to 0, then using the native Array push 
    229                 // is a super-fast way to populate an object with array-like properties 
    230                 this.length = 0; 
    231                 push.apply( this, elems ); 
    232  
    233                 return this; 
    234266        }, 
    235267 
     
    299331 
    300332jQuery.extend = jQuery.fn.extend = function() { 
    301         // copy reference to target object 
    302         var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy; 
     333         var options, name, src, copy, copyIsArray, clone, 
     334                target = arguments[0] || {}, 
     335                i = 1, 
     336                length = arguments.length, 
     337                deep = false; 
    303338 
    304339        // Handle a deep copy situation 
     
    334369                                } 
    335370 
    336                                 // Recurse if we're merging object literal values or arrays 
    337                                 if ( deep && copy && ( jQuery.isPlainObject(copy) || jQuery.isArray(copy) ) ) { 
    338                                         var clone = src && ( jQuery.isPlainObject(src) || jQuery.isArray(src) ) ? src 
    339                                                 : jQuery.isArray(copy) ? [] : {}; 
     371                                // Recurse if we're merging plain objects or arrays 
     372                                if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { 
     373                                        if ( copyIsArray ) { 
     374                                                copyIsArray = false; 
     375                                                clone = src && jQuery.isArray(src) ? src : []; 
     376 
     377                                        } else { 
     378                                                clone = src && jQuery.isPlainObject(src) ? src : {}; 
     379                                        } 
    340380 
    341381                                        // Never move original objects, clone them 
     
    367407        // Is the DOM ready to be used? Set to true once it occurs. 
    368408        isReady: false, 
     409 
     410        // A counter to track how many items to wait for before 
     411        // the ready event fires. See #6781 
     412        readyWait: 1, 
    369413         
    370414        // Handle when the DOM is ready 
    371         ready: function() { 
     415        ready: function( wait ) { 
     416                // A third-party is pushing the ready event forwards 
     417                if ( wait === true ) { 
     418                        jQuery.readyWait--; 
     419                } 
     420 
    372421                // Make sure that the DOM is not already loaded 
    373                 if ( !jQuery.isReady ) { 
     422                if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) { 
    374423                        // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). 
    375424                        if ( !document.body ) { 
    376                                 return setTimeout( jQuery.ready, 13 ); 
     425                                return setTimeout( jQuery.ready, 1 ); 
    377426                        } 
    378427 
    379428                        // Remember that the DOM is ready 
    380429                        jQuery.isReady = true; 
     430 
     431                        // If a normal DOM Ready event fired, decrement, and wait if need be 
     432                        if ( wait !== true && --jQuery.readyWait > 0 ) { 
     433                                return; 
     434                        } 
    381435 
    382436                        // If there are functions bound, to execute 
    383437                        if ( readyList ) { 
    384438                                // Execute all of them 
    385                                 var fn, i = 0; 
    386                                 while ( (fn = readyList[ i++ ]) ) { 
    387                                         fn.call( document, jQuery ); 
    388                                 } 
     439                                var fn, 
     440                                        i = 0, 
     441                                        ready = readyList; 
    389442 
    390443                                // Reset the list of functions 
    391444                                readyList = null; 
    392                         } 
    393  
    394                         // Trigger any bound ready events 
    395                         if ( jQuery.fn.triggerHandler ) { 
    396                                 jQuery( document ).triggerHandler( "ready" ); 
     445 
     446                                while ( (fn = ready[ i++ ]) ) { 
     447                                        fn.call( document, jQuery ); 
     448                                } 
     449 
     450                                // Trigger any bound ready events 
     451                                if ( jQuery.fn.trigger ) { 
     452                                        jQuery( document ).trigger( "ready" ).unbind( "ready" ); 
     453                                } 
    397454                        } 
    398455                } 
     
    409466                // browser event has already occurred. 
    410467                if ( document.readyState === "complete" ) { 
    411                         return jQuery.ready(); 
     468                        // Handle it asynchronously to allow scripts the opportunity to delay ready 
     469                        return setTimeout( jQuery.ready, 1 ); 
    412470                } 
    413471 
     
    447505        // aren't supported. They return false on IE (#2968). 
    448506        isFunction: function( obj ) { 
    449                 return toString.call(obj) === "[object Function]"; 
    450         }, 
    451  
    452         isArray: function( obj ) { 
    453                 return toString.call(obj) === "[object Array]"; 
     507                return jQuery.type(obj) === "function"; 
     508        }, 
     509 
     510        isArray: Array.isArray || function( obj ) { 
     511                return jQuery.type(obj) === "array"; 
     512        }, 
     513 
     514        // A crude way of determining if an object is a window 
     515        isWindow: function( obj ) { 
     516                return obj && typeof obj === "object" && "setInterval" in obj; 
     517        }, 
     518 
     519        isNaN: function( obj ) { 
     520                return obj == null || !rdigit.test( obj ) || isNaN( obj ); 
     521        }, 
     522 
     523        type: function( obj ) { 
     524                return obj == null ? 
     525                        String( obj ) : 
     526                        class2type[ toString.call(obj) ] || "object"; 
    454527        }, 
    455528 
     
    458531                // Because of IE, we also have to check the presence of the constructor property. 
    459532                // Make sure that DOM nodes and window objects don't pass through, as well 
    460                 if ( !obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval ) { 
     533                if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) { 
    461534                        return false; 
    462535                } 
    463536                 
    464537                // Not own constructor property must be Object 
    465                 if ( obj.constructor 
    466                         && !hasOwnProperty.call(obj, "constructor") 
    467                         && !hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf") ) { 
     538                if ( obj.constructor && 
     539                        !hasOwn.call(obj, "constructor") && 
     540                        !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { 
    468541                        return false; 
    469542                } 
     
    475548                for ( key in obj ) {} 
    476549                 
    477                 return key === undefined || hasOwnProperty.call( obj, key ); 
     550                return key === undefined || hasOwn.call( obj, key ); 
    478551        }, 
    479552 
     
    493566                        return null; 
    494567                } 
     568 
     569                // Make sure leading/trailing whitespace is removed (IE can't handle it) 
     570                data = jQuery.trim( data ); 
    495571                 
    496572                // Make sure the incoming data is actual JSON 
    497573                // Logic borrowed from http://json.org/json2.js 
    498                 if ( /^[\],:{}\s]*$/.test(data.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@") 
    499                         .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]") 
    500                         .replace(/(?:^|:|,)(?:\s*\[)+/g, "")) ) { 
     574                if ( rvalidchars.test(data.replace(rvalidescape, "@") 
     575                        .replace(rvalidtokens, "]") 
     576                        .replace(rvalidbraces, "")) ) { 
    501577 
    502578                        // Try to use the native JSON parser first 
     
    577653        }, 
    578654 
    579         trim: function( text ) { 
    580                 return (text || "").replace( rtrim, "" ); 
    581         }, 
     655        // Use native String.trim function wherever possible 
     656        trim: trim ? 
     657                function( text ) { 
     658                        return text == null ? 
     659                                "" : 
     660                                trim.call( text ); 
     661                } : 
     662 
     663                // Otherwise use our own trimming functionality 
     664                function( text ) { 
     665                        return text == null ? 
     666                                "" : 
     667                                text.toString().replace( trimLeft, "" ).replace( trimRight, "" ); 
     668                }, 
    582669 
    583670        // results is for internal usage only 
     
    589676                        // The extra typeof function check is to prevent crashes 
    590677                        // in Safari 2 (See: #3039) 
    591                         if ( array.length == null || typeof array === "string" || jQuery.isFunction(array) || (typeof array !== "function" && array.setInterval) ) { 
     678                        // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 
     679                        var type = jQuery.type(array); 
     680 
     681                        if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) { 
    592682                                push.call( ret, array ); 
    593683                        } else { 
     
    614704 
    615705        merge: function( first, second ) { 
    616                 var i = first.length, j = 0; 
     706                var i = first.length, 
     707                        j = 0; 
    617708 
    618709                if ( typeof second.length === "number" ) { 
     
    620711                                first[ i++ ] = second[ j ]; 
    621712                        } 
     713                 
    622714                } else { 
    623715                        while ( second[j] !== undefined ) { 
     
    632724 
    633725        grep: function( elems, callback, inv ) { 
    634                 var ret = []; 
     726                var ret = [], retVal; 
     727                inv = !!inv; 
    635728 
    636729                // Go through the array, only saving the items 
    637730                // that pass the validator function 
    638731                for ( var i = 0, length = elems.length; i < length; i++ ) { 
    639                         if ( !inv !== !callback( elems[ i ], i ) ) { 
     732                        retVal = !!callback( elems[ i ], i ); 
     733                        if ( inv !== retVal ) { 
    640734                                ret.push( elems[ i ] ); 
    641735                        } 
     
    693787        }, 
    694788 
     789        // Mutifunctional method to get and set values to a collection 
     790        // The value/s can be optionally by executed if its a function 
     791        access: function( elems, key, value, exec, fn, pass ) { 
     792                var length = elems.length; 
     793         
     794                // Setting many attributes 
     795                if ( typeof key === "object" ) { 
     796                        for ( var k in key ) { 
     797                                jQuery.access( elems, k, key[k], exec, fn, value ); 
     798                        } 
     799                        return elems; 
     800                } 
     801         
     802                // Setting one attribute 
     803                if ( value !== undefined ) { 
     804                        // Optionally, function values get executed if exec is true 
     805                        exec = !pass && exec && jQuery.isFunction(value); 
     806                 
     807                        for ( var i = 0; i < length; i++ ) { 
     808                                fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); 
     809                        } 
     810                 
     811                        return elems; 
     812                } 
     813         
     814                // Getting an attribute 
     815                return length ? fn( elems[0], key ) : undefined; 
     816        }, 
     817 
     818        now: function() { 
     819                return (new Date()).getTime(); 
     820        }, 
     821 
    695822        // Use of jQuery.browser is frowned upon. 
    696823        // More details: http://docs.jquery.com/Utilities/jQuery.browser 
     
    698825                ua = ua.toLowerCase(); 
    699826 
    700                 var match = /(webkit)[ \/]([\w.]+)/.exec( ua ) || 
    701                         /(opera)(?:.*version)?[ \/]([\w.]+)/.exec( ua ) || 
    702                         /(msie) ([\w.]+)/.exec( ua ) || 
    703                         !/compatible/.test( ua ) && /(mozilla)(?:.*? rv:([\w.]+))?/.exec( ua ) || 
    704                         []; 
     827                var match = rwebkit.exec( ua ) || 
     828                        ropera.exec( ua ) || 
     829                        rmsie.exec( ua ) || 
     830                        ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) || 
     831                        []; 
    705832 
    706833                return { browser: match[1] || "", version: match[2] || "0" }; 
     
    708835 
    709836        browser: {} 
     837}); 
     838 
     839// Populate the class2type map 
     840jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) { 
     841        class2type[ "[object " + name + "]" ] = name.toLowerCase(); 
    710842}); 
    711843 
     
    725857                return indexOf.call( array, elem ); 
    726858        }; 
     859} 
     860 
     861// Verify that \s matches non-breaking spaces 
     862// (IE fails on this test) 
     863if ( !rwhite.test( "\xA0" ) ) { 
     864        trimLeft = /^[\s\xA0]+/; 
     865        trimRight = /[\s\xA0]+$/; 
    727866} 
    728867 
     
    757896                // http://javascript.nwbox.com/IEContentLoaded/ 
    758897                document.documentElement.doScroll("left"); 
    759         } catch( error ) { 
     898        } catch(e) { 
    760899                setTimeout( doScrollCheck, 1 ); 
    761900                return; 
     
    766905} 
    767906 
    768 function evalScript( i, elem ) { 
    769         if ( elem.src ) { 
    770                 jQuery.ajax({ 
    771                         url: elem.src, 
    772                         async: false, 
    773                         dataType: "script" 
    774                 }); 
    775         } else { 
    776                 jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" ); 
    777         } 
    778  
    779         if ( elem.parentNode ) { 
    780                 elem.parentNode.removeChild( elem ); 
    781         } 
    782 } 
    783  
    784 // Mutifunctional method to get and set values to a collection 
    785 // The value/s can be optionally by executed if its a function 
    786 function access( elems, key, value, exec, fn, pass ) { 
    787         var length = elems.length; 
    788          
    789         // Setting many attributes 
    790         if ( typeof key === "object" ) { 
    791                 for ( var k in key ) { 
    792                         access( elems, k, key[k], exec, fn, value ); 
    793                 } 
    794                 return elems; 
    795         } 
    796          
    797         // Setting one attribute 
    798         if ( value !== undefined ) { 
    799                 // Optionally, function values get executed if exec is true 
    800                 exec = !pass && exec && jQuery.isFunction(value); 
    801                  
    802                 for ( var i = 0; i < length; i++ ) { 
    803                         fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass ); 
    804                 } 
    805                  
    806                 return elems; 
    807         } 
    808          
    809         // Getting an attribute 
    810         return length ? fn( elems[0], key ) : null; 
    811 } 
    812  
    813 function now() { 
    814         return (new Date).getTime(); 
    815 } 
     907// Expose jQuery to the global object 
     908return (window.jQuery = window.$ = jQuery); 
     909 
     910})(); 
     911 
     912 
    816913(function() { 
    817914 
     
    821918                script = document.createElement("script"), 
    822919                div = document.createElement("div"), 
    823                 id = "script" + now(); 
     920                id = "script" + jQuery.now(); 
    824921 
    825922        div.style.display = "none"; 
     
    827924 
    828925        var all = div.getElementsByTagName("*"), 
    829                 a = div.getElementsByTagName("a")[0]; 
     926                a = div.getElementsByTagName("a")[0], 
     927                select = document.createElement("select"), 
     928                opt = select.appendChild( document.createElement("option") ); 
    830929 
    831930        // Can't get basic test support 
     
    870969                // Make sure that a selected-by-default option has a working selected property. 
    871970                // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) 
    872                 optSelected: document.createElement("select").appendChild( document.createElement("option") ).selected, 
     971                optSelected: opt.selected, 
    873972 
    874973                // Will be defined later 
     974                deleteExpando: true, 
     975                optDisabled: false, 
    875976                checkClone: false, 
    876977                scriptEval: false, 
    877978                noCloneEvent: true, 
    878                 boxModel: null 
     979                boxModel: null, 
     980                inlineBlockNeedsLayout: false, 
     981                shrinkWrapBlocks: false, 
     982                reliableHiddenOffsets: true 
    879983        }; 
     984 
     985        // Make sure that the options inside disabled selects aren't marked as disabled 
     986        // (WebKit marks them as diabled) 
     987        select.disabled = true; 
     988        jQuery.support.optDisabled = !opt.disabled; 
    880989 
    881990        script.type = "text/javascript"; 
     
    8921001                jQuery.support.scriptEval = true; 
    8931002                delete window[ id ]; 
     1003        } 
     1004 
     1005        // Test to see if it's possible to delete an expando from an element 
     1006        // Fails in Internet Explorer 
     1007        try { 
     1008                delete script.test; 
     1009 
     1010        } catch(e) { 
     1011                jQuery.support.deleteExpando = false; 
    8941012        } 
    8951013 
     
    9231041                document.body.appendChild( div ); 
    9241042                jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2; 
    925                 document.body.removeChild( div ).style.display = 'none'; 
    926                 div = null; 
     1043 
     1044                if ( "zoom" in div.style ) { 
     1045                        // Check if natively block-level elements act like inline-block 
     1046                        // elements when setting their display to 'inline' and giving 
     1047                        // them layout 
     1048                        // (IE < 8 does this) 
     1049                        div.style.display = "inline"; 
     1050                        div.style.zoom = 1; 
     1051                        jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2; 
     1052 
     1053                        // Check if elements with layout shrink-wrap their children 
     1054                        // (IE 6 does this) 
     1055                        div.style.display = ""; 
     1056                        div.innerHTML = "<div style='width:4px;'></div>"; 
     1057                        jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2; 
     1058                } 
     1059 
     1060                div.innerHTML = "<table><tr><td style='padding:0;display:none'></td><td>t</td></tr></table>"; 
     1061                var tds = div.getElementsByTagName("td"); 
     1062 
     1063                // Check if table cells still have offsetWidth/Height when they are set 
     1064                // to display:none and there are still other visible table cells in a 
     1065                // table row; if so, offsetWidth/Height are not reliable for use when 
     1066                // determining if an element has been hidden directly using 
     1067                // display:none (it is still safe to use offsets if a parent element is 
     1068                // hidden; don safety goggles and see bug #4512 for more information). 
     1069                // (only IE 8 fails this test) 
     1070                jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0; 
     1071 
     1072                tds[0].style.display = ""; 
     1073                tds[1].style.display = "none"; 
     1074 
     1075                // Check if empty table cells still have offsetWidth/Height 
     1076                // (IE < 8 fail this test) 
     1077                jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0; 
     1078                div.innerHTML = ""; 
     1079 
     1080                document.body.removeChild( div ).style.display = "none"; 
     1081                div = tds = null; 
    9271082        }); 
    9281083 
    9291084        // Technique from Juriy Zaytsev 
    9301085        // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/ 
    931         var eventSupported = function( eventName ) {  
    932                 var el = document.createElement("div");  
    933                 eventName = "on" + eventName;  
    934  
    935                 var isSupported = (eventName in el);  
    936                 if ( !isSupported ) {  
    937                         el.setAttribute(eventName, "return;");  
    938                         isSupported = typeof el[eventName] === "function";  
    939                 }  
    940                 el = null;  
    941  
    942                 return isSupported;  
     1086        var eventSupported = function( eventName ) { 
     1087                var el = document.createElement("div"); 
     1088                eventName = "on" + eventName; 
     1089 
     1090                var isSupported = (eventName in el); 
     1091                if ( !isSupported ) { 
     1092                        el.setAttribute(eventName, "return;"); 
     1093                        isSupported = typeof el[eventName] === "function"; 
     1094                } 
     1095                el = null; 
     1096 
     1097                return isSupported; 
    9431098        }; 
    944          
     1099 
    9451100        jQuery.support.submitBubbles = eventSupported("submit"); 
    9461101        jQuery.support.changeBubbles = eventSupported("change"); 
     
    9491104        root = script = div = all = a = null; 
    9501105})(); 
     1106 
     1107 
     1108 
     1109var windowData = {}, 
     1110        rbrace = /^(?:\{.*\}|\[.*\])$/; 
     1111 
     1112jQuery.extend({ 
     1113        cache: {}, 
     1114 
     1115        // Please use with caution 
     1116        uuid: 0, 
     1117 
     1118        // Unique for each copy of jQuery on the page    
     1119        expando: "jQuery" + jQuery.now(), 
     1120 
     1121        // The following elements throw uncatchable exceptions if you 
     1122        // attempt to add expando properties to them. 
     1123        noData: { 
     1124                "embed": true, 
     1125                // Ban all objects except for Flash (which handle expandos) 
     1126                "object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000", 
     1127                "applet": true 
     1128        }, 
     1129 
     1130        data: function( elem, name, data ) { 
     1131                if ( !jQuery.acceptData( elem ) ) { 
     1132                        return; 
     1133                } 
     1134 
     1135                elem = elem == window ? 
     1136                        windowData : 
     1137                        elem; 
     1138 
     1139                var isNode = elem.nodeType, 
     1140                        id = isNode ? elem[ jQuery.expando ] : null, 
     1141                        cache = jQuery.cache, thisCache; 
     1142 
     1143                if ( isNode && !id && typeof name === "string" && data === undefined ) { 
     1144                        return; 
     1145                } 
     1146 
     1147                // Get the data from the object directly 
     1148                if ( !isNode ) { 
     1149                        cache = elem; 
     1150 
     1151                // Compute a unique ID for the element 
     1152                } else if ( !id ) { 
     1153                        elem[ jQuery.expando ] = id = ++jQuery.uuid; 
     1154                } 
     1155 
     1156                // Avoid generating a new cache unless none exists and we 
     1157                // want to manipulate it. 
     1158                if ( typeof name === "object" ) { 
     1159                        if ( isNode ) { 
     1160                                cache[ id ] = jQuery.extend(cache[ id ], name); 
     1161 
     1162                        } else { 
     1163                                jQuery.extend( cache, name ); 
     1164                        } 
     1165 
     1166                } else if ( isNode && !cache[ id ] ) { 
     1167                        cache[ id ] = {}; 
     1168                } 
     1169 
     1170                thisCache = isNode ? cache[ id ] : cache; 
     1171 
     1172                // Prevent overriding the named cache with undefined values 
     1173                if ( data !== undefined ) { 
     1174                        thisCache[ name ] = data; 
     1175                } 
     1176 
     1177                return typeof name === "string" ? thisCache[ name ] : thisCache; 
     1178        }, 
     1179 
     1180        removeData: function( elem, name ) { 
     1181                if ( !jQuery.acceptData( elem ) ) { 
     1182                        return; 
     1183                } 
     1184 
     1185                elem = elem == window ? 
     1186                        windowData : 
     1187                        elem; 
     1188 
     1189                var isNode = elem.nodeType, 
     1190                        id = isNode ? elem[ jQuery.expando ] : elem, 
     1191                        cache = jQuery.cache, 
     1192                        thisCache = isNode ? cache[ id ] : id; 
     1193 
     1194                // If we want to remove a specific section of the element's data 
     1195                if ( name ) { 
     1196                        if ( thisCache ) { 
     1197                                // Remove the section of cache data 
     1198                                delete thisCache[ name ]; 
     1199 
     1200                                // If we've removed all the data, remove the element's cache 
     1201                                if ( isNode && jQuery.isEmptyObject(thisCache) ) { 
     1202                                        jQuery.removeData( elem ); 
     1203                                } 
     1204                        } 
     1205 
     1206                // Otherwise, we want to remove all of the element's data 
     1207                } else { 
     1208                        if ( isNode && jQuery.support.deleteExpando ) { 
     1209                                delete elem[ jQuery.expando ]; 
     1210 
     1211                        } else if ( elem.removeAttribute ) { 
     1212                                elem.removeAttribute( jQuery.expando ); 
     1213 
     1214                        // Completely remove the data cache 
     1215                        } else if ( isNode ) { 
     1216                                delete cache[ id ]; 
     1217 
     1218                        // Remove all fields from the object 
     1219                        } else { 
     1220                                for ( var n in elem ) { 
     1221                                        delete elem[ n ]; 
     1222                                } 
     1223                        } 
     1224                } 
     1225        }, 
     1226 
     1227        // A method for determining if a DOM node can handle the data expando 
     1228        acceptData: function( elem ) { 
     1229                if ( elem.nodeName ) { 
     1230                        var match = jQuery.noData[ elem.nodeName.toLowerCase() ]; 
     1231 
     1232                        if ( match ) { 
     1233                                return !(match === true || elem.getAttribute("classid") !== match); 
     1234                        } 
     1235                } 
     1236 
     1237                return true; 
     1238        } 
     1239}); 
     1240 
     1241jQuery.fn.extend({ 
     1242        data: function( key, value ) { 
     1243                var data = null; 
     1244 
     1245                if ( typeof key === "undefined" ) { 
     1246                        if ( this.length ) { 
     1247                                var attr = this[0].attributes, name; 
     1248                                data = jQuery.data( this[0] ); 
     1249 
     1250                                for ( var i = 0, l = attr.length; i < l; i++ ) { 
     1251                                        name = attr[i].name; 
     1252 
     1253                                        if ( name.indexOf( "data-" ) === 0 ) { 
     1254                                                name = name.substr( 5 ); 
     1255                                                dataAttr( this[0], name, data[ name ] ); 
     1256                                        } 
     1257                                } 
     1258                        } 
     1259 
     1260                        return data; 
     1261 
     1262                } else if ( typeof key === "object" ) { 
     1263                        return this.each(function() { 
     1264                                jQuery.data( this, key ); 
     1265                        }); 
     1266                } 
     1267 
     1268                var parts = key.split("."); 
     1269                parts[1] = parts[1] ? "." + parts[1] : ""; 
     1270 
     1271                if ( value === undefined ) { 
     1272                        data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]); 
     1273 
     1274                        // Try to fetch any internally stored data first 
     1275                        if ( data === undefined && this.length ) { 
     1276                                data = jQuery.data( this[0], key ); 
     1277                                data = dataAttr( this[0], key, data ); 
     1278                        } 
     1279 
     1280                        return data === undefined && parts[1] ? 
     1281                                this.data( parts[0] ) : 
     1282                                data; 
     1283 
     1284                } else { 
     1285                        return this.each(function() { 
     1286                                var $this = jQuery( this ), 
     1287                                        args = [ parts[0], value ]; 
     1288 
     1289                                $this.triggerHandler( "setData" + parts[1] + "!", args ); 
     1290                                jQuery.data( this, key, value ); 
     1291                                $this.triggerHandler( "changeData" + parts[1] + "!", args ); 
     1292                        }); 
     1293                } 
     1294        }, 
     1295 
     1296        removeData: function( key ) { 
     1297                return this.each(function() { 
     1298                        jQuery.removeData( this, key ); 
     1299                }); 
     1300        } 
     1301}); 
     1302 
     1303function dataAttr( elem, key, data ) { 
     1304        // If nothing was found internally, try to fetch any 
     1305        // data from the HTML5 data-* attribute 
     1306        if ( data === undefined && elem.nodeType === 1 ) { 
     1307                data = elem.getAttribute( "data-" + key ); 
     1308 
     1309                if ( typeof data === "string" ) { 
     1310                        try { 
     1311                                data = data === "true" ? true : 
     1312                                data === "false" ? false : 
     1313                                data === "null" ? null : 
     1314                                !jQuery.isNaN( data ) ? parseFloat( data ) : 
     1315                                        rbrace.test( data ) ? jQuery.parseJSON( data ) : 
     1316                                        data; 
     1317                        } catch( e ) {} 
     1318 
     1319                        // Make sure we set the data so it isn't changed later 
     1320                        jQuery.data( elem, key, data ); 
     1321 
     1322                } else { 
     1323                        data = undefined; 
     1324                } 
     1325        } 
     1326 
     1327        return data; 
     1328} 
     1329 
     1330 
     1331 
     1332 
     1333jQuery.extend({ 
     1334        queue: function( elem, type, data ) { 
     1335                if ( !elem ) { 
     1336                        return; 
     1337                } 
     1338 
     1339                type = (type || "fx") + "queue"; 
     1340                var q = jQuery.data( elem, type ); 
     1341 
     1342                // Speed up dequeue by getting out quickly if this is just a lookup 
     1343                if ( !data ) { 
     1344                        return q || []; 
     1345                } 
     1346 
     1347                if ( !q || jQuery.isArray(data) ) { 
     1348                        q = jQuery.data( elem, type, jQuery.makeArray(data) ); 
     1349 
     1350                } else { 
     1351                        q.push( data ); 
     1352                } 
     1353 
     1354                return q; 
     1355        }, 
     1356 
     1357        dequeue: function( elem, type ) { 
     1358                type = type || "fx"; 
     1359 
     1360                var queue = jQuery.queue( elem, type ), 
     1361                        fn = queue.shift(); 
     1362 
     1363                // If the fx queue is dequeued, always remove the progress sentinel 
     1364                if ( fn === "inprogress" ) { 
     1365                        fn = queue.shift(); 
     1366                } 
     1367 
     1368                if ( fn ) { 
     1369                        // Add a progress sentinel to prevent the fx queue from being 
     1370                        // automatically dequeued 
     1371                        if ( type === "fx" ) { 
     1372                                queue.unshift("inprogress"); 
     1373                        } 
     1374 
     1375                        fn.call(elem, function() { 
     1376                                jQuery.dequeue(elem, type); 
     1377                        }); 
     1378                } 
     1379        } 
     1380}); 
     1381 
     1382jQuery.fn.extend({ 
     1383        queue: function( type, data ) { 
     1384                if ( typeof type !== "string" ) { 
     1385                        data = type; 
     1386                        type = "fx"; 
     1387                } 
     1388 
     1389                if ( data === undefined ) { 
     1390                        return jQuery.queue( this[0], type ); 
     1391                } 
     1392                return this.each(function( i ) { 
     1393                        var queue = jQuery.queue( this, type, data ); 
     1394 
     1395                        if ( type === "fx" && queue[0] !== "inprogress" ) { 
     1396                                jQuery.dequeue( this, type ); 
     1397                        } 
     1398                }); 
     1399        }, 
     1400        dequeue: function( type ) { 
     1401                return this.each(function() { 
     1402                        jQuery.dequeue( this, type ); 
     1403                }); 
     1404        }, 
     1405 
     1406        // Based off of the plugin by Clint Helfers, with permission. 
     1407        // http://blindsignals.com/index.php/2009/07/jquery-delay/ 
     1408        delay: function( time, type ) { 
     1409                time = jQuery.fx ? jQuery.fx.speeds[time] || time : time; 
     1410                type = type || "fx"; 
     1411 
     1412                return this.queue( type, function() { 
     1413                        var elem = this; 
     1414                        setTimeout(function() { 
     1415                                jQuery.dequeue( elem, type ); 
     1416                        }, time ); 
     1417                }); 
     1418        }, 
     1419 
     1420        clearQueue: function( type ) { 
     1421                return this.queue( type || "fx", [] ); 
     1422        } 
     1423}); 
     1424 
     1425 
     1426 
     1427 
     1428var rclass = /[\n\t]/g, 
     1429        rspaces = /\s+/, 
     1430        rreturn = /\r/g, 
     1431        rspecialurl = /^(?:href|src|style)$/, 
     1432        rtype = /^(?:button|input)$/i, 
     1433        rfocusable = /^(?:button|input|object|select|textarea)$/i, 
     1434        rclickable = /^a(?:rea)?$/i, 
     1435        rradiocheck = /^(?:radio|checkbox)$/i; 
    9511436 
    9521437jQuery.props = { 
     
    9621447        frameborder: "frameBorder" 
    9631448}; 
    964 var expando = "jQuery" + now(), uuid = 0, windowData = {}; 
    965 var emptyObject = {}; 
    966  
    967 jQuery.extend({ 
    968         cache: {}, 
    969          
    970         expando:expando, 
    971  
    972         // The following elements throw uncatchable exceptions if you 
    973         // attempt to add expando properties to them. 
    974         noData: { 
    975                 "embed": true, 
    976                 "object": true, 
    977                 "applet": true 
    978         }, 
    979  
    980         data: function( elem, name, data ) { 
    981                 if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) { 
    982                         return; 
    983                 } 
    984  
    985                 elem = elem == window ? 
    986                         windowData : 
    987                         elem; 
    988  
    989                 var id = elem[ expando ], cache = jQuery.cache, thisCache; 
    990  
    991                 // Handle the case where there's no name immediately 
    992                 if ( !name && !id ) { 
    993                         return null; 
    994                 } 
    995  
    996                 // Compute a unique ID for the element 
    997                 if ( !id ) {  
    998                         id = ++uuid; 
    999                 } 
    1000  
    1001                 // Avoid generating a new cache unless none exists and we 
    1002                 // want to manipulate it. 
    1003                 if ( typeof name === "object" ) { 
    1004                         elem[ expando ] = id; 
    1005                         thisCache = cache[ id ] = jQuery.extend(true, {}, name); 
    1006                 } else if ( cache[ id ] ) { 
    1007                         thisCache = cache[ id ]; 
    1008                 } else if ( typeof data === "undefined" ) { 
    1009                         thisCache = emptyObject; 
    1010                 } else { 
    1011                         thisCache = cache[ id ] = {}; 
    1012                 } 
    1013  
    1014                 // Prevent overriding the named cache with undefined values 
    1015                 if ( data !== undefined ) { 
    1016                         elem[ expando ] = id; 
    1017                         thisCache[ name ] = data; 
    1018                 } 
    1019  
    1020                 return typeof name === "string" ? thisCache[ name ] : thisCache; 
    1021         }, 
    1022  
    1023         removeData: function( elem, name ) { 
    1024                 if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) { 
    1025                         return; 
    1026                 } 
    1027  
    1028                 elem = elem == window ? 
    1029                         windowData : 
    1030                         elem; 
    1031  
    1032                 var id = elem[ expando ], cache = jQuery.cache, thisCache = cache[ id ]; 
    1033  
    1034                 // If we want to remove a specific section of the element's data 
    1035                 if ( name ) { 
    1036                         if ( thisCache ) { 
    1037                                 // Remove the section of cache data 
    1038                                 delete thisCache[ name ]; 
    1039  
    1040                                 // If we've removed all the data, remove the element's cache 
    1041                                 if ( jQuery.isEmptyObject(thisCache) ) { 
    1042                                         jQuery.removeData( elem ); 
    1043                                 } 
    1044                         } 
    1045  
    1046                 // Otherwise, we want to remove all of the element's data 
    1047                 } else { 
    1048                         // Clean up the element expando 
    1049                         try { 
    1050                                 delete elem[ expando ]; 
    1051                         } catch( e ) { 
    1052                                 // IE has trouble directly removing the expando 
    1053                                 // but it's ok with using removeAttribute 
    1054                                 if ( elem.removeAttribute ) { 
    1055                                         elem.removeAttribute( expando ); 
    1056                                 } 
    1057                         } 
    1058  
    1059                         // Completely remove the data cache 
    1060                         delete cache[ id ]; 
    1061                 } 
    1062         } 
    1063 }); 
    1064  
    1065 jQuery.fn.extend({ 
    1066         data: function( key, value ) { 
    1067                 if ( typeof key === "undefined" && this.length ) { 
    1068                         return jQuery.data( this[0] ); 
    1069  
    1070                 } else if ( typeof key === "object" ) { 
    1071                         return this.each(function() { 
    1072                                 jQuery.data( this, key ); 
    1073                         }); 
    1074                 } 
    1075  
    1076                 var parts = key.split("."); 
    1077                 parts[1] = parts[1] ? "." + parts[1] : ""; 
    1078  
    1079                 if ( value === undefined ) { 
    1080                         var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]); 
    1081  
    1082                         if ( data === undefined && this.length ) { 
    1083                                 data = jQuery.data( this[0], key ); 
    1084                         } 
    1085                         return data === undefined && parts[1] ? 
    1086                                 this.data( parts[0] ) : 
    1087                                 data; 
    1088                 } else { 
    1089                         return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function() { 
    1090                                 jQuery.data( this, key, value ); 
    1091                         }); 
    1092                 } 
    1093         }, 
    1094  
    1095         removeData: function( key ) { 
    1096                 return this.each(function() { 
    1097                         jQuery.removeData( this, key ); 
    1098                 }); 
    1099         } 
    1100 }); 
    1101 jQuery.extend({ 
    1102         queue: function( elem, type, data ) { 
    1103                 if ( !elem ) { 
    1104                         return; 
    1105                 } 
    1106  
    1107                 type = (type || "fx") + "queue"; 
    1108                 var q = jQuery.data( elem, type ); 
    1109  
    1110                 // Speed up dequeue by getting out quickly if this is just a lookup 
    1111                 if ( !data ) { 
    1112                         return q || []; 
    1113                 } 
    1114  
    1115                 if ( !q || jQuery.isArray(data) ) { 
    1116                         q = jQuery.data( elem, type, jQuery.makeArray(data) ); 
    1117  
    1118                 } else { 
    1119                         q.push( data ); 
    1120                 } 
    1121  
    1122                 return q; 
    1123         }, 
    1124  
    1125         dequeue: function( elem, type ) { 
    1126                 type = type || "fx"; 
    1127  
    1128                 var queue = jQuery.queue( elem, type ), fn = queue.shift(); 
    1129  
    1130                 // If the fx queue is dequeued, always remove the progress sentinel 
    1131                 if ( fn === "inprogress" ) { 
    1132                         fn = queue.shift(); 
    1133                 } 
    1134  
    1135                 if ( fn ) { 
    1136                         // Add a progress sentinel to prevent the fx queue from being 
    1137                         // automatically dequeued 
    1138                         if ( type === "fx" ) { 
    1139                                 queue.unshift("inprogress"); 
    1140                         } 
    1141  
    1142                         fn.call(elem, function() { 
    1143                                 jQuery.dequeue(elem, type); 
    1144                         }); 
    1145                 } 
    1146         } 
    1147 }); 
    1148  
    1149 jQuery.fn.extend({ 
    1150         queue: function( type, data ) { 
    1151                 if ( typeof type !== "string" ) { 
    1152                         data = type; 
    1153                         type = "fx"; 
    1154                 } 
    1155  
    1156                 if ( data === undefined ) { 
    1157                         return jQuery.queue( this[0], type ); 
    1158                 } 
    1159                 return this.each(function( i, elem ) { 
    1160                         var queue = jQuery.queue( this, type, data ); 
    1161  
    1162                         if ( type === "fx" && queue[0] !== "inprogress" ) { 
    1163                                 jQuery.dequeue( this, type ); 
    1164                         } 
    1165                 }); 
    1166         }, 
    1167         dequeue: function( type ) { 
    1168                 return this.each(function() { 
    1169                         jQuery.dequeue( this, type ); 
    1170                 }); 
    1171         }, 
    1172  
    1173         // Based off of the plugin by Clint Helfers, with permission. 
    1174         // http://blindsignals.com/index.php/2009/07/jquery-delay/ 
    1175         delay: function( time, type ) { 
    1176                 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time; 
    1177                 type = type || "fx"; 
    1178  
    1179                 return this.queue( type, function() { 
    1180                         var elem = this; 
    1181                         setTimeout(function() { 
    1182                                 jQuery.dequeue( elem, type ); 
    1183                         }, time ); 
    1184                 }); 
    1185         }, 
    1186  
    1187         clearQueue: function( type ) { 
    1188                 return this.queue( type || "fx", [] ); 
    1189         } 
    1190 }); 
    1191 var rclass = /[\n\t]/g, 
    1192         rspace = /\s+/, 
    1193         rreturn = /\r/g, 
    1194         rspecialurl = /href|src|style/, 
    1195         rtype = /(button|input)/i, 
    1196         rfocusable = /(button|input|object|select|textarea)/i, 
    1197         rclickable = /^(a|area)$/i, 
    1198         rradiocheck = /radio|checkbox/; 
    11991449 
    12001450jQuery.fn.extend({ 
    12011451        attr: function( name, value ) { 
    1202                 return access( this, name, value, true, jQuery.attr ); 
     1452                return jQuery.access( this, name, value, true, jQuery.attr ); 
    12031453        }, 
    12041454 
     
    12211471 
    12221472                if ( value && typeof value === "string" ) { 
    1223                         var classNames = (value || "").split( rspace ); 
     1473                        var classNames = (value || "").split( rspaces ); 
    12241474 
    12251475                        for ( var i = 0, l = this.length; i < l; i++ ) { 
     
    12311481 
    12321482                                        } else { 
    1233                                                 var className = " " + elem.className + " "; 
     1483                                                var className = " " + elem.className + " ", 
     1484                                                        setClass = elem.className; 
     1485 
    12341486                                                for ( var c = 0, cl = classNames.length; c < cl; c++ ) { 
    12351487                                                        if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) { 
    1236                                                                 elem.className += " " + classNames[c]; 
     1488                                                                setClass += " " + classNames[c]; 
    12371489                                                        } 
    12381490                                                } 
     1491                                                elem.className = jQuery.trim( setClass ); 
    12391492                                        } 
    12401493                                } 
     
    12541507 
    12551508                if ( (value && typeof value === "string") || value === undefined ) { 
    1256                         var classNames = (value || "").split(rspace); 
     1509                        var classNames = (value || "").split( rspaces ); 
    12571510 
    12581511                        for ( var i = 0, l = this.length; i < l; i++ ) { 
     
    12651518                                                        className = className.replace(" " + classNames[c] + " ", " "); 
    12661519                                                } 
    1267                                                 elem.className = className.substring(1, className.length - 1); 
     1520                                                elem.className = jQuery.trim( className ); 
    12681521 
    12691522                                        } else { 
     
    12781531 
    12791532        toggleClass: function( value, stateVal ) { 
    1280                 var type = typeof value, isBool = typeof stateVal === "boolean"; 
     1533                var type = typeof value, 
     1534                        isBool = typeof stateVal === "boolean"; 
    12811535 
    12821536                if ( jQuery.isFunction( value ) ) { 
     
    12901544                        if ( type === "string" ) { 
    12911545                                // toggle individual class names 
    1292                                 var className, i = 0, self = jQuery(this), 
     1546                                var className, 
     1547                                        i = 0, 
     1548                                        self = jQuery( this ), 
    12931549                                        state = stateVal, 
    1294                                         classNames = value.split( rspace ); 
     1550                                        classNames = value.split( rspaces ); 
    12951551 
    12961552                                while ( (className = classNames[ i++ ]) ) { 
     
    13241580 
    13251581        val: function( value ) { 
    1326                 if ( value === undefined ) { 
     1582                if ( !arguments.length ) { 
    13271583                        var elem = this[0]; 
    13281584 
    13291585                        if ( elem ) { 
    13301586                                if ( jQuery.nodeName( elem, "option" ) ) { 
    1331                                         return (elem.attributes.value || {}).specified ? elem.value : elem.text; 
     1587                                        // attributes.value is undefined in Blackberry 4.7 but 
     1588                                        // uses .value. See #6932 
     1589                                        var val = elem.attributes.value; 
     1590                                        return !val || val.specified ? elem.value : elem.text; 
    13321591                                } 
    13331592 
     
    13481607                                                var option = options[ i ]; 
    13491608 
    1350                                                 if ( option.selected ) { 
    1351                                                         // Get the specifc value for the option 
     1609                                                // Don't return options that are disabled or in a disabled optgroup 
     1610                                                if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&  
     1611                                                                (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) { 
     1612 
     1613                                                        // Get the specific value for the option 
    13521614                                                        value = jQuery(option).val(); 
    13531615 
     
    13921654                        } 
    13931655 
    1394                         // Typecast each time if the value is a Function and the appended 
    1395                         // value is therefore different each time. 
    1396                         if ( typeof val === "number" ) { 
     1656                        // Treat null/undefined as ""; convert numbers to string 
     1657                        if ( val == null ) { 
     1658                                val = ""; 
     1659                        } else if ( typeof val === "number" ) { 
    13971660                                val += ""; 
     1661                        } else if ( jQuery.isArray(val) ) { 
     1662                                val = jQuery.map(val, function (value) { 
     1663                                        return value == null ? "" : value + ""; 
     1664                                }); 
    13981665                        } 
    13991666 
     
    14481715                name = notxml && jQuery.props[ name ] || name; 
    14491716 
    1450                 // Only do all the following if this is a node (faster for style) 
    1451                 if ( elem.nodeType === 1 ) { 
    1452                         // These attributes require special treatment 
    1453                         var special = rspecialurl.test( name ); 
    1454  
    1455                         // Safari mis-reports the default selected property of an option 
    1456                         // Accessing the parent's selectedIndex property fixes it 
    1457                         if ( name === "selected" && !jQuery.support.optSelected ) { 
    1458                                 var parent = elem.parentNode; 
    1459                                 if ( parent ) { 
    1460                                         parent.selectedIndex; 
    1461          
    1462                                         // Make sure that it also works with optgroups, see #5701 
    1463                                         if ( parent.parentNode ) { 
    1464                                                 parent.parentNode.selectedIndex; 
     1717                // These attributes require special treatment 
     1718                var special = rspecialurl.test( name ); 
     1719 
     1720                // Safari mis-reports the default selected property of an option 
     1721                // Accessing the parent's selectedIndex property fixes it 
     1722                if ( name === "selected" && !jQuery.support.optSelected ) { 
     1723                        var parent = elem.parentNode; 
     1724                        if ( parent ) { 
     1725                                parent.selectedIndex; 
     1726 
     1727                                // Make sure that it also works with optgroups, see #5701 
     1728                                if ( parent.parentNode ) { 
     1729                                        parent.parentNode.selectedIndex; 
     1730                                } 
     1731                        } 
     1732                } 
     1733 
     1734                // If applicable, access the attribute via the DOM 0 way 
     1735                // 'in' checks fail in Blackberry 4.7 #6931 
     1736                if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) { 
     1737                        if ( set ) { 
     1738                                // We can't allow the type property to be changed (since it causes problems in IE) 
     1739                                if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) { 
     1740                                        jQuery.error( "type property can't be changed" ); 
     1741                                } 
     1742 
     1743                                if ( value === null ) { 
     1744                                        if ( elem.nodeType === 1 ) { 
     1745                                                elem.removeAttribute( name ); 
    14651746                                        } 
    1466                                 } 
    1467                         } 
    1468  
    1469                         // If applicable, access the attribute via the DOM 0 way 
    1470                         if ( name in elem && notxml && !special ) { 
    1471                                 if ( set ) { 
    1472                                         // We can't allow the type property to be changed (since it causes problems in IE) 
    1473                                         if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) { 
    1474                                                 jQuery.error( "type property can't be changed" ); 
    1475                                         } 
    1476  
     1747 
     1748                                } else { 
    14771749                                        elem[ name ] = value; 
    14781750                                } 
    1479  
    1480                                 // browsers index elements by id/name on forms, give priority to attributes. 
    1481                                 if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) { 
    1482                                         return elem.getAttributeNode( name ).nodeValue; 
    1483                                 } 
    1484  
    1485                                 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set 
    1486                                 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ 
    1487                                 if ( name === "tabIndex" ) { 
    1488                                         var attributeNode = elem.getAttributeNode( "tabIndex" ); 
    1489  
    1490                                         return attributeNode && attributeNode.specified ? 
    1491                                                 attributeNode.value : 
    1492                                                 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? 
    1493                                                         0 : 
    1494                                                         undefined; 
    1495                                 } 
    1496  
    1497                                 return elem[ name ]; 
    1498                         } 
    1499  
    1500                         if ( !jQuery.support.style && notxml && name === "style" ) { 
    1501                                 if ( set ) { 
    1502                                         elem.style.cssText = "" + value; 
    1503                                 } 
    1504  
    1505                                 return elem.style.cssText; 
    1506                         } 
    1507  
     1751                        } 
     1752 
     1753                        // browsers index elements by id/name on forms, give priority to attributes. 
     1754                        if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) { 
     1755                                return elem.getAttributeNode( name ).nodeValue; 
     1756                        } 
     1757 
     1758                        // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set 
     1759                        // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ 
     1760                        if ( name === "tabIndex" ) { 
     1761                                var attributeNode = elem.getAttributeNode( "tabIndex" ); 
     1762 
     1763                                return attributeNode && attributeNode.specified ? 
     1764                                        attributeNode.value : 
     1765                                        rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? 
     1766                                                0 : 
     1767                                                undefined; 
     1768                        } 
     1769 
     1770                        return elem[ name ]; 
     1771                } 
     1772 
     1773                if ( !jQuery.support.style && notxml && name === "style" ) { 
    15081774                        if ( set ) { 
    1509                                 // convert the value to a string (all browsers do this but IE) see #1070 
    1510                                 elem.setAttribute( name, "" + value ); 
    1511                         } 
    1512  
    1513                         var attr = !jQuery.support.hrefNormalized && notxml && special ? 
    1514                                         // Some attributes require a special call on IE 
    1515                                         elem.getAttribute( name, 2 ) : 
    1516                                         elem.getAttribute( name ); 
    1517  
    1518                         // Non-existent attributes return null, we normalize to undefined 
    1519                         return attr === null ? undefined : attr; 
    1520                 } 
    1521  
    1522                 // elem is actually elem.style ... set the style 
    1523                 // Using attr for specific style information is now deprecated. Use style insead. 
    1524                 return jQuery.style( elem, name, value ); 
     1775                                elem.style.cssText = "" + value; 
     1776                        } 
     1777 
     1778                        return elem.style.cssText; 
     1779                } 
     1780 
     1781                if ( set ) { 
     1782                        // convert the value to a string (all browsers do this but IE) see #1070 
     1783                        elem.setAttribute( name, "" + value ); 
     1784                } 
     1785 
     1786                // Ensure that missing attributes return undefined 
     1787                // Blackberry 4.7 returns "" from getAttribute #6938 
     1788                if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) { 
     1789                        return undefined; 
     1790                } 
     1791 
     1792                var attr = !jQuery.support.hrefNormalized && notxml && special ? 
     1793                                // Some attributes require a special call on IE 
     1794                                elem.getAttribute( name, 2 ) : 
     1795                                elem.getAttribute( name ); 
     1796 
     1797                // Non-existent attributes return null, we normalize to undefined 
     1798                return attr === null ? undefined : attr; 
    15251799        } 
    15261800}); 
    1527 var fcleanup = function( nm ) { 
    1528         return nm.replace(/[^\w\s\.\|`]/g, function( ch ) { 
    1529                 return "\\" + ch; 
    1530         }); 
    1531 }; 
     1801 
     1802 
     1803 
     1804 
     1805var rnamespaces = /\.(.*)$/, 
     1806        rformElems = /^(?:textarea|input|select)$/i, 
     1807        rperiod = /\./g, 
     1808        rspace = / /g, 
     1809        rescape = /[^\w\s.|`]/g, 
     1810        fcleanup = function( nm ) { 
     1811                return nm.replace(rescape, "\\$&"); 
     1812        }, 
     1813        focusCounts = { focusin: 0, focusout: 0 }; 
    15321814 
    15331815/* 
     
    15471829                // For whatever reason, IE has trouble passing the window object 
    15481830                // around, causing it to be cloned in the process 
    1549                 if ( elem.setInterval && ( elem !== window && !elem.frameElement ) ) { 
     1831                if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) { 
    15501832                        elem = window; 
     1833                } 
     1834 
     1835                if ( handler === false ) { 
     1836                        handler = returnFalse; 
     1837                } else if ( !handler ) { 
     1838                        // Fixes bug #7229. Fix recommended by jdalton 
     1839                  return; 
     1840                } 
     1841 
     1842                var handleObjIn, handleObj; 
     1843 
     1844                if ( handler.handler ) { 
     1845                        handleObjIn = handler; 
     1846                        handler = handleObjIn.handler; 
    15511847                } 
    15521848 
     
    15561852                } 
    15571853 
    1558                 // if data is passed, bind to handler 
    1559                 if ( data !== undefined ) { 
    1560                         // Create temporary function pointer to original handler 
    1561                         var fn = handler; 
    1562  
    1563                         // Create unique handler function, wrapped around original handler 
    1564                         handler = jQuery.proxy( fn ); 
    1565  
    1566                         // Store data in unique handler 
    1567                         handler.data = data; 
    1568                 } 
    1569  
    15701854                // Init the element's event structure 
    1571                 var events = jQuery.data( elem, "events" ) || jQuery.data( elem, "events", {} ), 
    1572                         handle = jQuery.data( elem, "handle" ), eventHandle; 
    1573  
    1574                 if ( !handle ) { 
    1575                         eventHandle = function() { 
     1855                var elemData = jQuery.data( elem ); 
     1856 
     1857                // If no elemData is found then we must be trying to bind to one of the 
     1858                // banned noData elements 
     1859                if ( !elemData ) { 
     1860                        return; 
     1861                } 
     1862 
     1863                // Use a key less likely to result in collisions for plain JS objects. 
     1864                // Fixes bug #7150. 
     1865                var eventKey = elem.nodeType ? "events" : "__events__", 
     1866                        events = elemData[ eventKey ], 
     1867                        eventHandle = elemData.handle; 
     1868                         
     1869                if ( typeof events === "function" ) { 
     1870                        // On plain objects events is a fn that holds the the data 
     1871                        // which prevents this data from being JSON serialized 
     1872                        // the function does not need to be called, it just contains the data 
     1873                        eventHandle = events.handle; 
     1874                        events = events.events; 
     1875 
     1876                } else if ( !events ) { 
     1877                        if ( !elem.nodeType ) { 
     1878                                // On plain objects, create a fn that acts as the holder 
     1879                                // of the values to avoid JSON serialization of event data 
     1880                                elemData[ eventKey ] = elemData = function(){}; 
     1881                        } 
     1882 
     1883                        elemData.events = events = {}; 
     1884                } 
     1885 
     1886                if ( !eventHandle ) { 
     1887                        elemData.handle = eventHandle = function() { 
    15761888                                // Handle the second event of a trigger and when 
    15771889                                // an event is called after a page has unloaded 
     
    15801892                                        undefined; 
    15811893                        }; 
    1582  
    1583                         handle = jQuery.data( elem, "handle", eventHandle ); 
    1584                 } 
    1585  
    1586                 // If no handle is found then we must be trying to bind to one of the 
    1587                 // banned noData elements 
    1588                 if ( !handle ) { 
    1589                         return; 
    15901894                } 
    15911895 
    15921896                // Add elem as a property of the handle function 
    1593                 // This is to prevent a memory leak with non-native 
    1594                 // event in IE. 
    1595                 handle.elem = elem; 
     1897                // This is to prevent a memory leak with non-native events in IE. 
     1898                eventHandle.elem = elem; 
    15961899 
    15971900                // Handle multiple events separated by a space 
    15981901                // jQuery(...).bind("mouseover mouseout", fn); 
    1599                 types = types.split( /\s+/ ); 
    1600  
    1601                 var type, i = 0; 
     1902                types = types.split(" "); 
     1903 
     1904                var type, i = 0, namespaces; 
    16021905 
    16031906                while ( (type = types[ i++ ]) ) { 
     1907                        handleObj = handleObjIn ? 
     1908                                jQuery.extend({}, handleObjIn) : 
     1909                                { handler: handler, data: data }; 
     1910 
    16041911                        // Namespaced event handlers 
    1605                         var namespaces = type.split("."); 
    1606                         type = namespaces.shift(); 
    1607  
    1608                         if ( i > 1 ) { 
    1609                                 handler = jQuery.proxy( handler ); 
    1610  
    1611                                 if ( data !== undefined ) { 
    1612                                         handler.data = data; 
    1613                                 } 
    1614                         } 
    1615  
    1616                         handler.type = namespaces.slice(0).sort().join("."); 
     1912                        if ( type.indexOf(".") > -1 ) { 
     1913                                namespaces = type.split("."); 
     1914                                type = namespaces.shift(); 
     1915                                handleObj.namespace = namespaces.slice(0).sort().join("."); 
     1916 
     1917                        } else { 
     1918                                namespaces = []; 
     1919                                handleObj.namespace = ""; 
     1920                        } 
     1921 
     1922                        handleObj.type = type; 
     1923                        if ( !handleObj.guid ) { 
     1924                                handleObj.guid = handler.guid; 
     1925                        } 
    16171926 
    16181927                        // Get the current list of functions bound to this event 
    16191928                        var handlers = events[ type ], 
    1620                                 special = this.special[ type ] || {}; 
     1929                                special = jQuery.event.special[ type ] || {}; 
    16211930 
    16221931                        // Init the event handler queue 
    16231932                        if ( !handlers ) { 
    1624                                 handlers = events[ type ] = {}; 
     1933                                handlers = events[ type ] = []; 
    16251934 
    16261935                                // Check for a special event handler 
    16271936                                // Only use addEventListener/attachEvent if the special 
    16281937                                // events handler returns false 
    1629                                 if ( !special.setup || special.setup.call( elem, data, namespaces, handler) === false ) { 
     1938                                if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { 
    16301939                                        // Bind the global event handler to the element 
    16311940                                        if ( elem.addEventListener ) { 
    1632                                                 elem.addEventListener( type, handle, false ); 
     1941                                                elem.addEventListener( type, eventHandle, false ); 
     1942 
    16331943                                        } else if ( elem.attachEvent ) { 
    1634                                                 elem.attachEvent( "on" + type, handle ); 
     1944                                                elem.attachEvent( "on" + type, eventHandle ); 
    16351945                                        } 
    16361946                                } 
     
    16381948                         
    16391949                        if ( special.add ) {  
    1640                                 var modifiedHandler = special.add.call( elem, handler, data, namespaces, handlers );  
    1641                                 if ( modifiedHandler && jQuery.isFunction( modifiedHandler ) ) {  
    1642                                         modifiedHandler.guid = modifiedHandler.guid || handler.guid;  
    1643                                         modifiedHandler.data = modifiedHandler.data || handler.data;  
    1644                                         modifiedHandler.type = modifiedHandler.type || handler.type;  
    1645                                         handler = modifiedHandler;  
    1646                                 }  
    1647                         }  
    1648                          
     1950                                special.add.call( elem, handleObj );  
     1951 
     1952                                if ( !handleObj.handler.guid ) { 
     1953                                        handleObj.handler.guid = handler.guid; 
     1954                                } 
     1955                        } 
     1956 
    16491957                        // Add the function to the element's handler list 
    1650                         handlers[ handler.guid ] = handler; 
     1958                        handlers.push( handleObj ); 
    16511959 
    16521960                        // Keep track of which events have been used, for global triggering 
    1653                         this.global[ type ] = true; 
     1961                        jQuery.event.global[ type ] = true; 
    16541962                } 
    16551963 
     
    16611969 
    16621970        // Detach an event or set of events from an element 
    1663         remove: function( elem, types, handler ) { 
     1971        remove: function( elem, types, handler, pos ) { 
    16641972                // don't do events on text and comment nodes 
    16651973                if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 
     
    16671975                } 
    16681976 
    1669                 var events = jQuery.data( elem, "events" ), ret, type, fn; 
    1670  
    1671                 if ( events ) { 
    1672                         // Unbind all events for the element 
    1673                         if ( types === undefined || (typeof types === "string" && types.charAt(0) === ".") ) { 
    1674                                 for ( type in events ) { 
    1675                                         this.remove( elem, type + (types || "") ); 
    1676                                 } 
    1677                         } else { 
    1678                                 // types is actually an event object here 
    1679                                 if ( types.type ) { 
    1680                                         handler = types.handler; 
    1681                                         types = types.type; 
    1682                                 } 
    1683  
    1684                                 // Handle multiple events separated by a space 
    1685                                 // jQuery(...).unbind("mouseover mouseout", fn); 
    1686                                 types = types.split(/\s+/); 
    1687                                 var i = 0; 
    1688                                 while ( (type = types[ i++ ]) ) { 
    1689                                         // Namespaced event handlers 
    1690                                         var namespaces = type.split("."); 
    1691                                         type = namespaces.shift(); 
    1692                                         var all = !namespaces.length, 
    1693                                                 cleaned = jQuery.map( namespaces.slice(0).sort(), fcleanup ), 
    1694                                                 namespace = new RegExp("(^|\\.)" + cleaned.join("\\.(?:.*\\.)?") + "(\\.|$)"), 
    1695                                                 special = this.special[ type ] || {}; 
    1696  
    1697                                         if ( events[ type ] ) { 
    1698                                                 // remove the given handler for the given type 
    1699                                                 if ( handler ) { 
    1700                                                         fn = events[ type ][ handler.guid ]; 
    1701                                                         delete events[ type ][ handler.guid ]; 
    1702  
    1703                                                 // remove all handlers for the given type 
    1704                                                 } else { 
    1705                                                         for ( var handle in events[ type ] ) { 
    1706                                                                 // Handle the removal of namespaced events 
    1707                                                                 if ( all || namespace.test( events[ type ][ handle ].type ) ) { 
    1708                                                                         delete events[ type ][ handle ]; 
    1709                                                                 } 
    1710                                                         } 
     1977                if ( handler === false ) { 
     1978                        handler = returnFalse; 
     1979                } 
     1980 
     1981                var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType, 
     1982                        eventKey = elem.nodeType ? "events" : "__events__", 
     1983                        elemData = jQuery.data( elem ), 
     1984                        events = elemData && elemData[ eventKey ]; 
     1985 
     1986                if ( !elemData || !events ) { 
     1987                        return; 
     1988                } 
     1989                 
     1990                if ( typeof events === "function" ) { 
     1991                        elemData = events; 
     1992                        events = events.events; 
     1993                } 
     1994 
     1995                // types is actually an event object here 
     1996                if ( types && types.type ) { 
     1997                        handler = types.handler; 
     1998                        types = types.type; 
     1999                } 
     2000 
     2001                // Unbind all events for the element 
     2002                if ( !types || typeof types === "string" && types.charAt(0) === "." ) { 
     2003                        types = types || ""; 
     2004 
     2005                        for ( type in events ) { 
     2006                                jQuery.event.remove( elem, type + types ); 
     2007                        } 
     2008 
     2009                        return; 
     2010                } 
     2011 
     2012                // Handle multiple events separated by a space 
     2013                // jQuery(...).unbind("mouseover mouseout", fn); 
     2014                types = types.split(" "); 
     2015 
     2016                while ( (type = types[ i++ ]) ) { 
     2017                        origType = type; 
     2018                        handleObj = null; 
     2019                        all = type.indexOf(".") < 0; 
     2020                        namespaces = []; 
     2021 
     2022                        if ( !all ) { 
     2023                                // Namespaced event handlers 
     2024                                namespaces = type.split("."); 
     2025                                type = namespaces.shift(); 
     2026 
     2027                                namespace = new RegExp("(^|\\.)" +  
     2028                                        jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)"); 
     2029                        } 
     2030 
     2031                        eventType = events[ type ]; 
     2032 
     2033                        if ( !eventType ) { 
     2034                                continue; 
     2035                        } 
     2036 
     2037                        if ( !handler ) { 
     2038                                for ( j = 0; j < eventType.length; j++ ) { 
     2039                                        handleObj = eventType[ j ]; 
     2040 
     2041                                        if ( all || namespace.test( handleObj.namespace ) ) { 
     2042                                                jQuery.event.remove( elem, origType, handleObj.handler, j ); 
     2043                                                eventType.splice( j--, 1 ); 
     2044                                        } 
     2045                                } 
     2046 
     2047                                continue; 
     2048                        } 
     2049 
     2050                        special = jQuery.event.special[ type ] || {}; 
     2051 
     2052                        for ( j = pos || 0; j < eventType.length; j++ ) { 
     2053                                handleObj = eventType[ j ]; 
     2054 
     2055                                if ( handler.guid === handleObj.guid ) { 
     2056                                        // remove the given handler for the given type 
     2057                                        if ( all || namespace.test( handleObj.namespace ) ) { 
     2058                                                if ( pos == null ) { 
     2059                                                        eventType.splice( j--, 1 ); 
    17112060                                                } 
    17122061 
    17132062                                                if ( special.remove ) { 
    1714                                                         special.remove.call( elem, namespaces, fn); 
    1715                                                 } 
    1716  
    1717                                                 // remove generic event handler if no more handlers exist 
    1718                                                 for ( ret in events[ type ] ) { 
    1719                                                         break; 
    1720                                                 } 
    1721                                                 if ( !ret ) { 
    1722                                                         if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) { 
    1723                                                                 if ( elem.removeEventListener ) { 
    1724                                                                         elem.removeEventListener( type, jQuery.data( elem, "handle" ), false ); 
    1725                                                                 } else if ( elem.detachEvent ) { 
    1726                                                                         elem.detachEvent( "on" + type, jQuery.data( elem, "handle" ) ); 
    1727                                                                 } 
    1728                                                         } 
    1729                                                         ret = null; 
    1730                                                         delete events[ type ]; 
     2063                                                        special.remove.call( elem, handleObj ); 
    17312064                                                } 
    17322065                                        } 
    1733                                 } 
    1734                         } 
    1735  
    1736                         // Remove the expando if it's no longer used 
    1737                         for ( ret in events ) { 
    1738                                 break; 
    1739                         } 
    1740                         if ( !ret ) { 
    1741                                 var handle = jQuery.data( elem, "handle" ); 
    1742                                 if ( handle ) { 
    1743                                         handle.elem = null; 
    1744                                 } 
    1745                                 jQuery.removeData( elem, "events" ); 
    1746                                 jQuery.removeData( elem, "handle" ); 
     2066 
     2067                                        if ( pos != null ) { 
     2068                                                break; 
     2069                                        } 
     2070                                } 
     2071                        } 
     2072 
     2073                        // remove generic event handler if no more handlers exist 
     2074                        if ( eventType.length === 0 || pos != null && eventType.length === 1 ) { 
     2075                                if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) { 
     2076                                        jQuery.removeEvent( elem, type, elemData.handle ); 
     2077                                } 
     2078 
     2079                                ret = null; 
     2080                                delete events[ type ]; 
     2081                        } 
     2082                } 
     2083 
     2084                // Remove the expando if it's no longer used 
     2085                if ( jQuery.isEmptyObject( events ) ) { 
     2086                        var handle = elemData.handle; 
     2087                        if ( handle ) { 
     2088                                handle.elem = null; 
     2089                        } 
     2090 
     2091                        delete elemData.events; 
     2092                        delete elemData.handle; 
     2093 
     2094                        if ( typeof elemData === "function" ) { 
     2095                                jQuery.removeData( elem, eventKey ); 
     2096 
     2097                        } else if ( jQuery.isEmptyObject( elemData ) ) { 
     2098                                jQuery.removeData( elem ); 
    17472099                        } 
    17482100                } 
     
    17582110                        event = typeof event === "object" ? 
    17592111                                // jQuery.Event object 
    1760                                 event[expando] ? event : 
     2112                                event[ jQuery.expando ] ? event : 
    17612113                                // Object literal 
    17622114                                jQuery.extend( jQuery.Event(type), event ) : 
     
    17752127 
    17762128                                // Only trigger if we've ever bound an event for it 
    1777                                 if ( this.global[ type ] ) { 
     2129                                if ( jQuery.event.global[ type ] ) { 
    17782130                                        jQuery.each( jQuery.cache, function() { 
    17792131                                                if ( this.events && this.events[type] ) { 
     
    18032155 
    18042156                // Trigger the event, it is assumed that "handle" is a function 
    1805                 var handle = jQuery.data( elem, "handle" ); 
     2157                var handle = elem.nodeType ? 
     2158                        jQuery.data( elem, "handle" ) : 
     2159                        (jQuery.data( elem, "__events__" ) || {}).handle; 
     2160 
    18062161                if ( handle ) { 
    18072162                        handle.apply( elem, data ); 
     
    18152170                                if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) { 
    18162171                                        event.result = false; 
     2172                                        event.preventDefault(); 
    18172173                                } 
    18182174                        } 
    18192175 
    18202176                // prevent IE from throwing an error for some elements with some event types, see #3533 
    1821                 } catch (e) {} 
     2177                } catch (inlineError) {} 
    18222178 
    18232179                if ( !event.isPropagationStopped() && parent ) { 
     
    18252181 
    18262182                } else if ( !event.isDefaultPrevented() ) { 
    1827                         var target = event.target, old, 
    1828                                 isClick = jQuery.nodeName(target, "a") && type === "click"; 
    1829  
    1830                         if ( !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) { 
     2183                        var old, 
     2184                                target = event.target, 
     2185                                targetType = type.replace( rnamespaces, "" ), 
     2186                                isClick = jQuery.nodeName( target, "a" ) && targetType === "click", 
     2187                                special = jQuery.event.special[ targetType ] || {}; 
     2188 
     2189                        if ( (!special._default || special._default.call( elem, event ) === false) &&  
     2190                                !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) { 
     2191 
    18312192                                try { 
    1832                                         if ( target[ type ] ) { 
     2193                                        if ( target[ targetType ] ) { 
    18332194                                                // Make sure that we don't accidentally re-trigger the onFOO events 
    1834                                                 old = target[ "on" + type ]; 
     2195                                                old = target[ "on" + targetType ]; 
    18352196 
    18362197                                                if ( old ) { 
    1837                                                         target[ "on" + type ] = null; 
     2198                                                        target[ "on" + targetType ] = null; 
    18382199                                                } 
    18392200 
    1840                                                 this.triggered = true; 
    1841                                                 target[ type ](); 
     2201                                                jQuery.event.triggered = true; 
     2202                                                target[ targetType ](); 
    18422203                                        } 
    18432204 
    18442205                                // prevent IE from throwing an error for some elements with some event types, see #3533 
    1845                                 } catch (e) {} 
     2206                                } catch (triggerError) {} 
    18462207 
    18472208                                if ( old ) { 
    1848                                         target[ "on" + type ] = old; 
    1849                                 } 
    1850  
    1851                                 this.triggered = false; 
     2209                                        target[ "on" + targetType ] = old; 
     2210                                } 
     2211 
     2212                                jQuery.event.triggered = false; 
    18522213                        } 
    18532214                } 
     
    18552216 
    18562217        handle: function( event ) { 
    1857                 // returned undefined or false 
    1858                 var all, handlers; 
    1859  
    1860                 event = arguments[0] = jQuery.event.fix( event || window.event ); 
     2218                var all, handlers, namespaces, namespace_re, events, 
     2219                        namespace_sort = [], 
     2220                        args = jQuery.makeArray( arguments ); 
     2221 
     2222                event = args[0] = jQuery.event.fix( event || window.event ); 
    18612223                event.currentTarget = this; 
    18622224 
    18632225                // Namespaced event handlers 
    1864                 var namespaces = event.type.split("."); 
    1865                 event.type = namespaces.shift(); 
    1866  
    1867                 // Cache this now, all = true means, any handler 
    1868                 all = !namespaces.length && !event.exclusive; 
    1869  
    1870                 var namespace = new RegExp("(^|\\.)" + namespaces.slice(0).sort().join("\\.(?:.*\\.)?") + "(\\.|$)"); 
    1871  
    1872                 handlers = ( jQuery.data(this, "events") || {} )[ event.type ]; 
    1873  
    1874                 for ( var j in handlers ) { 
    1875                         var handler = handlers[ j ]; 
    1876  
    1877                         // Filter the functions by class 
    1878                         if ( all || namespace.test(handler.type) ) { 
    1879                                 // Pass in a reference to the handler function itself 
    1880                                 // So that we can later remove it 
    1881                                 event.handler = handler; 
    1882                                 event.data = handler.data; 
    1883  
    1884                                 var ret = handler.apply( this, arguments ); 
    1885  
    1886                                 if ( ret !== undefined ) { 
    1887                                         event.result = ret; 
    1888                                         if ( ret === false ) { 
    1889                                                 event.preventDefault(); 
    1890                                                 event.stopPropagation(); 
     2226                all = event.type.indexOf(".") < 0 && !event.exclusive; 
     2227 
     2228                if ( !all ) { 
     2229                        namespaces = event.type.split("."); 
     2230                        event.type = namespaces.shift(); 
     2231                        namespace_sort = namespaces.slice(0).sort(); 
     2232                        namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)"); 
     2233                } 
     2234 
     2235                event.namespace = event.namespace || namespace_sort.join("."); 
     2236 
     2237                events = jQuery.data(this, this.nodeType ? "events" : "__events__"); 
     2238 
     2239                if ( typeof events === "function" ) { 
     2240                        events = events.events; 
     2241                } 
     2242 
     2243                handlers = (events || {})[ event.type ]; 
     2244 
     2245                if ( events && handlers ) { 
     2246                        // Clone the handlers to prevent manipulation 
     2247                        handlers = handlers.slice(0); 
     2248 
     2249                        for ( var j = 0, l = handlers.length; j < l; j++ ) { 
     2250                                var handleObj = handlers[ j ]; 
     2251 
     2252                                // Filter the functions by class 
     2253                                if ( all || namespace_re.test( handleObj.namespace ) ) { 
     2254                                        // Pass in a reference to the handler function itself 
     2255                                        // So that we can later remove it 
     2256                                        event.handler = handleObj.handler; 
     2257                                        event.data = handleObj.data; 
     2258                                        event.handleObj = handleObj; 
     2259         
     2260                                        var ret = handleObj.handler.apply( this, args ); 
     2261 
     2262                                        if ( ret !== undefined ) { 
     2263                                                event.result = ret; 
     2264                                                if ( ret === false ) { 
     2265                                                        event.preventDefault(); 
     2266                                                        event.stopPropagation(); 
     2267                                                } 
    18912268                                        } 
    1892                                 } 
    1893  
    1894                                 if ( event.isImmediatePropagationStopped() ) { 
    1895                                         break; 
    1896                                 } 
    1897  
     2269 
     2270                                        if ( event.isImmediatePropagationStopped() ) { 
     2271                                                break; 
     2272                                        } 
     2273                                } 
    18982274                        } 
    18992275                } 
     
    19022278        }, 
    19032279 
    1904         props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "), 
     2280        props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "), 
    19052281 
    19062282        fix: function( event ) { 
    1907                 if ( event[ expando ] ) { 
     2283                if ( event[ jQuery.expando ] ) { 
    19082284                        return event; 
    19092285                } 
     
    19212297                // Fix target property, if necessary 
    19222298                if ( !event.target ) { 
    1923                         event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either 
     2299                        // Fixes #1925 where srcElement might not be defined either 
     2300                        event.target = event.srcElement || document; 
    19242301                } 
    19252302 
     
    19362313                // Calculate pageX/Y if missing and clientX/Y available 
    19372314                if ( event.pageX == null && event.clientX != null ) { 
    1938                         var doc = document.documentElement, body = document.body; 
     2315                        var doc = document.documentElement, 
     2316                                body = document.body; 
     2317 
    19392318                        event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0); 
    19402319                        event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0); 
     
    19422321 
    19432322                // Add which for key events 
    1944                 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) ) { 
    1945                         event.which = event.charCode || event.keyCode; 
     2323                if ( event.which == null && (event.charCode != null || event.keyCode != null) ) { 
     2324                        event.which = event.charCode != null ? event.charCode : event.keyCode; 
    19462325                } 
    19472326 
     
    19742353 
    19752354                live: { 
    1976                         add: function( proxy, data, namespaces, live ) { 
    1977                                 jQuery.extend( proxy, data || {} ); 
    1978  
    1979                                 proxy.guid += data.selector + data.live;  
    1980                                 data.liveProxy = proxy; 
    1981  
    1982                                 jQuery.event.add( this, data.live, liveHandler, data );  
    1983                                  
     2355                        add: function( handleObj ) { 
     2356                                jQuery.event.add( this, 
     2357                                        liveConvert( handleObj.origType, handleObj.selector ), 
     2358                                        jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );  
    19842359                        }, 
    19852360 
    1986                         remove: function( namespaces ) { 
    1987                                 if ( namespaces.length ) { 
    1988                                         var remove = 0, name = new RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)"); 
    1989  
    1990                                         jQuery.each( (jQuery.data(this, "events").live || {}), function() { 
    1991                                                 if ( name.test(this.type) ) { 
    1992                                                         remove++; 
    1993                                                 } 
    1994                                         }); 
    1995  
    1996                                         if ( remove < 1 ) { 
    1997                                                 jQuery.event.remove( this, namespaces[0], liveHandler ); 
    1998                                         } 
     2361                        remove: function( handleObj ) { 
     2362                                jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj ); 
     2363                        } 
     2364                }, 
     2365 
     2366                beforeunload: { 
     2367                        setup: function( data, namespaces, eventHandle ) { 
     2368                                // We only want to do this special case on windows 
     2369                                if ( jQuery.isWindow( this ) ) { 
     2370                                        this.onbeforeunload = eventHandle; 
    19992371                                } 
    20002372                        }, 
    2001                         special: {} 
    2002                 }, 
    2003                 beforeunload: { 
    2004                         setup: function( data, namespaces, fn ) { 
    2005                                 // We only want to do this special case on windows 
    2006                                 if ( this.setInterval ) { 
    2007                                         this.onbeforeunload = fn; 
    2008                                 } 
    2009  
    2010                                 return false; 
    2011                         }, 
    2012                         teardown: function( namespaces, fn ) { 
    2013                                 if ( this.onbeforeunload === fn ) { 
     2373 
     2374                        teardown: function( namespaces, eventHandle ) { 
     2375                                if ( this.onbeforeunload === eventHandle ) { 
    20142376                                        this.onbeforeunload = null; 
    20152377                                } 
     
    20182380        } 
    20192381}; 
     2382 
     2383jQuery.removeEvent = document.removeEventListener ? 
     2384        function( elem, type, handle ) { 
     2385                if ( elem.removeEventListener ) { 
     2386                        elem.removeEventListener( type, handle, false ); 
     2387                } 
     2388        } :  
     2389        function( elem, type, handle ) { 
     2390                if ( elem.detachEvent ) { 
     2391                        elem.detachEvent( "on" + type, handle ); 
     2392                } 
     2393        }; 
    20202394 
    20212395jQuery.Event = function( src ) { 
     
    20362410        // timeStamp is buggy for some events on Firefox(#3843) 
    20372411        // So we won't rely on the native value 
    2038         this.timeStamp = now(); 
     2412        this.timeStamp = jQuery.now(); 
    20392413 
    20402414        // Mark it as fixed 
    2041         this[ expando ] = true; 
     2415        this[ jQuery.expando ] = true; 
    20422416}; 
    20432417 
     
    20632437                if ( e.preventDefault ) { 
    20642438                        e.preventDefault(); 
    2065                 } 
     2439 
    20662440                // otherwise set the returnValue property of the original event to false (IE) 
    2067                 e.returnValue = false; 
     2441                } else { 
     2442                        e.returnValue = false; 
     2443                } 
    20682444        }, 
    20692445        stopPropagation: function() { 
     
    20962472        var parent = event.relatedTarget; 
    20972473 
    2098         // Traverse up the tree 
    2099         while ( parent && parent !== this ) { 
    2100                 // Firefox sometimes assigns relatedTarget a XUL element 
    2101                 // which we cannot access the parentNode property of 
    2102                 try { 
     2474        // Firefox sometimes assigns relatedTarget a XUL element 
     2475        // which we cannot access the parentNode property of 
     2476        try { 
     2477                // Traverse up the tree 
     2478                while ( parent && parent !== this ) { 
    21032479                        parent = parent.parentNode; 
    2104  
    2105                 // assuming we've left the element since we most likely mousedover a xul element 
    2106                 } catch(e) { 
    2107                         break; 
    2108                 } 
    2109         } 
    2110  
    2111         if ( parent !== this ) { 
    2112                 // set the correct event type 
    2113                 event.type = event.data; 
    2114  
    2115                 // handle event if we actually just moused on to a non sub-element 
    2116                 jQuery.event.handle.apply( this, arguments ); 
    2117         } 
    2118  
     2480                } 
     2481 
     2482                if ( parent !== this ) { 
     2483                        // set the correct event type 
     2484                        event.type = event.data; 
     2485 
     2486                        // handle event if we actually just moused on to a non sub-element 
     2487                        jQuery.event.handle.apply( this, arguments ); 
     2488                } 
     2489 
     2490        // assuming we've left the element since we most likely mousedover a xul element 
     2491        } catch(e) { } 
    21192492}, 
    21202493 
     
    21442517if ( !jQuery.support.submitBubbles ) { 
    21452518 
    2146 jQuery.event.special.submit = { 
    2147         setup: function( data, namespaces, fn ) { 
    2148                 if ( this.nodeName.toLowerCase() !== "form" ) { 
    2149                         jQuery.event.add(this, "click.specialSubmit." + fn.guid, function( e ) { 
    2150                                 var elem = e.target, type = elem.type; 
    2151  
    2152                                 if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) { 
    2153                                         return trigger( "submit", this, arguments ); 
    2154                                 } 
    2155                         }); 
     2519        jQuery.event.special.submit = { 
     2520                setup: function( data, namespaces ) { 
     2521                        if ( this.nodeName.toLowerCase() !== "form" ) { 
     2522                                jQuery.event.add(this, "click.specialSubmit", function( e ) { 
     2523                                        var elem = e.target, 
     2524                                                type = elem.type; 
     2525 
     2526                                        if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) { 
     2527                                                e.liveFired = undefined; 
     2528                                                return trigger( "submit", this, arguments ); 
     2529                                        } 
     2530                                }); 
    21562531          
    2157                         jQuery.event.add(this, "keypress.specialSubmit." + fn.guid, function( e ) { 
    2158                                 var elem = e.target, type = elem.type; 
    2159  
    2160                                 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) { 
    2161                                         return trigger( "submit", this, arguments ); 
    2162                                 } 
    2163                         }); 
    2164  
    2165                 } else { 
    2166                         return false; 
    2167                 } 
    2168         }, 
    2169  
    2170         remove: function( namespaces, fn ) { 
    2171                 jQuery.event.remove( this, "click.specialSubmit" + (fn ? "."+fn.guid : "") ); 
    2172                 jQuery.event.remove( this, "keypress.specialSubmit" + (fn ? "."+fn.guid : "") ); 
    2173         } 
    2174 }; 
     2532                                jQuery.event.add(this, "keypress.specialSubmit", function( e ) { 
     2533                                        var elem = e.target, 
     2534                                                type = elem.type; 
     2535 
     2536                                        if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) { 
     2537                                                e.liveFired = undefined; 
     2538                                                return trigger( "submit", this, arguments ); 
     2539                                        } 
     2540                                }); 
     2541 
     2542                        } else { 
     2543                                return false; 
     2544                        } 
     2545                }, 
     2546 
     2547                teardown: function( namespaces ) { 
     2548                        jQuery.event.remove( this, ".specialSubmit" ); 
     2549                } 
     2550        }; 
    21752551 
    21762552} 
     
    21792555if ( !jQuery.support.changeBubbles ) { 
    21802556 
    2181 var formElems = /textarea|input|select/i; 
    2182  
    2183 function getVal( elem ) { 
    2184         var type = elem.type, val = elem.value; 
    2185  
    2186         if ( type === "radio" || type === "checkbox" ) { 
    2187                 val = elem.checked; 
    2188  
    2189         } else if ( type === "select-multiple" ) { 
    2190                 val = elem.selectedIndex > -1 ? 
    2191                         jQuery.map( elem.options, function( elem ) { 
    2192                                 return elem.selected; 
    2193                         }).join("-") : 
    2194                         ""; 
    2195  
    2196         } else if ( elem.nodeName.toLowerCase() === "select" ) { 
    2197                 val = elem.selectedIndex; 
    2198         } 
    2199  
    2200         return val; 
    2201 } 
    2202  
    2203 function testChange( e ) { 
     2557        var changeFilters, 
     2558 
     2559        getVal = function( elem ) { 
     2560                var type = elem.type, val = elem.value; 
     2561 
     2562                if ( type === "radio" || type === "checkbox" ) { 
     2563                        val = elem.checked; 
     2564 
     2565                } else if ( type === "select-multiple" ) { 
     2566                        val = elem.selectedIndex > -1 ? 
     2567                                jQuery.map( elem.options, function( elem ) { 
     2568                                        return elem.selected; 
     2569                                }).join("-") : 
     2570                                ""; 
     2571 
     2572                } else if ( elem.nodeName.toLowerCase() === "select" ) { 
     2573                        val = elem.selectedIndex; 
     2574                } 
     2575 
     2576                return val; 
     2577        }, 
     2578 
     2579        testChange = function testChange( e ) { 
    22042580                var elem = e.target, data, val; 
    22052581 
    2206                 if ( !formElems.test( elem.nodeName ) || elem.readOnly ) { 
     2582                if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) { 
    22072583                        return; 
    22082584                } 
     
    22222598                if ( data != null || val ) { 
    22232599                        e.type = "change"; 
     2600                        e.liveFired = undefined; 
    22242601                        return jQuery.event.trigger( e, arguments[1], elem ); 
    22252602                } 
    2226 } 
    2227  
    2228 jQuery.event.special.change = { 
    2229         filters: { 
    2230                 focusout: testChange,  
    2231  
    2232                 click: function( e ) { 
    2233                         var elem = e.target, type = elem.type; 
    2234  
    2235                         if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) { 
    2236                                 return testChange.call( this, e ); 
     2603        }; 
     2604 
     2605        jQuery.event.special.change = { 
     2606                filters: { 
     2607                        focusout: testChange,  
     2608 
     2609                        beforedeactivate: testChange, 
     2610 
     2611                        click: function( e ) { 
     2612                                var elem = e.target, type = elem.type; 
     2613 
     2614                                if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) { 
     2615                                        return testChange.call( this, e ); 
     2616                                } 
     2617                        }, 
     2618 
     2619                        // Change has to be called before submit 
     2620                        // Keydown will be called before keypress, which is used in submit-event delegation 
     2621                        keydown: function( e ) { 
     2622                                var elem = e.target, type = elem.type; 
     2623 
     2624                                if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") || 
     2625                                        (e.keyCode === 32 && (type === "checkbox" || type === "radio")) || 
     2626                                        type === "select-multiple" ) { 
     2627                                        return testChange.call( this, e ); 
     2628                                } 
     2629                        }, 
     2630 
     2631                        // Beforeactivate happens also before the previous element is blurred 
     2632                        // with this event you can't trigger a change event, but you can store 
     2633                        // information 
     2634                        beforeactivate: function( e ) { 
     2635                                var elem = e.target; 
     2636                                jQuery.data( elem, "_change_data", getVal(elem) ); 
    22372637                        } 
    22382638                }, 
    22392639 
    2240                 // Change has to be called before submit 
    2241                 // Keydown will be called before keypress, which is used in submit-event delegation 
    2242                 keydown: function( e ) { 
    2243                         var elem = e.target, type = elem.type; 
    2244  
    2245                         if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") || 
    2246                                 (e.keyCode === 32 && (type === "checkbox" || type === "radio")) || 
    2247                                 type === "select-multiple" ) { 
    2248                                 return testChange.call( this, e ); 
    2249                         } 
     2640                setup: function( data, namespaces ) { 
     2641                        if ( this.type === "file" ) { 
     2642                                return false; 
     2643                        } 
     2644 
     2645                        for ( var type in changeFilters ) { 
     2646                                jQuery.event.add( this, type + ".specialChange", changeFilters[type] ); 
     2647                        } 
     2648 
     2649                        return rformElems.test( this.nodeName ); 
    22502650                }, 
    22512651 
    2252                 // Beforeactivate happens also before the previous element is blurred 
    2253                 // with this event you can't trigger a change event, but you can store 
    2254                 // information/focus[in] is not needed anymore 
    2255                 beforeactivate: function( e ) { 
    2256                         var elem = e.target; 
    2257  
    2258                         if ( elem.nodeName.toLowerCase() === "input" && elem.type === "radio" ) { 
    2259                                 jQuery.data( elem, "_change_data", getVal(elem) ); 
    2260                         } 
    2261                 } 
    2262         }, 
    2263         setup: function( data, namespaces, fn ) { 
    2264                 for ( var type in changeFilters ) { 
    2265                         jQuery.event.add( this, type + ".specialChange." + fn.guid, changeFilters[type] ); 
    2266                 } 
    2267  
    2268                 return formElems.test( this.nodeName ); 
    2269         }, 
    2270         remove: function( namespaces, fn ) { 
    2271                 for ( var type in changeFilters ) { 
    2272                         jQuery.event.remove( this, type + ".specialChange" + (fn ? "."+fn.guid : ""), changeFilters[type] ); 
    2273                 } 
    2274  
    2275                 return formElems.test( this.nodeName ); 
    2276         } 
    2277 }; 
    2278  
    2279 var changeFilters = jQuery.event.special.change.filters; 
    2280  
     2652                teardown: function( namespaces ) { 
     2653                        jQuery.event.remove( this, ".specialChange" ); 
     2654 
     2655                        return rformElems.test( this.nodeName ); 
     2656                } 
     2657        }; 
     2658 
     2659        changeFilters = jQuery.event.special.change.filters; 
     2660 
     2661        // Handle when the input is .focus()'d 
     2662        changeFilters.focus = changeFilters.beforeactivate; 
    22812663} 
    22822664 
     
    22912673                jQuery.event.special[ fix ] = { 
    22922674                        setup: function() { 
    2293                                 this.addEventListener( orig, handler, true ); 
     2675                                if ( focusCounts[fix]++ === 0 ) { 
     2676                                        document.addEventListener( orig, handler, true ); 
     2677                                } 
    22942678                        },  
    22952679                        teardown: function() {  
    2296                                 this.removeEventListener( orig, handler, true ); 
     2680                                if ( --focusCounts[fix] === 0 ) { 
     2681                                        document.removeEventListener( orig, handler, true ); 
     2682                                } 
    22972683                        } 
    22982684                }; 
     
    23012687                        e = jQuery.event.fix( e ); 
    23022688                        e.type = fix; 
    2303                         return jQuery.event.handle.call( this, e ); 
     2689                        return jQuery.event.trigger( e, null, e.target ); 
    23042690                } 
    23052691        }); 
     
    23162702                } 
    23172703                 
    2318                 if ( jQuery.isFunction( data ) ) { 
     2704                if ( jQuery.isFunction( data ) || data === false ) { 
    23192705                        fn = data; 
    23202706                        data = undefined; 
     
    23262712                }) : fn; 
    23272713 
    2328                 return type === "unload" && name !== "one" ? 
    2329                         this.one( type, data, fn ) : 
    2330                         this.each(function() { 
    2331                                 jQuery.event.add( this, type, handler, data ); 
    2332                         }); 
     2714                if ( type === "unload" && name !== "one" ) { 
     2715                        this.one( type, data, fn ); 
     2716 
     2717                } else { 
     2718                        for ( var i = 0, l = this.length; i < l; i++ ) { 
     2719                                jQuery.event.add( this[i], type, handler, data ); 
     2720                        } 
     2721                } 
     2722 
     2723                return this; 
    23332724        }; 
    23342725}); 
     
    23412732                                this.unbind(key, type[key]); 
    23422733                        } 
    2343                         return this; 
    2344                 } 
    2345  
    2346                 return this.each(function() { 
    2347                         jQuery.event.remove( this, type, fn ); 
    2348                 }); 
    2349         }, 
     2734 
     2735                } else { 
     2736                        for ( var i = 0, l = this.length; i < l; i++ ) { 
     2737                                jQuery.event.remove( this[i], type, fn ); 
     2738                        } 
     2739                } 
     2740 
     2741                return this; 
     2742        }, 
     2743         
     2744        delegate: function( selector, types, data, fn ) { 
     2745                return this.live( types, data, fn, selector ); 
     2746        }, 
     2747         
     2748        undelegate: function( selector, types, fn ) { 
     2749                if ( arguments.length === 0 ) { 
     2750                                return this.unbind( "live" ); 
     2751                 
     2752                } else { 
     2753                        return this.die( types, null, fn, selector ); 
     2754                } 
     2755        }, 
     2756         
    23502757        trigger: function( type, data ) { 
    23512758                return this.each(function() { 
     
    23662773        toggle: function( fn ) { 
    23672774                // Save reference to arguments for access in closure 
    2368                 var args = arguments, i = 1; 
     2775                var args = arguments, 
     2776                        i = 1; 
    23692777 
    23702778                // link all the functions, so any of them can unbind this click handler 
     
    23912799}); 
    23922800 
     2801var liveMap = { 
     2802        focus: "focusin", 
     2803        blur: "focusout", 
     2804        mouseenter: "mouseover", 
     2805        mouseleave: "mouseout" 
     2806}; 
     2807 
    23932808jQuery.each(["live", "die"], function( i, name ) { 
    2394         jQuery.fn[ name ] = function( types, data, fn ) { 
    2395                 var type, i = 0; 
     2809        jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) { 
     2810                var type, i = 0, match, namespaces, preType, 
     2811                        selector = origSelector || this.selector, 
     2812                        context = origSelector ? this : jQuery( this.context ); 
     2813                 
     2814                if ( typeof types === "object" && !types.preventDefault ) { 
     2815                        for ( var key in types ) { 
     2816                                context[ name ]( key, data, types[key], selector ); 
     2817                        } 
     2818                         
     2819                        return this; 
     2820                } 
    23962821 
    23972822                if ( jQuery.isFunction( data ) ) { 
     
    24002825                } 
    24012826 
    2402                 types = (types || "").split( /\s+/ ); 
     2827                types = (types || "").split(" "); 
    24032828 
    24042829                while ( (type = types[ i++ ]) != null ) { 
    2405                         type = type === "focus" ? "focusin" : // focus --> focusin 
    2406                                         type === "blur" ? "focusout" : // blur --> focusout 
    2407                                         type === "hover" ? types.push("mouseleave") && "mouseenter" : // hover support 
    2408                                         type; 
    2409                          
     2830                        match = rnamespaces.exec( type ); 
     2831                        namespaces = ""; 
     2832 
     2833                        if ( match )  { 
     2834                                namespaces = match[0]; 
     2835                                type = type.replace( rnamespaces, "" ); 
     2836                        } 
     2837 
     2838                        if ( type === "hover" ) { 
     2839                                types.push( "mouseenter" + namespaces, "mouseleave" + namespaces ); 
     2840                                continue; 
     2841                        } 
     2842 
     2843                        preType = type; 
     2844 
     2845                        if ( type === "focus" || type === "blur" ) { 
     2846                                types.push( liveMap[ type ] + namespaces ); 
     2847                                type = type + namespaces; 
     2848 
     2849                        } else { 
     2850                                type = (liveMap[ type ] || type) + namespaces; 
     2851                        } 
     2852 
    24102853                        if ( name === "live" ) { 
    24112854                                // bind live handler 
    2412                                 jQuery( this.context ).bind( liveConvert( type, this.selector ), { 
    2413                                         data: data, selector: this.selector, live: type 
    2414                                 }, fn ); 
     2855                                for ( var j = 0, l = context.length; j < l; j++ ) { 
     2856                                        jQuery.event.add( context[j], "live." + liveConvert( type, selector ), 
     2857                                                { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } ); 
     2858                                } 
    24152859 
    24162860                        } else { 
    24172861                                // unbind live handler 
    2418                                 jQuery( this.context ).unbind( liveConvert( type, this.selector ), fn ? { guid: fn.guid + this.selector + type } : null ); 
     2862                                context.unbind( "live." + liveConvert( type, selector ), fn ); 
    24192863                        } 
    24202864                } 
    24212865                 
    24222866                return this; 
    2423         } 
     2867        }; 
    24242868}); 
    24252869 
    24262870function liveHandler( event ) { 
    2427         var stop, elems = [], selectors = [], args = arguments, 
    2428                 related, match, fn, elem, j, i, l, data, 
    2429                 live = jQuery.extend({}, jQuery.data( this, "events" ).live); 
     2871        var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret, 
     2872                elems = [], 
     2873                selectors = [], 
     2874                events = jQuery.data( this, this.nodeType ? "events" : "__events__" ); 
     2875 
     2876        if ( typeof events === "function" ) { 
     2877                events = events.events; 
     2878        } 
    24302879 
    24312880        // Make sure we avoid non-left-click bubbling in Firefox (#3861) 
    2432         if ( event.button && event.type === "click" ) { 
     2881        if ( event.liveFired === this || !events || !events.live || event.button && event.type === "click" ) { 
    24332882                return; 
    24342883        } 
    2435  
    2436         for ( j in live ) { 
    2437                 fn = live[j]; 
    2438                 if ( fn.live === event.type || 
    2439                                 fn.altLive && jQuery.inArray(event.type, fn.altLive) > -1 ) { 
    2440  
    2441                         data = fn.data; 
    2442                         if ( !(data.beforeFilter && data.beforeFilter[event.type] &&  
    2443                                         !data.beforeFilter[event.type](event)) ) { 
    2444                                 selectors.push( fn.selector ); 
    2445                         } 
     2884         
     2885        if ( event.namespace ) { 
     2886                namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)"); 
     2887        } 
     2888 
     2889        event.liveFired = this; 
     2890 
     2891        var live = events.live.slice(0); 
     2892 
     2893        for ( j = 0; j < live.length; j++ ) { 
     2894                handleObj = live[j]; 
     2895 
     2896                if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) { 
     2897                        selectors.push( handleObj.selector ); 
     2898 
    24462899                } else { 
    2447                         delete live[j]; 
     2900                        live.splice( j--, 1 ); 
    24482901                } 
    24492902        } 
     
    24522905 
    24532906        for ( i = 0, l = match.length; i < l; i++ ) { 
    2454                 for ( j in live ) { 
    2455                         fn = live[j]; 
    2456                         elem = match[i].elem; 
    2457                         related = null; 
    2458  
    2459                         if ( match[i].selector === fn.selector ) { 
     2907                close = match[i]; 
     2908 
     2909                for ( j = 0; j < live.length; j++ ) { 
     2910                        handleObj = live[j]; 
     2911 
     2912                        if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) ) { 
     2913                                elem = close.elem; 
     2914                                related = null; 
     2915 
    24602916                                // Those two events require additional checking 
    2461                                 if ( fn.live === "mouseenter" || fn.live === "mouseleave" ) { 
    2462                                         related = jQuery( event.relatedTarget ).closest( fn.selector )[0]; 
     2917                                if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) { 
     2918                                        event.type = handleObj.preType; 
     2919                                        related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0]; 
    24632920                                } 
    24642921 
    24652922                                if ( !related || related !== elem ) { 
    2466                                         elems.push({ elem: elem, fn: fn }); 
     2923                                        elems.push({ elem: elem, handleObj: handleObj, level: close.level }); 
    24672924                                } 
    24682925                        } 
     
    24722929        for ( i = 0, l = elems.length; i < l; i++ ) { 
    24732930                match = elems[i]; 
     2931 
     2932                if ( maxLevel && match.level > maxLevel ) { 
     2933                        break; 
     2934                } 
     2935 
    24742936                event.currentTarget = match.elem; 
    2475                 event.data = match.fn.data; 
    2476                 if ( match.fn.apply( match.elem, args ) === false ) { 
    2477                         stop = false; 
    2478                         break; 
     2937                event.data = match.handleObj.data; 
     2938                event.handleObj = match.handleObj; 
     2939 
     2940                ret = match.handleObj.origHandler.apply( match.elem, arguments ); 
     2941 
     2942                if ( ret === false || event.isPropagationStopped() ) { 
     2943                        maxLevel = match.level; 
     2944 
     2945                        if ( ret === false ) { 
     2946                                stop = false; 
     2947                        } 
     2948                        if ( event.isImmediatePropagationStopped() ) { 
     2949                                break; 
     2950                        } 
    24792951                } 
    24802952        } 
     
    24842956 
    24852957function liveConvert( type, selector ) { 
    2486         return "live." + (type ? type + "." : "") + selector.replace(/\./g, "`").replace(/ /g, "&"); 
     2958        return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&"); 
    24872959} 
    24882960 
     
    24922964 
    24932965        // Handle event binding 
    2494         jQuery.fn[ name ] = function( fn ) { 
    2495                 return fn ? this.bind( name, fn ) : this.trigger( name ); 
     2966        jQuery.fn[ name ] = function( data, fn ) { 
     2967                if ( fn == null ) { 
     2968                        fn = data; 
     2969                        data = null; 
     2970                } 
     2971 
     2972                return arguments.length > 0 ? 
     2973                        this.bind( name, data, fn ) : 
     2974                        this.trigger( name ); 
    24962975        }; 
    24972976 
     
    25062985//  - http://isaacschlueter.com/2006/10/msie-memory-leaks/ 
    25072986if ( window.attachEvent && !window.addEventListener ) { 
    2508         window.attachEvent("onunload", function() { 
     2987        jQuery(window).bind("unload", function() { 
    25092988                for ( var id in jQuery.cache ) { 
    25102989                        if ( jQuery.cache[ id ].handle ) { 
     
    25172996        }); 
    25182997} 
     2998 
     2999 
    25193000/*! 
    25203001 * Sizzle CSS Selector Engine - v1.0 
     
    25253006(function(){ 
    25263007 
    2527 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, 
     3008var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, 
    25283009        done = 0, 
    25293010        toString = Object.prototype.toString, 
     
    25353016// function. If that is the case, discard the hasDuplicate value. 
    25363017//   Thus far that includes Google Chrome. 
    2537 [0, 0].sort(function(){ 
     3018[0, 0].sort(function() { 
    25383019        baseHasDuplicate = false; 
    25393020        return 0; 
    25403021}); 
    25413022 
    2542 var Sizzle = function(selector, context, results, seed) { 
     3023var Sizzle = function( selector, context, results, seed ) { 
    25433024        results = results || []; 
    2544         var origContext = context = context || document; 
     3025        context = context || document; 
     3026 
     3027        var origContext = context; 
    25453028 
    25463029        if ( context.nodeType !== 1 && context.nodeType !== 9 ) { 
     
    25523035        } 
    25533036 
    2554         var parts = [], m, set, checkSet, extra, prune = true, contextXML = isXML(context), 
     3037        var m, set, checkSet, extra, ret, cur, pop, i, 
     3038                prune = true, 
     3039                contextXML = Sizzle.isXML( context ), 
     3040                parts = [], 
    25553041                soFar = selector; 
    25563042         
    25573043        // Reset the position of the chunker regexp (start from head) 
    2558         while ( (chunker.exec(""), m = chunker.exec(soFar)) !== null ) { 
    2559                 soFar = m[3]; 
     3044        do { 
     3045                chunker.exec( "" ); 
     3046                m = chunker.exec( soFar ); 
     3047 
     3048                if ( m ) { 
     3049                        soFar = m[3]; 
    25603050                 
    2561                 parts.push( m[1] ); 
     3051                        parts.push( m[1] ); 
    25623052                 
    2563                 if ( m[2] ) { 
    2564                         extra = m[3]; 
    2565                         break; 
    2566                 } 
    2567         } 
     3053                        if ( m[2] ) { 
     3054                                extra = m[3]; 
     3055                                break; 
     3056                        } 
     3057                } 
     3058        } while ( m ); 
    25683059 
    25693060        if ( parts.length > 1 && origPOS.exec( selector ) ) { 
     3061 
    25703062                if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { 
    25713063                        set = posProcess( parts[0] + parts[1], context ); 
     3064 
    25723065                } else { 
    25733066                        set = Expr.relative[ parts[0] ] ? 
     
    25853078                        } 
    25863079                } 
     3080 
    25873081        } else { 
    25883082                // Take a shortcut and set the context if the root selector is an ID 
     
    25903084                if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML && 
    25913085                                Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) { 
    2592                         var ret = Sizzle.find( parts.shift(), context, contextXML ); 
    2593                         context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0]; 
     3086 
     3087                        ret = Sizzle.find( parts.shift(), context, contextXML ); 
     3088                        context = ret.expr ? 
     3089                                Sizzle.filter( ret.expr, ret.set )[0] : 
     3090                                ret.set[0]; 
    25943091                } 
    25953092 
    25963093                if ( context ) { 
    2597                         var ret = seed ? 
     3094                        ret = seed ? 
    25983095                                { expr: parts.pop(), set: makeArray(seed) } : 
    25993096                                Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML ); 
    2600                         set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set; 
     3097 
     3098                        set = ret.expr ? 
     3099                                Sizzle.filter( ret.expr, ret.set ) : 
     3100                                ret.set; 
    26013101 
    26023102                        if ( parts.length > 0 ) { 
    2603                                 checkSet = makeArray(set); 
     3103                                checkSet = makeArray( set ); 
     3104 
    26043105                        } else { 
    26053106                                prune = false; 
     
    26073108 
    26083109                        while ( parts.length ) { 
    2609                                 var cur = parts.pop(), pop = cur; 
     3110                                cur = parts.pop(); 
     3111                                pop = cur; 
    26103112 
    26113113                                if ( !Expr.relative[ cur ] ) { 
     
    26213123                                Expr.relative[ cur ]( checkSet, pop, contextXML ); 
    26223124                        } 
     3125 
    26233126                } else { 
    26243127                        checkSet = parts = []; 
     
    26373140                if ( !prune ) { 
    26383141                        results.push.apply( results, checkSet ); 
     3142 
    26393143                } else if ( context && context.nodeType === 1 ) { 
    2640                         for ( var i = 0; checkSet[i] != null; i++ ) { 
    2641                                 if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) { 
     3144                        for ( i = 0; checkSet[i] != null; i++ ) { 
     3145                                if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) { 
    26423146                                        results.push( set[i] ); 
    26433147                                } 
    26443148                        } 
     3149 
    26453150                } else { 
    2646                         for ( var i = 0; checkSet[i] != null; i++ ) { 
     3151                        for ( i = 0; checkSet[i] != null; i++ ) { 
    26473152                                if ( checkSet[i] && checkSet[i].nodeType === 1 ) { 
    26483153                                        results.push( set[i] ); 
     
    26503155                        } 
    26513156                } 
     3157 
    26523158        } else { 
    26533159                makeArray( checkSet, results ); 
     
    26623168}; 
    26633169 
    2664 Sizzle.uniqueSort = function(results){ 
     3170Sizzle.uniqueSort = function( results ) { 
    26653171        if ( sortOrder ) { 
    26663172                hasDuplicate = baseHasDuplicate; 
    2667                 results.sort(sortOrder); 
     3173                results.sort( sortOrder ); 
    26683174 
    26693175                if ( hasDuplicate ) { 
    26703176                        for ( var i = 1; i < results.length; i++ ) { 
    2671                                 if ( results[i] === results[i-1] ) { 
    2672                                         results.splice(i--, 1); 
     3177                                if ( results[i] === results[ i - 1 ] ) { 
     3178                                        results.splice( i--, 1 ); 
    26733179                                } 
    26743180                        } 
     
    26793185}; 
    26803186 
    2681 Sizzle.matches = function(expr, set){ 
    2682         return Sizzle(expr, null, null, set); 
     3187Sizzle.matches = function( expr, set ) { 
     3188        return Sizzle( expr, null, null, set ); 
    26833189}; 
    26843190 
    2685 Sizzle.find = function(expr, context, isXML){ 
    2686         var set, match; 
     3191Sizzle.matchesSelector = function( node, expr ) { 
     3192        return Sizzle( expr, null, null, [node] ).length > 0; 
     3193}; 
     3194 
     3195Sizzle.find = function( expr, context, isXML ) { 
     3196        var set; 
    26873197 
    26883198        if ( !expr ) { 
     
    26913201 
    26923202        for ( var i = 0, l = Expr.order.length; i < l; i++ ) { 
    2693                 var type = Expr.order[i], match; 
     3203                var match, 
     3204                        type = Expr.order[i]; 
    26943205                 
    26953206                if ( (match = Expr.leftMatch[ type ].exec( expr )) ) { 
    26963207                        var left = match[1]; 
    2697                         match.splice(1,1); 
     3208                        match.splice( 1, 1 ); 
    26983209 
    26993210                        if ( left.substr( left.length - 1 ) !== "\\" ) { 
    27003211                                match[1] = (match[1] || "").replace(/\\/g, ""); 
    27013212                                set = Expr.find[ type ]( match, context, isXML ); 
     3213 
    27023214                                if ( set != null ) { 
    27033215                                        expr = expr.replace( Expr.match[ type ], "" ); 
     
    27093221 
    27103222        if ( !set ) { 
    2711                 set = context.getElementsByTagName("*"); 
    2712         } 
    2713  
    2714         return {set: set, expr: expr}; 
     3223                set = context.getElementsByTagName( "*" ); 
     3224        } 
     3225 
     3226        return { set: set, expr: expr }; 
    27153227}; 
    27163228 
    2717 Sizzle.filter = function(expr, set, inplace, not){ 
    2718         var old = expr, result = [], curLoop = set, match, anyFound, 
    2719                 isXMLFilter = set && set[0] && isXML(set[0]); 
     3229Sizzle.filter = function( expr, set, inplace, not ) { 
     3230        var match, anyFound, 
     3231                old = expr, 
     3232                result = [], 
     3233                curLoop = set, 
     3234                isXMLFilter = set && set[0] && Sizzle.isXML( set[0] ); 
    27203235 
    27213236        while ( expr && set.length ) { 
    27223237                for ( var type in Expr.filter ) { 
    27233238                        if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) { 
    2724                                 var filter = Expr.filter[ type ], found, item, left = match[1]; 
     3239                                var found, item, 
     3240                                        filter = Expr.filter[ type ], 
     3241                                        left = match[1]; 
     3242 
    27253243                                anyFound = false; 
    27263244 
     
    27403258                                        if ( !match ) { 
    27413259                                                anyFound = found = true; 
     3260 
    27423261                                        } else if ( match === true ) { 
    27433262                                                continue; 
     
    27543273                                                                if ( pass ) { 
    27553274                                                                        anyFound = true; 
     3275 
    27563276                                                                } else { 
    27573277                                                                        curLoop[i] = false; 
    27583278                                                                } 
     3279 
    27593280                                                        } else if ( pass ) { 
    27603281                                                                result.push( item ); 
     
    27853306                        if ( anyFound == null ) { 
    27863307                                Sizzle.error( expr ); 
     3308 
    27873309                        } else { 
    27883310                                break; 
     
    28023324var Expr = Sizzle.selectors = { 
    28033325        order: [ "ID", "NAME", "TAG" ], 
     3326 
    28043327        match: { 
    2805                 ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/, 
    2806                 CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/, 
    2807                 NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/, 
    2808                 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/, 
    2809                 TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/, 
    2810                 CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/, 
    2811                 POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/, 
    2812                 PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/ 
    2813         }, 
     3328                ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, 
     3329                CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/, 
     3330                NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/, 
     3331                ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/, 
     3332                TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/, 
     3333                CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+\-]*)\))?/, 
     3334                POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/, 
     3335                PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/ 
     3336        }, 
     3337 
    28143338        leftMatch: {}, 
     3339 
    28153340        attrMap: { 
    28163341                "class": "className", 
    28173342                "for": "htmlFor" 
    28183343        }, 
     3344 
    28193345        attrHandle: { 
    2820                 href: function(elem){ 
    2821                         return elem.getAttribute("href"); 
    2822                 } 
    2823         }, 
     3346                href: function( elem ) { 
     3347                        return elem.getAttribute( "href" ); 
     3348                } 
     3349        }, 
     3350 
    28243351        relative: { 
    28253352                "+": function(checkSet, part){ 
    28263353                        var isPartStr = typeof part === "string", 
    2827                                 isTag = isPartStr && !/\W/.test(part), 
     3354                                isTag = isPartStr && !/\W/.test( part ), 
    28283355                                isPartStrNotTag = isPartStr && !isTag; 
    28293356 
     
    28463373                        } 
    28473374                }, 
    2848                 ">": function(checkSet, part){ 
    2849                         var isPartStr = typeof part === "string"; 
    2850  
    2851                         if ( isPartStr && !/\W/.test(part) ) { 
     3375 
     3376                ">": function( checkSet, part ) { 
     3377                        var elem, 
     3378                                isPartStr = typeof part === "string", 
     3379                                i = 0, 
     3380                                l = checkSet.length; 
     3381 
     3382                        if ( isPartStr && !/\W/.test( part ) ) { 
    28523383                                part = part.toLowerCase(); 
    28533384 
    2854                                 for ( var i = 0, l = checkSet.length; i < l; i++ ) { 
    2855                                         var elem = checkSet[i]; 
     3385                                for ( ; i < l; i++ ) { 
     3386                                        elem = checkSet[i]; 
     3387 
    28563388                                        if ( elem ) { 
    28573389                                                var parent = elem.parentNode; 
     
    28593391                                        } 
    28603392                                } 
     3393 
    28613394                        } else { 
    2862                                 for ( var i = 0, l = checkSet.length; i < l; i++ ) { 
    2863                                         var elem = checkSet[i]; 
     3395                                for ( ; i < l; i++ ) { 
     3396                                        elem = checkSet[i]; 
     3397 
    28643398                                        if ( elem ) { 
    28653399                                                checkSet[i] = isPartStr ? 
     
    28743408                        } 
    28753409                }, 
     3410 
    28763411                "": function(checkSet, part, isXML){ 
    2877                         var doneName = done++, checkFn = dirCheck; 
     3412                        var nodeCheck, 
     3413                                doneName = done++, 
     3414                                checkFn = dirCheck; 
    28783415 
    28793416                        if ( typeof part === "string" && !/\W/.test(part) ) { 
    2880                                 var nodeCheck = part = part.toLowerCase(); 
     3417                                part = part.toLowerCase(); 
     3418                                nodeCheck = part; 
    28813419                                checkFn = dirNodeCheck; 
    28823420                        } 
    28833421 
    2884                         checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML); 
     3422                        checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML ); 
    28853423                }, 
    2886                 "~": function(checkSet, part, isXML){ 
    2887                         var doneName = done++, checkFn = dirCheck; 
    2888  
    2889                         if ( typeof part === "string" && !/\W/.test(part) ) { 
    2890                                 var nodeCheck = part = part.toLowerCase(); 
     3424 
     3425                "~": function( checkSet, part, isXML ) { 
     3426                        var nodeCheck, 
     3427                                doneName = done++, 
     3428                                checkFn = dirCheck; 
     3429 
     3430                        if ( typeof part === "string" && !/\W/.test( part ) ) { 
     3431                                part = part.toLowerCase(); 
     3432                                nodeCheck = part; 
    28913433                                checkFn = dirNodeCheck; 
    28923434                        } 
    28933435 
    2894                         checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML); 
    2895                 } 
    2896         }, 
     3436                        checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML ); 
     3437                } 
     3438        }, 
     3439 
    28973440        find: { 
    2898                 ID: function(match, context, isXML){ 
     3441                ID: function( match, context, isXML ) { 
    28993442                        if ( typeof context.getElementById !== "undefined" && !isXML ) { 
    29003443                                var m = context.getElementById(match[1]); 
    2901                                 return m ? [m] : []; 
     3444                                // Check parentNode to catch when Blackberry 4.6 returns 
     3445                                // nodes that are no longer in the document #6963 
     3446                                return m && m.parentNode ? [m] : []; 
    29023447                        } 
    29033448                }, 
    2904                 NAME: function(match, context){ 
     3449 
     3450                NAME: function( match, context ) { 
    29053451                        if ( typeof context.getElementsByName !== "undefined" ) { 
    2906                                 var ret = [], results = context.getElementsByName(match[1]); 
     3452                                var ret = [], 
     3453                                        results = context.getElementsByName( match[1] ); 
    29073454 
    29083455                                for ( var i = 0, l = results.length; i < l; i++ ) { 
     
    29153462                        } 
    29163463                }, 
    2917                 TAG: function(match, context){ 
    2918                         return context.getElementsByTagName(match[1]); 
     3464 
     3465                TAG: function( match, context ) { 
     3466                        return context.getElementsByTagName( match[1] ); 
    29193467                } 
    29203468        }, 
    29213469        preFilter: { 
    2922                 CLASS: function(match, curLoop, inplace, result, not, isXML){ 
     3470                CLASS: function( match, curLoop, inplace, result, not, isXML ) { 
    29233471                        match = " " + match[1].replace(/\\/g, "") + " "; 
    29243472 
     
    29333481                                                        result.push( elem ); 
    29343482                                                } 
     3483 
    29353484                                        } else if ( inplace ) { 
    29363485                                                curLoop[i] = false; 
     
    29413490                        return false; 
    29423491                }, 
    2943                 ID: function(match){ 
     3492 
     3493                ID: function( match ) { 
    29443494                        return match[1].replace(/\\/g, ""); 
    29453495                }, 
    2946                 TAG: function(match, curLoop){ 
     3496 
     3497                TAG: function( match, curLoop ) { 
    29473498                        return match[1].toLowerCase(); 
    29483499                }, 
    2949                 CHILD: function(match){ 
     3500 
     3501                CHILD: function( match ) { 
    29503502                        if ( match[1] === "nth" ) { 
    29513503                                // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6' 
     
    29643516                        return match; 
    29653517                }, 
    2966                 ATTR: function(match, curLoop, inplace, result, not, isXML){ 
     3518 
     3519                ATTR: function( match, curLoop, inplace, result, not, isXML ) { 
    29673520                        var name = match[1].replace(/\\/g, ""); 
    29683521                         
     
    29773530                        return match; 
    29783531                }, 
    2979                 PSEUDO: function(match, curLoop, inplace, result, not){ 
     3532 
     3533                PSEUDO: function( match, curLoop, inplace, result, not ) { 
    29803534                        if ( match[1] === "not" ) { 
    29813535                                // If we're dealing with a complex expression, or a simple one 
    29823536                                if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) { 
    29833537                                        match[3] = Sizzle(match[3], null, null, curLoop); 
     3538 
    29843539                                } else { 
    29853540                                        var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not); 
     3541 
    29863542                                        if ( !inplace ) { 
    29873543                                                result.push.apply( result, ret ); 
    29883544                                        } 
     3545 
    29893546                                        return false; 
    29903547                                } 
     3548 
    29913549                        } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) { 
    29923550                                return true; 
     
    29953553                        return match; 
    29963554                }, 
    2997                 POS: function(match){ 
     3555 
     3556                POS: function( match ) { 
    29983557                        match.unshift( true ); 
     3558 
    29993559                        return match; 
    30003560                } 
    30013561        }, 
     3562         
    30023563        filters: { 
    3003                 enabled: function(elem){ 
     3564                enabled: function( elem ) { 
    30043565                        return elem.disabled === false && elem.type !== "hidden"; 
    30053566                }, 
    3006                 disabled: function(elem){ 
     3567 
     3568                disabled: function( elem ) { 
    30073569                        return elem.disabled === true; 
    30083570                }, 
    3009                 checked: function(elem){ 
     3571 
     3572                checked: function( elem ) { 
    30103573                        return elem.checked === true; 
    30113574                }, 
    3012                 selected: function(elem){ 
     3575                 
     3576                selected: function( elem ) { 
    30133577                        // Accessing this property makes selected-by-default 
    30143578                        // options in Safari work properly 
    30153579                        elem.parentNode.selectedIndex; 
     3580                         
    30163581                        return elem.selected === true; 
    30173582                }, 
    3018                 parent: function(elem){ 
     3583 
     3584                parent: function( elem ) { 
    30193585                        return !!elem.firstChild; 
    30203586                }, 
    3021                 empty: function(elem){ 
     3587 
     3588                empty: function( elem ) { 
    30223589                        return !elem.firstChild; 
    30233590                }, 
    3024                 has: function(elem, i, match){ 
     3591 
     3592                has: function( elem, i, match ) { 
    30253593                        return !!Sizzle( match[3], elem ).length; 
    30263594                }, 
    3027                 header: function(elem){ 
    3028                         return /h\d/i.test( elem.nodeName ); 
     3595 
     3596                header: function( elem ) { 
     3597                        return (/h\d/i).test( elem.nodeName ); 
    30293598                }, 
    3030                 text: function(elem){ 
     3599 
     3600                text: function( elem ) { 
    30313601                        return "text" === elem.type; 
    30323602                }, 
    3033                 radio: function(elem){ 
     3603                radio: function( elem ) { 
    30343604                        return "radio" === elem.type; 
    30353605                }, 
    3036                 checkbox: function(elem){ 
     3606 
     3607                checkbox: function( elem ) { 
    30373608                        return "checkbox" === elem.type; 
    30383609                }, 
    3039                 file: function(elem){ 
     3610 
     3611                file: function( elem ) { 
    30403612                        return "file" === elem.type; 
    30413613                }, 
    3042                 password: function(elem){ 
     3614                password: function( elem ) { 
    30433615                        return "password" === elem.type; 
    30443616                }, 
    3045                 submit: function(elem){ 
     3617 
     3618                submit: function( elem ) { 
    30463619                        return "submit" === elem.type; 
    30473620                }, 
    3048                 image: function(elem){ 
     3621 
     3622                image: function( elem ) { 
    30493623                        return "image" === elem.type; 
    30503624                }, 
    3051                 reset: function(elem){ 
     3625 
     3626                reset: function( elem ) { 
    30523627                        return "reset" === elem.type; 
    30533628                }, 
    3054                 button: function(elem){ 
     3629 
     3630                button: function( elem ) { 
    30553631                        return "button" === elem.type || elem.nodeName.toLowerCase() === "button"; 
    30563632                }, 
    3057                 input: function(elem){ 
    3058                         return /input|select|textarea|button/i.test(elem.nodeName); 
     3633 
     3634                input: function( elem ) { 
     3635                        return (/input|select|textarea|button/i).test( elem.nodeName ); 
    30593636                } 
    30603637        }, 
    30613638        setFilters: { 
    3062                 first: function(elem, i){ 
     3639                first: function( elem, i ) { 
    30633640                        return i === 0; 
    30643641                }, 
    3065                 last: function(elem, i, match, array){ 
     3642 
     3643                last: function( elem, i, match, array ) { 
    30663644                        return i === array.length - 1; 
    30673645                }, 
    3068                 even: function(elem, i){ 
     3646 
     3647                even: function( elem, i ) { 
    30693648                        return i % 2 === 0; 
    30703649                }, 
    3071                 odd: function(elem, i){ 
     3650 
     3651                odd: function( elem, i ) { 
    30723652                        return i % 2 === 1; 
    30733653                }, 
    3074                 lt: function(elem, i, match){ 
     3654 
     3655                lt: function( elem, i, match ) { 
    30753656                        return i < match[3] - 0; 
    30763657                }, 
    3077                 gt: function(elem, i, match){ 
     3658 
     3659                gt: function( elem, i, match ) { 
    30783660                        return i > match[3] - 0; 
    30793661                }, 
    3080                 nth: function(elem, i, match){ 
     3662 
     3663                nth: function( elem, i, match ) { 
    30813664                        return match[3] - 0 === i; 
    30823665                }, 
    3083                 eq: function(elem, i, match){ 
     3666 
     3667                eq: function( elem, i, match ) { 
    30843668                        return match[3] - 0 === i; 
    30853669                } 
    30863670        }, 
    30873671        filter: { 
    3088                 PSEUDO: function(elem, match, i, array){ 
    3089                         var name = match[1], filter = Expr.filters[ name ]; 
     3672                PSEUDO: function( elem, match, i, array ) { 
     3673                        var name = match[1], 
     3674                                filter = Expr.filters[ name ]; 
    30903675 
    30913676                        if ( filter ) { 
    30923677                                return filter( elem, i, match, array ); 
     3678 
    30933679                        } else if ( name === "contains" ) { 
    3094                                 return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0; 
     3680                                return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0; 
     3681 
    30953682                        } else if ( name === "not" ) { 
    30963683                                var not = match[3]; 
    30973684 
    3098                                 for ( var i = 0, l = not.length; i < l; i++ ) { 
    3099                                         if ( not[i] === elem ) { 
     3685                                for ( var j = 0, l = not.length; j < l; j++ ) { 
     3686                                        if ( not[j] === elem ) { 
    31003687                                                return false; 
    31013688                                        } 
     
    31033690 
    31043691                                return true; 
     3692 
    31053693                        } else { 
    31063694                                Sizzle.error( "Syntax error, unrecognized expression: " + name ); 
    31073695                        } 
    31083696                }, 
    3109                 CHILD: function(elem, match){ 
    3110                         var type = match[1], node = elem; 
    3111                         switch (type) { 
    3112                                 case 'only': 
    3113                                 case 'first': 
     3697 
     3698                CHILD: function( elem, match ) { 
     3699                        var type = match[1], 
     3700                                node = elem; 
     3701 
     3702                        switch ( type ) { 
     3703                                case "only": 
     3704                                case "first": 
    31143705                                        while ( (node = node.previousSibling) )  { 
    31153706                                                if ( node.nodeType === 1 ) {  
     
    31173708                                                } 
    31183709                                        } 
     3710 
    31193711                                        if ( type === "first" ) {  
    31203712                                                return true;  
    31213713                                        } 
     3714 
    31223715                                        node = elem; 
    3123                                 case 'last': 
     3716 
     3717                                case "last": 
    31243718                                        while ( (node = node.nextSibling) )      { 
    31253719                                                if ( node.nodeType === 1 ) {  
     
    31273721                                                } 
    31283722                                        } 
     3723 
    31293724                                        return true; 
    3130                                 case 'nth': 
    3131                                         var first = match[2], last = match[3]; 
     3725 
     3726                                case "nth": 
     3727                                        var first = match[2], 
     3728                                                last = match[3]; 
    31323729 
    31333730                                        if ( first === 1 && last === 0 ) { 
     
    31403737                                        if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) { 
    31413738                                                var count = 0; 
     3739                                                 
    31423740                                                for ( node = parent.firstChild; node; node = node.nextSibling ) { 
    31433741                                                        if ( node.nodeType === 1 ) { 
     
    31453743                                                        } 
    31463744                                                }  
     3745 
    31473746                                                parent.sizcache = doneName; 
    31483747                                        } 
    31493748                                         
    31503749                                        var diff = elem.nodeIndex - last; 
     3750 
    31513751                                        if ( first === 0 ) { 
    31523752                                                return diff === 0; 
     3753 
    31533754                                        } else { 
    31543755                                                return ( diff % first === 0 && diff / first >= 0 ); 
     
    31563757                        } 
    31573758                }, 
    3158                 ID: function(elem, match){ 
     3759 
     3760                ID: function( elem, match ) { 
    31593761                        return elem.nodeType === 1 && elem.getAttribute("id") === match; 
    31603762                }, 
    3161                 TAG: function(elem, match){ 
     3763 
     3764                TAG: function( elem, match ) { 
    31623765                        return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match; 
    31633766                }, 
    3164                 CLASS: function(elem, match){ 
     3767                 
     3768                CLASS: function( elem, match ) { 
    31653769                        return (" " + (elem.className || elem.getAttribute("class")) + " ") 
    31663770                                .indexOf( match ) > -1; 
    31673771                }, 
    3168                 ATTR: function(elem, match){ 
     3772 
     3773                ATTR: function( elem, match ) { 
    31693774                        var name = match[1], 
    31703775                                result = Expr.attrHandle[ name ] ? 
     
    31973802                                false; 
    31983803                }, 
    3199                 POS: function(elem, match, i, array){ 
    3200                         var name = match[2], filter = Expr.setFilters[ name ]; 
     3804 
     3805                POS: function( elem, match, i, array ) { 
     3806                        var name = match[2], 
     3807                                filter = Expr.setFilters[ name ]; 
    32013808 
    32023809                        if ( filter ) { 
     
    32073814}; 
    32083815 
    3209 var origPOS = Expr.match.POS; 
     3816var origPOS = Expr.match.POS, 
     3817        fescape = function(all, num){ 
     3818                return "\\" + (num - 0 + 1); 
     3819        }; 
    32103820 
    32113821for ( var type in Expr.match ) { 
    3212         Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source ); 
    3213         Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, function(all, num){ 
    3214                 return "\\" + (num - 0 + 1); 
    3215         })); 
     3822        Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) ); 
     3823        Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) ); 
    32163824} 
    32173825 
    3218 var makeArray = function(array, results) { 
     3826var makeArray = function( array, results ) { 
    32193827        array = Array.prototype.slice.call( array, 0 ); 
    32203828 
     
    32293837// Perform a simple check to determine if the browser is capable of 
    32303838// converting a NodeList to an array using builtin methods. 
     3839// Also verifies that the returned array holds DOM nodes 
     3840// (which is not the case in the Blackberry browser) 
    32313841try { 
    3232         Array.prototype.slice.call( document.documentElement.childNodes, 0 ); 
     3842        Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType; 
    32333843 
    32343844// Provide a fallback method if it does not work 
    3235 } catch(e){ 
    3236         makeArray = function(array, results) { 
    3237                 var ret = results || []; 
     3845} catch( e ) { 
     3846        makeArray = function( array, results ) { 
     3847                var i = 0, 
     3848                        ret = results || []; 
    32383849 
    32393850                if ( toString.call(array) === "[object Array]" ) { 
    32403851                        Array.prototype.push.apply( ret, array ); 
     3852 
    32413853                } else { 
    32423854                        if ( typeof array.length === "number" ) { 
    3243                                 for ( var i = 0, l = array.length; i < l; i++ ) { 
     3855                                for ( var l = array.length; i < l; i++ ) { 
    32443856                                        ret.push( array[i] ); 
    32453857                                } 
     3858 
    32463859                        } else { 
    3247                                 for ( var i = 0; array[i]; i++ ) { 
     3860                                for ( ; array[i]; i++ ) { 
    32483861                                        ret.push( array[i] ); 
    32493862                                } 
     
    32553868} 
    32563869 
    3257 var sortOrder; 
     3870var sortOrder, siblingCheck; 
    32583871 
    32593872if ( document.documentElement.compareDocumentPosition ) { 
    32603873        sortOrder = function( a, b ) { 
     3874                if ( a === b ) { 
     3875                        hasDuplicate = true; 
     3876                        return 0; 
     3877                } 
     3878 
    32613879                if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) { 
    3262                         if ( a == b ) { 
    3263                                 hasDuplicate = true; 
    3264                         } 
    32653880                        return a.compareDocumentPosition ? -1 : 1; 
    32663881                } 
    32673882 
    3268                 var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1; 
    3269                 if ( ret === 0 ) { 
     3883                return a.compareDocumentPosition(b) & 4 ? -1 : 1; 
     3884        }; 
     3885 
     3886} else { 
     3887        sortOrder = function( a, b ) { 
     3888                var al, bl, 
     3889                        ap = [], 
     3890                        bp = [], 
     3891                        aup = a.parentNode, 
     3892                        bup = b.parentNode, 
     3893                        cur = aup; 
     3894 
     3895                // The nodes are identical, we can exit early 
     3896                if ( a === b ) { 
    32703897                        hasDuplicate = true; 
    3271                 } 
    3272                 return ret; 
     3898                        return 0; 
     3899 
     3900                // If the nodes are siblings (or identical) we can do a quick check 
     3901                } else if ( aup === bup ) { 
     3902                        return siblingCheck( a, b ); 
     3903 
     3904                // If no parents were found then the nodes are disconnected 
     3905                } else if ( !aup ) { 
     3906                        return -1; 
     3907 
     3908                } else if ( !bup ) { 
     3909                        return 1; 
     3910                } 
     3911 
     3912                // Otherwise they're somewhere else in the tree so we need 
     3913                // to build up a full list of the parentNodes for comparison 
     3914                while ( cur ) { 
     3915                        ap.unshift( cur ); 
     3916                        cur = cur.parentNode; 
     3917                } 
     3918 
     3919                cur = bup; 
     3920 
     3921                while ( cur ) { 
     3922                        bp.unshift( cur ); 
     3923                        cur = cur.parentNode; 
     3924                } 
     3925 
     3926                al = ap.length; 
     3927                bl = bp.length; 
     3928 
     3929                // Start walking down the tree looking for a discrepancy 
     3930                for ( var i = 0; i < al && i < bl; i++ ) { 
     3931                        if ( ap[i] !== bp[i] ) { 
     3932                                return siblingCheck( ap[i], bp[i] ); 
     3933                        } 
     3934                } 
     3935 
     3936                // We ended someplace up the tree so do a sibling check 
     3937                return i === al ? 
     3938                        siblingCheck( a, bp[i], -1 ) : 
     3939                        siblingCheck( ap[i], b, 1 ); 
    32733940        }; 
    3274 } else if ( "sourceIndex" in document.documentElement ) { 
    3275         sortOrder = function( a, b ) { 
    3276                 if ( !a.sourceIndex || !b.sourceIndex ) { 
    3277                         if ( a == b ) { 
    3278                                 hasDuplicate = true; 
    3279                         } 
    3280                         return a.sourceIndex ? -1 : 1; 
    3281                 } 
    3282  
    3283                 var ret = a.sourceIndex - b.sourceIndex; 
    3284                 if ( ret === 0 ) { 
    3285                         hasDuplicate = true; 
    3286                 } 
    3287                 return ret; 
    3288         }; 
    3289 } else if ( document.createRange ) { 
    3290         sortOrder = function( a, b ) { 
    3291                 if ( !a.ownerDocument || !b.ownerDocument ) { 
    3292                         if ( a == b ) { 
    3293                                 hasDuplicate = true; 
    3294                         } 
    3295                         return a.ownerDocument ? -1 : 1; 
    3296                 } 
    3297  
    3298                 var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange(); 
    3299                 aRange.setStart(a, 0); 
    3300                 aRange.setEnd(a, 0); 
    3301                 bRange.setStart(b, 0); 
    3302                 bRange.setEnd(b, 0); 
    3303                 var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange); 
    3304                 if ( ret === 0 ) { 
    3305                         hasDuplicate = true; 
    3306                 } 
    3307                 return ret; 
     3941 
     3942        siblingCheck = function( a, b, ret ) { 
     3943                if ( a === b ) { 
     3944                        return ret; 
     3945                } 
     3946 
     3947                var cur = a.nextSibling; 
     3948 
     3949                while ( cur ) { 
     3950                        if ( cur === b ) { 
     3951                                return -1; 
     3952                        } 
     3953 
     3954                        cur = cur.nextSibling; 
     3955                } 
     3956 
     3957                return 1; 
    33083958        }; 
    33093959} 
    33103960 
    33113961// Utility function for retreiving the text value of an array of DOM nodes 
    3312 function getText( elems ) { 
     3962Sizzle.getText = function( elems ) { 
    33133963        var ret = "", elem; 
    33143964 
     
    33223972                // Traverse everything else, except comment nodes 
    33233973                } else if ( elem.nodeType !== 8 ) { 
    3324                         ret += getText( elem.childNodes ); 
     3974                        ret += Sizzle.getText( elem.childNodes ); 
    33253975                } 
    33263976        } 
    33273977 
    33283978        return ret; 
    3329 } 
     3979}; 
    33303980 
    33313981// Check to see if the browser returns elements by name when 
     
    33343984        // We're going to inject a fake input element with a specified name 
    33353985        var form = document.createElement("div"), 
    3336                 id = "script" + (new Date).getTime(); 
     3986                id = "script" + (new Date()).getTime(), 
     3987                root = document.documentElement; 
     3988 
    33373989        form.innerHTML = "<a name='" + id + "'/>"; 
    33383990 
    33393991        // Inject it into the root element, check its status, and remove it quickly 
    3340         var root = document.documentElement; 
    33413992        root.insertBefore( form, root.firstChild ); 
    33423993 
     
    33443995        // Which slows things down for other browsers (hence the branching) 
    33453996        if ( document.getElementById( id ) ) { 
    3346                 Expr.find.ID = function(match, context, isXML){ 
     3997                Expr.find.ID = function( match, context, isXML ) { 
    33473998                        if ( typeof context.getElementById !== "undefined" && !isXML ) { 
    33483999                                var m = context.getElementById(match[1]); 
    3349                                 return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : []; 
     4000 
     4001                                return m ? 
     4002                                        m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? 
     4003                                                [m] : 
     4004                                                undefined : 
     4005                                        []; 
    33504006                        } 
    33514007                }; 
    33524008 
    3353                 Expr.filter.ID = function(elem, match){ 
     4009                Expr.filter.ID = function( elem, match ) { 
    33544010                        var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); 
     4011 
    33554012                        return elem.nodeType === 1 && node && node.nodeValue === match; 
    33564013                }; 
     
    33584015 
    33594016        root.removeChild( form ); 
    3360         root = form = null; // release memory in IE 
     4017 
     4018        // release memory in IE 
     4019        root = form = null; 
    33614020})(); 
    33624021 
     
    33714030        // Make sure no comments are found 
    33724031        if ( div.getElementsByTagName("*").length > 0 ) { 
    3373                 Expr.find.TAG = function(match, context){ 
    3374                         var results = context.getElementsByTagName(match[1]); 
     4032                Expr.find.TAG = function( match, context ) { 
     4033                        var results = context.getElementsByTagName( match[1] ); 
    33754034 
    33764035                        // Filter out possible comments 
     
    33934052        // Check to see if an attribute returns normalized href attributes 
    33944053        div.innerHTML = "<a href='#'></a>"; 
     4054 
    33954055        if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" && 
    33964056                        div.firstChild.getAttribute("href") !== "#" ) { 
    3397                 Expr.attrHandle.href = function(elem){ 
    3398                         return elem.getAttribute("href", 2); 
     4057 
     4058                Expr.attrHandle.href = function( elem ) { 
     4059                        return elem.getAttribute( "href", 2 ); 
    33994060                }; 
    34004061        } 
    34014062 
    3402         div = null; // release memory in IE 
     4063        // release memory in IE 
     4064        div = null; 
    34034065})(); 
    34044066 
    34054067if ( document.querySelectorAll ) { 
    34064068        (function(){ 
    3407                 var oldSizzle = Sizzle, div = document.createElement("div"); 
     4069                var oldSizzle = Sizzle, 
     4070                        div = document.createElement("div"), 
     4071                        id = "__sizzle__"; 
     4072 
    34084073                div.innerHTML = "<p class='TEST'></p>"; 
    34094074 
     
    34144079                } 
    34154080         
    3416                 Sizzle = function(query, context, extra, seed){ 
     4081                Sizzle = function( query, context, extra, seed ) { 
    34174082                        context = context || document; 
     4083 
     4084                        // Make sure that attribute selectors are quoted 
     4085                        query = query.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']"); 
    34184086 
    34194087                        // Only use querySelectorAll on non-XML documents 
    34204088                        // (ID selectors don't work in non-HTML documents) 
    3421                         if ( !seed && context.nodeType === 9 && !isXML(context) ) { 
    3422                                 try { 
    3423                                         return makeArray( context.querySelectorAll(query), extra ); 
    3424                                 } catch(e){} 
     4089                        if ( !seed && !Sizzle.isXML(context) ) { 
     4090                                if ( context.nodeType === 9 ) { 
     4091                                        try { 
     4092                                                return makeArray( context.querySelectorAll(query), extra ); 
     4093                                        } catch(qsaError) {} 
     4094 
     4095                                // qSA works strangely on Element-rooted queries 
     4096                                // We can work around this by specifying an extra ID on the root 
     4097                                // and working up from there (Thanks to Andrew Dupont for the technique) 
     4098                                // IE 8 doesn't work on object elements 
     4099                                } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { 
     4100                                        var old = context.getAttribute( "id" ), 
     4101                                                nid = old || id; 
     4102 
     4103                                        if ( !old ) { 
     4104                                                context.setAttribute( "id", nid ); 
     4105                                        } 
     4106 
     4107                                        try { 
     4108                                                return makeArray( context.querySelectorAll( "#" + nid + " " + query ), extra ); 
     4109 
     4110                                        } catch(pseudoError) { 
     4111                                        } finally { 
     4112                                                if ( !old ) { 
     4113                                                        context.removeAttribute( "id" ); 
     4114                                                } 
     4115                                        } 
     4116                                } 
    34254117                        } 
    34264118                 
     
    34324124                } 
    34334125 
    3434                 div = null; // release memory in IE 
     4126                // release memory in IE 
     4127                div = null; 
    34354128        })(); 
    34364129} 
     4130 
     4131(function(){ 
     4132        var html = document.documentElement, 
     4133                matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector, 
     4134                pseudoWorks = false; 
     4135 
     4136        try { 
     4137                // This should fail with an exception 
     4138                // Gecko does not error, returns false instead 
     4139                matches.call( document.documentElement, "[test!='']:sizzle" ); 
     4140         
     4141        } catch( pseudoError ) { 
     4142                pseudoWorks = true; 
     4143        } 
     4144 
     4145        if ( matches ) { 
     4146                Sizzle.matchesSelector = function( node, expr ) { 
     4147                        // Make sure that attribute selectors are quoted 
     4148                        expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']"); 
     4149 
     4150                        if ( !Sizzle.isXML( node ) ) { 
     4151                                try {  
     4152                                        if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) { 
     4153                                                return matches.call( node, expr ); 
     4154                                        } 
     4155                                } catch(e) {} 
     4156                        } 
     4157 
     4158                        return Sizzle(expr, null, null, [node]).length > 0; 
     4159                }; 
     4160        } 
     4161})(); 
    34374162 
    34384163(function(){ 
     
    34554180         
    34564181        Expr.order.splice(1, 0, "CLASS"); 
    3457         Expr.find.CLASS = function(match, context, isXML) { 
     4182        Expr.find.CLASS = function( match, context, isXML ) { 
    34584183                if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) { 
    34594184                        return context.getElementsByClassName(match[1]); 
     
    34614186        }; 
    34624187 
    3463         div = null; // release memory in IE 
     4188        // release memory in IE 
     4189        div = null; 
    34644190})(); 
    34654191 
     
    34674193        for ( var i = 0, l = checkSet.length; i < l; i++ ) { 
    34684194                var elem = checkSet[i]; 
     4195 
    34694196                if ( elem ) { 
     4197                        var match = false; 
     4198 
    34704199                        elem = elem[dir]; 
    3471                         var match = false; 
    34724200 
    34734201                        while ( elem ) { 
     
    34984226        for ( var i = 0, l = checkSet.length; i < l; i++ ) { 
    34994227                var elem = checkSet[i]; 
     4228 
    35004229                if ( elem ) { 
     4230                        var match = false; 
     4231                         
    35014232                        elem = elem[dir]; 
    3502                         var match = false; 
    35034233 
    35044234                        while ( elem ) { 
     
    35134243                                                elem.sizset = i; 
    35144244                                        } 
     4245 
    35154246                                        if ( typeof cur !== "string" ) { 
    35164247                                                if ( elem === cur ) { 
     
    35334264} 
    35344265 
    3535 var contains = document.compareDocumentPosition ? function(a, b){ 
    3536         return a.compareDocumentPosition(b) & 16; 
    3537 } : function(a, b){ 
    3538         return a !== b && (a.contains ? a.contains(b) : true); 
    3539 }; 
    3540  
    3541 var isXML = function(elem){ 
     4266if ( document.documentElement.contains ) { 
     4267        Sizzle.contains = function( a, b ) { 
     4268                return a !== b && (a.contains ? a.contains(b) : true); 
     4269        }; 
     4270 
     4271} else if ( document.documentElement.compareDocumentPosition ) { 
     4272        Sizzle.contains = function( a, b ) { 
     4273                return !!(a.compareDocumentPosition(b) & 16); 
     4274        }; 
     4275 
     4276} else { 
     4277        Sizzle.contains = function() { 
     4278                return false; 
     4279        }; 
     4280} 
     4281 
     4282Sizzle.isXML = function( elem ) { 
    35424283        // documentElement is verified for cases where it doesn't yet exist 
    35434284        // (such as loading iframes in IE - #4833)  
    35444285        var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement; 
     4286 
    35454287        return documentElement ? documentElement.nodeName !== "HTML" : false; 
    35464288}; 
    35474289 
    3548 var posProcess = function(selector, context){ 
    3549         var tmpSet = [], later = "", match, 
     4290var posProcess = function( selector, context ) { 
     4291        var match, 
     4292                tmpSet = [], 
     4293                later = "", 
    35504294                root = context.nodeType ? [context] : context; 
    35514295 
     
    35714315jQuery.expr[":"] = jQuery.expr.filters; 
    35724316jQuery.unique = Sizzle.uniqueSort; 
    3573 jQuery.getText = getText; 
    3574 jQuery.isXMLDoc = isXML; 
    3575 jQuery.contains = contains; 
    3576  
    3577 return; 
    3578  
    3579 window.Sizzle = Sizzle; 
     4317jQuery.text = Sizzle.getText; 
     4318jQuery.isXMLDoc = Sizzle.isXML; 
     4319jQuery.contains = Sizzle.contains; 
     4320 
    35804321 
    35814322})(); 
     4323 
     4324 
    35824325var runtil = /Until$/, 
    35834326        rparentsprev = /^(?:parents|prevUntil|prevAll)/, 
    35844327        // Note: This RegExp should be improved, or likely pulled from Sizzle 
    35854328        rmultiselector = /,/, 
    3586         slice = Array.prototype.slice; 
    3587  
    3588 // Implement the identical functionality for filter and not 
    3589 var winnow = function( elements, qualifier, keep ) { 
    3590         if ( jQuery.isFunction( qualifier ) ) { 
    3591                 return jQuery.grep(elements, function( elem, i ) { 
    3592                         return !!qualifier.call( elem, i, elem ) === keep; 
    3593                 }); 
    3594  
    3595         } else if ( qualifier.nodeType ) { 
    3596                 return jQuery.grep(elements, function( elem, i ) { 
    3597                         return (elem === qualifier) === keep; 
    3598                 }); 
    3599  
    3600         } else if ( typeof qualifier === "string" ) { 
    3601                 var filtered = jQuery.grep(elements, function( elem ) { 
    3602                         return elem.nodeType === 1; 
    3603                 }); 
    3604  
    3605                 if ( isSimple.test( qualifier ) ) { 
    3606                         return jQuery.filter(qualifier, filtered, !keep); 
    3607                 } else { 
    3608                         qualifier = jQuery.filter( qualifier, filtered ); 
    3609                 } 
    3610         } 
    3611  
    3612         return jQuery.grep(elements, function( elem, i ) { 
    3613                 return (jQuery.inArray( elem, qualifier ) >= 0) === keep; 
    3614         }); 
    3615 }; 
     4329        isSimple = /^.[^:#\[\.,]*$/, 
     4330        slice = Array.prototype.slice, 
     4331        POS = jQuery.expr.match.POS; 
    36164332 
    36174333jQuery.fn.extend({ 
    36184334        find: function( selector ) { 
    3619                 var ret = this.pushStack( "", "find", selector ), length = 0; 
     4335                var ret = this.pushStack( "", "find", selector ), 
     4336                        length = 0; 
    36204337 
    36214338                for ( var i = 0, l = this.length; i < l; i++ ) { 
     
    36634380 
    36644381        closest: function( selectors, context ) { 
     4382                var ret = [], i, l, cur = this[0]; 
     4383 
    36654384                if ( jQuery.isArray( selectors ) ) { 
    3666                         var ret = [], cur = this[0], match, matches = {}, selector; 
     4385                        var match, selector, 
     4386                                matches = {}, 
     4387                                level = 1; 
    36674388 
    36684389                        if ( cur && selectors.length ) { 
    3669                                 for ( var i = 0, l = selectors.length; i < l; i++ ) { 
     4390                                for ( i = 0, l = selectors.length; i < l; i++ ) { 
    36704391                                        selector = selectors[i]; 
    36714392 
     
    36824403 
    36834404                                                if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) { 
    3684                                                         ret.push({ selector: selector, elem: cur }); 
    3685                                                         delete matches[selector]; 
     4405                                                        ret.push({ selector: selector, elem: cur, level: level }); 
    36864406                                                } 
    36874407                                        } 
     4408 
    36884409                                        cur = cur.parentNode; 
     4410                                        level++; 
    36894411                                } 
    36904412                        } 
     
    36934415                } 
    36944416 
    3695                 var pos = jQuery.expr.match.POS.test( selectors ) ?  
     4417                var pos = POS.test( selectors ) ?  
    36964418                        jQuery( selectors, context || this.context ) : null; 
    36974419 
    3698                 return this.map(function( i, cur ) { 
    3699                         while ( cur && cur.ownerDocument && cur !== context ) { 
    3700                                 if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selectors) ) { 
    3701                                         return cur; 
    3702                                 } 
    3703                                 cur = cur.parentNode; 
    3704                         } 
    3705                         return null; 
    3706                 }); 
     4420                for ( i = 0, l = this.length; i < l; i++ ) { 
     4421                        cur = this[i]; 
     4422 
     4423                        while ( cur ) { 
     4424                                if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) { 
     4425                                        ret.push( cur ); 
     4426                                        break; 
     4427 
     4428                                } else { 
     4429                                        cur = cur.parentNode; 
     4430                                        if ( !cur || !cur.ownerDocument || cur === context ) { 
     4431                                                break; 
     4432                                        } 
     4433                                } 
     4434                        } 
     4435                } 
     4436 
     4437                ret = ret.length > 1 ? jQuery.unique(ret) : ret; 
     4438                 
     4439                return this.pushStack( ret, "closest", selectors ); 
    37074440        }, 
    37084441         
     
    38124545                } 
    38134546 
    3814                 return jQuery.find.matches(expr, elems); 
     4547                return elems.length === 1 ? 
     4548                        jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] : 
     4549                        jQuery.find.matches(expr, elems); 
    38154550        }, 
    38164551         
    38174552        dir: function( elem, dir, until ) { 
    3818                 var matched = [], cur = elem[dir]; 
     4553                var matched = [], 
     4554                        cur = elem[ dir ]; 
     4555 
    38194556                while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) { 
    38204557                        if ( cur.nodeType === 1 ) { 
     
    38514588        } 
    38524589}); 
     4590 
     4591// Implement the identical functionality for filter and not 
     4592function winnow( elements, qualifier, keep ) { 
     4593        if ( jQuery.isFunction( qualifier ) ) { 
     4594                return jQuery.grep(elements, function( elem, i ) { 
     4595                        var retVal = !!qualifier.call( elem, i, elem ); 
     4596                        return retVal === keep; 
     4597                }); 
     4598 
     4599        } else if ( qualifier.nodeType ) { 
     4600                return jQuery.grep(elements, function( elem, i ) { 
     4601                        return (elem === qualifier) === keep; 
     4602                }); 
     4603 
     4604        } else if ( typeof qualifier === "string" ) { 
     4605                var filtered = jQuery.grep(elements, function( elem ) { 
     4606                        return elem.nodeType === 1; 
     4607                }); 
     4608 
     4609                if ( isSimple.test( qualifier ) ) { 
     4610                        return jQuery.filter(qualifier, filtered, !keep); 
     4611                } else { 
     4612                        qualifier = jQuery.filter( qualifier, filtered ); 
     4613                } 
     4614        } 
     4615 
     4616        return jQuery.grep(elements, function( elem, i ) { 
     4617                return (jQuery.inArray( elem, qualifier ) >= 0) === keep; 
     4618        }); 
     4619} 
     4620 
     4621 
     4622 
     4623 
    38534624var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g, 
    38544625        rleadingWhitespace = /^\s+/, 
    3855         rxhtmlTag = /(<([\w:]+)[^>]*?)\/>/g, 
    3856         rselfClosing = /^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i, 
     4626        rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, 
    38574627        rtagName = /<([\w:]+)/, 
    38584628        rtbody = /<tbody/i, 
    3859         rhtml = /<|&\w+;/, 
    3860         rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,  // checked="checked" or checked (html5) 
    3861         fcloseTag = function( all, front, tag ) { 
    3862                 return rselfClosing.test( tag ) ? 
    3863                         all : 
    3864                         front + "></" + tag + ">"; 
    3865         }, 
     4629        rhtml = /<|&#?\w+;/, 
     4630        rnocache = /<(?:script|object|embed|option|style)/i, 
     4631        // checked="checked" or checked (html5) 
     4632        rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 
     4633        raction = /\=([^="'>\s]+\/)>/g, 
    38664634        wrapMap = { 
    38674635                option: [ 1, "<select multiple='multiple'>", "</select>" ], 
     
    38884656                if ( jQuery.isFunction(text) ) { 
    38894657                        return this.each(function(i) { 
    3890                                 var self = jQuery(this); 
     4658                                var self = jQuery( this ); 
     4659 
    38914660                                self.text( text.call(this, i, self.text()) ); 
    38924661                        }); 
     
    38974666                } 
    38984667 
    3899                 return jQuery.getText( this ); 
     4668                return jQuery.text( this ); 
    39004669        }, 
    39014670 
     
    39374706 
    39384707                return this.each(function() { 
    3939                         var self = jQuery( this ), contents = self.contents(); 
     4708                        var self = jQuery( this ), 
     4709                                contents = self.contents(); 
    39404710 
    39414711                        if ( contents.length ) { 
     
    40004770                        return set; 
    40014771                } 
     4772        }, 
     4773         
     4774        // keepData is for internal use only--do not document 
     4775        remove: function( selector, keepData ) { 
     4776                for ( var i = 0, elem; (elem = this[i]) != null; i++ ) { 
     4777                        if ( !selector || jQuery.filter( selector, [ elem ] ).length ) { 
     4778                                if ( !keepData && elem.nodeType === 1 ) { 
     4779                                        jQuery.cleanData( elem.getElementsByTagName("*") ); 
     4780                                        jQuery.cleanData( [ elem ] ); 
     4781                                } 
     4782 
     4783                                if ( elem.parentNode ) { 
     4784                                         elem.parentNode.removeChild( elem ); 
     4785                                } 
     4786                        } 
     4787                } 
     4788                 
     4789                return this; 
     4790        }, 
     4791 
     4792        empty: function() { 
     4793                for ( var i = 0, elem; (elem = this[i]) != null; i++ ) { 
     4794                        // Remove element nodes and prevent memory leaks 
     4795                        if ( elem.nodeType === 1 ) { 
     4796                                jQuery.cleanData( elem.getElementsByTagName("*") ); 
     4797                        } 
     4798 
     4799                        // Remove any remaining nodes 
     4800                        while ( elem.firstChild ) { 
     4801                                elem.removeChild( elem.firstChild ); 
     4802                        } 
     4803                } 
     4804                 
     4805                return this; 
    40024806        }, 
    40034807 
     
    40144818                                // as properties will not be copied (such as the 
    40154819                                // the name attribute on an input). 
    4016                                 var html = this.outerHTML, ownerDocument = this.ownerDocument; 
     4820                                var html = this.outerHTML, 
     4821                                        ownerDocument = this.ownerDocument; 
     4822 
    40174823                                if ( !html ) { 
    40184824                                        var div = ownerDocument.createElement("div"); 
     
    40224828 
    40234829                                return jQuery.clean([html.replace(rinlinejQuery, "") 
     4830                                        // Handle the case in IE 8 where action=/test/> self-closes a tag 
     4831                                        .replace(raction, '="$1">') 
    40244832                                        .replace(rleadingWhitespace, "")], ownerDocument)[0]; 
    40254833                        } else { 
     
    40454853 
    40464854                // See if we can take a shortcut and just use innerHTML 
    4047                 } else if ( typeof value === "string" && !/<script/i.test( value ) && 
     4855                } else if ( typeof value === "string" && !rnocache.test( value ) && 
    40484856                        (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) && 
    40494857                        !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) { 
    40504858 
    4051                         value = value.replace(rxhtmlTag, fcloseTag); 
     4859                        value = value.replace(rxhtmlTag, "<$1></$2>"); 
    40524860 
    40534861                        try { 
     
    40674875                } else if ( jQuery.isFunction( value ) ) { 
    40684876                        this.each(function(i){ 
    4069                                 var self = jQuery(this), old = self.html(); 
    4070                                 self.empty().append(function(){ 
    4071                                         return value.call( this, i, old ); 
    4072                                 }); 
     4877                                var self = jQuery( this ); 
     4878 
     4879                                self.html( value.call(this, i, self.html()) ); 
    40734880                        }); 
    40744881 
     
    40844891                        // Make sure that the elements are removed from the DOM before they are inserted 
    40854892                        // this can help fix replacing a parent with child elements 
    4086                         if ( !jQuery.isFunction( value ) ) { 
    4087                                 value = jQuery( value ).detach(); 
    4088  
    4089                         } else { 
     4893                        if ( jQuery.isFunction( value ) ) { 
    40904894                                return this.each(function(i) { 
    40914895                                        var self = jQuery(this), old = self.html(); 
     
    40944898                        } 
    40954899 
     4900                        if ( typeof value !== "string" ) { 
     4901                                value = jQuery( value ).detach(); 
     4902                        } 
     4903 
    40964904                        return this.each(function() { 
    4097                                 var next = this.nextSibling, parent = this.parentNode; 
    4098  
    4099                                 jQuery(this).remove(); 
     4905                                var next = this.nextSibling, 
     4906                                        parent = this.parentNode; 
     4907 
     4908                                jQuery( this ).remove(); 
    41004909 
    41014910                                if ( next ) { 
     
    41154924 
    41164925        domManip: function( args, table, callback ) { 
    4117                 var results, first, value = args[0], scripts = []; 
     4926                var results, first, fragment, parent, 
     4927                        value = args[0], 
     4928                        scripts = []; 
    41184929 
    41194930                // We can't cloneNode fragments that contain checked, in WebKit 
     
    41334944 
    41344945                if ( this[0] ) { 
     4946                        parent = value && value.parentNode; 
     4947 
    41354948                        // If we're in a fragment, just use that instead of building a new one 
    4136                         if ( args[0] && args[0].parentNode && args[0].parentNode.nodeType === 11 ) { 
    4137                                 results = { fragment: args[0].parentNode }; 
     4949                        if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) { 
     4950                                results = { fragment: parent }; 
     4951 
    41384952                        } else { 
    4139                                 results = buildFragment( args, this, scripts ); 
    4140                         } 
    4141  
    4142                         first = results.fragment.firstChild; 
     4953                                results = jQuery.buildFragment( args, this, scripts ); 
     4954                        } 
     4955                         
     4956                        fragment = results.fragment; 
     4957                         
     4958                        if ( fragment.childNodes.length === 1 ) { 
     4959                                first = fragment = fragment.firstChild; 
     4960                        } else { 
     4961                                first = fragment.firstChild; 
     4962                        } 
    41434963 
    41444964                        if ( first ) { 
     
    41504970                                                        root(this[i], first) : 
    41514971                                                        this[i], 
    4152                                                 results.cacheable || this.length > 1 || i > 0 ? 
    4153                                                         results.fragment.cloneNode(true) : 
    4154                                                         results.fragment 
     4972                                                i > 0 || results.cacheable || this.length > 1 ? 
     4973                                                        fragment.cloneNode(true) : 
     4974                                                        fragment 
    41554975                                        ); 
    41564976                                } 
    41574977                        } 
    41584978 
    4159                         if ( scripts ) { 
     4979                        if ( scripts.length ) { 
    41604980                                jQuery.each( scripts, evalScript ); 
    41614981                        } 
     
    41634983 
    41644984                return this; 
    4165  
    4166                 function root( elem, cur ) { 
    4167                         return jQuery.nodeName(elem, "table") ? 
    4168                                 (elem.getElementsByTagName("tbody")[0] || 
    4169                                 elem.appendChild(elem.ownerDocument.createElement("tbody"))) : 
    4170                                 elem; 
    4171                 } 
    41724985        } 
    41734986}); 
     4987 
     4988function root( elem, cur ) { 
     4989        return jQuery.nodeName(elem, "table") ? 
     4990                (elem.getElementsByTagName("tbody")[0] || 
     4991                elem.appendChild(elem.ownerDocument.createElement("tbody"))) : 
     4992                elem; 
     4993} 
    41744994 
    41754995function cloneCopyEvent(orig, ret) { 
     
    41815001                } 
    41825002 
    4183                 var oldData = jQuery.data( orig[i++] ), curData = jQuery.data( this, oldData ), events = oldData && oldData.events; 
     5003                var oldData = jQuery.data( orig[i++] ), 
     5004                        curData = jQuery.data( this, oldData ), 
     5005                        events = oldData && oldData.events; 
    41845006 
    41855007                if ( events ) { 
     
    41965018} 
    41975019 
    4198 function buildFragment( args, nodes, scripts ) { 
    4199         var fragment, cacheable, cacheresults, doc; 
    4200  
    4201         // webkit does not clone 'checked' attribute of radio inputs on cloneNode, so don't cache if string has a checked 
    4202         if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && args[0].indexOf("<option") < 0 && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) { 
     5020jQuery.buildFragment = function( args, nodes, scripts ) { 
     5021        var fragment, cacheable, cacheresults, 
     5022                doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document); 
     5023 
     5024        // Only cache "small" (1/2 KB) strings that are associated with the main document 
     5025        // Cloning options loses the selected state, so don't cache them 
     5026        // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment 
     5027        // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache 
     5028        if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document && 
     5029                !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) { 
     5030 
    42035031                cacheable = true; 
    42045032                cacheresults = jQuery.fragments[ args[0] ]; 
     
    42115039 
    42125040        if ( !fragment ) { 
    4213                 doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document); 
    42145041                fragment = doc.createDocumentFragment(); 
    42155042                jQuery.clean( args, doc, fragment, scripts ); 
     
    42215048 
    42225049        return { fragment: fragment, cacheable: cacheable }; 
    4223 } 
     5050}; 
    42245051 
    42255052jQuery.fragments = {}; 
     
    42335060}, function( name, original ) { 
    42345061        jQuery.fn[ name ] = function( selector ) { 
    4235                 var ret = [], insert = jQuery( selector ); 
    4236  
    4237                 for ( var i = 0, l = insert.length; i < l; i++ ) { 
    4238                         var elems = (i > 0 ? this.clone(true) : this).get(); 
    4239                         jQuery.fn[ original ].apply( jQuery(insert[i]), elems ); 
    4240                         ret = ret.concat( elems ); 
    4241                 } 
    4242                 return this.pushStack( ret, name, insert.selector ); 
    4243         }; 
    4244 }); 
    4245  
    4246 jQuery.each({ 
    4247         // keepData is for internal use only--do not document 
    4248         remove: function( selector, keepData ) { 
    4249                 if ( !selector || jQuery.filter( selector, [ this ] ).length ) { 
    4250                         if ( !keepData && this.nodeType === 1 ) { 
    4251                                 jQuery.cleanData( this.getElementsByTagName("*") ); 
    4252                                 jQuery.cleanData( [ this ] ); 
    4253                         } 
    4254  
    4255                         if ( this.parentNode ) { 
    4256                                  this.parentNode.removeChild( this ); 
    4257                         } 
    4258                 } 
    4259         }, 
    4260  
    4261         empty: function() { 
    4262                 // Remove element nodes and prevent memory leaks 
    4263                 if ( this.nodeType === 1 ) { 
    4264                         jQuery.cleanData( this.getElementsByTagName("*") ); 
    4265                 } 
    4266  
    4267                 // Remove any remaining nodes 
    4268                 while ( this.firstChild ) { 
    4269                         this.removeChild( this.firstChild ); 
    4270                 } 
    4271         } 
    4272 }, function( name, fn ) { 
    4273         jQuery.fn[ name ] = function() { 
    4274                 return this.each( fn, arguments ); 
     5062                var ret = [], 
     5063                        insert = jQuery( selector ), 
     5064                        parent = this.length === 1 && this[0].parentNode; 
     5065                 
     5066                if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) { 
     5067                        insert[ original ]( this[0] ); 
     5068                        return this; 
     5069                         
     5070                } else { 
     5071                        for ( var i = 0, l = insert.length; i < l; i++ ) { 
     5072                                var elems = (i > 0 ? this.clone(true) : this).get(); 
     5073                                jQuery( insert[i] )[ original ]( elems ); 
     5074                                ret = ret.concat( elems ); 
     5075                        } 
     5076                 
     5077                        return this.pushStack( ret, name, insert.selector ); 
     5078                } 
    42755079        }; 
    42765080}); 
     
    42875091                var ret = []; 
    42885092 
    4289                 jQuery.each(elems, function( i, elem ) { 
     5093                for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) { 
    42905094                        if ( typeof elem === "number" ) { 
    42915095                                elem += ""; 
     
    42935097 
    42945098                        if ( !elem ) { 
    4295                                 return; 
     5099                          &nb