Changeset 8162


Ignore:
Timestamp:
Dec 16, 2010, 7:09:14 AM (10 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                                continue;
    42965100                        }
    42975101
     
    43025106                        } else if ( typeof elem === "string" ) {
    43035107                                // Fix "XHTML"-style tags in all browsers
    4304                                 elem = elem.replace(rxhtmlTag, fcloseTag);
     5108                                elem = elem.replace(rxhtmlTag, "<$1></$2>");
    43055109
    43065110                                // Trim whitespace, otherwise indexOf won't work as expected
     
    43445148                                }
    43455149
    4346                                 elem = jQuery.makeArray( div.childNodes );
     5150                                elem = div.childNodes;
    43475151                        }
    43485152
     
    43525156                                ret = jQuery.merge( ret, elem );
    43535157                        }
    4354 
    4355                 });
     5158                }
    43565159
    43575160                if ( fragment ) {
    4358                         for ( var i = 0; ret[i]; i++ ) {
     5161                        for ( i = 0; ret[i]; i++ ) {
    43595162                                if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
    43605163                                        scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
     5164                               
    43615165                                } else {
    43625166