Changeset 9172


Ignore:
Timestamp:
Feb 11, 2011, 4:57:04 PM (9 years ago)
Author:
patdenice
Message:

Update jQuery to 1.5 and jQuery UI to 1.8.9

Location:
trunk
Files:
155 added
82 deleted
13 edited

Legend:

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

    r9057 r9172  
    1 {combine_script id='jquery.ui' load='header' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js' }
    2 {combine_script id='jquery.ui.accordion' load='header' require='jquery.ui' path='themes/default/js/ui/packed/ui.accordion.packed.js' }
     1{combine_script id='jquery.ui' load='header' require='jquery' path='themes/default/js/jquery.ui.min.js' }
     2{combine_script id='jquery.ui.accordion' load='header' require='jquery.ui' path='themes/default/js/ui/minified/jquery.ui.accordion.min.js' }
    33{footer_script require='jquery.ui.accordion'}
    44jQuery(document).ready(function(){ldelim}
  • trunk/admin/themes/default/template/cat_list.tpl

    r8727 r9172  
    1 {combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js' }
    2 {combine_script id='jquery.ui.sortable' load='async' require='jquery.ui' path='themes/default/js/ui/packed/ui.sortable.packed.js' }
     1{combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/jquery.ui.min.js' }
     2{combine_script id='jquery.ui.sortable' load='async' require='jquery.ui' path='themes/default/js/ui/minified/jquery.ui.sortable.min.js' }
    33{footer_script require='jquery.ui.sortable'}
    44jQuery(document).ready(function(){ldelim}
  • trunk/admin/themes/default/template/element_set_ranks.tpl

    r9051 r9172  
    1 {combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js' }
    2 {combine_script id='jquery.ui.sortable' load='async' require='jquery.ui' path='themes/default/js/ui/packed/ui.sortable.packed.js' }
     1{combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/jquery.ui.min.js' }
     2{combine_script id='jquery.ui.sortable' load='async' require='jquery.ui' path='themes/default/js/ui/minified/jquery.ui.sortable.min.js' }
    33{footer_script require='jquery.ui.sortable'}{literal}
    44jQuery(document).ready(function() {
  • trunk/admin/themes/default/template/include/datepicker.inc.tpl

    r8162 r9172  
    11{combine_script id='jquery' load='footer' path='themes/default/js/jquery.min.js'}
    2 {combine_script id='jquery.ui' load='footer' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js'}
    3 {combine_script id='jquery.ui.datepicker' load='footer' require='jquery.ui' path='themes/default/js/ui/packed/ui.datepicker.packed.js'}
     2{combine_script id='jquery.ui' load='footer' require='jquery' path='themes/default/js/jquery.ui.min.js'}
     3{combine_script id='jquery.ui.datepicker' load='footer' require='jquery.ui' path='themes/default/js/ui/minified/jquery.ui.datepicker.min.js'}
    44{combine_script id='datepicker.js' load='footer' require='jquery.ui.datepicker' path='themes/default/js/datepicker.js'}
    55
    6 {assign var="datepicker_language" value="themes/default/js/ui/i18n/ui.datepicker-`$lang_info.code`.js"}
     6{assign var="datepicker_language" value="themes/default/js/ui/i18n/jquery.ui.datepicker-`$lang_info.code`.js"}
    77
    88{if "PHPWG_ROOT_PATH"|@constant|@cat:$datepicker_language|@file_exists}
     
    1010{/if}
    1111
    12 {html_head}
    13 <link rel="stylesheet" type="text/css" href="{$ROOT_URL}themes/default/js/ui/theme/ui.datepicker.css">
    14 {/html_head}
     12{combine_css path="themes/default/js/ui/theme/jquery.ui.datepicker.css"}
    1513
    1614{footer_script}
  • trunk/admin/themes/default/template/include/dbselect.inc.tpl

    r8162 r9172  
    11{combine_script id='jquery' load='async' path='themes/default/js/jquery.min.js'}
    2 {combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js' }
    3 {combine_script id='jquery.ui.resizable' load='async' require='jquery.ui' path='themes/default/js/ui/packed/ui.resizable.packed.js' }
     2{combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/jquery.ui.min.js' }
     3{combine_script id='jquery.ui.resizable' load='async' require='jquery.ui' path='themes/default/js/ui/minified/jquery.ui.resizable.min.js' }
    44{footer_script require='jquery.ui.resizable'}{literal}
    55jQuery(document).ready(function(){
  • trunk/admin/themes/default/template/include/resize.inc.tpl

    r8162 r9172  
    11{combine_script id='jquery' load='async' path='themes/default/js/jquery.min.js'}
    2 {combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js'}
    3 {combine_script id='jquery.ui.resizable' load='async' require='jquery.ui' path='themes/default/js/ui/packed/ui.resizable.packed.js'}
     2{combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/jquery.ui.min.js'}
     3{combine_script id='jquery.ui.resizable' load='async' require='jquery.ui' path='themes/default/js/ui/minified/jquery.ui.resizable.min.js'}
    44
    55{* Resize possible *}
  • trunk/admin/themes/default/template/menubar.tpl

    r8128 r9172  
    1 {combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js' }
    2 {combine_script id='jquery.ui.sortable' load='async' require='jquery.ui' path='themes/default/js/ui/packed/ui.sortable.packed.js' }
     1{combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/jquery.ui.min.js' }
     2{combine_script id='jquery.ui.sortable' load='async' require='jquery.ui' path='themes/default/js/ui/minified/jquery.ui.sortable.min.js' }
    33{footer_script require='jquery.ui.sortable'}
    44jQuery(document).ready(function(){ldelim}
  • trunk/admin/themes/default/template/plugins_new.tpl

    r7995 r9172  
    1 {combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/ui/packed/ui.core.packed.js' }
    2 {combine_script id='jquery.ui.effects' load='async' require='jquery.ui' path='themes/default/js/ui/packed/effects.core.packed.js' }
    3 {combine_script id='jquery.ui.effects.blind' load='async' require='jquery.ui.effects' path='themes/default/js/ui/packed/effects.blind.packed.js' }
     1{combine_script id='jquery.ui' load='async' require='jquery' path='themes/default/js/jquery.ui.min.js' }
     2{combine_script id='jquery.ui.effects' load='async' require='jquery.ui' path='themes/default/js/ui/minified/jquery.effects.core.min.js' }
     3{combine_script id='jquery.ui.effects.blind' load='async' require='jquery.ui.effects' path='themes/default/js/ui/minified/jquery.effects.blind.min.js' }
    44
    55{footer_script require='jquery.ui.effects.blind'}
  • trunk/include/template.class.php

    r8728 r9172  
    903903      'core.scripts' => 'themes/default/js/scripts.js',
    904904      'jquery' => 'themes/default/js/jquery.min.js',
    905       'jquery.ui' => 'themes/default/js/ui/packed/ui.core.packed.js'
     905      'jquery.ui' => 'themes/default/js/jquery.ui.min.js'
    906906    );
    907907
  • trunk/themes/default/js/jquery.js

    r8162 r9172  
    11/*!
    2  * jQuery JavaScript Library v1.4.4
     2 * jQuery JavaScript Library v1.5
    33 * http://jquery.com/
    44 *
    5  * Copyright 2010, John Resig
     5 * Copyright 2011, John Resig
    66 * Dual licensed under the MIT or GPL Version 2 licenses.
    77 * http://jquery.org/license
     
    99 * Includes Sizzle.js
    1010 * http://sizzlejs.com/
    11  * Copyright 2010, The Dojo Foundation
     11 * Copyright 2011, The Dojo Foundation
    1212 * Released under the MIT, BSD, and GPL Licenses.
    1313 *
    14  * Date: Thu Nov 11 19:04:53 2010 -0500
     14 * Date: Mon Jan 31 08:31:29 2011 -0500
    1515 */
    1616(function( window, undefined ) {
     
    2323var jQuery = function( selector, context ) {
    2424                // The jQuery object is actually just the init constructor 'enhanced'
    25                 return new jQuery.fn.init( selector, context );
     25                return new jQuery.fn.init( selector, context, rootjQuery );
    2626        },
    2727
     
    3939        quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,
    4040
    41         // Is it a simple selector
    42         isSimple = /^.[^:#\[\.,]*$/,
    43 
    4441        // Check if a string has a non-whitespace character in it
    4542        rnotwhite = /\S/,
    46         rwhite = /\s/,
    4743
    4844        // Used for trimming whitespace
    4945        trimLeft = /^\s+/,
    5046        trimRight = /\s+$/,
    51 
    52         // Check for non-word characters
    53         rnonword = /\W/,
    5447
    5548        // Check for digits
     
    7669        // For matching the engine and version of the browser
    7770        browserMatch,
    78        
     71
    7972        // Has the ready events already been bound?
    8073        readyBound = false,
    81        
    82         // The functions to execute on DOM ready
    83         readyList = [],
     74
     75        // The deferred used on DOM ready
     76        readyList,
     77
     78        // Promise methods
     79        promiseMethods = "then done fail isResolved isRejected promise".split( " " ),
    8480
    8581        // The ready event handler
     
    9389        trim = String.prototype.trim,
    9490        indexOf = Array.prototype.indexOf,
    95        
     91
    9692        // [[Class]] -> type pairs
    9793        class2type = {};
    9894
    9995jQuery.fn = jQuery.prototype = {
    100         init: function( selector, context ) {
     96        constructor: jQuery,
     97        init: function( selector, context, rootjQuery ) {
    10198                var match, elem, ret, doc;
    10299
     
    112109                        return this;
    113110                }
    114                
     111
    115112                // The body element only exists once, optimize finding it
    116113                if ( selector === "body" && !context && document.body ) {
     
    132129                                // HANDLE: $(html) -> $(array)
    133130                                if ( match[1] ) {
     131                                        context = context instanceof jQuery ? context[0] : context;
    134132                                        doc = (context ? context.ownerDocument || context : document);
    135133
     
    149147                                        } else {
    150148                                                ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
    151                                                 selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
    152                                         }
    153                                        
     149                                                selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
     150                                        }
     151
    154152                                        return jQuery.merge( this, selector );
    155                                        
     153
    156154                                // HANDLE: $("#id")
    157155                                } else {
     
    177175                                }
    178176
    179                         // HANDLE: $("TAG")
    180                         } else if ( !context && !rnonword.test( selector ) ) {
    181                                 this.selector = selector;
    182                                 this.context = document;
    183                                 selector = document.getElementsByTagName( selector );
    184                                 return jQuery.merge( this, selector );
    185 
    186177                        // HANDLE: $(expr, $(...))
    187178                        } else if ( !context || context.jquery ) {
     
    191182                        // (which is just equivalent to: $(context).find(expr)
    192183                        } else {
    193                                 return jQuery( context ).find( selector );
     184                                return this.constructor( context ).find( selector );
    194185                        }
    195186
     
    212203
    213204        // The current version of jQuery being used
    214         jquery: "1.4.4",
     205        jquery: "1.5",
    215206
    216207        // The default length of a jQuery object is 0
     
    235226
    236227                        // Return just the object
    237                         ( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
     228                        ( num < 0 ? this[ this.length + num ] : this[ num ] );
    238229        },
    239230
     
    242233        pushStack: function( elems, name, selector ) {
    243234                // Build a new jQuery matched element set
    244                 var ret = jQuery();
     235                var ret = this.constructor();
    245236
    246237                if ( jQuery.isArray( elems ) ) {
    247238                        push.apply( ret, elems );
    248                
     239
    249240                } else {
    250241                        jQuery.merge( ret, elems );
     
    272263                return jQuery.each( this, callback, args );
    273264        },
    274        
     265
    275266        ready: function( fn ) {
    276267                // Attach the listeners
    277268                jQuery.bindReady();
    278269
    279                 // If the DOM is already ready
    280                 if ( jQuery.isReady ) {
    281                         // Execute the function immediately
    282                         fn.call( document, jQuery );
    283 
    284                 // Otherwise, remember the function for later
    285                 } else if ( readyList ) {
    286                         // Add the function to the wait list
    287                         readyList.push( fn );
    288                 }
     270                // Add the callback
     271                readyList.done( fn );
    289272
    290273                return this;
    291274        },
    292        
     275
    293276        eq: function( i ) {
    294277                return i === -1 ?
     
    315298                }));
    316299        },
    317        
     300
    318301        end: function() {
    319                 return this.prevObject || jQuery(null);
     302                return this.prevObject || this.constructor(null);
    320303        },
    321304
     
    404387                return jQuery;
    405388        },
    406        
     389
    407390        // Is the DOM ready to be used? Set to true once it occurs.
    408391        isReady: false,
     
    411394        // the ready event fires. See #6781
    412395        readyWait: 1,
    413        
     396
    414397        // Handle when the DOM is ready
    415398        ready: function( wait ) {
     
    435418
    436419                        // If there are functions bound, to execute
    437                         if ( readyList ) {
    438                                 // Execute all of them
    439                                 var fn,
    440                                         i = 0,
    441                                         ready = readyList;
    442 
    443                                 // Reset the list of functions
    444                                 readyList = null;
    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                                 }
    454                         }
    455                 }
    456         },
    457        
     420                        readyList.resolveWith( document, [ jQuery ] );
     421
     422                        // Trigger any bound ready events
     423                        if ( jQuery.fn.trigger ) {
     424                                jQuery( document ).trigger( "ready" ).unbind( "ready" );
     425                        }
     426                }
     427        },
     428
    458429        bindReady: function() {
    459430                if ( readyBound ) {
     
    474445                        // Use the handy event callback
    475446                        document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
    476                        
     447
    477448                        // A fallback to window.onload, that will always work
    478449                        window.addEventListener( "load", jQuery.ready, false );
     
    483454                        // maybe late but safe also for iframes
    484455                        document.attachEvent("onreadystatechange", DOMContentLoaded);
    485                        
     456
    486457                        // A fallback to window.onload, that will always work
    487458                        window.attachEvent( "onload", jQuery.ready );
     
    534505                        return false;
    535506                }
    536                
     507
    537508                // Not own constructor property must be Object
    538509                if ( obj.constructor &&
     
    541512                        return false;
    542513                }
    543                
     514
    544515                // Own properties are enumerated firstly, so to speed up,
    545516                // if last one is own, then all properties are own.
    546        
     517
    547518                var key;
    548519                for ( key in obj ) {}
    549                
     520
    550521                return key === undefined || hasOwn.call( obj, key );
    551522        },
     
    557528                return true;
    558529        },
    559        
     530
    560531        error: function( msg ) {
    561532                throw msg;
    562533        },
    563        
     534
    564535        parseJSON: function( data ) {
    565536                if ( typeof data !== "string" || !data ) {
     
    569540                // Make sure leading/trailing whitespace is removed (IE can't handle it)
    570541                data = jQuery.trim( data );
    571                
     542
    572543                // Make sure the incoming data is actual JSON
    573544                // Logic borrowed from http://json.org/json2.js
     
    584555                        jQuery.error( "Invalid JSON: " + data );
    585556                }
     557        },
     558
     559        // Cross-browser xml parsing
     560        // (xml & tmp used internally)
     561        parseXML: function( data , xml , tmp ) {
     562
     563                if ( window.DOMParser ) { // Standard
     564                        tmp = new DOMParser();
     565                        xml = tmp.parseFromString( data , "text/xml" );
     566                } else { // IE
     567                        xml = new ActiveXObject( "Microsoft.XMLDOM" );
     568                        xml.async = "false";
     569                        xml.loadXML( data );
     570                }
     571
     572                tmp = xml.documentElement;
     573
     574                if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
     575                        jQuery.error( "Invalid XML: " + data );
     576                }
     577
     578                return xml;
    586579        },
    587580
     
    598591                        script.type = "text/javascript";
    599592
    600                         if ( jQuery.support.scriptEval ) {
     593                        if ( jQuery.support.scriptEval() ) {
    601594                                script.appendChild( document.createTextNode( data ) );
    602595                        } else {
     
    711704                                first[ i++ ] = second[ j ];
    712705                        }
    713                
     706
    714707                } else {
    715708                        while ( second[j] !== undefined ) {
     
    753746                }
    754747
     748                // Flatten any nested arrays
    755749                return ret.concat.apply( [], ret );
    756750        },
     
    791785        access: function( elems, key, value, exec, fn, pass ) {
    792786                var length = elems.length;
    793        
     787
    794788                // Setting many attributes
    795789                if ( typeof key === "object" ) {
     
    799793                        return elems;
    800794                }
    801        
     795
    802796                // Setting one attribute
    803797                if ( value !== undefined ) {
    804798                        // Optionally, function values get executed if exec is true
    805799                        exec = !pass && exec && jQuery.isFunction(value);
    806                
     800
    807801                        for ( var i = 0; i < length; i++ ) {
    808802                                fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
    809803                        }
    810                
     804
    811805                        return elems;
    812806                }
    813        
     807
    814808                // Getting an attribute
    815809                return length ? fn( elems[0], key ) : undefined;
     
    818812        now: function() {
    819813                return (new Date()).getTime();
     814        },
     815
     816        // Create a simple deferred (one callbacks list)
     817        _Deferred: function() {
     818                var // callbacks list
     819                        callbacks = [],
     820                        // stored [ context , args ]
     821                        fired,
     822                        // to avoid firing when already doing so
     823                        firing,
     824                        // flag to know if the deferred has been cancelled
     825                        cancelled,
     826                        // the deferred itself
     827                        deferred  = {
     828
     829                                // done( f1, f2, ...)
     830                                done: function() {
     831                                        if ( !cancelled ) {
     832                                                var args = arguments,
     833                                                        i,
     834                                                        length,
     835                                                        elem,
     836                                                        type,
     837                                                        _fired;
     838                                                if ( fired ) {
     839                                                        _fired = fired;
     840                                                        fired = 0;
     841                                                }
     842                                                for ( i = 0, length = args.length; i < length; i++ ) {
     843                                                        elem = args[ i ];
     844                                                        type = jQuery.type( elem );
     845                                                        if ( type === "array" ) {
     846                                                                deferred.done.apply( deferred, elem );
     847                                                        } else if ( type === "function" ) {
     848                                                                callbacks.push( elem );
     849                                                        }
     850                                                }
     851                                                if ( _fired ) {
     852                                                        deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
     853                                                }
     854                                        }
     855                                        return this;
     856                                },
     857
     858                                // resolve with given context and args
     859                                resolveWith: function( context, args ) {
     860                                        if ( !cancelled && !fired && !firing ) {
     861                                                firing = 1;
     862                                                try {
     863                                                        while( callbacks[ 0 ] ) {
     864                                                                callbacks.shift().apply( context, args );
     865                                                        }
     866                                                }
     867                                                finally {
     868                                                        fired = [ context, args ];
     869                                                        firing = 0;
     870                                                }
     871                                        }
     872                                        return this;
     873                                },
     874
     875                                // resolve with this as context and given arguments
     876                                resolve: function() {
     877                                        deferred.resolveWith( jQuery.isFunction( this.promise ) ? this.promise() : this, arguments );
     878                                        return this;
     879                                },
     880
     881                                // Has this deferred been resolved?
     882                                isResolved: function() {
     883                                        return !!( firing || fired );
     884                                },
     885
     886                                // Cancel
     887                                cancel: function() {
     888                                        cancelled = 1;
     889                                        callbacks = [];
     890                                        return this;
     891                                }
     892                        };
     893
     894                return deferred;
     895        },
     896
     897        // Full fledged deferred (two callbacks list)
     898        Deferred: function( func ) {
     899                var deferred = jQuery._Deferred(),
     900                        failDeferred = jQuery._Deferred(),
     901                        promise;
     902                // Add errorDeferred methods, then and promise
     903                jQuery.extend( deferred, {
     904                        then: function( doneCallbacks, failCallbacks ) {
     905                                deferred.done( doneCallbacks ).fail( failCallbacks );
     906                                return this;
     907                        },
     908                        fail: failDeferred.done,
     909                        rejectWith: failDeferred.resolveWith,
     910                        reject: failDeferred.resolve,
     911                        isRejected: failDeferred.isResolved,
     912                        // Get a promise for this deferred
     913                        // If obj is provided, the promise aspect is added to the object
     914                        promise: function( obj , i /* internal */ ) {
     915                                if ( obj == null ) {
     916                                        if ( promise ) {
     917                                                return promise;
     918                                        }
     919                                        promise = obj = {};
     920                                }
     921                                i = promiseMethods.length;
     922                                while( i-- ) {
     923                                        obj[ promiseMethods[ i ] ] = deferred[ promiseMethods[ i ] ];
     924                                }
     925                                return obj;
     926                        }
     927                } );
     928                // Make sure only one callback list will be used
     929                deferred.then( failDeferred.cancel, deferred.cancel );
     930                // Unexpose cancel
     931                delete deferred.cancel;
     932                // Call given func if any
     933                if ( func ) {
     934                        func.call( deferred, deferred );
     935                }
     936                return deferred;
     937        },
     938
     939        // Deferred helper
     940        when: function( object ) {
     941                var args = arguments,
     942                        length = args.length,
     943                        deferred = length <= 1 && object && jQuery.isFunction( object.promise ) ?
     944                                object :
     945                                jQuery.Deferred(),
     946                        promise = deferred.promise(),
     947                        resolveArray;
     948
     949                if ( length > 1 ) {
     950                        resolveArray = new Array( length );
     951                        jQuery.each( args, function( index, element ) {
     952                                jQuery.when( element ).then( function( value ) {
     953                                        resolveArray[ index ] = arguments.length > 1 ? slice.call( arguments, 0 ) : value;
     954                                        if( ! --length ) {
     955                                                deferred.resolveWith( promise, resolveArray );
     956                                        }
     957                                }, deferred.reject );
     958                        } );
     959                } else if ( deferred !== object ) {
     960                        deferred.resolve( object );
     961                }
     962                return promise;
    820963        },
    821964
     
    834977        },
    835978
     979        sub: function() {
     980                function jQuerySubclass( selector, context ) {
     981                        return new jQuerySubclass.fn.init( selector, context );
     982                }
     983                jQuery.extend( true, jQuerySubclass, this );
     984                jQuerySubclass.superclass = this;
     985                jQuerySubclass.fn = jQuerySubclass.prototype = this();
     986                jQuerySubclass.fn.constructor = jQuerySubclass;
     987                jQuerySubclass.subclass = this.subclass;
     988                jQuerySubclass.fn.init = function init( selector, context ) {
     989                        if ( context && context instanceof jQuery && !(context instanceof jQuerySubclass) ) {
     990                                context = jQuerySubclass(context);
     991                        }
     992
     993                        return jQuery.fn.init.call( this, selector, context, rootjQuerySubclass );
     994                };
     995                jQuerySubclass.fn.init.prototype = jQuerySubclass.fn;
     996                var rootjQuerySubclass = jQuerySubclass(document);
     997                return jQuerySubclass;
     998        },
     999
    8361000        browser: {}
    8371001});
     1002
     1003// Create readyList deferred
     1004readyList = jQuery._Deferred();
    8381005
    8391006// Populate the class2type map
     
    8591026}
    8601027
    861 // Verify that \s matches non-breaking spaces
    862 // (IE fails on this test)
    863 if ( !rwhite.test( "\xA0" ) ) {
     1028// IE doesn't match non-breaking spaces with \s
     1029if ( rnotwhite.test( "\xA0" ) ) {
    8641030        trimLeft = /^[\s\xA0]+/;
    8651031        trimRight = /[\s\xA0]+$/;
     
    9151081        jQuery.support = {};
    9161082
    917         var root = document.documentElement,
    918                 script = document.createElement("script"),
    919                 div = document.createElement("div"),
    920                 id = "script" + jQuery.now();
     1083        var div = document.createElement("div");
    9211084
    9221085        div.style.display = "none";
     
    9751138                optDisabled: false,
    9761139                checkClone: false,
    977                 scriptEval: false,
     1140                _scriptEval: null,
    9781141                noCloneEvent: true,
    9791142                boxModel: null,
     
    9881151        jQuery.support.optDisabled = !opt.disabled;
    9891152
    990         script.type = "text/javascript";
    991         try {
    992                 script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
    993         } catch(e) {}
    994 
    995         root.insertBefore( script, root.firstChild );
    996 
    997         // Make sure that the execution of code works by injecting a script
    998         // tag with appendChild/createTextNode
    999         // (IE doesn't support this, fails, and uses .text instead)
    1000         if ( window[ id ] ) {
    1001                 jQuery.support.scriptEval = true;
    1002                 delete window[ id ];
    1003         }
     1153        jQuery.support.scriptEval = function() {
     1154                if ( jQuery.support._scriptEval === null ) {
     1155                        var root = document.documentElement,
     1156                                script = document.createElement("script"),
     1157                                id = "script" + jQuery.now();
     1158
     1159                        script.type = "text/javascript";
     1160                        try {
     1161                                script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
     1162                        } catch(e) {}
     1163
     1164                        root.insertBefore( script, root.firstChild );
     1165
     1166                        // Make sure that the execution of code works by injecting a script
     1167                        // tag with appendChild/createTextNode
     1168                        // (IE doesn't support this, fails, and uses .text instead)
     1169                        if ( window[ id ] ) {
     1170                                jQuery.support._scriptEval = true;
     1171                                delete window[ id ];
     1172                        } else {
     1173                                jQuery.support._scriptEval = false;
     1174                        }
     1175
     1176                        root.removeChild( script );
     1177                        // release memory in IE
     1178                        root = script = id  = null;
     1179                }
     1180
     1181                return jQuery.support._scriptEval;
     1182        };
    10041183
    10051184        // Test to see if it's possible to delete an expando from an element
    10061185        // Fails in Internet Explorer
    10071186        try {
    1008                 delete script.test;
     1187                delete div.test;
    10091188
    10101189        } catch(e) {
    10111190                jQuery.support.deleteExpando = false;
    10121191        }
    1013 
    1014         root.removeChild( script );
    10151192
    10161193        if ( div.attachEvent && div.fireEvent ) {
     
    10361213        // document.body must exist before we can do this
    10371214        jQuery(function() {
    1038                 var div = document.createElement("div");
     1215                var div = document.createElement("div"),
     1216                        body = document.getElementsByTagName("body")[0];
     1217
     1218                // Frameset documents with no body should not run this code
     1219                if ( !body ) {
     1220                        return;
     1221                }
     1222
    10391223                div.style.width = div.style.paddingLeft = "1px";
    1040 
    1041                 document.body.appendChild( div );
     1224                body.appendChild( div );
    10421225                jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
    10431226
     
    10581241                }
    10591242
    1060                 div.innerHTML = "<table><tr><td style='padding:0;display:none'></td><td>t</td></tr></table>";
     1243                div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
    10611244                var tds = div.getElementsByTagName("td");
    10621245
     
    10781261                div.innerHTML = "";
    10791262
    1080                 document.body.removeChild( div ).style.display = "none";
     1263                body.removeChild( div ).style.display = "none";
    10811264                div = tds = null;
    10821265        });
     
    10881271                eventName = "on" + eventName;
    10891272
     1273                // We only care about the case where non-standard event systems
     1274                // are used, namely in IE. Short-circuiting here helps us to
     1275                // avoid an eval call (in setAttribute) which can cause CSP
     1276                // to go haywire. See: https://developer.mozilla.org/en/Security/CSP
     1277                if ( !el.attachEvent ) {
     1278                        return true;
     1279                }
     1280
    10901281                var isSupported = (eventName in el);
    10911282                if ( !isSupported ) {
     
    11021293
    11031294        // release memory in IE
    1104         root = script = div = all = a = null;
     1295        div = all = a = null;
    11051296})();
    11061297
    11071298
    11081299
    1109 var windowData = {},
    1110         rbrace = /^(?:\{.*\}|\[.*\])$/;
     1300var rbrace = /^(?:\{.*\}|\[.*\])$/;
    11111301
    11121302jQuery.extend({
     
    11161306        uuid: 0,
    11171307
    1118         // Unique for each copy of jQuery on the page   
    1119         expando: "jQuery" + jQuery.now(),
     1308        // Unique for each copy of jQuery on the page
     1309        // Non-digits removed to match rinlinejQuery
     1310        expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
    11201311
    11211312        // The following elements throw uncatchable exceptions if you
     
    11281319        },
    11291320
    1130         data: function( elem, name, data ) {
     1321        hasData: function( elem ) {
     1322                elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
     1323
     1324                return !!elem && !jQuery.isEmptyObject(elem);
     1325        },
     1326
     1327        data: function( elem, name, data, pvt /* Internal Use Only */ ) {
    11311328                if ( !jQuery.acceptData( elem ) ) {
    11321329                        return;
    11331330                }
    11341331
    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 ) {
     1332                var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
     1333
     1334                        // We have to handle DOM nodes and JS objects differently because IE6-7
     1335                        // can't GC object references properly across the DOM-JS boundary
     1336                        isNode = elem.nodeType,
     1337
     1338                        // Only DOM nodes need the global jQuery cache; JS object data is
     1339                        // attached directly to the object so GC can occur automatically
     1340                        cache = isNode ? jQuery.cache : elem,
     1341
     1342                        // Only defining an ID for JS objects if its cache already exists allows
     1343                        // the code to shortcut on the same path as a DOM node with no cache
     1344                        id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
     1345
     1346                // Avoid doing any more work than we need to when trying to get data on an
     1347                // object that has no data at all
     1348                if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
    11441349                        return;
    11451350                }
    11461351
    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.
     1352                if ( !id ) {
     1353                        // Only DOM nodes need a new unique ID for each element since their data
     1354                        // ends up in the global cache
     1355                        if ( isNode ) {
     1356                                elem[ jQuery.expando ] = id = ++jQuery.uuid;
     1357                        } else {
     1358                                id = jQuery.expando;
     1359                        }
     1360                }
     1361
     1362                if ( !cache[ id ] ) {
     1363                        cache[ id ] = {};
     1364                }
     1365
     1366                // An object can be passed to jQuery.data instead of a key/value pair; this gets
     1367                // shallow copied over onto the existing cache
    11581368                if ( typeof name === "object" ) {
    1159                         if ( isNode ) {
     1369                        if ( pvt ) {
     1370                                cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
     1371                        } else {
    11601372                                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
     1373                        }
     1374                }
     1375
     1376                thisCache = cache[ id ];
     1377
     1378                // Internal jQuery data is stored in a separate object inside the object's data
     1379                // cache in order to avoid key collisions between internal data and user-defined
     1380                // data
     1381                if ( pvt ) {
     1382                        if ( !thisCache[ internalKey ] ) {
     1383                                thisCache[ internalKey ] = {};
     1384                        }
     1385
     1386                        thisCache = thisCache[ internalKey ];
     1387                }
     1388
    11731389                if ( data !== undefined ) {
    11741390                        thisCache[ name ] = data;
    11751391                }
    11761392
    1177                 return typeof name === "string" ? thisCache[ name ] : thisCache;
    1178         },
    1179 
    1180         removeData: function( elem, name ) {
     1393                // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
     1394                // not attempt to inspect the internal events object using jQuery.data, as this
     1395                // internal data object is undocumented and subject to change.
     1396                if ( name === "events" && !thisCache[name] ) {
     1397                        return thisCache[ internalKey ] && thisCache[ internalKey ].events;
     1398                }
     1399
     1400                return getByName ? thisCache[ name ] : thisCache;
     1401        },
     1402
     1403        removeData: function( elem, name, pvt /* Internal Use Only */ ) {
    11811404                if ( !jQuery.acceptData( elem ) ) {
    11821405                        return;
    11831406                }
    11841407
    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
     1408                var internalKey = jQuery.expando, isNode = elem.nodeType,
     1409
     1410                        // See jQuery.data for more information
     1411                        cache = isNode ? jQuery.cache : elem,
     1412
     1413                        // See jQuery.data for more information
     1414                        id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
     1415
     1416                // If there is already no cache entry for this object, there is no
     1417                // purpose in continuing
     1418                if ( !cache[ id ] ) {
     1419                        return;
     1420                }
     1421
    11951422                if ( name ) {
     1423                        var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
     1424
    11961425                        if ( thisCache ) {
    1197                                 // Remove the section of cache data
    11981426                                delete thisCache[ name ];
    11991427
    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
     1428                                // If there is no data left in the cache, we want to continue
     1429                                // and let the cache object itself get destroyed
     1430                                if ( !jQuery.isEmptyObject(thisCache) ) {
     1431                                        return;
     1432                                }
     1433                        }
     1434                }
     1435
     1436                // See jQuery.data for more information
     1437                if ( pvt ) {
     1438                        delete cache[ id ][ internalKey ];
     1439
     1440                        // Don't destroy the parent cache unless the internal data object
     1441                        // had been the only thing left in it
     1442                        if ( !jQuery.isEmptyObject(cache[ id ]) ) {
     1443                                return;
     1444                        }
     1445                }
     1446
     1447                var internalCache = cache[ id ][ internalKey ];
     1448
     1449                // Browsers that fail expando deletion also refuse to delete expandos on
     1450                // the window, but it will allow it on all other JS objects; other browsers
     1451                // don't care
     1452                if ( jQuery.support.deleteExpando || cache != window ) {
     1453                        delete cache[ id ];
    12071454                } else {
    1208                         if ( isNode && jQuery.support.deleteExpando ) {
     1455                        cache[ id ] = null;
     1456                }
     1457
     1458                // We destroyed the entire user cache at once because it's faster than
     1459                // iterating through each key, but we need to continue to persist internal
     1460                // data if it existed
     1461                if ( internalCache ) {
     1462                        cache[ id ] = {};
     1463                        cache[ id ][ internalKey ] = internalCache;
     1464
     1465                // Otherwise, we need to eliminate the expando on the node to avoid
     1466                // false lookups in the cache for entries that no longer exist
     1467                } else if ( isNode ) {
     1468                        // IE does not allow us to delete expando properties from nodes,
     1469                        // nor does it have a removeAttribute function on Document nodes;
     1470                        // we must handle all of these cases
     1471                        if ( jQuery.support.deleteExpando ) {
    12091472                                delete elem[ jQuery.expando ];
    1210 
    12111473                        } else if ( elem.removeAttribute ) {
    12121474                                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
    12191475                        } else {
    1220                                 for ( var n in elem ) {
    1221                                         delete elem[ n ];
    1222                                 }
    1223                         }
    1224                 }
     1476                                elem[ jQuery.expando ] = null;
     1477                        }
     1478                }
     1479        },
     1480
     1481        // For internal use only.
     1482        _data: function( elem, name, data ) {
     1483                return jQuery.data( elem, name, data, true );
    12251484        },
    12261485
     
    12451504                if ( typeof key === "undefined" ) {
    12461505                        if ( this.length ) {
    1247                                 var attr = this[0].attributes, name;
    12481506                                data = jQuery.data( this[0] );
    12491507
    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 ] );
     1508                                if ( this[0].nodeType === 1 ) {
     1509                                        var attr = this[0].attributes, name;
     1510                                        for ( var i = 0, l = attr.length; i < l; i++ ) {
     1511                                                name = attr[i].name;
     1512
     1513                                                if ( name.indexOf( "data-" ) === 0 ) {
     1514                                                        name = name.substr( 5 );
     1515                                                        dataAttr( this[0], name, data[ name ] );
     1516                                                }
    12561517                                        }
    12571518                                }
     
    13381599
    13391600                type = (type || "fx") + "queue";
    1340                 var q = jQuery.data( elem, type );
     1601                var q = jQuery._data( elem, type );
    13411602
    13421603                // Speed up dequeue by getting out quickly if this is just a lookup
     
    13461607
    13471608                if ( !q || jQuery.isArray(data) ) {
    1348                         q = jQuery.data( elem, type, jQuery.makeArray(data) );
     1609                        q = jQuery._data( elem, type, jQuery.makeArray(data) );
    13491610
    13501611                } else {
     
    13761637                                jQuery.dequeue(elem, type);
    13771638                        });
     1639                }
     1640
     1641                if ( !queue.length ) {
     1642                        jQuery.removeData( elem, type + "queue", true );
    13781643                }
    13791644        }
     
    14261691
    14271692
    1428 var rclass = /[\n\t]/g,
     1693var rclass = /[\n\t\r]/g,
    14291694        rspaces = /\s+/,
    14301695        rreturn = /\r/g,
     
    15591824                                if ( this.className ) {
    15601825                                        // store className if set
    1561                                         jQuery.data( this, "__className__", this.className );
     1826                                        jQuery._data( this, "__className__", this.className );
    15621827                                }
    15631828
    15641829                                // toggle whole className
    1565                                 this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
     1830                                this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
    15661831                        }
    15671832                });
     
    16081873
    16091874                                                // 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) && 
     1875                                                if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
    16111876                                                                (!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
    16121877
     
    16311896                                        return elem.getAttribute("value") === null ? "on" : elem.value;
    16321897                                }
    1633                                
    16341898
    16351899                                // Everything else, we just grab the value
     
    16971961                offset: true
    16981962        },
    1699                
     1963
    17001964        attr: function( elem, name, value, pass ) {
    1701                 // don't set attributes on text and comment nodes
    1702                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
     1965                // don't get/set attributes on text, comment and attribute nodes
     1966                if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || elem.nodeType === 2 ) {
    17031967                        return undefined;
    17041968                }
     
    17151979                name = notxml && jQuery.props[ name ] || name;
    17161980
    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 ) {
     1981                // Only do all the following if this is a node (faster for style)
     1982                if ( elem.nodeType === 1 ) {
     1983                        // These attributes require special treatment
     1984                        var special = rspecialurl.test( name );
     1985
     1986                        // Safari mis-reports the default selected property of an option
     1987                        // Accessing the parent's selectedIndex property fixes it
     1988                        if ( name === "selected" && !jQuery.support.optSelected ) {
     1989                                var parent = elem.parentNode;
     1990                                if ( parent ) {
     1991                                        parent.selectedIndex;
     1992
     1993                                        // Make sure that it also works with optgroups, see #5701
     1994                                        if ( parent.parentNode ) {
     1995                                                parent.parentNode.selectedIndex;
     1996                                        }
     1997                                }
     1998                        }
     1999
     2000                        // If applicable, access the attribute via the DOM 0 way
     2001                        // 'in' checks fail in Blackberry 4.7 #6931
     2002                        if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
     2003                                if ( set ) {
     2004                                        // We can't allow the type property to be changed (since it causes problems in IE)
     2005                                        if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
     2006                                                jQuery.error( "type property can't be changed" );
     2007                                        }
     2008
     2009                                        if ( value === null ) {
     2010                                                if ( elem.nodeType === 1 ) {
     2011                                                        elem.removeAttribute( name );
     2012                                                }
     2013
     2014                                        } else {
     2015                                                elem[ name ] = value;
     2016                                        }
     2017                                }
     2018
     2019                                // browsers index elements by id/name on forms, give priority to attributes.
     2020                                if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
     2021                                        return elem.getAttributeNode( name ).nodeValue;
     2022                                }
     2023
     2024                                // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
     2025                                // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
     2026                                if ( name === "tabIndex" ) {
     2027                                        var attributeNode = elem.getAttributeNode( "tabIndex" );
     2028
     2029                                        return attributeNode && attributeNode.specified ?
     2030                                                attributeNode.value :
     2031                                                rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
     2032                                                        0 :
     2033                                                        undefined;
     2034                                }
     2035
     2036                                return elem[ name ];
     2037                        }
     2038
     2039                        if ( !jQuery.support.style && notxml && name === "style" ) {
     2040                                if ( set ) {
     2041                                        elem.style.cssText = "" + value;
     2042                                }
     2043
     2044                                return elem.style.cssText;
     2045                        }
     2046
    17372047                        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 );
    1746                                         }
    1747 
    1748                                 } else {
    1749                                         elem[ name ] = value;
    1750                                 }
    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" ) {
    1774                         if ( set ) {
    1775                                 elem.style.cssText = "" + value;
    1776                         }
    1777 
    1778                         return elem.style.cssText;
    1779                 }
    1780 
     2048                                // convert the value to a string (all browsers do this but IE) see #1070
     2049                                elem.setAttribute( name, "" + value );
     2050                        }
     2051
     2052                        // Ensure that missing attributes return undefined
     2053                        // Blackberry 4.7 returns "" from getAttribute #6938
     2054                        if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
     2055                                return undefined;
     2056                        }
     2057
     2058                        var attr = !jQuery.support.hrefNormalized && notxml && special ?
     2059                                        // Some attributes require a special call on IE
     2060                                        elem.getAttribute( name, 2 ) :
     2061                                        elem.getAttribute( name );
     2062
     2063                        // Non-existent attributes return null, we normalize to undefined
     2064                        return attr === null ? undefined : attr;
     2065                }
     2066                // Handle everything which isn't a DOM element node
    17812067                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;
     2068                        elem[ name ] = value;
     2069                }
     2070                return elem[ name ];
    17992071        }
    18002072});
     
    18112083                return nm.replace(rescape, "\\$&");
    18122084        },
    1813         focusCounts = { focusin: 0, focusout: 0 };
     2085        eventKey = "events";
    18142086
    18152087/*
     
    18532125
    18542126                // Init the element's event structure
    1855                 var elemData = jQuery.data( elem );
     2127                var elemData = jQuery._data( elem );
    18562128
    18572129                // If no elemData is found then we must be trying to bind to one of the
     
    18612133                }
    18622134
    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 ],
     2135                var events = elemData[ eventKey ],
    18672136                        eventHandle = elemData.handle;
    1868                        
     2137
    18692138                if ( typeof events === "function" ) {
    18702139                        // On plain objects events is a fn that holds the the data
     
    19462215                                }
    19472216                        }
    1948                        
    1949                         if ( special.add ) { 
    1950                                 special.add.call( elem, handleObj ); 
     2217
     2218                        if ( special.add ) {
     2219                                special.add.call( elem, handleObj );
    19512220
    19522221                                if ( !handleObj.handler.guid ) {
     
    19802249
    19812250                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 ),
     2251                        elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
    19842252                        events = elemData && elemData[ eventKey ];
    19852253
     
    19872255                        return;
    19882256                }
    1989                
     2257
    19902258                if ( typeof events === "function" ) {
    19912259                        elemData = events;
     
    20252293                                type = namespaces.shift();
    20262294
    2027                                 namespace = new RegExp("(^|\\.)" + 
     2295                                namespace = new RegExp("(^|\\.)" +
    20282296                                        jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
    20292297                        }
     
    20932361
    20942362                        if ( typeof elemData === "function" ) {
    2095                                 jQuery.removeData( elem, eventKey );
     2363                                jQuery.removeData( elem, eventKey, true );
    20962364
    20972365                        } else if ( jQuery.isEmptyObject( elemData ) ) {
    2098                                 jQuery.removeData( elem );
     2366                                jQuery.removeData( elem, undefined, true );
    20992367                        }
    21002368                }
     
    21282396                                // Only trigger if we've ever bound an event for it
    21292397                                if ( jQuery.event.global[ type ] ) {
     2398                                        // XXX This code smells terrible. event.js should not be directly
     2399                                        // inspecting the data cache
    21302400                                        jQuery.each( jQuery.cache, function() {
    2131                                                 if ( this.events && this.events[type] ) {
    2132                                                         jQuery.event.trigger( event, data, this.handle.elem );
     2401                                                // internalKey variable is just used to make it easier to find
     2402                                                // and potentially change this stuff later; currently it just
     2403                                                // points to jQuery.expando
     2404                                                var internalKey = jQuery.expando,
     2405                                                        internalCache = this[ internalKey ];
     2406                                                if ( internalCache && internalCache.events && internalCache.events[type] ) {
     2407                                                        jQuery.event.trigger( event, data, internalCache.handle.elem );
    21332408                                                }
    21342409                                        });
     
    21562431                // Trigger the event, it is assumed that "handle" is a function
    21572432                var handle = elem.nodeType ?
    2158                         jQuery.data( elem, "handle" ) :
    2159                         (jQuery.data( elem, "__events__" ) || {}).handle;
     2433                        jQuery._data( elem, "handle" ) :
     2434                        (jQuery._data( elem, eventKey ) || {}).handle;
    21602435
    21612436                if ( handle ) {
     
    21872462                                special = jQuery.event.special[ targetType ] || {};
    21882463
    2189                         if ( (!special._default || special._default.call( elem, event ) === false) && 
     2464                        if ( (!special._default || special._default.call( elem, event ) === false) &&
    21902465                                !isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
    21912466
     
    22352510                event.namespace = event.namespace || namespace_sort.join(".");
    22362511
    2237                 events = jQuery.data(this, this.nodeType ? "events" : "__events__");
     2512                events = jQuery._data(this, eventKey);
    22382513
    22392514                if ( typeof events === "function" ) {
     
    22572532                                        event.data = handleObj.data;
    22582533                                        event.handleObj = handleObj;
    2259        
     2534
    22602535                                        var ret = handleObj.handler.apply( this, args );
    22612536
     
    23562631                                jQuery.event.add( this,
    23572632                                        liveConvert( handleObj.origType, handleObj.selector ),
    2358                                         jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) ); 
     2633                                        jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
    23592634                        },
    23602635
     
    23862661                        elem.removeEventListener( type, handle, false );
    23872662                }
    2388         } : 
     2663        } :
    23892664        function( elem, type, handle ) {
    23902665                if ( elem.detachEvent ) {
     
    24032678                this.originalEvent = src;
    24042679                this.type = src.type;
     2680
     2681                // Events bubbling up the document may have been marked as prevented
     2682                // by a handler lower down the tree; reflect the correct value.
     2683                this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
     2684                        src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
     2685
    24052686        // Event type
    24062687        } else {
     
    24332714                        return;
    24342715                }
    2435                
     2716
    24362717                // if preventDefault exists run it on the original event
    24372718                if ( e.preventDefault ) {
     
    25192800        jQuery.event.special.submit = {
    25202801                setup: function( data, namespaces ) {
    2521                         if ( this.nodeName.toLowerCase() !== "form" ) {
     2802                        if ( this.nodeName && this.nodeName.toLowerCase() !== "form" ) {
    25222803                                jQuery.event.add(this, "click.specialSubmit", function( e ) {
    25232804                                        var elem = e.target,
     
    25292810                                        }
    25302811                                });
    2531          
     2812
    25322813                                jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
    25332814                                        var elem = e.target,
     
    25842865                }
    25852866
    2586                 data = jQuery.data( elem, "_change_data" );
     2867                data = jQuery._data( elem, "_change_data" );
    25872868                val = getVal(elem);
    25882869
    25892870                // the current data will be also retrieved by beforeactivate
    25902871                if ( e.type !== "focusout" || elem.type !== "radio" ) {
    2591                         jQuery.data( elem, "_change_data", val );
    2592                 }
    2593                
     2872                        jQuery._data( elem, "_change_data", val );
     2873                }
     2874
    25942875                if ( data === undefined || val === data ) {
    25952876                        return;
     
    26052886        jQuery.event.special.change = {
    26062887                filters: {
    2607                         focusout: testChange, 
     2888                        focusout: testChange,
    26082889
    26092890                        beforedeactivate: testChange,
     
    26342915                        beforeactivate: function( e ) {
    26352916                                var elem = e.target;
    2636                                 jQuery.data( elem, "_change_data", getVal(elem) );
     2917                                jQuery._data( elem, "_change_data", getVal(elem) );
    26372918                        }
    26382919                },
     
    26732954                jQuery.event.special[ fix ] = {
    26742955                        setup: function() {
    2675                                 if ( focusCounts[fix]++ === 0 ) {
    2676                                         document.addEventListener( orig, handler, true );
    2677                                 }
     2956                                this.addEventListener( orig, handler, true );
    26782957                        },
    26792958                        teardown: function() {
    2680                                 if ( --focusCounts[fix] === 0 ) {
    2681                                         document.removeEventListener( orig, handler, true );
    2682                                 }
     2959                                this.removeEventListener( orig, handler, true );
    26832960                        }
    26842961                };
    26852962
    2686                 function handler( e ) { 
     2963                function handler( e ) {
    26872964                        e = jQuery.event.fix( e );
    26882965                        e.type = fix;
    2689                         return jQuery.event.trigger( e, null, e.target );
     2966                        return jQuery.event.handle.call( this, e );
    26902967                }
    26912968        });
     
    27012978                        return this;
    27022979                }
    2703                
     2980
    27042981                if ( jQuery.isFunction( data ) || data === false ) {
    27052982                        fn = data;
     
    27413018                return this;
    27423019        },
    2743        
     3020
    27443021        delegate: function( selector, types, data, fn ) {
    27453022                return this.live( types, data, fn, selector );
    27463023        },
    2747        
     3024
    27483025        undelegate: function( selector, types, fn ) {
    27493026                if ( arguments.length === 0 ) {
    27503027                                return this.unbind( "live" );
    2751                
     3028
    27523029                } else {
    27533030                        return this.die( types, null, fn, selector );
    27543031                }
    27553032        },
    2756        
     3033
    27573034        trigger: function( type, data ) {
    27583035                return this.each(function() {
     
    27833060                return this.click( jQuery.proxy( fn, function( event ) {
    27843061                        // Figure out which function to execute
    2785                         var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
    2786                         jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
     3062                        var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
     3063                        jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
    27873064
    27883065                        // Make sure that clicks stop
     
    28113088                        selector = origSelector || this.selector,
    28123089                        context = origSelector ? this : jQuery( this.context );
    2813                
     3090
    28143091                if ( typeof types === "object" && !types.preventDefault ) {
    28153092                        for ( var key in types ) {
    28163093                                context[ name ]( key, data, types[key], selector );
    28173094                        }
    2818                        
     3095
    28193096                        return this;
    28203097                }
     
    28633140                        }
    28643141                }
    2865                
     3142
    28663143                return this;
    28673144        };
     
    28723149                elems = [],
    28733150                selectors = [],
    2874                 events = jQuery.data( this, this.nodeType ? "events" : "__events__" );
     3151                events = jQuery._data( this, eventKey );
    28753152
    28763153        if ( typeof events === "function" ) {
     
    28783155        }
    28793156
    2880         // Make sure we avoid non-left-click bubbling in Firefox (#3861)
    2881         if ( event.liveFired === this || !events || !events.live || event.button && event.type === "click" ) {
     3157        // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
     3158        if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
    28823159                return;
    28833160        }
    2884        
     3161
    28853162        if ( event.namespace ) {
    28863163                namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
     
    29803257});
    29813258
    2982 // Prevent memory leaks in IE
    2983 // Window isn't included so as not to unbind existing unload events
    2984 // More info:
    2985 //  - http://isaacschlueter.com/2006/10/msie-memory-leaks/
    2986 if ( window.attachEvent && !window.addEventListener ) {
    2987         jQuery(window).bind("unload", function() {
    2988                 for ( var id in jQuery.cache ) {
    2989                         if ( jQuery.cache[ id ].handle ) {
    2990                                 // Try/Catch is to handle iframes being unloaded, see #4280
    2991                                 try {
    2992                                         jQuery.event.remove( jQuery.cache[ id ].handle.elem );
    2993                                 } catch(e) {}
    2994                         }
    2995                 }
    2996         });
    2997 }
    2998 
    29993259
    30003260/*!
    3001  * Sizzle CSS Selector Engine - v1.0
    3002  *  Copyright 2009, The Dojo Foundation
     3261 * Sizzle CSS Selector Engine
     3262 *  Copyright 2011, The Dojo Foundation
    30033263 *  Released under the MIT, BSD, and GPL Licenses.
    30043264 *  More information: http://sizzlejs.com/
     
    32213481
    32223482        if ( !set ) {
    3223                 set = context.getElementsByTagName( "*" );
     3483                set = typeof context.getElementsByTagName !== "undefined" ?
     3484                        context.getElementsByTagName( "*" ) :
     3485                        [];
    32243486        }
    32253487
     
    33293591                CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
    33303592                NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
    3331                 ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
     3593                ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
    33323594                TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
    3333                 CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+\-]*)\))?/,
     3595                CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
    33343596                POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
    33353597                PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
     
    34643726
    34653727                TAG: function( match, context ) {
    3466                         return context.getElementsByTagName( match[1] );
     3728                        if ( typeof context.getElementsByTagName !== "undefined" ) {
     3729                                return context.getElementsByTagName( match[1] );
     3730                        }
    34673731                }
    34683732        },
     
    34773741                        for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
    34783742                                if ( elem ) {
    3479                                         if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
     3743                                        if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
    34803744                                                if ( !inplace ) {
    34813745                                                        result.push( elem );
     
    35013765                CHILD: function( match ) {
    35023766                        if ( match[1] === "nth" ) {
     3767                                if ( !match[2] ) {
     3768                                        Sizzle.error( match[0] );
     3769                                }
     3770
     3771                                match[2] = match[2].replace(/^\+|\s*/g, '');
     3772
    35033773                                // parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
    3504                                 var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
     3774                                var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
    35053775                                        match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
    35063776                                        !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
     
    35103780                                match[3] = test[3] - 0;
    35113781                        }
     3782                        else if ( match[2] ) {
     3783                                Sizzle.error( match[0] );
     3784                        }
    35123785
    35133786                        // TODO: Move to normal caching system
     
    35183791
    35193792                ATTR: function( match, curLoop, inplace, result, not, isXML ) {
    3520                         var name = match[1].replace(/\\/g, "");
     3793                        var name = match[1] = match[1].replace(/\\/g, "");
    35213794                       
    35223795                        if ( !isXML && Expr.attrMap[name] ) {
    35233796                                match[1] = Expr.attrMap[name];
    35243797                        }
     3798
     3799                        // Handle if an un-quoted value was used
     3800                        match[4] = ( match[4] || match[5] || "" ).replace(/\\/g, "");
    35253801
    35263802                        if ( match[2] === "~=" ) {
     
    36923968
    36933969                        } else {
    3694                                 Sizzle.error( "Syntax error, unrecognized expression: " + name );
     3970                                Sizzle.error( name );
    36953971                        }
    36963972                },
     
    40824358                        context = context || document;
    40834359
    4084                         // Make sure that attribute selectors are quoted
    4085                         query = query.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
    4086 
    40874360                        // Only use querySelectorAll on non-XML documents
    40884361                        // (ID selectors don't work in non-HTML documents)
    40894362                        if ( !seed && !Sizzle.isXML(context) ) {
     4363                                // See if we find a selector to speed up
     4364                                var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
     4365                               
     4366                                if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
     4367                                        // Speed-up: Sizzle("TAG")
     4368                                        if ( match[1] ) {
     4369                                                return makeArray( context.getElementsByTagName( query ), extra );
     4370                                       
     4371                                        // Speed-up: Sizzle(".CLASS")
     4372                                        } else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
     4373                                                return makeArray( context.getElementsByClassName( match[2] ), extra );
     4374                                        }
     4375                                }
     4376                               
    40904377                                if ( context.nodeType === 9 ) {
     4378                                        // Speed-up: Sizzle("body")
     4379                                        // The body element only exists once, optimize finding it
     4380                                        if ( query === "body" && context.body ) {
     4381                                                return makeArray( [ context.body ], extra );
     4382                                               
     4383                                        // Speed-up: Sizzle("#ID")
     4384                                        } else if ( match && match[3] ) {
     4385                                                var elem = context.getElementById( match[3] );
     4386
     4387                                                // Check parentNode to catch when Blackberry 4.6 returns
     4388                                                // nodes that are no longer in the document #6963
     4389                                                if ( elem && elem.parentNode ) {
     4390                                                        // Handle the case where IE and Opera return items
     4391                                                        // by name instead of ID
     4392                                                        if ( elem.id === match[3] ) {
     4393                                                                return makeArray( [ elem ], extra );
     4394                                                        }
     4395                                                       
     4396                                                } else {
     4397                                                        return makeArray( [], extra );
     4398                                                }
     4399                                        }
     4400                                       
    40914401                                        try {
    40924402                                                return makeArray( context.querySelectorAll(query), extra );
     
    40994409                                } else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
    41004410                                        var old = context.getAttribute( "id" ),
    4101                                                 nid = old || id;
     4411                                                nid = old || id,
     4412                                                hasParent = context.parentNode,
     4413                                                relativeHierarchySelector = /^\s*[+~]/.test( query );
    41024414
    41034415                                        if ( !old ) {
    41044416                                                context.setAttribute( "id", nid );
     4417                                        } else {
     4418                                                nid = nid.replace( /'/g, "\\$&" );
     4419                                        }
     4420                                        if ( relativeHierarchySelector && hasParent ) {
     4421                                                context = context.parentNode;
    41054422                                        }
    41064423
    41074424                                        try {
    4108                                                 return makeArray( context.querySelectorAll( "#" + nid + " " + query ), extra );
     4425                                                if ( !relativeHierarchySelector || hasParent ) {
     4426                                                        return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
     4427                                                }
    41094428
    41104429                                        } catch(pseudoError) {
     
    43294648        isSimple = /^.[^:#\[\.,]*$/,
    43304649        slice = Array.prototype.slice,
    4331         POS = jQuery.expr.match.POS;
     4650        POS = jQuery.expr.match.POS,
     4651        // methods guaranteed to produce a unique set when starting from a unique set
     4652        guaranteedUnique = {
     4653                children: true,
     4654                contents: true,
     4655                next: true,
     4656                prev: true
     4657        };
    43324658
    43334659jQuery.fn.extend({
     
    43744700                return this.pushStack( winnow(this, selector, true), "filter", selector );
    43754701        },
    4376        
     4702
    43774703        is: function( selector ) {
    43784704                return !!selector && jQuery.filter( selector, this ).length > 0;
     
    43924718
    43934719                                        if ( !matches[selector] ) {
    4394                                                 matches[selector] = jQuery.expr.match.POS.test( selector ) ? 
     4720                                                matches[selector] = jQuery.expr.match.POS.test( selector ) ?
    43954721                                                        jQuery( selector, context || this.context ) :
    43964722                                                        selector;
     
    44154741                }
    44164742
    4417                 var pos = POS.test( selectors ) ? 
     4743                var pos = POS.test( selectors ) ?
    44184744                        jQuery( selectors, context || this.context ) : null;
    44194745
     
    44364762
    44374763                ret = ret.length > 1 ? jQuery.unique(ret) : ret;
    4438                
     4764
    44394765                return this.pushStack( ret, "closest", selectors );
    44404766        },
    4441        
     4767
    44424768        // Determine the position of an element within
    44434769        // the matched set of elements
     
    44574783        add: function( selector, context ) {
    44584784                var set = typeof selector === "string" ?
    4459                                 jQuery( selector, context || this.context ) :
     4785                                jQuery( selector, context ) :
    44604786                                jQuery.makeArray( selector ),
    44614787                        all = jQuery.merge( this.get(), set );
     
    45194845}, function( name, fn ) {
    45204846        jQuery.fn[ name ] = function( until, selector ) {
    4521                 var ret = jQuery.map( this, fn, until );
    4522                
     4847                var ret = jQuery.map( this, fn, until ),
     4848                // The variable 'args' was introduced in
     4849                // https://github.com/jquery/jquery/commit/52a0238
     4850                // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
     4851                // http://code.google.com/p/v8/issues/detail?id=1050
     4852                    args = slice.call(arguments);
     4853
    45234854                if ( !runtil.test( name ) ) {
    45244855                        selector = until;
     
    45294860                }
    45304861
    4531                 ret = this.length > 1 ? jQuery.unique( ret ) : ret;
     4862                ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
    45324863
    45334864                if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
     
    45354866                }
    45364867
    4537                 return this.pushStack( ret, name, slice.call(arguments).join(",") );
     4868                return this.pushStack( ret, name, args.join(",") );
    45384869        };
    45394870});
     
    45494880                        jQuery.find.matches(expr, elems);
    45504881        },
    4551        
     4882
    45524883        dir: function( elem, dir, until ) {
    45534884                var matched = [],
     
    46314962        // checked="checked" or checked (html5)
    46324963        rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
    4633         raction = /\=([^="'>\s]+\/)>/g,
    46344964        wrapMap = {
    46354965                option: [ 1, "<select multiple='multiple'>", "</select>" ],
     
    47715101                }
    47725102        },
    4773        
     5103
    47745104        // keepData is for internal use only--do not document
    47755105        remove: function( selector, keepData ) {
     
    47865116                        }
    47875117                }
    4788                
     5118
    47895119                return this;
    47905120        },
     
    48025132                        }
    48035133                }
    4804                
     5134
    48055135                return this;
    48065136        },
    48075137
    4808         clone: function( events ) {
    4809                 // Do the clone
    4810                 var ret = this.map(function() {
    4811                         if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
    4812                                 // IE copies events bound via attachEvent when
    4813                                 // using cloneNode. Calling detachEvent on the
    4814                                 // clone will also remove the events from the orignal
    4815                                 // In order to get around this, we use innerHTML.
    4816                                 // Unfortunately, this means some modifications to
    4817                                 // attributes in IE that are actually only stored
    4818                                 // as properties will not be copied (such as the
    4819                                 // the name attribute on an input).
    4820                                 var html = this.outerHTML,
    4821                                         ownerDocument = this.ownerDocument;
    4822 
    4823                                 if ( !html ) {
    4824                                         var div = ownerDocument.createElement("div");
    4825                                         div.appendChild( this.cloneNode(true) );
    4826                                         html = div.innerHTML;
    4827                                 }
    4828 
    4829                                 return jQuery.clean([html.replace(rinlinejQuery, "")
    4830                                         // Handle the case in IE 8 where action=/test/> self-closes a tag
    4831                                         .replace(raction, '="$1">')
    4832                                         .replace(rleadingWhitespace, "")], ownerDocument)[0];
    4833                         } else {
    4834                                 return this.cloneNode(true);
    4835                         }
     5138        clone: function( dataAndEvents, deepDataAndEvents ) {
     5139                dataAndEvents = dataAndEvents == null ? true : dataAndEvents;
     5140                deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
     5141
     5142                return this.map( function () {
     5143                        return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
    48365144                });
    4837 
    4838                 // Copy the events from the original to the clone
    4839                 if ( events === true ) {
    4840                         cloneCopyEvent( this, ret );
    4841                         cloneCopyEvent( this.find("*"), ret.find("*") );
    4842                 }
    4843 
    4844                 // Return the cloned set
    4845                 return ret;
    48465145        },
    48475146
     
    49535252                                results = jQuery.buildFragment( args, this, scripts );
    49545253                        }
    4955                        
     5254
    49565255                        fragment = results.fragment;
    4957                        
     5256
    49585257                        if ( fragment.childNodes.length === 1 ) {
    49595258                                first = fragment = fragment.firstChild;
     
    49655264                                table = table && jQuery.nodeName( first, "tr" );
    49665265
    4967                                 for ( var i = 0, l = this.length; i < l; i++ ) {
     5266                                for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
    49685267                                        callback.call(
    49695268                                                table ?
    49705269                                                        root(this[i], first) :
    49715270                                                        this[i],
    4972                                                 i > 0 || results.cacheable || this.length > 1  ?
    4973                                                         fragment.cloneNode(true) :
     5271                                                // Make sure that we do not leak memory by inadvertently discarding
     5272                                                // the original fragment (which might have attached data) instead of
     5273                                                // using it; in addition, use the original fragment object for the last
     5274                                                // item instead of first because it can end up being emptied incorrectly
     5275                                                // in certain situations (Bug #8070).
     5276                                                // Fragments from the fragment cache must always be cloned and never used
     5277                                                // in place.
     5278                                                results.cacheable || (l > 1 && i < lastIndex) ?
     5279                                                        jQuery.clone( fragment, true, true ) :
    49745280                                                        fragment
    49755281                                        );
     
    49935299}
    49945300
    4995 function cloneCopyEvent(orig, ret) {
    4996         var i = 0;
    4997 
    4998         ret.each(function() {
    4999                 if ( this.nodeName !== (orig[i] && orig[i].nodeName) ) {
    5000                         return;
    5001                 }
    5002 
    5003                 var oldData = jQuery.data( orig[i++] ),
    5004                         curData = jQuery.data( this, oldData ),
    5005                         events = oldData && oldData.events;
     5301function cloneCopyEvent( src, dest ) {
     5302
     5303        if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
     5304                return;
     5305        }
     5306
     5307        var internalKey = jQuery.expando,
     5308                        oldData = jQuery.data( src ),
     5309                        curData = jQuery.data( dest, oldData );
     5310
     5311        // Switch to use the internal data object, if it exists, for the next
     5312        // stage of data copying
     5313        if ( (oldData = oldData[ internalKey ]) ) {
     5314                var events = oldData.events;
     5315                                curData = curData[ internalKey ] = jQuery.extend({}, oldData);
    50065316
    50075317                if ( events ) {
     
    50105320
    50115321                        for ( var type in events ) {
    5012                                 for ( var handler in events[ type ] ) {
    5013                                         jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
    5014                                 }
    5015                         }
    5016                 }
    5017         });
     5322                                for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
     5323                                        jQuery.event.add( dest, type, events[ type ][ i ], events[ type ][ i ].data );
     5324                                }
     5325                        }
     5326                }
     5327        }
     5328}
     5329
     5330function cloneFixAttributes(src, dest) {
     5331        // We do not need to do anything for non-Elements
     5332        if ( dest.nodeType !== 1 ) {
     5333                return;
     5334        }
     5335
     5336        var nodeName = dest.nodeName.toLowerCase();
     5337
     5338        // clearAttributes removes the attributes, which we don't want,
     5339        // but also removes the attachEvent events, which we *do* want
     5340        dest.clearAttributes();
     5341
     5342        // mergeAttributes, in contrast, only merges back on the
     5343        // original attributes, not the events
     5344        dest.mergeAttributes(src);
     5345
     5346        // IE6-8 fail to clone children inside object elements that use
     5347        // the proprietary classid attribute value (rather than the type
     5348        // attribute) to identify the type of content to display
     5349        if ( nodeName === "object" ) {
     5350                dest.outerHTML = src.outerHTML;
     5351
     5352        } else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
     5353                // IE6-8 fails to persist the checked state of a cloned checkbox
     5354                // or radio button. Worse, IE6-7 fail to give the cloned element
     5355                // a checked appearance if the defaultChecked value isn't also set
     5356                if ( src.checked ) {
     5357                        dest.defaultChecked = dest.checked = src.checked;
     5358                }
     5359
     5360                // IE6-7 get confused and end up setting the value of a cloned
     5361                // checkbox/radio button to an empty string instead of "on"
     5362                if ( dest.value !== src.value ) {
     5363                        dest.value = src.value;
     5364                }
     5365
     5366        // IE6-8 fails to return the selected option to the default selected
     5367        // state when cloning options
     5368        } else if ( nodeName === "option" ) {
     5369                dest.selected = src.defaultSelected;
     5370
     5371        // IE6-8 fails to set the defaultValue to the correct value when
     5372        // cloning other types of input fields
     5373        } else if ( nodeName === "input" || nodeName === "textarea" ) {
     5374                dest.defaultValue = src.defaultValue;
     5375        }
     5376
     5377        // Event data gets referenced instead of copied if the expando
     5378        // gets copied too
     5379        dest.removeAttribute( jQuery.expando );
    50185380}
    50195381
     
    50225384                doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
    50235385
    5024         // Only cache "small" (1/2 KB) strings that are associated with the main document
     5386        // Only cache "small" (1/2 KB) HTML strings that are associated with the main document
    50255387        // Cloning options loses the selected state, so don't cache them
    50265388        // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
    50275389        // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
    50285390        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] )) ) {
     5391                args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
    50305392
    50315393                cacheable = true;
     
    50635425                        insert = jQuery( selector ),
    50645426                        parent = this.length === 1 && this[0].parentNode;
    5065                
     5427
    50665428                if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
    50675429                        insert[ original ]( this[0] );
    50685430                        return this;
    5069                        
     5431
    50705432                } else {
    50715433                        for ( var i = 0, l = insert.length; i < l; i++ ) {
     
    50745436                                ret = ret.concat( elems );
    50755437                        }
    5076                
     5438
    50775439                        return this.pushStack( ret, name, insert.selector );
    50785440                }
     
    50815443
    50825444jQuery.extend({
     5445        clone: function( elem, dataAndEvents, deepDataAndEvents ) {
     5446                var clone = elem.cloneNode(true),
     5447                                srcElements,
     5448                                destElements,
     5449                                i;
     5450
     5451                if ( !jQuery.support.noCloneEvent && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
     5452                        // IE copies events bound via attachEvent when using cloneNode.
     5453                        // Calling detachEvent on the clone will also remove the events
     5454                        // from the original. In order to get around this, we use some
     5455                        // proprietary methods to clear the events. Thanks to MooTools
     5456                        // guys for this hotness.
     5457
     5458                        // Using Sizzle here is crazy slow, so we use getElementsByTagName
     5459                        // instead
     5460                        srcElements = elem.getElementsByTagName("*");
     5461                        destElements = clone.getElementsByTagName("*");
     5462
     5463                        // Weird iteration because IE will replace the length property
     5464                        // with an element if you are cloning the body and one of the
     5465                        // elements on the page has a name or id of "length"
     5466                        for ( i = 0; srcElements[i]; ++i ) {
     5467                                cloneFixAttributes( srcElements[i], destElements[i] );
     5468                        }
     5469
     5470                        cloneFixAttributes( elem, clone );
     5471                }
     5472
     5473                // Copy the events from the original to the clone
     5474                if ( dataAndEvents ) {
     5475
     5476                        cloneCopyEvent( elem, clone );
     5477
     5478                        if ( deepDataAndEvents && "getElementsByTagName" in elem ) {
     5479
     5480                                srcElements = elem.getElementsByTagName("*");
     5481                                destElements = clone.getElementsByTagName("*");
     5482
     5483                                if ( srcElements.length ) {
     5484                                        for ( i = 0; srcElements[i]; ++i ) {
     5485                                                cloneCopyEvent( srcElements[i], destElements[i] );
     5486                                        }
     5487                                }
     5488                        }
     5489                }
     5490                // Return the cloned set
     5491                return clone;
     5492  },
    50835493        clean: function( elems, context, fragment, scripts ) {
    50845494                context = context || document;
     
    51625572                                if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
    51635573                                        scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
    5164                                
     5574
    51655575                                } else {
    51665576                                        if ( ret[i].nodeType === 1 ) {
     
    51745584                return ret;
    51755585        },
    5176        
     5586
    51775587        cleanData: function( elems ) {
    5178                 var data, id, cache = jQuery.cache,
    5179                         special = jQuery.event.special,
     5588                var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
    51805589                        deleteExpando = jQuery.support.deleteExpando;
    5181                
     5590
    51825591                for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
    51835592                        if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
     
    51865595
    51875596                        id = elem[ jQuery.expando ];
    5188                        
     5597
    51895598                        if ( id ) {
    5190                                 data = cache[ id ];
    5191                                
     5599                                data = cache[ id ] && cache[ id ][ internalKey ];
     5600
    51925601                                if ( data && data.events ) {
    51935602                                        for ( var type in data.events ) {
     
    51955604                                                        jQuery.event.remove( elem, type );
    51965605
     5606                                                // This is a shortcut to avoid jQuery.event.remove's overhead
    51975607                                                } else {
    51985608                                                        jQuery.removeEvent( elem, type, data.handle );
    51995609                                                }
    52005610                                        }
    5201                                 }
    5202                                
     5611
     5612                                        // Null the DOM reference to avoid IE6/7/8 leak (#7054)
     5613                                        if ( data.handle ) {
     5614                                                data.handle.elem = null;
     5615                                        }
     5616                                }
     5617
    52035618                                if ( deleteExpando ) {
    52045619                                        delete elem[ jQuery.expando ];
     
    52075622                                        elem.removeAttribute( jQuery.expando );
    52085623                                }
    5209                                
     5624
    52105625                                delete cache[ id ];
    52115626                        }
     
    54965911if ( document.documentElement.currentStyle ) {
    54975912        currentStyle = function( elem, name ) {
    5498                 var left, rsLeft,
     5913                var left,
    54995914                        ret = elem.currentStyle && elem.currentStyle[ name ],
     5915                        rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
    55005916                        style = elem.style;
    55015917
     
    55085924                        // Remember the original values
    55095925                        left = style.left;
    5510                         rsLeft = elem.runtimeStyle.left;
    55115926
    55125927                        // Put in the new values to get a computed value out
    5513                         elem.runtimeStyle.left = elem.currentStyle.left;
     5928                        if ( rsLeft ) {
     5929                                elem.runtimeStyle.left = elem.currentStyle.left;
     5930                        }
    55145931                        style.left = name === "fontSize" ? "1em" : (ret || 0);
    55155932                        ret = style.pixelLeft + "px";
     
    55175934                        // Revert the changed values
    55185935                        style.left = left;
    5519                         elem.runtimeStyle.left = rsLeft;
     5936                        if ( rsLeft ) {
     5937                                elem.runtimeStyle.left = rsLeft;
     5938                        }
    55205939                }
    55215940
     
    55665985
    55675986
    5568 var jsc = jQuery.now(),
     5987var r20 = /%20/g,
     5988        rbracket = /\[\]$/,
     5989        rCRLF = /\r?\n/g,
     5990        rhash = /#.*$/,
     5991        rheaders = /^(.*?):\s*(.*?)\r?$/mg, // IE leaves an \r character at EOL
     5992        rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
     5993        rnoContent = /^(?:GET|HEAD)$/,
     5994        rprotocol = /^\/\//,
     5995        rquery = /\?/,
    55695996        rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
    55705997        rselectTextarea = /^(?:select|textarea)/i,
    5571         rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
    5572         rnoContent = /^(?:GET|HEAD)$/,
    5573         rbracket = /\[\]$/,
    5574         jsre = /\=\?(&|$)/,
    5575         rquery = /\?/,
     5998        rspacesAjax = /\s+/,
    55765999        rts = /([?&])_=[^&]*/,
    5577         rurl = /^(\w+:)?\/\/([^\/?#]+)/,
    5578         r20 = /%20/g,
    5579         rhash = /#.*$/,
     6000        rurl = /^(\w+:)\/\/([^\/?#:]+)(?::(\d+))?/,
    55806001
    55816002        // Keep a copy of the old load method
    5582         _load = jQuery.fn.load;
     6003        _load = jQuery.fn.load,
     6004
     6005        /* Prefilters
     6006         * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
     6007         * 2) These are called:
     6008         *    - BEFORE asking for a transport
     6009         *    - AFTER param serialization (s.data is a string if s.processData is true)
     6010         * 3) key is the dataType
     6011         * 4) the catchall symbol "*" can be used
     6012         * 5) execution will start with transport dataType and THEN continue down to "*" if needed
     6013         */
     6014        prefilters = {},
     6015
     6016        /* Transports bindings
     6017         * 1) key is the dataType
     6018         * 2) the catchall symbol "*" can be used
     6019         * 3) selection will start with transport dataType and THEN go to "*" if needed
     6020         */
     6021        transports = {};
     6022
     6023// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
     6024function addToPrefiltersOrTransports( structure ) {
     6025
     6026        // dataTypeExpression is optional and defaults to "*"
     6027        return function( dataTypeExpression, func ) {
     6028
     6029                if ( typeof dataTypeExpression !== "string" ) {
     6030                        func = dataTypeExpression;
     6031                        dataTypeExpression = "*";
     6032                }
     6033
     6034                if ( jQuery.isFunction( func ) ) {
     6035                        var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
     6036                                i = 0,
     6037                                length = dataTypes.length,
     6038                                dataType,
     6039                                list,
     6040                                placeBefore;
     6041
     6042                        // For each dataType in the dataTypeExpression
     6043                        for(; i < length; i++ ) {
     6044                                dataType = dataTypes[ i ];
     6045                                // We control if we're asked to add before
     6046                                // any existing element
     6047                                placeBefore = /^\+/.test( dataType );
     6048                                if ( placeBefore ) {
     6049                                        dataType = dataType.substr( 1 ) || "*";
     6050                                }
     6051                                list = structure[ dataType ] = structure[ dataType ] || [];
     6052                                // then we add to the structure accordingly
     6053                                list[ placeBefore ? "unshift" : "push" ]( func );
     6054                        }
     6055                }
     6056        };
     6057}
     6058
     6059//Base inspection function for prefilters and transports
     6060function inspectPrefiltersOrTransports( structure, options, originalOptions, jXHR,
     6061                dataType /* internal */, inspected /* internal */ ) {
     6062
     6063        dataType = dataType || options.dataTypes[ 0 ];
     6064        inspected = inspected || {};
     6065
     6066        inspected[ dataType ] = true;
     6067
     6068        var list = structure[ dataType ],
     6069                i = 0,
     6070                length = list ? list.length : 0,
     6071                executeOnly = ( structure === prefilters ),
     6072                selection;
     6073
     6074        for(; i < length && ( executeOnly || !selection ); i++ ) {
     6075                selection = list[ i ]( options, originalOptions, jXHR );
     6076                // If we got redirected to another dataType
     6077                // we try there if not done already
     6078                if ( typeof selection === "string" ) {
     6079                        if ( inspected[ selection ] ) {
     6080                                selection = undefined;
     6081                        } else {
     6082                                options.dataTypes.unshift( selection );
     6083                                selection = inspectPrefiltersOrTransports(
     6084                                                structure, options, originalOptions, jXHR, selection, inspected );
     6085                        }
     6086                }
     6087        }
     6088        // If we're only executing or nothing was selected
     6089        // we try the catchall dataType if not done already
     6090        if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
     6091                selection = inspectPrefiltersOrTransports(
     6092                                structure, options, originalOptions, jXHR, "*", inspected );
     6093        }
     6094        // unnecessary when only executing (prefilters)
     6095        // but it'll be ignored by the caller in that case
     6096        return selection;
     6097}
    55836098
    55846099jQuery.fn.extend({
     
    55926107                }
    55936108
    5594                 var off = url.indexOf(" ");
     6109                var off = url.indexOf( " " );
    55956110                if ( off >= 0 ) {
    5596                         var selector = url.slice(off, url.length);
    5597                         url = url.slice(0, off);
     6111                        var selector = url.slice( off, url.length );
     6112                        url = url.slice( 0, off );
    55986113                }
    55996114
     
    56246139                        dataType: "html",
    56256140                        data: params,
    5626                         complete: function( res, status ) {
     6141                        // Complete callback (responseText is used internally)
     6142                        complete: function( jXHR, status, responseText ) {
     6143                                // Store the response as specified by the jXHR object
     6144                                responseText = jXHR.responseText;
    56276145                                // If successful, inject the HTML into all the matched elements
    5628                                 if ( status === "success" || status === "notmodified" ) {
     6146                                if ( jXHR.isResolved() ) {
     6147                                        // #4825: Get the actual response in case
     6148                                        // a dataFilter is present in ajaxSettings
     6149                                        jXHR.done(function( r ) {
     6150                                                responseText = r;
     6151                                        });
    56296152                                        // See if a selector was specified
    56306153                                        self.html( selector ?
     
    56336156                                                        // inject the contents of the document in, removing the scripts
    56346157                                                        // to avoid any 'Permission Denied' errors in IE
    5635                                                         .append(res.responseText.replace(rscript, ""))
     6158                                                        .append(responseText.replace(rscript, ""))
    56366159
    56376160                                                        // Locate the specified elements
     
    56396162
    56406163                                                // If not, just inject the full result
    5641                                                 res.responseText );
     6164                                                responseText );
    56426165                                }
    56436166
    56446167                                if ( callback ) {
    5645                                         self.each( callback, [res.responseText, status, res] );
     6168                                        self.each( callback, [ responseText, status, jXHR ] );
    56466169                                }
    56476170                        }
     
    56526175
    56536176        serialize: function() {
    5654                 return jQuery.param(this.serializeArray());
     6177                return jQuery.param( this.serializeArray() );
    56556178        },
    56566179
    56576180        serializeArray: function() {
    5658                 return this.map(function() {
    5659                         return this.elements ? jQuery.makeArray(this.elements) : this;
     6181                return this.map(function(){
     6182                        return this.elements ? jQuery.makeArray( this.elements ) : this;
    56606183                })
    5661                 .filter(function() {
     6184                .filter(function(){
    56626185                        return this.name && !this.disabled &&
    5663                                 (this.checked || rselectTextarea.test(this.nodeName) ||
    5664                                         rinput.test(this.type));
     6186                                ( this.checked || rselectTextarea.test( this.nodeName ) ||
     6187                                        rinput.test( this.type ) );
    56656188                })
    5666                 .map(function( i, elem ) {
    5667                         var val = jQuery(this).val();
     6189                .map(function( i, elem ){
     6190                        var val = jQuery( this ).val();
    56686191
    56696192                        return val == null ?
    56706193                                null :
    5671                                 jQuery.isArray(val) ?
    5672                                         jQuery.map( val, function( val, i ) {
    5673                                                 return { name: elem.name, value: val };
     6194                                jQuery.isArray( val ) ?
     6195                                        jQuery.map( val, function( val, i ){
     6196                                                return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
    56746197                                        }) :
    5675                                         { name: elem.name, value: val };
     6198                                        { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
    56766199                }).get();
    56776200        }
     
    56796202
    56806203// Attach a bunch of functions for handling common AJAX events
    5681 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
    5682         jQuery.fn[o] = function( f ) {
    5683                 return this.bind(o, f);
     6204jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
     6205        jQuery.fn[ o ] = function( f ){
     6206                return this.bind( o, f );
    56846207        };
    5685 });
    5686 
    5687 jQuery.extend({
    5688         get: function( url, data, callback, type ) {
    5689                 // shift arguments if data argument was omited
     6208} );
     6209
     6210jQuery.each( [ "get", "post" ], function( i, method ) {
     6211        jQuery[ method ] = function( url, data, callback, type ) {
     6212                // shift arguments if data argument was omitted
    56906213                if ( jQuery.isFunction( data ) ) {
    56916214                        type = type || callback;
     
    56956218
    56966219                return jQuery.ajax({
    5697                         type: "GET",
     6220                        type: method,
    56986221                        url: url,
    56996222                        data: data,
     
    57016224                        dataType: type
    57026225                });
    5703         },
     6226        };
     6227} );
     6228
     6229jQuery.extend({
    57046230
    57056231        getScript: function( url, callback ) {
    5706                 return jQuery.get(url, null, callback, "script");
     6232                return jQuery.get( url, null, callback, "script" );
    57076233        },
    57086234
    57096235        getJSON: function( url, data, callback ) {
    5710                 return jQuery.get(url, data, callback, "json");
    5711         },
    5712 
    5713         post: function( url, data, callback, type ) {
    5714                 // shift arguments if data argument was omited
    5715                 if ( jQuery.isFunction( data ) ) {
    5716                         type = type || callback;
    5717                         callback = data;
    5718                         data = {};
    5719                 }
    5720 
    5721                 return jQuery.ajax({
    5722                         type: "POST",
    5723                         url: url,
    5724                         data: data,
    5725                         success: callback,
    5726                         dataType: type
    5727                 });
     6236                return jQuery.get( url, data, callback, "json" );
    57286237        },
    57296238
    57306239        ajaxSetup: function( settings ) {
    5731                 jQuery.extend( jQuery.ajaxSettings, settings );
     6240                jQuery.extend( true, jQuery.ajaxSettings, settings );
     6241                if ( settings.context ) {
     6242                        jQuery.ajaxSettings.context = settings.context;
     6243                }
    57326244        },
    57336245
     
    57426254                timeout: 0,
    57436255                data: null,
     6256                dataType: null,
    57446257                username: null,
    57456258                password: null,
     6259                cache: null,
    57466260                traditional: false,
     6261                headers: {},
     6262                crossDomain: null,
    57476263                */
    5748                 // This function can be overriden by calling jQuery.ajaxSetup
    5749                 xhr: function() {
    5750                         return new window.XMLHttpRequest();
    5751                 },
     6264
    57526265                accepts: {
    57536266                        xml: "application/xml, text/xml",
    57546267                        html: "text/html",
    5755                         script: "text/javascript, application/javascript",
     6268                        text: "text/plain",
    57566269                        json: "application/json, text/javascript",
    5757                         text: "text/plain",
    5758                         _default: "*/*"
    5759                 }
    5760         },
    5761 
    5762         ajax: function( origSettings ) {
    5763                 var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings),
    5764                         jsonp, status, data, type = s.type.toUpperCase(), noContent = rnoContent.test(type);
    5765 
    5766                 s.url = s.url.replace( rhash, "" );
    5767 
    5768                 // Use original (not extended) context object if it was provided
    5769                 s.context = origSettings && origSettings.context != null ? origSettings.context : s;
    5770 
    5771                 // convert data if not already a string
     6270                        "*": "*/*"
     6271                },
     6272
     6273                contents: {
     6274                        xml: /xml/,
     6275                        html: /html/,
     6276                        json: /json/
     6277                },
     6278
     6279                responseFields: {
     6280                        xml: "responseXML",
     6281                        text: "responseText"
     6282                },
     6283
     6284                // List of data converters
     6285                // 1) key format is "source_type destination_type" (a single space in-between)
     6286                // 2) the catchall symbol "*" can be used for source_type
     6287                converters: {
     6288
     6289                        // Convert anything to text
     6290                        "* text": window.String,
     6291
     6292                        // Text to html (true = no transformation)
     6293                        "text html": true,
     6294
     6295                        // Evaluate text as a json expression
     6296                        "text json": jQuery.parseJSON,
     6297
     6298                        // Parse text as xml
     6299                        "text xml": jQuery.parseXML
     6300                }
     6301        },
     6302
     6303        ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
     6304        ajaxTransport: addToPrefiltersOrTransports( transports ),
     6305
     6306        // Main method
     6307        ajax: function( url, options ) {
     6308
     6309                // If options is not an object,
     6310                // we simulate pre-1.5 signature
     6311                if ( typeof options !== "object" ) {
     6312                        options = url;
     6313                        url = undefined;
     6314                }
     6315
     6316                // Force options to be an object
     6317                options = options || {};
     6318
     6319                var // Create the final options object
     6320                        s = jQuery.extend( true, {}, jQuery.ajaxSettings, options ),
     6321                        // Callbacks contexts
     6322                        // We force the original context if it exists
     6323                        // or take it from jQuery.ajaxSettings otherwise
     6324                        // (plain objects used as context get extended)
     6325                        callbackContext =
     6326                                ( s.context = ( "context" in options ? options : jQuery.ajaxSettings ).context ) || s,
     6327                        globalEventContext = callbackContext === s ? jQuery.event : jQuery( callbackContext ),
     6328                        // Deferreds
     6329                        deferred = jQuery.Deferred(),
     6330                        completeDeferred = jQuery._Deferred(),
     6331                        // Status-dependent callbacks
     6332                        statusCode = s.statusCode || {},
     6333                        // Headers (they are sent all at once)
     6334                        requestHeaders = {},
     6335                        // Response headers
     6336                        responseHeadersString,
     6337                        responseHeaders,
     6338                        // transport
     6339                        transport,
     6340                        // timeout handle
     6341                        timeoutTimer,
     6342                        // Cross-domain detection vars
     6343                        loc = document.location,
     6344                        protocol = loc.protocol || "http:",
     6345                        parts,
     6346                        // The jXHR state
     6347                        state = 0,
     6348                        // Loop variable
     6349                        i,
     6350                        // Fake xhr
     6351                        jXHR = {
     6352
     6353                                readyState: 0,
     6354
     6355                                // Caches the header
     6356                                setRequestHeader: function( name, value ) {
     6357                                        if ( state === 0 ) {
     6358                                                requestHeaders[ name.toLowerCase() ] = value;
     6359                                        }
     6360                                        return this;
     6361                                },
     6362
     6363                                // Raw string
     6364                                getAllResponseHeaders: function() {
     6365                                        return state === 2 ? responseHeadersString : null;
     6366                                },
     6367
     6368                                // Builds headers hashtable if needed
     6369                                getResponseHeader: function( key ) {
     6370                                        var match;
     6371                                        if ( state === 2 ) {
     6372                                                if ( !responseHeaders ) {
     6373                                                        responseHeaders = {};
     6374                                                        while( ( match = rheaders.exec( responseHeadersString ) ) ) {
     6375                                                                responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
     6376                                                        }
     6377                                                }
     6378                                                match = responseHeaders[ key.toLowerCase() ];
     6379                                        }
     6380                                        return match || null;
     6381                                },
     6382
     6383                                // Cancel the request
     6384                                abort: function( statusText ) {
     6385                                        statusText = statusText || "abort";
     6386                                        if ( transport ) {
     6387                                                transport.abort( statusText );
     6388                                        }
     6389                                        done( 0, statusText );
     6390                                        return this;
     6391                                }
     6392                        };
     6393
     6394                // Callback for when everything is done
     6395                // It is defined here because jslint complains if it is declared
     6396                // at the end of the function (which would be more logical and readable)
     6397                function done( status, statusText, responses, headers) {
     6398
     6399                        // Called once
     6400                        if ( state === 2 ) {
     6401                                return;
     6402                        }
     6403
     6404                        // State is "done" now
     6405                        state = 2;
     6406
     6407                        // Clear timeout if it exists
     6408                        if ( timeoutTimer ) {
     6409                                clearTimeout( timeoutTimer );
     6410                        }
     6411
     6412                        // Dereference transport for early garbage collection
     6413                        // (no matter how long the jXHR object will be used)
     6414                        transport = undefined;
     6415
     6416                        // Cache response headers
     6417                        responseHeadersString = headers || "";
     6418
     6419                        // Set readyState
     6420                        jXHR.readyState = status ? 4 : 0;
     6421
     6422                        var isSuccess,
     6423                                success,
     6424                                error,
     6425                                response = responses ? ajaxHandleResponses( s, jXHR, responses ) : undefined,
     6426                                lastModified,
     6427                                etag;
     6428
     6429                        // If successful, handle type chaining
     6430                        if ( status >= 200 && status < 300 || status === 304 ) {
     6431
     6432                                // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
     6433                                if ( s.ifModified ) {
     6434
     6435                                        if ( ( lastModified = jXHR.getResponseHeader( "Last-Modified" ) ) ) {
     6436                                                jQuery.lastModified[ s.url ] = lastModified;
     6437                                        }
     6438                                        if ( ( etag = jXHR.getResponseHeader( "Etag" ) ) ) {
     6439                                                jQuery.etag[ s.url ] = etag;
     6440                                        }
     6441                                }
     6442
     6443                                // If not modified
     6444                                if ( status === 304 ) {
     6445
     6446                                        statusText = "notmodified";
     6447                                        isSuccess = true;
     6448
     6449                                // If we have data
     6450                                } else {
     6451
     6452                                        try {
     6453                                                success = ajaxConvert( s, response );
     6454                                                statusText = "success";
     6455                                                isSuccess = true;
     6456                                        } catch(e) {
     6457                                                // We have a parsererror
     6458                                                statusText = "parsererror";
     6459                                                error = e;
     6460                                        }
     6461                                }
     6462                        } else {
     6463                                // We extract error from statusText
     6464                                // then normalize statusText and status for non-aborts
     6465                                error = statusText;
     6466                                if( status ) {
     6467                                        statusText = "error";
     6468                                        if ( status < 0 ) {
     6469                                                status = 0;
     6470                                        }
     6471                                }
     6472                        }
     6473
     6474                        // Set data for the fake xhr object
     6475                        jXHR.status = status;
     6476                        jXHR.statusText = statusText;
     6477
     6478                        // Success/Error
     6479                        if ( isSuccess ) {
     6480                                deferred.resolveWith( callbackContext, [ success, statusText, jXHR ] );
     6481                        } else {
     6482                                deferred.rejectWith( callbackContext, [ jXHR, statusText, error ] );
     6483                        }
     6484
     6485                        // Status-dependent callbacks
     6486                        jXHR.statusCode( statusCode );
     6487                        statusCode = undefined;
     6488
     6489                        if ( s.global ) {
     6490                                globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
     6491                                                [ jXHR, s, isSuccess ? success : error ] );
     6492                        }
     6493
     6494                        // Complete
     6495                        completeDeferred.resolveWith( callbackContext, [ jXHR, statusText ] );
     6496
     6497                        if ( s.global ) {
     6498                                globalEventContext.trigger( "ajaxComplete", [ jXHR, s] );
     6499                                // Handle the global AJAX counter
     6500                                if ( !( --jQuery.active ) ) {
     6501                                        jQuery.event.trigger( "ajaxStop" );
     6502                                }
     6503                        }
     6504                }
     6505
     6506                // Attach deferreds
     6507                deferred.promise( jXHR );
     6508                jXHR.success = jXHR.done;
     6509                jXHR.error = jXHR.fail;
     6510                jXHR.complete = completeDeferred.done;
     6511
     6512                // Status-dependent callbacks
     6513                jXHR.statusCode = function( map ) {
     6514                        if ( map ) {
     6515                                var tmp;
     6516                                if ( state < 2 ) {
     6517                                        for( tmp in map ) {
     6518                                                statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
     6519                                        }
     6520                                } else {
     6521                                        tmp = map[ jXHR.status ];
     6522                                        jXHR.then( tmp, tmp );
     6523                                }
     6524                        }
     6525                        return this;
     6526                };
     6527
     6528                // Remove hash character (#7531: and string promotion)
     6529                // Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
     6530                // We also use the url parameter if available
     6531                s.url = ( "" + ( url || s.url ) ).replace( rhash, "" ).replace( rprotocol, protocol + "//" );
     6532
     6533                // Extract dataTypes list
     6534                s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
     6535
     6536                // Determine if a cross-domain request is in order
     6537                if ( !s.crossDomain ) {
     6538                        parts = rurl.exec( s.url.toLowerCase() );
     6539                        s.crossDomain = !!( parts &&
     6540                                ( parts[ 1 ] != protocol || parts[ 2 ] != loc.hostname ||
     6541                                        ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
     6542                                                ( loc.port || ( protocol === "http:" ? 80 : 443 ) ) )
     6543                        );
     6544                }
     6545
     6546                // Convert data if not already a string
    57726547                if ( s.data && s.processData && typeof s.data !== "string" ) {
    57736548                        s.data = jQuery.param( s.data, s.traditional );
    57746549                }
    57756550
    5776                 // Handle JSONP Parameter Callbacks
    5777                 if ( s.dataType === "jsonp" ) {
    5778                         if ( type === "GET" ) {
    5779                                 if ( !jsre.test( s.url ) ) {
    5780                                         s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
    5781                                 }
    5782                         } else if ( !s.data || !jsre.test(s.data) ) {
    5783                                 s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
    5784                         }
    5785                         s.dataType = "json";
    5786                 }
    5787 
    5788                 // Build temporary JSONP function
    5789                 if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
    5790                         jsonp = s.jsonpCallback || ("jsonp" + jsc++);
    5791 
    5792                         // Replace the =? sequence both in the query string and the data
    5793                         if ( s.data ) {
    5794                                 s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
    5795                         }
    5796 
    5797                         s.url = s.url.replace(jsre, "=" + jsonp + "$1");
    5798 
    5799                         // We need to make sure
    5800                         // that a JSONP style response is executed properly
    5801                         s.dataType = "script";
    5802 
    5803                         // Handle JSONP-style loading
    5804                         var customJsonp = window[ jsonp ];
    5805 
    5806                         window[ jsonp ] = function( tmp ) {
    5807                                 if ( jQuery.isFunction( customJsonp ) ) {
    5808                                         customJsonp( tmp );
    5809 
    5810                                 } else {
    5811                                         // Garbage collect
    5812                                         window[ jsonp ] = undefined;
    5813 
    5814                                         try {
    5815                                                 delete window[ jsonp ];
    5816                                         } catch( jsonpError ) {}
    5817                                 }
    5818 
    5819                                 data = tmp;
    5820                                 jQuery.handleSuccess( s, xhr, status, data );
    5821                                 jQuery.handleComplete( s, xhr, status, data );
    5822                                
    5823                                 if ( head ) {
    5824                                         head.removeChild( script );
    5825                                 }
    5826                         };
    5827                 }
    5828 
    5829                 if ( s.dataType === "script" && s.cache === null ) {
    5830                         s.cache = false;
    5831                 }
    5832 
    5833                 if ( s.cache === false && noContent ) {
    5834                         var ts = jQuery.now();
    5835 
    5836                         // try replacing _= if it is there
    5837                         var ret = s.url.replace(rts, "$1_=" + ts);
    5838 
    5839                         // if nothing was replaced, add timestamp to the end
    5840                         s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
    5841                 }
    5842 
    5843                 // If data is available, append data to url for GET/HEAD requests
    5844                 if ( s.data && noContent ) {
    5845                         s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
    5846                 }
     6551                // Apply prefilters
     6552                inspectPrefiltersOrTransports( prefilters, s, options, jXHR );
     6553
     6554                // Uppercase the type
     6555                s.type = s.type.toUpperCase();
     6556
     6557                // Determine if request has content
     6558                s.hasContent = !rnoContent.test( s.type );
    58476559
    58486560                // Watch for a new set of requests
     
    58516563                }
    58526564
    5853                 // Matches an absolute URL, and saves the domain
    5854                 var parts = rurl.exec( s.url ),
    5855                         remote = parts && (parts[1] && parts[1].toLowerCase() !== location.protocol || parts[2].toLowerCase() !== location.host);
    5856 
    5857                 // If we're requesting a remote document
    5858                 // and trying to load JSON or Script with a GET
    5859                 if ( s.dataType === "script" && type === "GET" && remote ) {
    5860                         var head = document.getElementsByTagName("head")[0] || document.documentElement;
    5861                         var script = document.createElement("script");
    5862                         if ( s.scriptCharset ) {
    5863                                 script.charset = s.scriptCharset;
    5864                         }
    5865                         script.src = s.url;
    5866 
    5867                         // Handle Script loading
    5868                         if ( !jsonp ) {
    5869                                 var done = false;
    5870 
    5871                                 // Attach handlers for all browsers
    5872                                 script.onload = script.onreadystatechange = function() {
    5873                                         if ( !done && (!this.readyState ||
    5874                                                         this.readyState === "loaded" || this.readyState === "complete") ) {
    5875                                                 done = true;
    5876                                                 jQuery.handleSuccess( s, xhr, status, data );
    5877                                                 jQuery.handleComplete( s, xhr, status, data );
    5878 
    5879                                                 // Handle memory leak in IE
    5880                                                 script.onload = script.onreadystatechange = null;
    5881                                                 if ( head && script.parentNode ) {
    5882                                                         head.removeChild( script );
    5883                                                 }
    5884                                         }
    5885                                 };
    5886                         }
    5887 
    5888                         // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
    5889                         // This arises when a base node is used (#2709 and #4378).
    5890                         head.insertBefore( script, head.firstChild );
    5891 
    5892                         // We handle everything using the script element injection
    5893                         return undefined;
    5894                 }
    5895 
    5896                 var requestDone = false;
    5897 
    5898                 // Create the request object
    5899                 var xhr = s.xhr();
    5900 
    5901                 if ( !xhr ) {
    5902                         return;
    5903                 }
    5904 
    5905                 // Open the socket
    5906                 // Passing null username, generates a login popup on Opera (#2865)
    5907                 if ( s.username ) {
    5908                         xhr.open(type, s.url, s.async, s.username, s.password);
     6565                // More options handling for requests with no content
     6566                if ( !s.hasContent ) {
     6567
     6568                        // If data is available, append data to url
     6569                        if ( s.data ) {
     6570                                s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
     6571                        }
     6572
     6573                        // Add anti-cache in url if needed
     6574                        if ( s.cache === false ) {
     6575
     6576                                var ts = jQuery.now(),
     6577                                        // try replacing _= if it is there
     6578                                        ret = s.url.replace( rts, "$1_=" + ts );
     6579
     6580                                // if nothing was replaced, add timestamp to the end
     6581                                s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
     6582                        }
     6583                }
     6584
     6585                // Set the correct header, if data is being sent
     6586                if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
     6587                        requestHeaders[ "content-type" ] = s.contentType;
     6588                }
     6589
     6590                // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
     6591                if ( s.ifModified ) {
     6592                        if ( jQuery.lastModified[ s.url ] ) {
     6593                                requestHeaders[ "if-modified-since" ] = jQuery.lastModified[ s.url ];
     6594                        }
     6595                        if ( jQuery.etag[ s.url ] ) {
     6596                                requestHeaders[ "if-none-match" ] = jQuery.etag[ s.url ];
     6597                        }
     6598                }
     6599
     6600                // Set the Accepts header for the server, depending on the dataType
     6601                requestHeaders.accept = s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
     6602                        s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
     6603                        s.accepts[ "*" ];
     6604
     6605                // Check for headers option
     6606                for ( i in s.headers ) {
     6607                        requestHeaders[ i.toLowerCase() ] = s.headers[ i ];
     6608                }
     6609
     6610                // Allow custom headers/mimetypes and early abort
     6611                if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jXHR, s ) === false || state === 2 ) ) {
     6612                                // Abort if not done already
     6613                                done( 0, "abort" );
     6614                                // Return false
     6615                                jXHR = false;
     6616
    59096617                } else {
    5910                         xhr.open(type, s.url, s.async);
    5911                 }
    5912 
    5913                 // Need an extra try/catch for cross domain requests in Firefox 3
    5914                 try {
    5915                         // Set content-type if data specified and content-body is valid for this type
    5916                         if ( (s.data != null && !noContent) || (origSettings && origSettings.contentType) ) {
    5917                                 xhr.setRequestHeader("Content-Type", s.contentType);
    5918                         }
    5919 
    5920                         // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
    5921                         if ( s.ifModified ) {
    5922                                 if ( jQuery.lastModified[s.url] ) {
    5923                                         xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);
    5924                                 }
    5925 
    5926                                 if ( jQuery.etag[s.url] ) {
    5927                                         xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);
    5928                                 }
    5929                         }
    5930 
    5931                         // Set header so the called script knows that it's an XMLHttpRequest
    5932                         // Only send the header if it's not a remote XHR
    5933                         if ( !remote ) {
    5934                                 xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
    5935                         }
    5936 
    5937                         // Set the Accepts header for the server, depending on the dataType
    5938                         xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
    5939                                 s.accepts[ s.dataType ] + ", */*; q=0.01" :
    5940                                 s.accepts._default );
    5941                 } catch( headerError ) {}
    5942 
    5943                 // Allow custom headers/mimetypes and early abort
    5944                 if ( s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false ) {
    5945                         // Handle the global AJAX counter
    5946                         if ( s.global && jQuery.active-- === 1 ) {
    5947                                 jQuery.event.trigger( "ajaxStop" );
    5948                         }
    5949 
    5950                         // close opended socket
    5951                         xhr.abort();
    5952                         return false;
    5953                 }
    5954 
    5955                 if ( s.global ) {
    5956                         jQuery.triggerGlobal( s, "ajaxSend", [xhr, s] );
    5957                 }
    5958 
    5959                 // Wait for a response to come back
    5960                 var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) {
    5961                         // The request was aborted
    5962                         if ( !xhr || xhr.readyState === 0 || isTimeout === "abort" ) {
    5963                                 // Opera doesn't call onreadystatechange before this point
    5964                                 // so we simulate the call
    5965                                 if ( !requestDone ) {
    5966                                         jQuery.handleComplete( s, xhr, status, data );
    5967                                 }
    5968 
    5969                                 requestDone = true;
    5970                                 if ( xhr ) {
    5971                                         xhr.onreadystatechange = jQuery.noop;
    5972                                 }
    5973 
    5974                         // The transfer is complete and the data is available, or the request timed out
    5975                         } else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) {
    5976                                 requestDone = true;
    5977                                 xhr.onreadystatechange = jQuery.noop;
    5978 
    5979                                 status = isTimeout === "timeout" ?
    5980                                         "timeout" :
    5981                                         !jQuery.httpSuccess( xhr ) ?
    5982                                                 "error" :
    5983                                                 s.ifModified && jQuery.httpNotModified( xhr, s.url ) ?
    5984                                                         "notmodified" :
    5985                                                         "success";
    5986 
    5987                                 var errMsg;
    5988 
    5989                                 if ( status === "success" ) {
    5990                                         // Watch for, and catch, XML document parse errors
    5991                                         try {
    5992                                                 // process the data (runs the xml through httpData regardless of callback)
    5993                                                 data = jQuery.httpData( xhr, s.dataType, s );
    5994                                         } catch( parserError ) {
    5995                                                 status = "parsererror";
    5996                                                 errMsg = parserError;
    5997                                         }
    5998                                 }
    5999 
    6000                                 // Make sure that the request was successful or notmodified
    6001                                 if ( status === "success" || status === "notmodified" ) {
    6002                                         // JSONP handles its own success callback
    6003                                         if ( !jsonp ) {
    6004                                                 jQuery.handleSuccess( s, xhr, status, data );
    6005                                         }
    6006                                 } else {
    6007                                         jQuery.handleError( s, xhr, status, errMsg );
    6008                                 }
    6009 
    6010                                 // Fire the complete handlers
    6011                                 if ( !jsonp ) {
    6012                                         jQuery.handleComplete( s, xhr, status, data );
    6013                                 }
    6014 
    6015                                 if ( isTimeout === "timeout" ) {
    6016                                         xhr.abort();
    6017                                 }
    6018 
    6019                                 // Stop memory leaks
    6020                                 if ( s.async ) {
    6021                                         xhr = null;
    6022                                 }
    6023                         }
    6024                 };
    6025 
    6026                 // Override the abort handler, if we can (IE 6 doesn't allow it, but that's OK)
    6027                 // Opera doesn't fire onreadystatechange at all on abort
    6028                 try {
    6029                         var oldAbort = xhr.abort;
    6030                         xhr.abort = function() {
    6031                                 if ( xhr ) {
    6032                                         // oldAbort has no call property in IE7 so
    6033                                         // just do it this way, which works in all
    6034                                         // browsers
    6035                                         Function.prototype.call.call( oldAbort, xhr );
    6036                                 }
    6037 
    6038                                 onreadystatechange( "abort" );
    6039                         };
    6040                 } catch( abortError ) {}
    6041 
    6042                 // Timeout checker
    6043                 if ( s.async && s.timeout > 0 ) {
    6044                         setTimeout(function() {
    6045                                 // Check to see if the request is still happening
    6046                                 if ( xhr && !requestDone ) {
    6047                                         onreadystatechange( "timeout" );
    6048                                 }
    6049                         }, s.timeout);
    6050                 }
    6051 
    6052                 // Send the data
    6053                 try {
    6054                         xhr.send( noContent || s.data == null ? null : s.data );
    6055 
    6056                 } catch( sendError ) {
    6057                         jQuery.handleError( s, xhr, null, sendError );
    6058 
    6059                         // Fire the complete handlers
    6060                         jQuery.handleComplete( s, xhr, status, data );
    6061                 }
    6062 
    6063                 // firefox 1.5 doesn't fire statechange for sync requests
    6064                 if ( !s.async ) {
    6065                         onreadystatechange();
    6066                 }
    6067 
    6068                 // return XMLHttpRequest to allow aborting the request etc.
    6069                 return xhr;
     6618
     6619                        // Install callbacks on deferreds
     6620                        for ( i in { success: 1, error: 1, complete: 1 } ) {
     6621                                jXHR[ i ]( s[ i ] );
     6622                        }
     6623
     6624                        // Get transport
     6625                        transport = inspectPrefiltersOrTransports( transports, s, options, jXHR );
     6626
     6627                        // If no transport, we auto-abort
     6628                        if ( !transport ) {
     6629                                done( -1, "No Transport" );
     6630                        } else {
     6631                                // Set state as sending
     6632                                state = jXHR.readyState = 1;
     6633                                // Send global event
     6634                                if ( s.global ) {
     6635                                        globalEventContext.trigger( "ajaxSend", [ jXHR, s ] );
     6636                                }
     6637                                // Timeout
     6638                                if ( s.async && s.timeout > 0 ) {
     6639                                        timeoutTimer = setTimeout( function(){
     6640                                                jXHR.abort( "timeout" );
     6641                                        }, s.timeout );
     6642                                }
     6643
     6644                                try {
     6645                                        transport.send( requestHeaders, done );
     6646                                } catch (e) {
     6647                                        // Propagate exception as error if not done
     6648                                        if ( status < 2 ) {
     6649                                                done( -1, e );
     6650                                        // Simply rethrow otherwise
     6651                                        } else {
     6652                                                jQuery.error( e );
     6653                                        }
     6654                                }
     6655                        }
     6656                }
     6657                return jXHR;
    60706658        },
    60716659
     
    60766664                        add = function( key, value ) {
    60776665                                // If value is a function, invoke it and return its value
    6078                                 value = jQuery.isFunction(value) ? value() : value;
    6079                                 s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
     6666                                value = jQuery.isFunction( value ) ? value() : value;
     6667                                s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
    60806668                        };
    6081                
     6669
    60826670                // Set traditional to true for jQuery <= 1.3.2 behavior.
    60836671                if ( traditional === undefined ) {
    60846672                        traditional = jQuery.ajaxSettings.traditional;
    60856673                }
    6086                
     6674
    60876675                // If an array was passed in, assume that it is an array of form elements.
    6088                 if ( jQuery.isArray(a) || a.jquery ) {
     6676                if ( jQuery.isArray( a ) || a.jquery ) {
    60896677                        // Serialize the form elements
    60906678                        jQuery.each( a, function() {
    60916679                                add( this.name, this.value );
    6092                         });
    6093                        
     6680                        } );
     6681
    60946682                } else {
    60956683                        // If traditional, encode the "old" way (the way 1.3.2 or older
    60966684                        // did it), otherwise encode params recursively.
    60976685                        for ( var prefix in a ) {
    6098                                 buildParams( prefix, a[prefix], traditional, add );
     6686                                buildParams( prefix, a[ prefix ], traditional, add );
    60996687                        }
    61006688                }
    61016689
    61026690                // Return the resulting serialization
    6103                 return s.join("&").replace(r20, "+");
     6691                return s.join( "&" ).replace( r20, "+" );
    61046692        }
    61056693});
    61066694
    61076695function buildParams( prefix, obj, traditional, add ) {
    6108         if ( jQuery.isArray(obj) && obj.length ) {
     6696        if ( jQuery.isArray( obj ) && obj.length ) {
    61096697                // Serialize array item.
    61106698                jQuery.each( obj, function( i, v ) {
     
    61246712                        }
    61256713                });
    6126                        
     6714
    61276715        } else if ( !traditional && obj != null && typeof obj === "object" ) {
    6128                 if ( jQuery.isEmptyObject( obj ) ) {
     6716                // If we see an array here, it is empty and should be treated as an empty
     6717                // object
     6718                if ( jQuery.isArray( obj ) || jQuery.isEmptyObject( obj ) ) {
    61296719                        add( prefix, "" );
    61306720
     
    61356725                        });
    61366726                }
    6137                                        
     6727
    61386728        } else {
    61396729                // Serialize scalar item.
     
    61516741        // Last-Modified header cache for next request
    61526742        lastModified: {},
    6153         etag: {},
    6154 
    6155         handleError: function( s, xhr, status, e ) {
    6156                 // If a local callback was specified, fire it
    6157                 if ( s.error ) {
    6158                         s.error.call( s.context, xhr, status, e );
    6159                 }
    6160 
    6161                 // Fire the global callback
    6162                 if ( s.global ) {
    6163                         jQuery.triggerGlobal( s, "ajaxError", [xhr, s, e] );
    6164                 }
    6165         },
    6166 
    6167         handleSuccess: function( s, xhr, status, data ) {
    6168                 // If a local callback was specified, fire it and pass it the data
    6169                 if ( s.success ) {
    6170                         s.success.call( s.context, data, status, xhr );
    6171                 }
    6172 
    6173                 // Fire the global callback
    6174                 if ( s.global ) {
    6175                         jQuery.triggerGlobal( s, "ajaxSuccess", [xhr, s] );
    6176                 }
    6177         },
    6178 
    6179         handleComplete: function( s, xhr, status ) {
    6180                 // Process result
    6181                 if ( s.complete ) {
    6182                         s.complete.call( s.context, xhr, status );
    6183                 }
    6184 
    6185                 // The request was completed
    6186                 if ( s.global ) {
    6187                         jQuery.triggerGlobal( s, "ajaxComplete", [xhr, s] );
    6188                 }
    6189 
    6190                 // Handle the global AJAX counter
    6191                 if ( s.global && jQuery.active-- === 1 ) {
    6192                         jQuery.event.trigger( "ajaxStop" );
    6193                 }
    6194         },
    6195                
    6196         triggerGlobal: function( s, type, args ) {
    6197                 (s.context && s.context.url == null ? jQuery(s.context) : jQuery.event).trigger(type, args);
    6198         },
    6199 
    6200         // Determines if an XMLHttpRequest was successful or not
    6201         httpSuccess: function( xhr ) {
    6202                 try {
    6203                         // IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
    6204                         return !xhr.status && location.protocol === "file:" ||
    6205                                 xhr.status >= 200 && xhr.status < 300 ||
    6206                                 xhr.status === 304 || xhr.status === 1223;
    6207                 } catch(e) {}
    6208 
    6209                 return false;
    6210         },
    6211 
    6212         // Determines if an XMLHttpRequest returns NotModified
    6213         httpNotModified: function( xhr, url ) {
    6214                 var lastModified = xhr.getResponseHeader("Last-Modified"),
    6215                         etag = xhr.getResponseHeader("Etag");
    6216 
    6217                 if ( lastModified ) {
    6218                         jQuery.lastModified[url] = lastModified;
    6219                 }
    6220 
    6221                 if ( etag ) {
    6222                         jQuery.etag[url] = etag;
    6223                 }
    6224 
    6225                 return xhr.status === 304;
    6226         },
    6227 
    6228         httpData: function( xhr, type, s ) {
    6229                 var ct = xhr.getResponseHeader("content-type") || "",
    6230                         xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
    6231                         data = xml ? xhr.responseXML : xhr.responseText;
    6232 
    6233                 if ( xml && data.documentElement.nodeName === "parsererror" ) {
    6234                         jQuery.error( "parsererror" );
    6235                 }
    6236 
    6237                 // Allow a pre-filtering function to sanitize the response
    6238                 // s is checked to keep backwards compatibility
    6239                 if ( s && s.dataFilter ) {
    6240                         data = s.dataFilter( data, type );
    6241                 }
    6242 
    6243                 // The filter can actually parse the response
    6244                 if ( typeof data === "string" ) {
    6245                         // Get the JavaScript object, if JSON is used.
    6246                         if ( type === "json" || !type && ct.indexOf("json") >= 0 ) {
    6247                                 data = jQuery.parseJSON( data );
    6248 
    6249                         // If the type is "script", eval it in global context
    6250                         } else if ( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
    6251                                 jQuery.globalEval( data );
    6252                         }
    6253                 }
    6254 
    6255                 return data;
    6256         }
     6743        etag: {}
    62576744
    62586745});
    62596746
    6260 /*
    6261  * Create the request object; Microsoft failed to properly
    6262  * implement the XMLHttpRequest in IE7 (can't request local files),
    6263  * so we use the ActiveXObject when it is available
    6264  * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
    6265  * we need a fallback.
     6747/* Handles responses to an ajax request:
     6748 * - sets all responseXXX fields accordingly
     6749 * - finds the right dataType (mediates between content-type and expected dataType)
     6750 * - returns the corresponding response
    62666751 */
    6267 if ( window.ActiveXObject ) {
    6268         jQuery.ajaxSettings.xhr = function() {
     6752function ajaxHandleResponses( s, jXHR, responses ) {
     6753
     6754        var contents = s.contents,
     6755                dataTypes = s.dataTypes,
     6756                responseFields = s.responseFields,
     6757                ct,
     6758                type,
     6759                finalDataType,
     6760                firstDataType;
     6761
     6762        // Fill responseXXX fields
     6763        for( type in responseFields ) {
     6764                if ( type in responses ) {
     6765                        jXHR[ responseFields[type] ] = responses[ type ];
     6766                }
     6767        }
     6768
     6769        // Remove auto dataType and get content-type in the process
     6770        while( dataTypes[ 0 ] === "*" ) {
     6771                dataTypes.shift();
     6772                if ( ct === undefined ) {
     6773                        ct = jXHR.getResponseHeader( "content-type" );
     6774                }
     6775        }
     6776
     6777        // Check if we're dealing with a known content-type
     6778        if ( ct ) {
     6779                for ( type in contents ) {
     6780                        if ( contents[ type ] && contents[ type ].test( ct ) ) {
     6781                                dataTypes.unshift( type );
     6782                                break;
     6783                        }
     6784                }
     6785        }
     6786
     6787        // Check to see if we have a response for the expected dataType
     6788        if ( dataTypes[ 0 ] in responses ) {
     6789                finalDataType = dataTypes[ 0 ];
     6790        } else {
     6791                // Try convertible dataTypes
     6792                for ( type in responses ) {
     6793                        if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
     6794                                finalDataType = type;
     6795                                break;
     6796                        }
     6797                        if ( !firstDataType ) {
     6798                                firstDataType = type;
     6799                        }
     6800                }
     6801                // Or just use first one
     6802                finalDataType = finalDataType || firstDataType;
     6803        }
     6804
     6805        // If we found a dataType
     6806        // We add the dataType to the list if needed
     6807        // and return the corresponding response
     6808        if ( finalDataType ) {
     6809                if ( finalDataType !== dataTypes[ 0 ] ) {
     6810                        dataTypes.unshift( finalDataType );
     6811                }
     6812                return responses[ finalDataType ];
     6813        }
     6814}
     6815
     6816// Chain conversions given the request and the original response
     6817function ajaxConvert( s, response ) {
     6818
     6819        // Apply the dataFilter if provided
     6820        if ( s.dataFilter ) {
     6821                response = s.dataFilter( response, s.dataType );
     6822        }
     6823
     6824        var dataTypes = s.dataTypes,
     6825                converters = s.converters,
     6826                i,
     6827                length = dataTypes.length,
     6828                tmp,
     6829                // Current and previous dataTypes
     6830                current = dataTypes[ 0 ],
     6831                prev,
     6832                // Conversion expression
     6833                conversion,
     6834                // Conversion function
     6835                conv,
     6836                // Conversion functions (transitive conversion)
     6837                conv1,
     6838                conv2;
     6839
     6840        // For each dataType in the chain
     6841        for( i = 1; i < length; i++ ) {
     6842
     6843                // Get the dataTypes
     6844                prev = current;
     6845                current = dataTypes[ i ];
     6846
     6847                // If current is auto dataType, update it to prev
     6848                if( current === "*" ) {
     6849                        current = prev;
     6850                // If no auto and dataTypes are actually different
     6851                } else if ( prev !== "*" && prev !== current ) {
     6852
     6853                        // Get the converter
     6854                        conversion = prev + " " + current;
     6855                        conv = converters[ conversion ] || converters[ "* " + current ];
     6856
     6857                        // If there is no direct converter, search transitively
     6858                        if ( !conv ) {
     6859                                conv2 = undefined;
     6860                                for( conv1 in converters ) {
     6861                                        tmp = conv1.split( " " );
     6862                                        if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
     6863                                                conv2 = converters[ tmp[1] + " " + current ];
     6864                                                if ( conv2 ) {
     6865                                                        conv1 = converters[ conv1 ];
     6866                                                        if ( conv1 === true ) {
     6867                                                                conv = conv2;
     6868                                                        } else if ( conv2 === true ) {
     6869                                                                conv = conv1;
     6870                                                        }
     6871                                                        break;
     6872                                                }
     6873                                        }
     6874                                }
     6875                        }
     6876                        // If we found no converter, dispatch an error
     6877                        if ( !( conv || conv2 ) ) {
     6878                                jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
     6879                        }
     6880                        // If found converter is not an equivalence
     6881                        if ( conv !== true ) {
     6882                                // Convert with 1 or 2 converters accordingly
     6883                                response = conv ? conv( response ) : conv2( conv1(response) );
     6884                        }
     6885                }
     6886        }
     6887        return response;
     6888}
     6889
     6890
     6891
     6892
     6893var jsc = jQuery.now(),
     6894        jsre = /(\=)\?(&|$)|()\?\?()/i;
     6895
     6896// Default jsonp settings
     6897jQuery.ajaxSetup({
     6898        jsonp: "callback",
     6899        jsonpCallback: function() {
     6900                return jQuery.expando + "_" + ( jsc++ );
     6901        }
     6902});
     6903
     6904// Detect, normalize options and install callbacks for jsonp requests
     6905jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, dataIsString /* internal */ ) {
     6906
     6907        dataIsString = ( typeof s.data === "string" );
     6908
     6909        if ( s.dataTypes[ 0 ] === "jsonp" ||
     6910                originalSettings.jsonpCallback ||
     6911                originalSettings.jsonp != null ||
     6912                s.jsonp !== false && ( jsre.test( s.url ) ||
     6913                                dataIsString && jsre.test( s.data ) ) ) {
     6914
     6915                var responseContainer,
     6916                        jsonpCallback = s.jsonpCallback =
     6917                                jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
     6918                        previous = window[ jsonpCallback ],
     6919                        url = s.url,
     6920                        data = s.data,
     6921                        replace = "$1" + jsonpCallback + "$2";
     6922
     6923                if ( s.jsonp !== false ) {
     6924                        url = url.replace( jsre, replace );
     6925                        if ( s.url === url ) {
     6926                                if ( dataIsString ) {
     6927                                        data = data.replace( jsre, replace );
     6928                                }
     6929                                if ( s.data === data ) {
     6930                                        // Add callback manually
     6931                                        url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
     6932                                }
     6933                        }
     6934                }
     6935
     6936                s.url = url;
     6937                s.data = data;
     6938
     6939                window[ jsonpCallback ] = function( response ) {
     6940                        responseContainer = [ response ];
     6941                };
     6942
     6943                s.complete = [ function() {
     6944
     6945                        // Set callback back to previous value
     6946                        window[ jsonpCallback ] = previous;
     6947
     6948                        // Call if it was a function and we have a response
     6949                        if ( previous) {
     6950                                if ( responseContainer && jQuery.isFunction( previous ) ) {
     6951                                        window[ jsonpCallback ] ( responseContainer[ 0 ] );
     6952                                }
     6953                        } else {
     6954                                // else, more memory leak avoidance
     6955                                try{
     6956                                        delete window[ jsonpCallback ];
     6957                                } catch( e ) {}
     6958                        }
     6959
     6960                }, s.complete ];
     6961
     6962                // Use data converter to retrieve json after script execution
     6963                s.converters["script json"] = function() {
     6964                        if ( ! responseContainer ) {
     6965                                jQuery.error( jsonpCallback + " was not called" );
     6966                        }
     6967                        return responseContainer[ 0 ];
     6968                };
     6969
     6970                // force json dataType
     6971                s.dataTypes[ 0 ] = "json";
     6972
     6973                // Delegate to script
     6974                return "script";
     6975        }
     6976} );
     6977
     6978
     6979
     6980
     6981// Install script dataType
     6982jQuery.ajaxSetup({
     6983        accepts: {
     6984                script: "text/javascript, application/javascript"
     6985        },
     6986        contents: {
     6987                script: /javascript/
     6988        },
     6989        converters: {
     6990                "text script": function( text ) {
     6991                        jQuery.globalEval( text );
     6992                        return text;
     6993                }
     6994        }
     6995});
     6996
     6997// Handle cache's special case and global
     6998jQuery.ajaxPrefilter( "script", function( s ) {
     6999        if ( s.cache === undefined ) {
     7000                s.cache = false;
     7001        }
     7002        if ( s.crossDomain ) {
     7003                s.type = "GET";
     7004                s.global = false;
     7005        }
     7006} );
     7007
     7008// Bind script tag hack transport
     7009jQuery.ajaxTransport( "script", function(s) {
     7010
     7011        // This transport only deals with cross domain requests
     7012        if ( s.crossDomain ) {
     7013
     7014                var script,
     7015                        head = document.getElementsByTagName( "head" )[ 0 ] || document.documentElement;
     7016
     7017                return {
     7018
     7019                        send: function( _, callback ) {
     7020
     7021                                script = document.createElement( "script" );
     7022
     7023                                script.async = "async";
     7024
     7025                                if ( s.scriptCharset ) {
     7026                                        script.charset = s.scriptCharset;
     7027                                }
     7028
     7029                                script.src = s.url;
     7030
     7031                                // Attach handlers for all browsers
     7032                                script.onload = script.onreadystatechange = function( _, isAbort ) {
     7033
     7034                                        if ( !script.readyState || /loaded|complete/.test( script.readyState ) ) {
     7035
     7036                                                // Handle memory leak in IE
     7037                                                script.onload = script.onreadystatechange = null;
     7038
     7039                                                // Remove the script
     7040                                                if ( head && script.parentNode ) {
     7041                                                        head.removeChild( script );
     7042                                                }
     7043
     7044                                                // Dereference the script
     7045                                                script = undefined;
     7046
     7047                                                // Callback if not abort
     7048                                                if ( !isAbort ) {
     7049                                                        callback( 200, "success" );
     7050                                                }
     7051                                        }
     7052                                };
     7053                                // Use insertBefore instead of appendChild  to circumvent an IE6 bug.
     7054                                // This arises when a base node is used (#2709 and #4378).
     7055                                head.insertBefore( script, head.firstChild );
     7056                        },
     7057
     7058                        abort: function() {
     7059                                if ( script ) {
     7060                                        script.onload( 0, 1 );
     7061                                }
     7062                        }
     7063                };
     7064        }
     7065} );
     7066
     7067
     7068
     7069
     7070var // Next active xhr id
     7071        xhrId = jQuery.now(),
     7072
     7073        // active xhrs
     7074        xhrs = {},
     7075
     7076        // #5280: see below
     7077        xhrUnloadAbortInstalled,
     7078
     7079        // XHR used to determine supports properties
     7080        testXHR;
     7081
     7082// Create the request object
     7083// (This is still attached to ajaxSettings for backward compatibility)
     7084jQuery.ajaxSettings.xhr = window.ActiveXObject ?
     7085        /* Microsoft failed to properly
     7086         * implement the XMLHttpRequest in IE7 (can't request local files),
     7087         * so we use the ActiveXObject when it is available
     7088         * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
     7089         * we need a fallback.
     7090         */
     7091        function() {
    62697092                if ( window.location.protocol !== "file:" ) {
    62707093                        try {
    62717094                                return new window.XMLHttpRequest();
    6272                         } catch(xhrError) {}
     7095                        } catch( xhrError ) {}
    62737096                }
    62747097
    62757098                try {
    62767099                        return new window.ActiveXObject("Microsoft.XMLHTTP");
    6277                 } catch(activeError) {}
     7100                } catch( activeError ) {}
     7101        } :
     7102        // For all other browsers, use the standard XMLHttpRequest object
     7103        function() {
     7104                return new window.XMLHttpRequest();
    62787105        };
     7106
     7107// Test if we can create an xhr object
     7108try {
     7109        testXHR = jQuery.ajaxSettings.xhr();
     7110} catch( xhrCreationException ) {}
     7111
     7112//Does this browser support XHR requests?
     7113jQuery.support.ajax = !!testXHR;
     7114
     7115// Does this browser support crossDomain XHR requests
     7116jQuery.support.cors = testXHR && ( "withCredentials" in testXHR );
     7117
     7118// No need for the temporary xhr anymore
     7119testXHR = undefined;
     7120
     7121// Create transport if the browser can provide an xhr
     7122if ( jQuery.support.ajax ) {
     7123
     7124        jQuery.ajaxTransport(function( s ) {
     7125                // Cross domain only allowed if supported through XMLHttpRequest
     7126                if ( !s.crossDomain || jQuery.support.cors ) {
     7127
     7128                        var callback;
     7129
     7130                        return {
     7131                                send: function( headers, complete ) {
     7132
     7133                                        // #5280: we need to abort on unload or IE will keep connections alive
     7134                                        if ( !xhrUnloadAbortInstalled ) {
     7135
     7136                                                xhrUnloadAbortInstalled = 1;
     7137
     7138                                                jQuery(window).bind( "unload", function() {
     7139
     7140                                                        // Abort all pending requests
     7141                                                        jQuery.each( xhrs, function( _, xhr ) {
     7142                                                                if ( xhr.onreadystatechange ) {
     7143                                                                        xhr.onreadystatechange( 1 );
     7144                                                                }
     7145                                                        } );
     7146
     7147                                                } );
     7148                                        }
     7149
     7150                                        // Get a new xhr
     7151                                        var xhr = s.xhr(),
     7152                                                handle;
     7153
     7154                                        // Open the socket
     7155                                        // Passing null username, generates a login popup on Opera (#2865)
     7156                                        if ( s.username ) {
     7157                                                xhr.open( s.type, s.url, s.async, s.username, s.password );
     7158                                        } else {
     7159                                                xhr.open( s.type, s.url, s.async );
     7160                                        }
     7161
     7162                                        // Requested-With header
     7163                                        // Not set for crossDomain requests with no content
     7164                                        // (see why at http://trac.dojotoolkit.org/ticket/9486)
     7165                                        // Won't change header if already provided
     7166                                        if ( !( s.crossDomain && !s.hasContent ) && !headers["x-requested-with"] ) {
     7167                                                headers[ "x-requested-with" ] = "XMLHttpRequest";
     7168                                        }
     7169
     7170                                        // Need an extra try/catch for cross domain requests in Firefox 3
     7171                                        try {
     7172                                                jQuery.each( headers, function( key, value ) {
     7173                                                        xhr.setRequestHeader( key, value );
     7174                                                } );
     7175                                        } catch( _ ) {}
     7176
     7177                                        // Do send the request
     7178                                        // This may raise an exception which is actually
     7179                                        // handled in jQuery.ajax (so no try/catch here)
     7180                                        xhr.send( ( s.hasContent && s.data ) || null );
     7181
     7182                                        // Listener
     7183                                        callback = function( _, isAbort ) {
     7184
     7185                                                // Was never called and is aborted or complete
     7186                                                if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
     7187
     7188                                                        // Only called once
     7189                                                        callback = 0;
     7190
     7191                                                        // Do not keep as active anymore
     7192                                                        if ( handle ) {
     7193                                                                xhr.onreadystatechange = jQuery.noop;
     7194                                                                delete xhrs[ handle ];
     7195                                                        }
     7196
     7197                                                        // If it's an abort
     7198                                                        if ( isAbort ) {
     7199                                                                // Abort it manually if needed
     7200                                                                if ( xhr.readyState !== 4 ) {
     7201                                                                        xhr.abort();
     7202                                                                }
     7203                                                        } else {
     7204                                                                // Get info
     7205                                                                var status = xhr.status,
     7206                                                                        statusText,
     7207                                                                        responseHeaders = xhr.getAllResponseHeaders(),
     7208                                                                        responses = {},
     7209                                                                        xml = xhr.responseXML;
     7210
     7211                                                                // Construct response list
     7212                                                                if ( xml && xml.documentElement /* #4958 */ ) {
     7213                                                                        responses.xml = xml;
     7214                                                                }
     7215                                                                responses.text = xhr.responseText;
     7216
     7217                                                                // Firefox throws an exception when accessing
     7218                                                                // statusText for faulty cross-domain requests
     7219                                                                try {
     7220                                                                        statusText = xhr.statusText;
     7221                                                                } catch( e ) {
     7222                                                                        // We normalize with Webkit giving an empty statusText
     7223                                                                        statusText = "";
     7224                                                                }
     7225
     7226                                                                // Filter status for non standard behaviours
     7227                                                                status =
     7228                                                                        // Opera returns 0 when it should be 304
     7229                                                                        // Webkit returns 0 for failing cross-domain no matter the real status
     7230                                                                        status === 0 ?
     7231                                                                                (
     7232                                                                                        // Webkit, Firefox: filter out faulty cross-domain requests
     7233                                                                                        !s.crossDomain || statusText ?
     7234                                                                                        (
     7235                                                                                                // Opera: filter out real aborts #6060
     7236                                                                                                responseHeaders ?
     7237                                                                                                304 :
     7238                                                                                                0
     7239                                                                                        ) :
     7240                                                                                        // We assume 302 but could be anything cross-domain related
     7241                                                                                        302
     7242                                                                                ) :
     7243                                                                                (
     7244                                                                                        // IE sometimes returns 1223 when it should be 204 (see #1450)
     7245                                                                                        status == 1223 ?
     7246                                                                                                204 :
     7247                                                                                                status
     7248                                                                                );
     7249
     7250                                                                // Call complete
     7251                                                                complete( status, statusText, responses, responseHeaders );
     7252                                                        }
     7253                                                }
     7254                                        };
     7255
     7256                                        // if we're in sync mode or it's in cache
     7257                                        // and has been retrieved directly (IE6 & IE7)
     7258                                        // we need to manually fire the callback
     7259                                        if ( !s.async || xhr.readyState === 4 ) {
     7260                                                callback();
     7261                                        } else {
     7262                                                // Add to list of active xhrs
     7263                                                handle = xhrId++;
     7264                                                xhrs[ handle ] = xhr;
     7265                                                xhr.onreadystatechange = callback;
     7266                                        }
     7267                                },
     7268
     7269                                abort: function() {
     7270                                        if ( callback ) {
     7271                                                callback(0,1);
     7272                                        }
     7273                                }
     7274                        };
     7275                }
     7276        });
    62797277}
    6280 
    6281 // Does this browser support XHR requests?
    6282 jQuery.support.ajax = !!jQuery.ajaxSettings.xhr();
    62837278
    62847279
     
    62877282var elemdisplay = {},
    62887283        rfxtypes = /^(?:toggle|show|hide)$/,
    6289         rfxnum = /^([+\-]=)?([\d+.\-]+)(.*)$/,
     7284        rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
    62907285        timerId,
    62917286        fxAttrs = [
     
    63127307                                // Reset the inline display of this element to learn if it is
    63137308                                // being hidden by cascaded rules or not
    6314                                 if ( !jQuery.data(elem, "olddisplay") && display === "none" ) {
     7309                                if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
    63157310                                        display = elem.style.display = "";
    63167311                                }
     
    63207315                                // for such an element
    63217316                                if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
    6322                                         jQuery.data(elem, "olddisplay", defaultDisplay(elem.nodeName));
     7317                                        jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
    63237318                                }
    63247319                        }
     
    63317326
    63327327                                if ( display === "" || display === "none" ) {
    6333                                         elem.style.display = jQuery.data(elem, "olddisplay") || "";
     7328                                        elem.style.display = jQuery._data(elem, "olddisplay") || "";
    63347329                                }
    63357330                        }
     
    63477342                                var display = jQuery.css( this[i], "display" );
    63487343
    6349                                 if ( display !== "none" ) {
    6350                                         jQuery.data( this[i], "olddisplay", display );
     7344                                if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
     7345                                        jQuery._data( this[i], "olddisplay", display );
    63517346                                }
    63527347                        }
     
    66227617
    66237618                var r = parseFloat( jQuery.css( this.elem, this.prop ) );
    6624                 return r && r > -10000 ? r : 0;
     7619                return r || 0;
    66257620        },
    66267621
     
    68167811                var elem = this[0], box;
    68177812
    6818                 if ( options ) { 
     7813                if ( options ) {
    68197814                        return this.each(function( i ) {
    68207815                                jQuery.offset.setOffset( this, options, i );
     
    68397834                // Make sure we're not dealing with a disconnected DOM node
    68407835                if ( !box || !jQuery.contains( docElem, elem ) ) {
    6841                         return box || { top: 0, left: 0 };
     7836                        return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
    68427837                }
    68437838
     
    68587853                var elem = this[0];
    68597854
    6860                 if ( options ) { 
     7855                if ( options ) {
    68617856                        return this.each(function( i ) {
    68627857                                jQuery.offset.setOffset( this, options, i );
     
    69777972                return { top: top, left: left };
    69787973        },
    6979        
     7974
    69807975        setOffset: function( elem, options, i ) {
    69817976                var position = jQuery.css( elem, "position" );
     
    70118006                        props.left = (options.left - curOffset.left) + curLeft;
    70128007                }
    7013                
     8008
    70148009                if ( "using" in options ) {
    70158010                        options.using.call( elem, props );
     
    70718066        jQuery.fn[ method ] = function(val) {
    70728067                var elem = this[0], win;
    7073                
     8068
    70748069                if ( !elem ) {
    70758070                        return null;
     
    71398134                        return size == null ? null : this;
    71408135                }
    7141                
     8136
    71428137                if ( jQuery.isFunction( size ) ) {
    71438138                        return this.each(function( i ) {
     
    71498144                if ( jQuery.isWindow( elem ) ) {
    71508145                        // Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
    7151                         return elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
    7152                                 elem.document.body[ "client" + name ];
     8146                        // 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
     8147                        var docElemProp = elem.document.documentElement[ "client" + name ];
     8148                        return elem.document.compatMode === "CSS1Compat" && docElemProp ||
     8149                                elem.document.body[ "client" + name ] || docElemProp;
    71538150
    71548151                // Get document width or height
  • trunk/themes/default/js/jquery.min.js

    r8162 r9172  
    11/*!
    2  * jQuery JavaScript Library v1.4.4
     2 * jQuery JavaScript Library v1.5
    33 * http://jquery.com/
    44 *
    5  * Copyright 2010, John Resig
     5 * Copyright 2011, John Resig
    66 * Dual licensed under the MIT or GPL Version 2 licenses.
    77 * http://jquery.org/license
     
    99 * Includes Sizzle.js
    1010 * http://sizzlejs.com/
    11  * Copyright 2010, The Dojo Foundation
     11 * Copyright 2011, The Dojo Foundation
    1212 * Released under the MIT, BSD, and GPL Licenses.
    1313 *
    14  * Date: Thu Nov 11 19:04:53 2010 -0500
     14 * Date: Mon Jan 31 08:31:29 2011 -0500
    1515 */
    16 (function(E,B){function ka(a,b,d){if(d===B&&a.nodeType===1){d=a.getAttribute("data-"+b);if(typeof d==="string"){try{d=d==="true"?true:d==="false"?false:d==="null"?null:!c.isNaN(d)?parseFloat(d):Ja.test(d)?c.parseJSON(d):d}catch(e){}c.data(a,b,d)}else d=B}return d}function U(){return false}function ca(){return true}function la(a,b,d){d[0].type=a;return c.event.handle.apply(b,d)}function Ka(a){var b,d,e,f,h,l,k,o,x,r,A,C=[];f=[];h=c.data(this,this.nodeType?"events":"__events__");if(typeof h==="function")h=
    17 h.events;if(!(a.liveFired===this||!h||!h.live||a.button&&a.type==="click")){if(a.namespace)A=RegExp("(^|\\.)"+a.namespace.split(".").join("\\.(?:.*\\.)?")+"(\\.|$)");a.liveFired=this;var J=h.live.slice(0);for(k=0;k<J.length;k++){h=J[k];h.origType.replace(X,"")===a.type?f.push(h.selector):J.splice(k--,1)}f=c(a.target).closest(f,a.currentTarget);o=0;for(x=f.length;o<x;o++){r=f[o];for(k=0;k<J.length;k++){h=J[k];if(r.selector===h.selector&&(!A||A.test(h.namespace))){l=r.elem;e=null;if(h.preType==="mouseenter"||
    18 h.preType==="mouseleave"){a.type=h.preType;e=c(a.relatedTarget).closest(h.selector)[0]}if(!e||e!==l)C.push({elem:l,handleObj:h,level:r.level})}}}o=0;for(x=C.length;o<x;o++){f=C[o];if(d&&f.level>d)break;a.currentTarget=f.elem;a.data=f.handleObj.data;a.handleObj=f.handleObj;A=f.handleObj.origHandler.apply(f.elem,arguments);if(A===false||a.isPropagationStopped()){d=f.level;if(A===false)b=false;if(a.isImmediatePropagationStopped())break}}return b}}function Y(a,b){return(a&&a!=="*"?a+".":"")+b.replace(La,
    19 "`").replace(Ma,"&")}function ma(a,b,d){if(c.isFunction(b))return c.grep(a,function(f,h){return!!b.call(f,h,f)===d});else if(b.nodeType)return c.grep(a,function(f){return f===b===d});else if(typeof b==="string"){var e=c.grep(a,function(f){return f.nodeType===1});if(Na.test(b))return c.filter(b,e,!d);else b=c.filter(b,e)}return c.grep(a,function(f){return c.inArray(f,b)>=0===d})}function na(a,b){var d=0;b.each(function(){if(this.nodeName===(a[d]&&a[d].nodeName)){var e=c.data(a[d++]),f=c.data(this,
    20 e);if(e=e&&e.events){delete f.handle;f.events={};for(var h in e)for(var l in e[h])c.event.add(this,h,e[h][l],e[h][l].data)}}})}function Oa(a,b){b.src?c.ajax({url:b.src,async:false,dataType:"script"}):c.globalEval(b.text||b.textContent||b.innerHTML||"");b.parentNode&&b.parentNode.removeChild(b)}function oa(a,b,d){var e=b==="width"?a.offsetWidth:a.offsetHeight;if(d==="border")return e;c.each(b==="width"?Pa:Qa,function(){d||(e-=parseFloat(c.css(a,"padding"+this))||0);if(d==="margin")e+=parseFloat(c.css(a,
    21 "margin"+this))||0;else e-=parseFloat(c.css(a,"border"+this+"Width"))||0});return e}function da(a,b,d,e){if(c.isArray(b)&&b.length)c.each(b,function(f,h){d||Ra.test(a)?e(a,h):da(a+"["+(typeof h==="object"||c.isArray(h)?f:"")+"]",h,d,e)});else if(!d&&b!=null&&typeof b==="object")c.isEmptyObject(b)?e(a,""):c.each(b,function(f,h){da(a+"["+f+"]",h,d,e)});else e(a,b)}function S(a,b){var d={};c.each(pa.concat.apply([],pa.slice(0,b)),function(){d[this]=a});return d}function qa(a){if(!ea[a]){var b=c("<"+
    22 a+">").appendTo("body"),d=b.css("display");b.remove();if(d==="none"||d==="")d="block";ea[a]=d}return ea[a]}function fa(a){return c.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:false}var t=E.document,c=function(){function a(){if(!b.isReady){try{t.documentElement.doScroll("left")}catch(j){setTimeout(a,1);return}b.ready()}}var b=function(j,s){return new b.fn.init(j,s)},d=E.jQuery,e=E.$,f,h=/^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,l=/\S/,k=/^\s+/,o=/\s+$/,x=/\W/,r=/\d/,A=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,
    23 C=/^[\],:{}\s]*$/,J=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,w=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,I=/(?:^|:|,)(?:\s*\[)+/g,L=/(webkit)[ \/]([\w.]+)/,g=/(opera)(?:.*version)?[ \/]([\w.]+)/,i=/(msie) ([\w.]+)/,n=/(mozilla)(?:.*? rv:([\w.]+))?/,m=navigator.userAgent,p=false,q=[],u,y=Object.prototype.toString,F=Object.prototype.hasOwnProperty,M=Array.prototype.push,N=Array.prototype.slice,O=String.prototype.trim,D=Array.prototype.indexOf,R={};b.fn=b.prototype={init:function(j,
    24 s){var v,z,H;if(!j)return this;if(j.nodeType){this.context=this[0]=j;this.length=1;return this}if(j==="body"&&!s&&t.body){this.context=t;this[0]=t.body;this.selector="body";this.length=1;return this}if(typeof j==="string")if((v=h.exec(j))&&(v[1]||!s))if(v[1]){H=s?s.ownerDocument||s:t;if(z=A.exec(j))if(b.isPlainObject(s)){j=[t.createElement(z[1])];b.fn.attr.call(j,s,true)}else j=[H.createElement(z[1])];else{z=b.buildFragment([v[1]],[H]);j=(z.cacheable?z.fragment.cloneNode(true):z.fragment).childNodes}return b.merge(this,
    25 j)}else{if((z=t.getElementById(v[2]))&&z.parentNode){if(z.id!==v[2])return f.find(j);this.length=1;this[0]=z}this.context=t;this.selector=j;return this}else if(!s&&!x.test(j)){this.selector=j;this.context=t;j=t.getElementsByTagName(j);return b.merge(this,j)}else return!s||s.jquery?(s||f).find(j):b(s).find(j);else if(b.isFunction(j))return f.ready(j);if(j.selector!==B){this.selector=j.selector;this.context=j.context}return b.makeArray(j,this)},selector:"",jquery:"1.4.4",length:0,size:function(){return this.length},
    26 toArray:function(){return N.call(this,0)},get:function(j){return j==null?this.toArray():j<0?this.slice(j)[0]:this[j]},pushStack:function(j,s,v){var z=b();b.isArray(j)?M.apply(z,j):b.merge(z,j);z.prevObject=this;z.context=this.context;if(s==="find")z.selector=this.selector+(this.selector?" ":"")+v;else if(s)z.selector=this.selector+"."+s+"("+v+")";return z},each:function(j,s){return b.each(this,j,s)},ready:function(j){b.bindReady();if(b.isReady)j.call(t,b);else q&&q.push(j);return this},eq:function(j){return j===
    27 -1?this.slice(j):this.slice(j,+j+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(N.apply(this,arguments),"slice",N.call(arguments).join(","))},map:function(j){return this.pushStack(b.map(this,function(s,v){return j.call(s,v,s)}))},end:function(){return this.prevObject||b(null)},push:M,sort:[].sort,splice:[].splice};b.fn.init.prototype=b.fn;b.extend=b.fn.extend=function(){var j,s,v,z,H,G=arguments[0]||{},K=1,Q=arguments.length,ga=false;
    28 if(typeof G==="boolean"){ga=G;G=arguments[1]||{};K=2}if(typeof G!=="object"&&!b.isFunction(G))G={};if(Q===K){G=this;--K}for(;K<Q;K++)if((j=arguments[K])!=null)for(s in j){v=G[s];z=j[s];if(G!==z)if(ga&&z&&(b.isPlainObject(z)||(H=b.isArray(z)))){if(H){H=false;v=v&&b.isArray(v)?v:[]}else v=v&&b.isPlainObject(v)?v:{};G[s]=b.extend(ga,v,z)}else if(z!==B)G[s]=z}return G};b.extend({noConflict:function(j){E.$=e;if(j)E.jQuery=d;return b},isReady:false,readyWait:1,ready:function(j){j===true&&b.readyWait--;
    29 if(!b.readyWait||j!==true&&!b.isReady){if(!t.body)return setTimeout(b.ready,1);b.isReady=true;if(!(j!==true&&--b.readyWait>0))if(q){var s=0,v=q;for(q=null;j=v[s++];)j.call(t,b);b.fn.trigger&&b(t).trigger("ready").unbind("ready")}}},bindReady:function(){if(!p){p=true;if(t.readyState==="complete")return setTimeout(b.ready,1);if(t.addEventListener){t.addEventListener("DOMContentLoaded",u,false);E.addEventListener("load",b.ready,false)}else if(t.attachEvent){t.attachEvent("onreadystatechange",u);E.attachEvent("onload",
    30 b.ready);var j=false;try{j=E.frameElement==null}catch(s){}t.documentElement.doScroll&&j&&a()}}},isFunction:function(j){return b.type(j)==="function"},isArray:Array.isArray||function(j){return b.type(j)==="array"},isWindow:function(j){return j&&typeof j==="object"&&"setInterval"in j},isNaN:function(j){return j==null||!r.test(j)||isNaN(j)},type:function(j){return j==null?String(j):R[y.call(j)]||"object"},isPlainObject:function(j){if(!j||b.type(j)!=="object"||j.nodeType||b.isWindow(j))return false;if(j.constructor&&
    31 !F.call(j,"constructor")&&!F.call(j.constructor.prototype,"isPrototypeOf"))return false;for(var s in j);return s===B||F.call(j,s)},isEmptyObject:function(j){for(var s in j)return false;return true},error:function(j){throw j;},parseJSON:function(j){if(typeof j!=="string"||!j)return null;j=b.trim(j);if(C.test(j.replace(J,"@").replace(w,"]").replace(I,"")))return E.JSON&&E.JSON.parse?E.JSON.parse(j):(new Function("return "+j))();else b.error("Invalid JSON: "+j)},noop:function(){},globalEval:function(j){if(j&&
    32 l.test(j)){var s=t.getElementsByTagName("head")[0]||t.documentElement,v=t.createElement("script");v.type="text/javascript";if(b.support.scriptEval)v.appendChild(t.createTextNode(j));else v.text=j;s.insertBefore(v,s.firstChild);s.removeChild(v)}},nodeName:function(j,s){return j.nodeName&&j.nodeName.toUpperCase()===s.toUpperCase()},each:function(j,s,v){var z,H=0,G=j.length,K=G===B||b.isFunction(j);if(v)if(K)for(z in j){if(s.apply(j[z],v)===false)break}else for(;H<G;){if(s.apply(j[H++],v)===false)break}else if(K)for(z in j){if(s.call(j[z],
    33 z,j[z])===false)break}else for(v=j[0];H<G&&s.call(v,H,v)!==false;v=j[++H]);return j},trim:O?function(j){return j==null?"":O.call(j)}:function(j){return j==null?"":j.toString().replace(k,"").replace(o,"")},makeArray:function(j,s){var v=s||[];if(j!=null){var z=b.type(j);j.length==null||z==="string"||z==="function"||z==="regexp"||b.isWindow(j)?M.call(v,j):b.merge(v,j)}return v},inArray:function(j,s){if(s.indexOf)return s.indexOf(j);for(var v=0,z=s.length;v<z;v++)if(s[v]===j)return v;return-1},merge:function(j,
    34 s){var v=j.length,z=0;if(typeof s.length==="number")for(var H=s.length;z<H;z++)j[v++]=s[z];else for(;s[z]!==B;)j[v++]=s[z++];j.length=v;return j},grep:function(j,s,v){var z=[],H;v=!!v;for(var G=0,K=j.length;G<K;G++){H=!!s(j[G],G);v!==H&&z.push(j[G])}return z},map:function(j,s,v){for(var z=[],H,G=0,K=j.length;G<K;G++){H=s(j[G],G,v);if(H!=null)z[z.length]=H}return z.concat.apply([],z)},guid:1,proxy:function(j,s,v){if(arguments.length===2)if(typeof s==="string"){v=j;j=v[s];s=B}else if(s&&!b.isFunction(s)){v=
    35 s;s=B}if(!s&&j)s=function(){return j.apply(v||this,arguments)};if(j)s.guid=j.guid=j.guid||s.guid||b.guid++;return s},access:function(j,s,v,z,H,G){var K=j.length;if(typeof s==="object"){for(var Q in s)b.access(j,Q,s[Q],z,H,v);return j}if(v!==B){z=!G&&z&&b.isFunction(v);for(Q=0;Q<K;Q++)H(j[Q],s,z?v.call(j[Q],Q,H(j[Q],s)):v,G);return j}return K?H(j[0],s):B},now:function(){return(new Date).getTime()},uaMatch:function(j){j=j.toLowerCase();j=L.exec(j)||g.exec(j)||i.exec(j)||j.indexOf("compatible")<0&&n.exec(j)||
    36 [];return{browser:j[1]||"",version:j[2]||"0"}},browser:{}});b.each("Boolean Number String Function Array Date RegExp Object".split(" "),function(j,s){R["[object "+s+"]"]=s.toLowerCase()});m=b.uaMatch(m);if(m.browser){b.browser[m.browser]=true;b.browser.version=m.version}if(b.browser.webkit)b.browser.safari=true;if(D)b.inArray=function(j,s){return D.call(s,j)};if(!/\s/.test("\u00a0")){k=/^[\s\xA0]+/;o=/[\s\xA0]+$/}f=b(t);if(t.addEventListener)u=function(){t.removeEventListener("DOMContentLoaded",u,
    37 false);b.ready()};else if(t.attachEvent)u=function(){if(t.readyState==="complete"){t.detachEvent("onreadystatechange",u);b.ready()}};return E.jQuery=E.$=b}();(function(){c.support={};var a=t.documentElement,b=t.createElement("script"),d=t.createElement("div"),e="script"+c.now();d.style.display="none";d.innerHTML="   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";var f=d.getElementsByTagName("*"),h=d.getElementsByTagName("a")[0],l=t.createElement("select"),
    38 k=l.appendChild(t.createElement("option"));if(!(!f||!f.length||!h)){c.support={leadingWhitespace:d.firstChild.nodeType===3,tbody:!d.getElementsByTagName("tbody").length,htmlSerialize:!!d.getElementsByTagName("link").length,style:/red/.test(h.getAttribute("style")),hrefNormalized:h.getAttribute("href")==="/a",opacity:/^0.55$/.test(h.style.opacity),cssFloat:!!h.style.cssFloat,checkOn:d.getElementsByTagName("input")[0].value==="on",optSelected:k.selected,deleteExpando:true,optDisabled:false,checkClone:false,
    39 scriptEval:false,noCloneEvent:true,boxModel:null,inlineBlockNeedsLayout:false,shrinkWrapBlocks:false,reliableHiddenOffsets:true};l.disabled=true;c.support.optDisabled=!k.disabled;b.type="text/javascript";try{b.appendChild(t.createTextNode("window."+e+"=1;"))}catch(o){}a.insertBefore(b,a.firstChild);if(E[e]){c.support.scriptEval=true;delete E[e]}try{delete b.test}catch(x){c.support.deleteExpando=false}a.removeChild(b);if(d.attachEvent&&d.fireEvent){d.attachEvent("onclick",function r(){c.support.noCloneEvent=
    40 false;d.detachEvent("onclick",r)});d.cloneNode(true).fireEvent("onclick")}d=t.createElement("div");d.innerHTML="<input type='radio' name='radiotest' checked='checked'/>";a=t.createDocumentFragment();a.appendChild(d.firstChild);c.support.checkClone=a.cloneNode(true).cloneNode(true).lastChild.checked;c(function(){var r=t.createElement("div");r.style.width=r.style.paddingLeft="1px";t.body.appendChild(r);c.boxModel=c.support.boxModel=r.offsetWidth===2;if("zoom"in r.style){r.style.display="inline";r.style.zoom=
    41 1;c.support.inlineBlockNeedsLayout=r.offsetWidth===2;r.style.display="";r.innerHTML="<div style='width:4px;'></div>";c.support.shrinkWrapBlocks=r.offsetWidth!==2}r.innerHTML="<table><tr><td style='padding:0;display:none'></td><td>t</td></tr></table>";var A=r.getElementsByTagName("td");c.support.reliableHiddenOffsets=A[0].offsetHeight===0;A[0].style.display="";A[1].style.display="none";c.support.reliableHiddenOffsets=c.support.reliableHiddenOffsets&&A[0].offsetHeight===0;r.innerHTML="";t.body.removeChild(r).style.display=
    42 "none"});a=function(r){var A=t.createElement("div");r="on"+r;var C=r in A;if(!C){A.setAttribute(r,"return;");C=typeof A[r]==="function"}return C};c.support.submitBubbles=a("submit");c.support.changeBubbles=a("change");a=b=d=f=h=null}})();var ra={},Ja=/^(?:\{.*\}|\[.*\])$/;c.extend({cache:{},uuid:0,expando:"jQuery"+c.now(),noData:{embed:true,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:true},data:function(a,b,d){if(c.acceptData(a)){a=a==E?ra:a;var e=a.nodeType,f=e?a[c.expando]:null,h=
    43 c.cache;if(!(e&&!f&&typeof b==="string"&&d===B)){if(e)f||(a[c.expando]=f=++c.uuid);else h=a;if(typeof b==="object")if(e)h[f]=c.extend(h[f],b);else c.extend(h,b);else if(e&&!h[f])h[f]={};a=e?h[f]:h;if(d!==B)a[b]=d;return typeof b==="string"?a[b]:a}}},removeData:function(a,b){if(c.acceptData(a)){a=a==E?ra:a;var d=a.nodeType,e=d?a[c.expando]:a,f=c.cache,h=d?f[e]:e;if(b){if(h){delete h[b];d&&c.isEmptyObject(h)&&c.removeData(a)}}else if(d&&c.support.deleteExpando)delete a[c.expando];else if(a.removeAttribute)a.removeAttribute(c.expando);
    44 else if(d)delete f[e];else for(var l in a)delete a[l]}},acceptData:function(a){if(a.nodeName){var b=c.noData[a.nodeName.toLowerCase()];if(b)return!(b===true||a.getAttribute("classid")!==b)}return true}});c.fn.extend({data:function(a,b){var d=null;if(typeof a==="undefined"){if(this.length){var e=this[0].attributes,f;d=c.data(this[0]);for(var h=0,l=e.length;h<l;h++){f=e[h].name;if(f.indexOf("data-")===0){f=f.substr(5);ka(this[0],f,d[f])}}}return d}else if(typeof a==="object")return this.each(function(){c.data(this,
    45 a)});var k=a.split(".");k[1]=k[1]?"."+k[1]:"";if(b===B){d=this.triggerHandler("getData