Changeset 13052


Ignore:
Timestamp:
02/07/12 22:25:20 (8 years ago)
Author:
rvelices
Message:

upgrade jquery to 1.7.1
mouseout on index drop down bozes
improved multisize center of interest

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/admin/include/functions.php

    r13025 r13052  
    203203 
    204204    $ok = true; 
    205                 if (!isset($conf['never_delete_originals'])) 
    206                 { 
    207                         foreach ($files as $path) 
    208                         { 
    209                                 if (is_file($path) and !unlink($path)) 
    210                                 { 
    211                                         $ok = false; 
    212                                         trigger_error('"'.$path.'" cannot be removed', E_USER_WARNING); 
    213                                         break; 
    214                                 } 
    215                         } 
    216                 } 
     205    if (!isset($conf['never_delete_originals'])) 
     206    { 
     207      foreach ($files as $path) 
     208      { 
     209        if (is_file($path) and !unlink($path)) 
     210        { 
     211          $ok = false; 
     212          trigger_error('"'.$path.'" cannot be removed', E_USER_WARNING); 
     213          break; 
     214        } 
     215      } 
     216    } 
    217217 
    218218    if ($ok) 
     
    23072307} 
    23082308 
    2309 function delete_element_derivatives($infos) 
     2309function delete_element_derivatives($infos, $type='all') 
    23102310{ 
    23112311  $path = $infos['path']; 
     
    23182318    $path = substr($path, 3); 
    23192319  } 
    2320   $dot = strpos($path, '.'); 
    2321   $path = substr_replace($path, '-*', $dot, 0); 
     2320  $dot = strrpos($path, '.'); 
     2321  if ($type=='all') 
     2322  { 
     2323    $pattern = '-*'; 
     2324  } 
     2325  else 
     2326  { 
     2327    $pattern = '-'.derivative_to_url($type).'*'; 
     2328  } 
     2329  $path = substr_replace($path, $pattern, $dot, 0); 
    23222330  foreach( glob(PHPWG_ROOT_PATH.PWG_DERIVATIVE_DIR.$path) as $file) 
    23232331  { 
  • trunk/admin/picture_coi.php

    r13038 r13052  
    5858if (isset($_POST['submit'])) 
    5959{ 
    60   delete_element_derivatives($row); 
     60  foreach(ImageStdParams::get_defined_type_map() as $params) 
     61  { 
     62    if ($params->sizing->max_crop != 0) 
     63    { 
     64      delete_element_derivatives($row, $params->type); 
     65    } 
     66  } 
     67  delete_element_derivatives($row, IMG_CUSTOM); 
     68  $uid = '&b='.time(); 
     69  $conf['question_mark_in_urls'] = $conf['php_extension_in_urls'] = true; 
     70  if ($conf['derivative_url_style']==1) 
     71  { 
     72    $conf['derivative_url_style']=0; //auto 
     73  } 
     74} 
     75else 
     76{ 
     77  $uid = ''; 
    6178} 
    6279 
     
    7794} 
    7895 
    79 if (isset($_POST['submit'])) 
     96foreach(ImageStdParams::get_defined_type_map() as $params) 
    8097{ 
    81   $uid = '&b='.time(); 
    82   $conf['question_mark_in_urls'] = $conf['php_extension_in_urls'] = true; 
    83   $conf['derivative_url_style']=2; //script 
    84   $tpl_var['U_SQUARE'] = DerivativeImage::url(IMG_SQUARE, $row).$uid; 
    85   $tpl_var['U_THUMB'] = DerivativeImage::url(IMG_THUMB, $row).$uid; 
     98  if ($params->sizing->max_crop != 0) 
     99  { 
     100    $derivative = new DerivativeImage($params, new SrcImage($row) ); 
     101    $template->append( 'cropped_derivatives', array(  
     102      'U_IMG' => $derivative->get_url().$uid, 
     103      'HTM_SIZE' => $derivative->get_size_htm(), 
     104    ) ); 
     105  } 
    86106} 
    87 else 
    88 { 
    89   $tpl_var['U_SQUARE'] = DerivativeImage::url(IMG_SQUARE, $row); 
    90   $tpl_var['U_THUMB'] = DerivativeImage::url(IMG_THUMB, $row); 
    91 } 
     107 
    92108 
    93109$template->assign($tpl_var); 
  • trunk/admin/themes/default/template/picture_coi.tpl

    r13038 r13052  
    99</div> 
    1010 
    11 <div> 
    12 <img src="{$U_SQUARE}" alt="{$ALT}"> 
    13 <img src="{$U_THUMB}" alt="{$ALT}"> 
    14 </div> 
     11<form method="post"> 
    1512 
    16 <div> 
    17 <form method="post"> 
     13<fieldset> 
     14<legend>{'Crop'|@translate}</legend> 
     15{foreach from=$cropped_derivatives item=deriv} 
     16<img src="{$deriv.U_IMG}" alt="{$ALT}" {$deriv.HTM_SIZE}> 
     17{/foreach} 
     18</fieldset> 
     19 
     20<fieldset> 
     21<legend>{'Center of interest'|@translate}</legend> 
    1822<input type="hidden" id="l" name="l" value="{if isset($coi)}{$coi.l}{/if}"> 
    1923<input type="hidden" id="t" name="t" value="{if isset($coi)}{$coi.t}{/if}"> 
     
    2630<input type="submit" name="submit" value="{'Submit'|@translate}"> 
    2731</p> 
     32</fieldset> 
    2833</form> 
    29 </div> 
    3034 
    3135{footer_script} 
     
    5256{/literal} 
    5357jQuery("#jcrop").Jcrop( {ldelim} 
    54         boxWidth: 400, boxHeight: 400, 
     58        boxWidth: 500, boxHeight: 400, 
    5559        onChange: jOnChange, 
    5660        onRelease: jOnRelease 
  • trunk/themes/default/js/jquery.js

    r12525 r13052  
    11/*! 
    2  * jQuery JavaScript Library v1.6.4 
     2 * jQuery JavaScript Library v1.7.1 
    33 * http://jquery.com/ 
    44 * 
     
    1212 * Released under the MIT, BSD, and GPL Licenses. 
    1313 * 
    14  * Date: Mon Sep 12 18:54:48 2011 -0400 
     14 * Date: Mon Nov 21 21:11:03 2011 -0500 
    1515 */ 
    1616(function( window, undefined ) { 
     
    4747        trimLeft = /^\s+/, 
    4848        trimRight = /\s+$/, 
    49  
    50         // Check for digits 
    51         rdigit = /\d/, 
    5249 
    5350        // Match a standalone tag 
     
    141138                                if ( match[1] ) { 
    142139                                        context = context instanceof jQuery ? context[0] : context; 
    143                                         doc = (context ? context.ownerDocument || context : document); 
     140                                        doc = ( context ? context.ownerDocument || context : document ); 
    144141 
    145142                                        // If a single string is passed in and it's a single tag 
     
    158155                                        } else { 
    159156                                                ret = jQuery.buildFragment( [ match[1] ], [ doc ] ); 
    160                                                 selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes; 
     157                                                selector = ( ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment ).childNodes; 
    161158                                        } 
    162159 
     
    188185                        // HANDLE: $(expr, $(...)) 
    189186                        } else if ( !context || context.jquery ) { 
    190                                 return (context || rootjQuery).find( selector ); 
     187                                return ( context || rootjQuery ).find( selector ); 
    191188 
    192189                        // HANDLE: $(expr, context) 
     
    202199                } 
    203200 
    204                 if (selector.selector !== undefined) { 
     201                if ( selector.selector !== undefined ) { 
    205202                        this.selector = selector.selector; 
    206203                        this.context = selector.context; 
     
    214211 
    215212        // The current version of jQuery being used 
    216         jquery: "1.6.4", 
     213        jquery: "1.7.1", 
    217214 
    218215        // The default length of a jQuery object is 0 
     
    259256 
    260257                if ( name === "find" ) { 
    261                         ret.selector = this.selector + (this.selector ? " " : "") + selector; 
     258                        ret.selector = this.selector + ( this.selector ? " " : "" ) + selector; 
    262259                } else if ( name ) { 
    263260                        ret.selector = this.selector + "." + name + "(" + selector + ")"; 
     
    280277 
    281278                // Add the callback 
    282                 readyList.done( fn ); 
     279                readyList.add( fn ); 
    283280 
    284281                return this; 
     
    286283 
    287284        eq: function( i ) { 
     285                i = +i; 
    288286                return i === -1 ? 
    289287                        this.slice( i ) : 
    290                         this.slice( i, +i + 1 ); 
     288                        this.slice( i, i + 1 ); 
    291289        }, 
    292290 
     
    435433 
    436434                        // If there are functions bound, to execute 
    437                         readyList.resolveWith( document, [ jQuery ] ); 
     435                        readyList.fireWith( document, [ jQuery ] ); 
    438436 
    439437                        // Trigger any bound ready events 
    440438                        if ( jQuery.fn.trigger ) { 
    441                                 jQuery( document ).trigger( "ready" ).unbind( "ready" ); 
     439                                jQuery( document ).trigger( "ready" ).off( "ready" ); 
    442440                        } 
    443441                } 
     
    449447                } 
    450448 
    451                 readyList = jQuery._Deferred(); 
     449                readyList = jQuery.Callbacks( "once memory" ); 
    452450 
    453451                // Catch cases where $(document).ready() is called after the 
     
    505503        }, 
    506504 
    507         isNaN: function( obj ) { 
    508                 return obj == null || !rdigit.test( obj ) || isNaN( obj ); 
     505        isNumeric: function( obj ) { 
     506                return !isNaN( parseFloat(obj) ) && isFinite( obj ); 
    509507        }, 
    510508 
     
    552550 
    553551        error: function( msg ) { 
    554                 throw msg; 
     552                throw new Error( msg ); 
    555553        }, 
    556554 
     
    574572                        .replace( rvalidbraces, "")) ) { 
    575573 
    576                         return (new Function( "return " + data ))(); 
     574                        return ( new Function( "return " + data ) )(); 
    577575 
    578576                } 
     
    689687                if ( array != null ) { 
    690688                        // The window, strings (and functions) also have 'length' 
    691                         // The extra typeof function check is to prevent crashes 
    692                         // in Safari 2 (See: #3039) 
    693689                        // Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930 
    694690                        var type = jQuery.type( array ); 
     
    704700        }, 
    705701 
    706         inArray: function( elem, array ) { 
    707                 if ( !array ) { 
    708                         return -1; 
    709                 } 
    710  
    711                 if ( indexOf ) { 
    712                         return indexOf.call( array, elem ); 
    713                 } 
    714  
    715                 for ( var i = 0, length = array.length; i < length; i++ ) { 
    716                         if ( array[ i ] === elem ) { 
    717                                 return i; 
     702        inArray: function( elem, array, i ) { 
     703                var len; 
     704 
     705                if ( array ) { 
     706                        if ( indexOf ) { 
     707                                return indexOf.call( array, elem, i ); 
     708                        } 
     709 
     710                        len = array.length; 
     711                        i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; 
     712 
     713                        for ( ; i < len; i++ ) { 
     714                                // Skip accessing in sparse arrays 
     715                                if ( i in array && array[ i ] === elem ) { 
     716                                        return i; 
     717                                } 
    718718                        } 
    719719                } 
     
    851851 
    852852        now: function() { 
    853                 return (new Date()).getTime(); 
     853                return ( new Date() ).getTime(); 
    854854        }, 
    855855 
     
    958958 
    959959 
    960 var // Promise methods 
    961         promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ), 
    962         // Static reference to slice 
    963         sliceDeferred = [].slice; 
    964  
    965 jQuery.extend({ 
    966         // Create a simple deferred (one callbacks list) 
    967         _Deferred: function() { 
    968                 var // callbacks list 
    969                         callbacks = [], 
    970                         // stored [ context , args ] 
    971                         fired, 
    972                         // to avoid firing when already doing so 
    973                         firing, 
    974                         // flag to know if the deferred has been cancelled 
    975                         cancelled, 
    976                         // the deferred itself 
    977                         deferred  = { 
    978  
    979                                 // done( f1, f2, ...) 
    980                                 done: function() { 
    981                                         if ( !cancelled ) { 
    982                                                 var args = arguments, 
    983                                                         i, 
    984                                                         length, 
    985                                                         elem, 
    986                                                         type, 
    987                                                         _fired; 
    988                                                 if ( fired ) { 
    989                                                         _fired = fired; 
    990                                                         fired = 0; 
    991                                                 } 
    992                                                 for ( i = 0, length = args.length; i < length; i++ ) { 
    993                                                         elem = args[ i ]; 
    994                                                         type = jQuery.type( elem ); 
    995                                                         if ( type === "array" ) { 
    996                                                                 deferred.done.apply( deferred, elem ); 
    997                                                         } else if ( type === "function" ) { 
    998                                                                 callbacks.push( elem ); 
     960// String to Object flags format cache 
     961var flagsCache = {}; 
     962 
     963// Convert String-formatted flags into Object-formatted ones and store in cache 
     964function createFlags( flags ) { 
     965        var object = flagsCache[ flags ] = {}, 
     966                i, length; 
     967        flags = flags.split( /\s+/ ); 
     968        for ( i = 0, length = flags.length; i < length; i++ ) { 
     969                object[ flags[i] ] = true; 
     970        } 
     971        return object; 
     972} 
     973 
     974/* 
     975 * Create a callback list using the following parameters: 
     976 * 
     977 *      flags:  an optional list of space-separated flags that will change how 
     978 *                      the callback list behaves 
     979 * 
     980 * By default a callback list will act like an event callback list and can be 
     981 * "fired" multiple times. 
     982 * 
     983 * Possible flags: 
     984 * 
     985 *      once:                   will ensure the callback list can only be fired once (like a Deferred) 
     986 * 
     987 *      memory:                 will keep track of previous values and will call any callback added 
     988 *                                      after the list has been fired right away with the latest "memorized" 
     989 *                                      values (like a Deferred) 
     990 * 
     991 *      unique:                 will ensure a callback can only be added once (no duplicate in the list) 
     992 * 
     993 *      stopOnFalse:    interrupt callings when a callback returns false 
     994 * 
     995 */ 
     996jQuery.Callbacks = function( flags ) { 
     997 
     998        // Convert flags from String-formatted to Object-formatted 
     999        // (we check in cache first) 
     1000        flags = flags ? ( flagsCache[ flags ] || createFlags( flags ) ) : {}; 
     1001 
     1002        var // Actual callback list 
     1003                list = [], 
     1004                // Stack of fire calls for repeatable lists 
     1005                stack = [], 
     1006                // Last fire value (for non-forgettable lists) 
     1007                memory, 
     1008                // Flag to know if list is currently firing 
     1009                firing, 
     1010                // First callback to fire (used internally by add and fireWith) 
     1011                firingStart, 
     1012                // End of the loop when firing 
     1013                firingLength, 
     1014                // Index of currently firing callback (modified by remove if needed) 
     1015                firingIndex, 
     1016                // Add one or several callbacks to the list 
     1017                add = function( args ) { 
     1018                        var i, 
     1019                                length, 
     1020                                elem, 
     1021                                type, 
     1022                                actual; 
     1023                        for ( i = 0, length = args.length; i < length; i++ ) { 
     1024                                elem = args[ i ]; 
     1025                                type = jQuery.type( elem ); 
     1026                                if ( type === "array" ) { 
     1027                                        // Inspect recursively 
     1028                                        add( elem ); 
     1029                                } else if ( type === "function" ) { 
     1030                                        // Add if not in unique mode and callback is not in 
     1031                                        if ( !flags.unique || !self.has( elem ) ) { 
     1032                                                list.push( elem ); 
     1033                                        } 
     1034                                } 
     1035                        } 
     1036                }, 
     1037                // Fire callbacks 
     1038                fire = function( context, args ) { 
     1039                        args = args || []; 
     1040                        memory = !flags.memory || [ context, args ]; 
     1041                        firing = true; 
     1042                        firingIndex = firingStart || 0; 
     1043                        firingStart = 0; 
     1044                        firingLength = list.length; 
     1045                        for ( ; list && firingIndex < firingLength; firingIndex++ ) { 
     1046                                if ( list[ firingIndex ].apply( context, args ) === false && flags.stopOnFalse ) { 
     1047                                        memory = true; // Mark as halted 
     1048                                        break; 
     1049                                } 
     1050                        } 
     1051                        firing = false; 
     1052                        if ( list ) { 
     1053                                if ( !flags.once ) { 
     1054                                        if ( stack && stack.length ) { 
     1055                                                memory = stack.shift(); 
     1056                                                self.fireWith( memory[ 0 ], memory[ 1 ] ); 
     1057                                        } 
     1058                                } else if ( memory === true ) { 
     1059                                        self.disable(); 
     1060                                } else { 
     1061                                        list = []; 
     1062                                } 
     1063                        } 
     1064                }, 
     1065                // Actual Callbacks object 
     1066                self = { 
     1067                        // Add a callback or a collection of callbacks to the list 
     1068                        add: function() { 
     1069                                if ( list ) { 
     1070                                        var length = list.length; 
     1071                                        add( arguments ); 
     1072                                        // Do we need to add the callbacks to the 
     1073                                        // current firing batch? 
     1074                                        if ( firing ) { 
     1075                                                firingLength = list.length; 
     1076                                        // With memory, if we're not firing then 
     1077                                        // we should call right away, unless previous 
     1078                                        // firing was halted (stopOnFalse) 
     1079                                        } else if ( memory && memory !== true ) { 
     1080                                                firingStart = length; 
     1081                                                fire( memory[ 0 ], memory[ 1 ] ); 
     1082                                        } 
     1083                                } 
     1084                                return this; 
     1085                        }, 
     1086                        // Remove a callback from the list 
     1087                        remove: function() { 
     1088                                if ( list ) { 
     1089                                        var args = arguments, 
     1090                                                argIndex = 0, 
     1091                                                argLength = args.length; 
     1092                                        for ( ; argIndex < argLength ; argIndex++ ) { 
     1093                                                for ( var i = 0; i < list.length; i++ ) { 
     1094                                                        if ( args[ argIndex ] === list[ i ] ) { 
     1095                                                                // Handle firingIndex and firingLength 
     1096                                                                if ( firing ) { 
     1097                                                                        if ( i <= firingLength ) { 
     1098                                                                                firingLength--; 
     1099                                                                                if ( i <= firingIndex ) { 
     1100                                                                                        firingIndex--; 
     1101                                                                                } 
     1102                                                                        } 
     1103                                                                } 
     1104                                                                // Remove the element 
     1105                                                                list.splice( i--, 1 ); 
     1106                                                                // If we have some unicity property then 
     1107                                                                // we only need to do this once 
     1108                                                                if ( flags.unique ) { 
     1109                                                                        break; 
     1110                                                                } 
    9991111                                                        } 
    10001112                                                } 
    1001                                                 if ( _fired ) { 
    1002                                                         deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] ); 
     1113                                        } 
     1114                                } 
     1115                                return this; 
     1116                        }, 
     1117                        // Control if a given callback is in the list 
     1118                        has: function( fn ) { 
     1119                                if ( list ) { 
     1120                                        var i = 0, 
     1121                                                length = list.length; 
     1122                                        for ( ; i < length; i++ ) { 
     1123                                                if ( fn === list[ i ] ) { 
     1124                                                        return true; 
    10031125                                                } 
    10041126                                        } 
     1127                                } 
     1128                                return false; 
     1129                        }, 
     1130                        // Remove all callbacks from the list 
     1131                        empty: function() { 
     1132                                list = []; 
     1133                                return this; 
     1134                        }, 
     1135                        // Have the list do nothing anymore 
     1136                        disable: function() { 
     1137                                list = stack = memory = undefined; 
     1138                                return this; 
     1139                        }, 
     1140                        // Is it disabled? 
     1141                        disabled: function() { 
     1142                                return !list; 
     1143                        }, 
     1144                        // Lock the list in its current state 
     1145                        lock: function() { 
     1146                                stack = undefined; 
     1147                                if ( !memory || memory === true ) { 
     1148                                        self.disable(); 
     1149                                } 
     1150                                return this; 
     1151                        }, 
     1152                        // Is it locked? 
     1153                        locked: function() { 
     1154                                return !stack; 
     1155                        }, 
     1156                        // Call all callbacks with the given context and arguments 
     1157                        fireWith: function( context, args ) { 
     1158                                if ( stack ) { 
     1159                                        if ( firing ) { 
     1160                                                if ( !flags.once ) { 
     1161                                                        stack.push( [ context, args ] ); 
     1162                                                } 
     1163                                        } else if ( !( flags.once && memory ) ) { 
     1164                                                fire( context, args ); 
     1165                                        } 
     1166                                } 
     1167                                return this; 
     1168                        }, 
     1169                        // Call all the callbacks with the given arguments 
     1170                        fire: function() { 
     1171                                self.fireWith( this, arguments ); 
     1172                                return this; 
     1173                        }, 
     1174                        // To know if the callbacks have already been called at least once 
     1175                        fired: function() { 
     1176                                return !!memory; 
     1177                        } 
     1178                }; 
     1179 
     1180        return self; 
     1181}; 
     1182 
     1183 
     1184 
     1185 
     1186var // Static reference to slice 
     1187        sliceDeferred = [].slice; 
     1188 
     1189jQuery.extend({ 
     1190 
     1191        Deferred: function( func ) { 
     1192                var doneList = jQuery.Callbacks( "once memory" ), 
     1193                        failList = jQuery.Callbacks( "once memory" ), 
     1194                        progressList = jQuery.Callbacks( "memory" ), 
     1195                        state = "pending", 
     1196                        lists = { 
     1197                                resolve: doneList, 
     1198                                reject: failList, 
     1199                                notify: progressList 
     1200                        }, 
     1201                        promise = { 
     1202                                done: doneList.add, 
     1203                                fail: failList.add, 
     1204                                progress: progressList.add, 
     1205 
     1206                                state: function() { 
     1207                                        return state; 
     1208                                }, 
     1209 
     1210                                // Deprecated 
     1211                                isResolved: doneList.fired, 
     1212                                isRejected: failList.fired, 
     1213 
     1214                                then: function( doneCallbacks, failCallbacks, progressCallbacks ) { 
     1215                                        deferred.done( doneCallbacks ).fail( failCallbacks ).progress( progressCallbacks ); 
    10051216                                        return this; 
    10061217                                }, 
    1007  
    1008                                 // resolve with given context and args 
    1009                                 resolveWith: function( context, args ) { 
    1010                                         if ( !cancelled && !fired && !firing ) { 
    1011                                                 // make sure args are available (#8421) 
    1012                                                 args = args || []; 
    1013                                                 firing = 1; 
    1014                                                 try { 
    1015                                                         while( callbacks[ 0 ] ) { 
    1016                                                                 callbacks.shift().apply( context, args ); 
    1017                                                         } 
    1018                                                 } 
    1019                                                 finally { 
    1020                                                         fired = [ context, args ]; 
    1021                                                         firing = 0; 
    1022                                                 } 
    1023                                         } 
     1218                                always: function() { 
     1219                                        deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments ); 
    10241220                                        return this; 
    10251221                                }, 
    1026  
    1027                                 // resolve with this as context and given arguments 
    1028                                 resolve: function() { 
    1029                                         deferred.resolveWith( this, arguments ); 
    1030                                         return this; 
     1222                                pipe: function( fnDone, fnFail, fnProgress ) { 
     1223                                        return jQuery.Deferred(function( newDefer ) { 
     1224                                                jQuery.each( { 
     1225                                                        done: [ fnDone, "resolve" ], 
     1226                                                        fail: [ fnFail, "reject" ], 
     1227                                                        progress: [ fnProgress, "notify" ] 
     1228                                                }, function( handler, data ) { 
     1229                                                        var fn = data[ 0 ], 
     1230                                                                action = data[ 1 ], 
     1231                                                                returned; 
     1232                                                        if ( jQuery.isFunction( fn ) ) { 
     1233                                                                deferred[ handler ](function() { 
     1234                                                                        returned = fn.apply( this, arguments ); 
     1235                                                                        if ( returned && jQuery.isFunction( returned.promise ) ) { 
     1236                                                                                returned.promise().then( newDefer.resolve, newDefer.reject, newDefer.notify ); 
     1237                                                                        } else { 
     1238                                                                                newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] ); 
     1239                                                                        } 
     1240                                                                }); 
     1241                                                        } else { 
     1242                                                                deferred[ handler ]( newDefer[ action ] ); 
     1243                                                        } 
     1244                                                }); 
     1245                                        }).promise(); 
    10311246                                }, 
    1032  
    1033                                 // Has this deferred been resolved? 
    1034                                 isResolved: function() { 
    1035                                         return !!( firing || fired ); 
    1036                                 }, 
    1037  
    1038                                 // Cancel 
    1039                                 cancel: function() { 
    1040                                         cancelled = 1; 
    1041                                         callbacks = []; 
    1042                                         return this; 
    1043                                 } 
    1044                         }; 
    1045  
    1046                 return deferred; 
    1047         }, 
    1048  
    1049         // Full fledged deferred (two callbacks list) 
    1050         Deferred: function( func ) { 
    1051                 var deferred = jQuery._Deferred(), 
    1052                         failDeferred = jQuery._Deferred(), 
    1053                         promise; 
    1054                 // Add errorDeferred methods, then and promise 
    1055                 jQuery.extend( deferred, { 
    1056                         then: function( doneCallbacks, failCallbacks ) { 
    1057                                 deferred.done( doneCallbacks ).fail( failCallbacks ); 
    1058                                 return this; 
     1247                                // Get a promise for this deferred 
     1248                                // If obj is provided, the promise aspect is added to the object 
     1249                                promise: function( obj ) { 
     1250                                        if ( obj == null ) { 
     1251                                                obj = promise; 
     1252                                        } else { 
     1253                                                for ( var key in promise ) { 
     1254                                                        obj[ key ] = promise[ key ]; 
     1255                                                } 
     1256                                        } 
     1257                                        return obj; 
     1258                                } 
    10591259                        }, 
    1060                         always: function() { 
    1061                                 return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments ); 
    1062                         }, 
    1063                         fail: failDeferred.done, 
    1064                         rejectWith: failDeferred.resolveWith, 
    1065                         reject: failDeferred.resolve, 
    1066                         isRejected: failDeferred.isResolved, 
    1067                         pipe: function( fnDone, fnFail ) { 
    1068                                 return jQuery.Deferred(function( newDefer ) { 
    1069                                         jQuery.each( { 
    1070                                                 done: [ fnDone, "resolve" ], 
    1071                                                 fail: [ fnFail, "reject" ] 
    1072                                         }, function( handler, data ) { 
    1073                                                 var fn = data[ 0 ], 
    1074                                                         action = data[ 1 ], 
    1075                                                         returned; 
    1076                                                 if ( jQuery.isFunction( fn ) ) { 
    1077                                                         deferred[ handler ](function() { 
    1078                                                                 returned = fn.apply( this, arguments ); 
    1079                                                                 if ( returned && jQuery.isFunction( returned.promise ) ) { 
    1080                                                                         returned.promise().then( newDefer.resolve, newDefer.reject ); 
    1081                                                                 } else { 
    1082                                                                         newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] ); 
    1083                                                                 } 
    1084                                                         }); 
    1085                                                 } else { 
    1086                                                         deferred[ handler ]( newDefer[ action ] ); 
    1087                                                 } 
    1088                                         }); 
    1089                                 }).promise(); 
    1090                         }, 
    1091                         // Get a promise for this deferred 
    1092                         // If obj is provided, the promise aspect is added to the object 
    1093                         promise: function( obj ) { 
    1094                                 if ( obj == null ) { 
    1095                                         if ( promise ) { 
    1096                                                 return promise; 
    1097                                         } 
    1098                                         promise = obj = {}; 
    1099                                 } 
    1100                                 var i = promiseMethods.length; 
    1101                                 while( i-- ) { 
    1102                                         obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ]; 
    1103                                 } 
    1104                                 return obj; 
    1105                         } 
    1106                 }); 
    1107                 // Make sure only one callback list will be used 
    1108                 deferred.done( failDeferred.cancel ).fail( deferred.cancel ); 
    1109                 // Unexpose cancel 
    1110                 delete deferred.cancel; 
     1260                        deferred = promise.promise({}), 
     1261                        key; 
     1262 
     1263                for ( key in lists ) { 
     1264                        deferred[ key ] = lists[ key ].fire; 
     1265                        deferred[ key + "With" ] = lists[ key ].fireWith; 
     1266                } 
     1267 
     1268                // Handle state 
     1269                deferred.done( function() { 
     1270                        state = "resolved"; 
     1271                }, failList.disable, progressList.lock ).fail( function() { 
     1272                        state = "rejected"; 
     1273                }, doneList.disable, progressList.lock ); 
     1274 
    11111275                // Call given func if any 
    11121276                if ( func ) { 
    11131277                        func.call( deferred, deferred ); 
    11141278                } 
     1279 
     1280                // All done! 
    11151281                return deferred; 
    11161282        }, 
     
    11181284        // Deferred helper 
    11191285        when: function( firstParam ) { 
    1120                 var args = arguments, 
     1286                var args = sliceDeferred.call( arguments, 0 ), 
    11211287                        i = 0, 
    11221288                        length = args.length, 
     1289                        pValues = new Array( length ), 
    11231290                        count = length, 
     1291                        pCount = length, 
    11241292                        deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ? 
    11251293                                firstParam : 
    1126                                 jQuery.Deferred(); 
     1294                                jQuery.Deferred(), 
     1295                        promise = deferred.promise(); 
    11271296                function resolveFunc( i ) { 
    11281297                        return function( value ) { 
    11291298                                args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; 
    11301299                                if ( !( --count ) ) { 
    1131                                         // Strange bug in FF4: 
    1132                                         // Values changed onto the arguments object sometimes end up as undefined values 
    1133                                         // outside the $.when method. Cloning the object into a fresh array solves the issue 
    1134                                         deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) ); 
     1300                                        deferred.resolveWith( deferred, args ); 
    11351301                                } 
    11361302                        }; 
    11371303                } 
     1304                function progressFunc( i ) { 
     1305                        return function( value ) { 
     1306                                pValues[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value; 
     1307                                deferred.notifyWith( promise, pValues ); 
     1308                        }; 
     1309                } 
    11381310                if ( length > 1 ) { 
    1139                         for( ; i < length; i++ ) { 
    1140                                 if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) { 
    1141                                         args[ i ].promise().then( resolveFunc(i), deferred.reject ); 
     1311                        for ( ; i < length; i++ ) { 
     1312                                if ( args[ i ] && args[ i ].promise && jQuery.isFunction( args[ i ].promise ) ) { 
     1313                                        args[ i ].promise().then( resolveFunc(i), deferred.reject, progressFunc(i) ); 
    11421314                                } else { 
    11431315                                        --count; 
     
    11501322                        deferred.resolveWith( deferred, length ? [ firstParam ] : [] ); 
    11511323                } 
    1152                 return deferred.promise(); 
     1324                return promise; 
    11531325        } 
    11541326}); 
     
    11561328 
    11571329 
     1330 
    11581331jQuery.support = (function() { 
    11591332 
    1160         var div = document.createElement( "div" ), 
    1161                 documentElement = document.documentElement, 
     1333        var support, 
    11621334                all, 
    11631335                a, 
     
    11661338                input, 
    11671339                marginDiv, 
    1168                 support, 
    11691340                fragment, 
    1170                 body, 
    1171                 testElementParent, 
    1172                 testElement, 
    1173                 testElementStyle, 
    11741341                tds, 
    11751342                events, 
    11761343                eventName, 
    11771344                i, 
    1178                 isSupported; 
     1345                isSupported, 
     1346                div = document.createElement( "div" ), 
     1347                documentElement = document.documentElement; 
    11791348 
    11801349        // Preliminary tests 
    11811350        div.setAttribute("className", "t"); 
    11821351        div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>"; 
    1183  
    11841352 
    11851353        all = div.getElementsByTagName( "*" ); 
     
    12021370                // Make sure that tbody elements aren't automatically inserted 
    12031371                // IE will insert them into empty tables 
    1204                 tbody: !div.getElementsByTagName( "tbody" ).length, 
     1372                tbody: !div.getElementsByTagName("tbody").length, 
    12051373 
    12061374                // Make sure that link elements get serialized correctly by innerHTML 
    12071375                // This requires a wrapper element in IE 
    1208                 htmlSerialize: !!div.getElementsByTagName( "link" ).length, 
     1376                htmlSerialize: !!div.getElementsByTagName("link").length, 
    12091377 
    12101378                // Get the style information from getAttribute 
     
    12141382                // Make sure that URLs aren't manipulated 
    12151383                // (IE normalizes it by default) 
    1216                 hrefNormalized: ( a.getAttribute( "href" ) === "/a" ), 
     1384                hrefNormalized: ( a.getAttribute("href") === "/a" ), 
    12171385 
    12181386                // Make sure that element opacity exists 
    12191387                // (IE uses filter instead) 
    12201388                // Use a regex to work around a WebKit issue. See #5145 
    1221                 opacity: /^0.55$/.test( a.style.opacity ), 
     1389                opacity: /^0.55/.test( a.style.opacity ), 
    12221390 
    12231391                // Verify style float existence 
     
    12361404                // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) 
    12371405                getSetAttribute: div.className !== "t", 
     1406 
     1407                // Tests for enctype support on a form(#6743) 
     1408                enctype: !!document.createElement("form").enctype, 
     1409 
     1410                // Makes sure cloning an html5 element does not cause problems 
     1411                // Where outerHTML is undefined, this still works 
     1412                html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>", 
    12381413 
    12391414                // Will be defined later 
     
    12741449        } 
    12751450 
    1276         // Check if a radio maintains it's value 
     1451        // Check if a radio maintains its value 
    12771452        // after being appended to the DOM 
    12781453        input = document.createElement("input"); 
     
    12841459        div.appendChild( input ); 
    12851460        fragment = document.createDocumentFragment(); 
    1286         fragment.appendChild( div.firstChild ); 
     1461        fragment.appendChild( div.lastChild ); 
    12871462 
    12881463        // WebKit doesn't clone checked state correctly in fragments 
    12891464        support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked; 
    1290  
    1291         div.innerHTML = ""; 
    1292  
    1293         // Figure out if the W3C box model works as expected 
    1294         div.style.width = div.style.paddingLeft = "1px"; 
    1295  
    1296         body = document.getElementsByTagName( "body" )[ 0 ]; 
    1297         // We use our own, invisible, body unless the body is already present 
    1298         // in which case we use a div (#9239) 
    1299         testElement = document.createElement( body ? "div" : "body" ); 
    1300         testElementStyle = { 
    1301                 visibility: "hidden", 
    1302                 width: 0, 
    1303                 height: 0, 
    1304                 border: 0, 
    1305                 margin: 0, 
    1306                 background: "none" 
    1307         }; 
    1308         if ( body ) { 
    1309                 jQuery.extend( testElementStyle, { 
    1310                         position: "absolute", 
    1311                         left: "-1000px", 
    1312                         top: "-1000px" 
    1313                 }); 
    1314         } 
    1315         for ( i in testElementStyle ) { 
    1316                 testElement.style[ i ] = testElementStyle[ i ]; 
    1317         } 
    1318         testElement.appendChild( div ); 
    1319         testElementParent = body || documentElement; 
    1320         testElementParent.insertBefore( testElement, testElementParent.firstChild ); 
    13211465 
    13221466        // Check if a disconnected checkbox will retain its checked 
     
    13241468        support.appendChecked = input.checked; 
    13251469 
    1326         support.boxModel = div.offsetWidth === 2; 
    1327  
    1328         if ( "zoom" in div.style ) { 
    1329                 // Check if natively block-level elements act like inline-block 
    1330                 // elements when setting their display to 'inline' and giving 
    1331                 // them layout 
    1332                 // (IE < 8 does this) 
    1333                 div.style.display = "inline"; 
    1334                 div.style.zoom = 1; 
    1335                 support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 ); 
    1336  
    1337                 // Check if elements with layout shrink-wrap their children 
    1338                 // (IE 6 does this) 
    1339                 div.style.display = ""; 
    1340                 div.innerHTML = "<div style='width:4px;'></div>"; 
    1341                 support.shrinkWrapBlocks = ( div.offsetWidth !== 2 ); 
    1342         } 
    1343  
    1344         div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>"; 
    1345         tds = div.getElementsByTagName( "td" ); 
    1346  
    1347         // Check if table cells still have offsetWidth/Height when they are set 
    1348         // to display:none and there are still other visible table cells in a 
    1349         // table row; if so, offsetWidth/Height are not reliable for use when 
    1350         // determining if an element has been hidden directly using 
    1351         // display:none (it is still safe to use offsets if a parent element is 
    1352         // hidden; don safety goggles and see bug #4512 for more information). 
    1353         // (only IE 8 fails this test) 
    1354         isSupported = ( tds[ 0 ].offsetHeight === 0 ); 
    1355  
    1356         tds[ 0 ].style.display = ""; 
    1357         tds[ 1 ].style.display = "none"; 
    1358  
    1359         // Check if empty table cells still have offsetWidth/Height 
    1360         // (IE < 8 fail this test) 
    1361         support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); 
     1470        fragment.removeChild( input ); 
     1471        fragment.appendChild( div ); 
     1472 
    13621473        div.innerHTML = ""; 
    13631474 
     
    13671478        // Fails in WebKit before Feb 2011 nightlies 
    13681479        // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right 
    1369         if ( document.defaultView && document.defaultView.getComputedStyle ) { 
     1480        if ( window.getComputedStyle ) { 
    13701481                marginDiv = document.createElement( "div" ); 
    13711482                marginDiv.style.width = "0"; 
    13721483                marginDiv.style.marginRight = "0"; 
     1484                div.style.width = "2px"; 
    13731485                div.appendChild( marginDiv ); 
    13741486                support.reliableMarginRight = 
    1375                         ( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0; 
    1376         } 
    1377  
    1378         // Remove the body element we added 
    1379         testElement.innerHTML = ""; 
    1380         testElementParent.removeChild( testElement ); 
     1487                        ( parseInt( ( window.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0; 
     1488        } 
    13811489 
    13821490        // Technique from Juriy Zaytsev 
    1383         // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/ 
     1491        // http://perfectionkills.com/detecting-event-support-without-browser-sniffing/ 
    13841492        // We only care about the case where non-standard event systems 
    13851493        // are used, namely in IE. Short-circuiting here helps us to 
     
    13911499                        change: 1, 
    13921500                        focusin: 1 
    1393                 } ) { 
     1501                }) { 
    13941502                        eventName = "on" + i; 
    13951503                        isSupported = ( eventName in div ); 
     
    14021510        } 
    14031511 
    1404         // Null connected elements to avoid leaks in IE 
    1405         testElement = fragment = select = opt = body = marginDiv = div = input = null; 
     1512        fragment.removeChild( div ); 
     1513 
     1514        // Null elements to avoid leaks in IE 
     1515        fragment = select = opt = marginDiv = div = input = null; 
     1516 
     1517        // Run tests that need a body at doc ready 
     1518        jQuery(function() { 
     1519                var container, outer, inner, table, td, offsetSupport, 
     1520                        conMarginTop, ptlm, vb, style, html, 
     1521                        body = document.getElementsByTagName("body")[0]; 
     1522 
     1523                if ( !body ) { 
     1524                        // Return for frameset docs that don't have a body 
     1525                        return; 
     1526                } 
     1527 
     1528                conMarginTop = 1; 
     1529                ptlm = "position:absolute;top:0;left:0;width:1px;height:1px;margin:0;"; 
     1530                vb = "visibility:hidden;border:0;"; 
     1531                style = "style='" + ptlm + "border:5px solid #000;padding:0;'"; 
     1532                html = "<div " + style + "><div></div></div>" + 
     1533                        "<table " + style + " cellpadding='0' cellspacing='0'>" + 
     1534                        "<tr><td></td></tr></table>"; 
     1535 
     1536                container = document.createElement("div"); 
     1537                container.style.cssText = vb + "width:0;height:0;position:static;top:0;margin-top:" + conMarginTop + "px"; 
     1538                body.insertBefore( container, body.firstChild ); 
     1539 
     1540                // Construct the test element 
     1541                div = document.createElement("div"); 
     1542                container.appendChild( div ); 
     1543 
     1544                // Check if table cells still have offsetWidth/Height when they are set 
     1545                // to display:none and there are still other visible table cells in a 
     1546                // table row; if so, offsetWidth/Height are not reliable for use when 
     1547                // determining if an element has been hidden directly using 
     1548                // display:none (it is still safe to use offsets if a parent element is 
     1549                // hidden; don safety goggles and see bug #4512 for more information). 
     1550                // (only IE 8 fails this test) 
     1551                div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>"; 
     1552                tds = div.getElementsByTagName( "td" ); 
     1553                isSupported = ( tds[ 0 ].offsetHeight === 0 ); 
     1554 
     1555                tds[ 0 ].style.display = ""; 
     1556                tds[ 1 ].style.display = "none"; 
     1557 
     1558                // Check if empty table cells still have offsetWidth/Height 
     1559                // (IE <= 8 fail this test) 
     1560                support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 ); 
     1561 
     1562                // Figure out if the W3C box model works as expected 
     1563                div.innerHTML = ""; 
     1564                div.style.width = div.style.paddingLeft = "1px"; 
     1565                jQuery.boxModel = support.boxModel = div.offsetWidth === 2; 
     1566 
     1567                if ( typeof div.style.zoom !== "undefined" ) { 
     1568                        // Check if natively block-level elements act like inline-block 
     1569                        // elements when setting their display to 'inline' and giving 
     1570                        // them layout 
     1571                        // (IE < 8 does this) 
     1572                        div.style.display = "inline"; 
     1573                        div.style.zoom = 1; 
     1574                        support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 ); 
     1575 
     1576                        // Check if elements with layout shrink-wrap their children 
     1577                        // (IE 6 does this) 
     1578                        div.style.display = ""; 
     1579                        div.innerHTML = "<div style='width:4px;'></div>"; 
     1580                        support.shrinkWrapBlocks = ( div.offsetWidth !== 2 ); 
     1581                } 
     1582 
     1583                div.style.cssText = ptlm + vb; 
     1584                div.innerHTML = html; 
     1585 
     1586                outer = div.firstChild; 
     1587                inner = outer.firstChild; 
     1588                td = outer.nextSibling.firstChild.firstChild; 
     1589 
     1590                offsetSupport = { 
     1591                        doesNotAddBorder: ( inner.offsetTop !== 5 ), 
     1592                        doesAddBorderForTableAndCells: ( td.offsetTop === 5 ) 
     1593                }; 
     1594 
     1595                inner.style.position = "fixed"; 
     1596                inner.style.top = "20px"; 
     1597 
     1598                // safari subtracts parent border width here which is 5px 
     1599                offsetSupport.fixedPosition = ( inner.offsetTop === 20 || inner.offsetTop === 15 ); 
     1600                inner.style.position = inner.style.top = ""; 
     1601 
     1602                outer.style.overflow = "hidden"; 
     1603                outer.style.position = "relative"; 
     1604 
     1605                offsetSupport.subtractsBorderForOverflowNotVisible = ( inner.offsetTop === -5 ); 
     1606                offsetSupport.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== conMarginTop ); 
     1607 
     1608                body.removeChild( container ); 
     1609                div  = container = null; 
     1610 
     1611                jQuery.extend( support, offsetSupport ); 
     1612        }); 
    14061613 
    14071614        return support; 
    14081615})(); 
    1409  
    1410 // Keep track of boxModel 
    1411 jQuery.boxModel = jQuery.support.boxModel; 
    14121616 
    14131617 
     
    14381642        hasData: function( elem ) { 
    14391643                elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ]; 
    1440  
    14411644                return !!elem && !isEmptyDataObject( elem ); 
    14421645        }, 
     
    14471650                } 
    14481651 
    1449                 var thisCache, ret, 
     1652                var privateCache, thisCache, ret, 
    14501653                        internalKey = jQuery.expando, 
    14511654                        getByName = typeof name === "string", 
     
    14611664                        // Only defining an ID for JS objects if its cache already exists allows 
    14621665                        // the code to shortcut on the same path as a DOM node with no cache 
    1463                         id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando; 
     1666                        id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey, 
     1667                        isEvents = name === "events"; 
    14641668 
    14651669                // Avoid doing any more work than we need to when trying to get data on an 
    14661670                // object that has no data at all 
    1467                 if ( (!id || (pvt && id && (cache[ id ] && !cache[ id ][ internalKey ]))) && getByName && data === undefined ) { 
     1671                if ( (!id || !cache[id] || (!isEvents && !pvt && !cache[id].data)) && getByName && data === undefined ) { 
    14681672                        return; 
    14691673                } 
     
    14731677                        // ends up in the global cache 
    14741678                        if ( isNode ) { 
    1475                                 elem[ jQuery.expando ] = id = ++jQuery.uuid; 
     1679                                elem[ internalKey ] = id = ++jQuery.uuid; 
    14761680                        } else { 
    1477                                 id = jQuery.expando; 
     1681                                id = internalKey; 
    14781682                        } 
    14791683                } 
     
    14821686                        cache[ id ] = {}; 
    14831687 
    1484                         // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery 
    1485                         // metadata on plain JS objects when the object is serialized using 
    1486                         // JSON.stringify 
     1688                        // Avoids exposing jQuery metadata on plain JS objects when the object 
     1689                        // is serialized using JSON.stringify 
    14871690                        if ( !isNode ) { 
    14881691                                cache[ id ].toJSON = jQuery.noop; 
     
    14941697                if ( typeof name === "object" || typeof name === "function" ) { 
    14951698                        if ( pvt ) { 
    1496                                 cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name); 
     1699                                cache[ id ] = jQuery.extend( cache[ id ], name ); 
    14971700                        } else { 
    1498                                 cache[ id ] = jQuery.extend(cache[ id ], name); 
    1499                         } 
    1500                 } 
    1501  
    1502                 thisCache = cache[ id ]; 
    1503  
    1504                 // Internal jQuery data is stored in a separate object inside the object's data 
     1701                                cache[ id ].data = jQuery.extend( cache[ id ].data, name ); 
     1702                        } 
     1703                } 
     1704 
     1705                privateCache = thisCache = cache[ id ]; 
     1706 
     1707                // jQuery data() is stored in a separate object inside the object's internal data 
    15051708                // cache in order to avoid key collisions between internal data and user-defined 
    1506                 // data 
    1507                 if ( pvt ) { 
    1508                         if ( !thisCache[ internalKey ] ) { 
    1509                                 thisCache[ internalKey ] = {}; 
    1510                         } 
    1511  
    1512                         thisCache = thisCache[ internalKey ]; 
     1709                // data. 
     1710                if ( !pvt ) { 
     1711                        if ( !thisCache.data ) { 
     1712                                thisCache.data = {}; 
     1713                        } 
     1714 
     1715                        thisCache = thisCache.data; 
    15131716                } 
    15141717 
     
    15171720                } 
    15181721 
    1519                 // TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should 
    1520                 // not attempt to inspect the internal events object using jQuery.data, as this 
    1521                 // internal data object is undocumented and subject to change. 
    1522                 if ( name === "events" && !thisCache[name] ) { 
    1523                         return thisCache[ internalKey ] && thisCache[ internalKey ].events; 
     1722                // Users should not attempt to inspect the internal events object using jQuery.data, 
     1723                // it is undocumented and subject to change. But does anyone listen? No. 
     1724                if ( isEvents && !thisCache[ name ] ) { 
     1725                        return privateCache.events; 
    15241726                } 
    15251727 
     
    15491751                } 
    15501752 
    1551                 var thisCache, 
     1753                var thisCache, i, l, 
    15521754 
    15531755                        // Reference to internal data cache key 
     
    15601762 
    15611763                        // See jQuery.data for more information 
    1562                         id = isNode ? elem[ jQuery.expando ] : jQuery.expando; 
     1764                        id = isNode ? elem[ internalKey ] : internalKey; 
    15631765 
    15641766                // If there is already no cache entry for this object, there is no 
     
    15701772                if ( name ) { 
    15711773 
    1572                         thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ]; 
     1774                        thisCache = pvt ? cache[ id ] : cache[ id ].data; 
    15731775 
    15741776                        if ( thisCache ) { 
    15751777 
    1576                                 // Support interoperable removal of hyphenated or camelcased keys 
    1577                                 if ( !thisCache[ name ] ) { 
    1578                                         name = jQuery.camelCase( name ); 
    1579                                 } 
    1580  
    1581                                 delete thisCache[ name ]; 
     1778                                // Support array or space separated string names for data keys 
     1779                                if ( !jQuery.isArray( name ) ) { 
     1780 
     1781                                        // try the string as a key before any manipulation 
     1782                                        if ( name in thisCache ) { 
     1783                                                name = [ name ]; 
     1784                                        } else { 
     1785 
     1786                                                // split the camel cased version by spaces unless a key with the spaces exists 
     1787                                                name = jQuery.camelCase( name ); 
     1788                                                if ( name in thisCache ) { 
     1789                                                        name = [ name ]; 
     1790                                                } else { 
     1791                                                        name = name.split( " " ); 
     1792                                                } 
     1793                                        } 
     1794                                } 
     1795 
     1796                                for ( i = 0, l = name.length; i < l; i++ ) { 
     1797                                        delete thisCache[ name[i] ]; 
     1798                                } 
    15821799 
    15831800                                // If there is no data left in the cache, we want to continue 
    15841801                                // and let the cache object itself get destroyed 
    1585                                 if ( !isEmptyDataObject(thisCache) ) { 
     1802                                if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) { 
    15861803                                        return; 
    15871804                                } 
     
    15901807 
    15911808                // See jQuery.data for more information 
    1592                 if ( pvt ) { 
    1593                         delete cache[ id ][ internalKey ]; 
     1809                if ( !pvt ) { 
     1810                        delete cache[ id ].data; 
    15941811 
    15951812                        // Don't destroy the parent cache unless the internal data object 
     
    15991816                        } 
    16001817                } 
    1601  
    1602                 var internalCache = cache[ id ][ internalKey ]; 
    16031818 
    16041819                // Browsers that fail expando deletion also refuse to delete expandos on 
     
    16121827                } 
    16131828 
    1614                 // We destroyed the entire user cache at once because it's faster than 
    1615                 // iterating through each key, but we need to continue to persist internal 
    1616                 // data if it existed 
    1617                 if ( internalCache ) { 
    1618                         cache[ id ] = {}; 
    1619                         // TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery 
    1620                         // metadata on plain JS objects when the object is serialized using 
    1621                         // JSON.stringify 
    1622                         if ( !isNode ) { 
    1623                                 cache[ id ].toJSON = jQuery.noop; 
    1624                         } 
    1625  
    1626                         cache[ id ][ internalKey ] = internalCache; 
    1627  
    1628                 // Otherwise, we need to eliminate the expando on the node to avoid 
     1829                // We destroyed the cache and need to eliminate the expando on the node to avoid 
    16291830                // false lookups in the cache for entries that no longer exist 
    1630                 } else if ( isNode ) { 
     1831                if ( isNode ) { 
    16311832                        // IE does not allow us to delete expando properties from nodes, 
    16321833                        // nor does it have a removeAttribute function on Document nodes; 
    16331834                        // we must handle all of these cases 
    16341835                        if ( jQuery.support.deleteExpando ) { 
    1635                                 delete elem[ jQuery.expando ]; 
     1836                                delete elem[ internalKey ]; 
    16361837                        } else if ( elem.removeAttribute ) { 
    1637                                 elem.removeAttribute( jQuery.expando ); 
     1838                                elem.removeAttribute( internalKey ); 
    16381839                        } else { 
    1639                                 elem[ jQuery.expando ] = null; 
     1840                                elem[ internalKey ] = null; 
    16401841                        } 
    16411842                } 
     
    16631864jQuery.fn.extend({ 
    16641865        data: function( key, value ) { 
    1665                 var data = null; 
     1866                var parts, attr, name, 
     1867                        data = null; 
    16661868 
    16671869                if ( typeof key === "undefined" ) { 
     
    16691871                                data = jQuery.data( this[0] ); 
    16701872 
    1671                                 if ( this[0].nodeType === 1 ) { 
    1672                             var attr = this[0].attributes, name; 
     1873                                if ( this[0].nodeType === 1 && !jQuery._data( this[0], "parsedAttrs" ) ) { 
     1874                                        attr = this[0].attributes; 
    16731875                                        for ( var i = 0, l = attr.length; i < l; i++ ) { 
    16741876                                                name = attr[i].name; 
     
    16801882                                                } 
    16811883                                        } 
     1884                                        jQuery._data( this[0], "parsedAttrs", true ); 
    16821885                                } 
    16831886                        } 
     
    16911894                } 
    16921895 
    1693                 var parts = key.split("."); 
     1896                parts = key.split("."); 
    16941897                parts[1] = parts[1] ? "." + parts[1] : ""; 
    16951898 
     
    17091912                } else { 
    17101913                        return this.each(function() { 
    1711                                 var $this = jQuery( this ), 
     1914                                var self = jQuery( this ), 
    17121915                                        args = [ parts[0], value ]; 
    17131916 
    1714                                 $this.triggerHandler( "setData" + parts[1] + "!", args ); 
     1917                                self.triggerHandler( "setData" + parts[1] + "!", args ); 
    17151918                                jQuery.data( this, key, value ); 
    1716                                 $this.triggerHandler( "changeData" + parts[1] + "!", args ); 
     1919                                self.triggerHandler( "changeData" + parts[1] + "!", args ); 
    17171920                        }); 
    17181921                } 
     
    17401943                                data === "false" ? false : 
    17411944                                data === "null" ? null : 
    1742                                 !jQuery.isNaN( data ) ? parseFloat( data ) : 
     1945                                jQuery.isNumeric( data ) ? parseFloat( data ) : 
    17431946                                        rbrace.test( data ) ? jQuery.parseJSON( data ) : 
    17441947                                        data; 
     
    17561959} 
    17571960 
    1758 // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON 
    1759 // property to be considered empty objects; this property always exists in 
    1760 // order to make sure JSON.stringify does not expose internal metadata 
     1961// checks a cache object for emptiness 
    17611962function isEmptyDataObject( obj ) { 
    17621963        for ( var name in obj ) { 
     1964 
     1965                // if the public data object is empty, the private is still empty 
     1966                if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) { 
     1967                        continue; 
     1968                } 
    17631969                if ( name !== "toJSON" ) { 
    17641970                        return false; 
     
    17761982                queueDataKey = type + "queue", 
    17771983                markDataKey = type + "mark", 
    1778                 defer = jQuery.data( elem, deferDataKey, undefined, true ); 
     1984                defer = jQuery._data( elem, deferDataKey ); 
    17791985        if ( defer && 
    1780                 ( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) && 
    1781                 ( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) { 
     1986                ( src === "queue" || !jQuery._data(elem, queueDataKey) ) && 
     1987                ( src === "mark" || !jQuery._data(elem, markDataKey) ) ) { 
    17821988                // Give room for hard-coded callbacks to fire first 
    17831989                // and eventually mark/queue something else on the element 
    17841990                setTimeout( function() { 
    1785                         if ( !jQuery.data( elem, queueDataKey, undefined, true ) && 
    1786                                 !jQuery.data( elem, markDataKey, undefined, true ) ) { 
     1991                        if ( !jQuery._data( elem, queueDataKey ) && 
     1992                                !jQuery._data( elem, markDataKey ) ) { 
    17871993                                jQuery.removeData( elem, deferDataKey, true ); 
    1788                                 defer.resolve(); 
     1994                                defer.fire(); 
    17891995                        } 
    17901996                }, 0 ); 
     
    17962002        _mark: function( elem, type ) { 
    17972003                if ( elem ) { 
    1798                         type = (type || "fx") + "mark"; 
    1799                         jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true ); 
     2004                        type = ( type || "fx" ) + "mark"; 
     2005                        jQuery._data( elem, type, (jQuery._data( elem, type ) || 0) + 1 ); 
    18002006                } 
    18012007        }, 
     
    18102016                        type = type || "fx"; 
    18112017                        var key = type + "mark", 
    1812                                 count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 ); 
     2018                                count = force ? 0 : ( (jQuery._data( elem, key ) || 1) - 1 ); 
    18132019                        if ( count ) { 
    1814                                 jQuery.data( elem, key, count, true ); 
     2020                                jQuery._data( elem, key, count ); 
    18152021                        } else { 
    18162022                                jQuery.removeData( elem, key, true ); 
     
    18212027 
    18222028        queue: function( elem, type, data ) { 
     2029                var q; 
    18232030                if ( elem ) { 
    1824                         type = (type || "fx") + "queue"; 
    1825                         var q = jQuery.data( elem, type, undefined, true ); 
     2031                        type = ( type || "fx" ) + "queue"; 
     2032                        q = jQuery._data( elem, type ); 
     2033 
    18262034                        // Speed up dequeue by getting out quickly if this is just a lookup 
    18272035                        if ( data ) { 
    18282036                                if ( !q || jQuery.isArray(data) ) { 
    1829                                         q = jQuery.data( elem, type, jQuery.makeArray(data), true ); 
     2037                                        q = jQuery._data( elem, type, jQuery.makeArray(data) ); 
    18302038                                } else { 
    18312039                                        q.push( data ); 
     
    18412049                var queue = jQuery.queue( elem, type ), 
    18422050                        fn = queue.shift(), 
    1843                         defer; 
     2051                        hooks = {}; 
    18442052 
    18452053                // If the fx queue is dequeued, always remove the progress sentinel 
     
    18522060                        // automatically dequeued 
    18532061                        if ( type === "fx" ) { 
    1854                                 queue.unshift("inprogress"); 
    1855                         } 
    1856  
    1857                         fn.call(elem, function() { 
    1858                                 jQuery.dequeue(elem, type); 
    1859                         }); 
     2062                                queue.unshift( "inprogress" ); 
     2063                        } 
     2064 
     2065                        jQuery._data( elem, type + ".run", hooks ); 
     2066                        fn.call( elem, function() { 
     2067                                jQuery.dequeue( elem, type ); 
     2068                        }, hooks ); 
    18602069                } 
    18612070 
    18622071                if ( !queue.length ) { 
    1863                         jQuery.removeData( elem, type + "queue", true ); 
     2072                        jQuery.removeData( elem, type + "queue " + type + ".run", true ); 
    18642073                        handleQueueMarkDefer( elem, type, "queue" ); 
    18652074                } 
     
    18932102        // http://blindsignals.com/index.php/2009/07/jquery-delay/ 
    18942103        delay: function( time, type ) { 
    1895                 time = jQuery.fx ? jQuery.fx.speeds[time] || time : time; 
     2104                time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; 
    18962105                type = type || "fx"; 
    18972106 
    1898                 return this.queue( type, function() { 
    1899                         var elem = this; 
    1900                         setTimeout(function() { 
    1901                                 jQuery.dequeue( elem, type ); 
    1902                         }, time ); 
     2107                return this.queue( type, function( next, hooks ) { 
     2108                        var timeout = setTimeout( next, time ); 
     2109                        hooks.stop = function() { 
     2110                                clearTimeout( timeout ); 
     2111                        }; 
    19032112                }); 
    19042113        }, 
     
    19312140                                        ( jQuery.data( elements[ i ], queueDataKey, undefined, true ) || 
    19322141                                                jQuery.data( elements[ i ], markDataKey, undefined, true ) ) && 
    1933                                         jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) { 
     2142                                        jQuery.data( elements[ i ], deferDataKey, jQuery.Callbacks( "once memory" ), true ) )) { 
    19342143                                count++; 
    1935                                 tmp.done( resolve ); 
     2144                                tmp.add( resolve ); 
    19362145                        } 
    19372146                } 
     
    19512160        rclickable = /^a(?:rea)?$/i, 
    19522161        rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, 
    1953         nodeHook, boolHook; 
     2162        getSetAttribute = jQuery.support.getSetAttribute, 
     2163        nodeHook, boolHook, fixSpecified; 
    19542164 
    19552165jQuery.fn.extend({ 
     
    19632173                }); 
    19642174        }, 
    1965          
     2175 
    19662176        prop: function( name, value ) { 
    19672177                return jQuery.access( this, name, value, true, jQuery.prop ); 
    19682178        }, 
    1969          
     2179 
    19702180        removeProp: function( name ) { 
    19712181                name = jQuery.propFix[ name ] || name; 
     
    20262236 
    20272237                if ( (value && typeof value === "string") || value === undefined ) { 
    2028                         classNames = (value || "").split( rspace ); 
     2238                        classNames = ( value || "" ).split( rspace ); 
    20292239 
    20302240                        for ( i = 0, l = this.length; i < l; i++ ) { 
     
    20872297 
    20882298        hasClass: function( selector ) { 
    2089                 var className = " " + selector + " "; 
    2090                 for ( var i = 0, l = this.length; i < l; i++ ) { 
     2299                var className = " " + selector + " ", 
     2300                        i = 0, 
     2301                        l = this.length; 
     2302                for ( ; i < l; i++ ) { 
    20912303                        if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) { 
    20922304                                return true; 
     
    20982310 
    20992311        val: function( value ) { 
    2100                 var hooks, ret, 
     2312                var hooks, ret, isFunction, 
    21012313                        elem = this[0]; 
    2102                  
     2314 
    21032315                if ( !arguments.length ) { 
    21042316                        if ( elem ) { 
     
    21112323                                ret = elem.value; 
    21122324 
    2113                                 return typeof ret === "string" ?  
     2325                                return typeof ret === "string" ? 
    21142326                                        // handle most common string cases 
    2115                                         ret.replace(rreturn, "") :  
     2327                                        ret.replace(rreturn, "") : 
    21162328                                        // handle cases where value is null/undef or number 
    21172329                                        ret == null ? "" : ret; 
    21182330                        } 
    21192331 
    2120                         return undefined; 
    2121                 } 
    2122  
    2123                 var isFunction = jQuery.isFunction( value ); 
     2332                        return; 
     2333                } 
     2334 
     2335                isFunction = jQuery.isFunction( value ); 
    21242336 
    21252337                return this.each(function( i ) { 
     
    21692381                select: { 
    21702382                        get: function( elem ) { 
    2171                                 var value, 
     2383                                var value, i, max, option, 
    21722384                                        index = elem.selectedIndex, 
    21732385                                        values = [], 
     
    21812393 
    21822394                                // Loop through all the selected options 
    2183                                 for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) { 
    2184                                         var option = options[ i ]; 
     2395                                i = one ? index : 0; 
     2396                                max = one ? index + 1 : options.length; 
     2397                                for ( ; i < max; i++ ) { 
     2398                                        option = options[ i ]; 
    21852399 
    21862400                                        // Don't return options that are disabled or in a disabled optgroup 
     
    22342448                offset: true 
    22352449        }, 
    2236          
    2237         attrFix: { 
    2238                 // Always normalize to ensure hook usage 
    2239                 tabindex: "tabIndex" 
    2240         }, 
    2241          
     2450 
    22422451        attr: function( elem, name, value, pass ) { 
    2243                 var nType = elem.nodeType; 
    2244                  
     2452                var ret, hooks, notxml, 
     2453                        nType = elem.nodeType; 
     2454 
    22452455                // don't get/set attributes on text, comment and attribute nodes 
    22462456                if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { 
    2247                         return undefined; 
     2457                        return; 
    22482458                } 
    22492459 
     
    22532463 
    22542464                // Fallback to prop when attributes are not supported 
    2255                 if ( !("getAttribute" in elem) ) { 
     2465                if ( typeof elem.getAttribute === "undefined" ) { 
    22562466                        return jQuery.prop( elem, name, value ); 
    22572467                } 
    22582468 
    2259                 var ret, hooks, 
    2260                         notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); 
    2261  
    2262                 // Normalize the name if needed 
     2469                notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); 
     2470 
     2471                // All attributes are lowercase 
     2472                // Grab necessary hook if one is defined 
    22632473                if ( notxml ) { 
    2264                         name = jQuery.attrFix[ name ] || name; 
    2265  
    2266                         hooks = jQuery.attrHooks[ name ]; 
    2267  
    2268                         if ( !hooks ) { 
    2269                                 // Use boolHook for boolean attributes 
    2270                                 if ( rboolean.test( name ) ) { 
    2271                                         hooks = boolHook; 
    2272  
    2273                                 // Use nodeHook if available( IE6/7 ) 
    2274                                 } else if ( nodeHook ) { 
    2275                                         hooks = nodeHook; 
    2276                                 } 
    2277                         } 
     2474                        name = name.toLowerCase(); 
     2475                        hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook ); 
    22782476                } 
    22792477 
     
    22822480                        if ( value === null ) { 
    22832481                                jQuery.removeAttr( elem, name ); 
    2284                                 return undefined; 
     2482                                return; 
    22852483 
    22862484                        } else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) { 
     
    23062504        }, 
    23072505 
    2308         removeAttr: function( elem, name ) { 
    2309                 var propName; 
    2310                 if ( elem.nodeType === 1 ) { 
    2311                         name = jQuery.attrFix[ name ] || name; 
    2312  
    2313                         jQuery.attr( elem, name, "" ); 
    2314                         elem.removeAttribute( name ); 
    2315  
    2316                         // Set corresponding property to false for boolean attributes 
    2317                         if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) { 
    2318                                 elem[ propName ] = false; 
     2506        removeAttr: function( elem, value ) { 
     2507                var propName, attrNames, name, l, 
     2508                        i = 0; 
     2509 
     2510                if ( value && elem.nodeType === 1 ) { 
     2511                        attrNames = value.toLowerCase().split( rspace ); 
     2512                        l = attrNames.length; 
     2513 
     2514                        for ( ; i < l; i++ ) { 
     2515                                name = attrNames[ i ]; 
     2516 
     2517                                if ( name ) { 
     2518                                        propName = jQuery.propFix[ name ] || name; 
     2519 
     2520                                        // See #9699 for explanation of this approach (setting first, then removal) 
     2521                                        jQuery.attr( elem, name, "" ); 
     2522                                        elem.removeAttribute( getSetAttribute ? name : propName ); 
     2523 
     2524                                        // Set corresponding property to false for boolean attributes 
     2525                                        if ( rboolean.test( name ) && propName in elem ) { 
     2526                                                elem[ propName ] = false; 
     2527                                        } 
     2528                                } 
    23192529                        } 
    23202530                } 
     
    23752585                contenteditable: "contentEditable" 
    23762586        }, 
    2377          
     2587 
    23782588        prop: function( elem, name, value ) { 
    2379                 var nType = elem.nodeType; 
     2589                var ret, hooks, notxml, 
     2590                        nType = elem.nodeType; 
    23802591 
    23812592                // don't get/set properties on text, comment and attribute nodes 
    23822593                if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { 
    2383                         return undefined; 
    2384                 } 
    2385  
    2386                 var ret, hooks, 
    2387                         notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); 
     2594                        return; 
     2595                } 
     2596 
     2597                notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); 
    23882598 
    23892599                if ( notxml ) { 
     
    23982608 
    23992609                        } else { 
    2400                                 return (elem[ name ] = value); 
     2610                                return ( elem[ name ] = value ); 
    24012611                        } 
    24022612 
     
    24102620                } 
    24112621        }, 
    2412          
     2622 
    24132623        propHooks: { 
    24142624                tabIndex: { 
     
    24282638}); 
    24292639 
    2430 // Add the tabindex propHook to attrHooks for back-compat 
    2431 jQuery.attrHooks.tabIndex = jQuery.propHooks.tabIndex; 
     2640// Add the tabIndex propHook to attrHooks for back-compat (different case is intentional) 
     2641jQuery.attrHooks.tabindex = jQuery.propHooks.tabIndex; 
    24322642 
    24332643// Hook for boolean attributes 
     
    24362646                // Align boolean attributes with corresponding properties 
    24372647                // Fall back to attribute presence where some booleans are not supported 
    2438                 var attrNode; 
    2439                 return jQuery.prop( elem, name ) === true || ( attrNode = elem.getAttributeNode( name ) ) && attrNode.nodeValue !== false ? 
     2648                var attrNode, 
     2649                        property = jQuery.prop( elem, name ); 
     2650                return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ? 
    24402651                        name.toLowerCase() : 
    24412652                        undefined; 
     
    24622673 
    24632674// IE6/7 do not support getting/setting some attributes with get/setAttribute 
    2464 if ( !jQuery.support.getSetAttribute ) { 
    2465          
     2675if ( !getSetAttribute ) { 
     2676 
     2677        fixSpecified = { 
     2678                name: true, 
     2679                id: true 
     2680        }; 
     2681 
    24662682        // Use this for any attribute in IE6/7 
    24672683        // This fixes almost every IE6/7 issue 
     
    24702686                        var ret; 
    24712687                        ret = elem.getAttributeNode( name ); 
    2472                         // Return undefined if nodeValue is empty string 
    2473                         return ret && ret.nodeValue !== "" ? 
     2688                        return ret && ( fixSpecified[ name ] ? ret.nodeValue !== "" : ret.specified ) ? 
    24742689                                ret.nodeValue : 
    24752690                                undefined; 
     
    24822697                                elem.setAttributeNode( ret ); 
    24832698                        } 
    2484                         return (ret.nodeValue = value + ""); 
     2699                        return ( ret.nodeValue = value + "" ); 
    24852700                } 
    24862701        }; 
     2702 
     2703        // Apply the nodeHook to tabindex 
     2704        jQuery.attrHooks.tabindex.set = nodeHook.set; 
    24872705 
    24882706        // Set width and height to auto instead of 0 on empty string( Bug #8150 ) 
     
    24982716                }); 
    24992717        }); 
     2718 
     2719        // Set contenteditable to false on removals(#10429) 
     2720        // Setting to empty string throws an error as an invalid value 
     2721        jQuery.attrHooks.contenteditable = { 
     2722                get: nodeHook.get, 
     2723                set: function( elem, value, name ) { 
     2724                        if ( value === "" ) { 
     2725                                value = "false"; 
     2726                        } 
     2727                        nodeHook.set( elem, value, name ); 
     2728                } 
     2729        }; 
    25002730} 
    25012731 
     
    25212751                }, 
    25222752                set: function( elem, value ) { 
    2523                         return (elem.style.cssText = "" + value); 
     2753                        return ( elem.style.cssText = "" + value ); 
    25242754                } 
    25252755        }; 
     
    25442774                } 
    25452775        }); 
     2776} 
     2777 
     2778// IE6/7 call enctype encoding 
     2779if ( !jQuery.support.enctype ) { 
     2780        jQuery.propFix.enctype = "encoding"; 
    25462781} 
    25472782 
     
    25612796                set: function( elem, value ) { 
    25622797                        if ( jQuery.isArray( value ) ) { 
    2563                                 return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0); 
     2798                                return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 ); 
    25642799                        } 
    25652800                } 
     
    25702805 
    25712806 
    2572 var rnamespaces = /\.(.*)$/, 
    2573         rformElems = /^(?:textarea|input|select)$/i, 
    2574         rperiod = /\./g, 
    2575         rspaces = / /g, 
    2576         rescape = /[^\w\s.|`]/g, 
    2577         fcleanup = function( nm ) { 
    2578                 return nm.replace(rescape, "\\$&"); 
     2807var rformElems = /^(?:textarea|input|select)$/i, 
     2808        rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/, 
     2809        rhoverHack = /\bhover(\.\S+)?\b/, 
     2810        rkeyEvent = /^key/, 
     2811        rmouseEvent = /^(?:mouse|contextmenu)|click/, 
     2812        rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 
     2813        rquickIs = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/, 
     2814        quickParse = function( selector ) { 
     2815                var quick = rquickIs.exec( selector ); 
     2816                if ( quick ) { 
     2817                        //   0  1    2   3 
     2818                        // [ _, tag, id, class ] 
     2819                        quick[1] = ( quick[1] || "" ).toLowerCase(); 
     2820                        quick[3] = quick[3] && new RegExp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" ); 
     2821                } 
     2822                return quick; 
     2823        }, 
     2824        quickIs = function( elem, m ) { 
     2825                var attrs = elem.attributes || {}; 
     2826                return ( 
     2827                        (!m[1] || elem.nodeName.toLowerCase() === m[1]) && 
     2828                        (!m[2] || (attrs.id || {}).value === m[2]) && 
     2829                        (!m[3] || m[3].test( (attrs[ "class" ] || {}).value )) 
     2830                ); 
     2831        }, 
     2832        hoverHack = function( events ) { 
     2833                return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" ); 
    25792834        }; 
    25802835 
    25812836/* 
    2582  * A number of helper functions used for managing events. 
    2583  * Many of the ideas behind this code originated from 
    2584  * Dean Edwards' addEvent library. 
     2837 * Helper functions for managing events -- not part of the public interface. 
     2838 * Props to Dean Edwards' addEvent library for many of the ideas. 
    25852839 */ 
    25862840jQuery.event = { 
    25872841 
    2588         // Bind an event to an element 
    2589         // Original by Dean Edwards 
    2590         add: function( elem, types, handler, data ) { 
    2591                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 
     2842        add: function( elem, types, handler, data, selector ) { 
     2843 
     2844                var elemData, eventHandle, events, 
     2845                        t, tns, type, namespaces, handleObj, 
     2846                        handleObjIn, quick, handlers, special; 
     2847 
     2848                // Don't attach events to noData or text/comment nodes (allow plain objects tho) 
     2849                if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) { 
    25922850                        return; 
    25932851                } 
    25942852 
    2595                 if ( handler === false ) { 
    2596                         handler = returnFalse; 
    2597                 } else if ( !handler ) { 
    2598                         // Fixes bug #7229. Fix recommended by jdalton 
    2599                         return; 
    2600                 } 
    2601  
    2602                 var handleObjIn, handleObj; 
    2603  
     2853                // Caller can pass in an object of custom data in lieu of the handler 
    26042854                if ( handler.handler ) { 
    26052855                        handleObjIn = handler; 
     
    26072857                } 
    26082858 
    2609                 // Make sure that the function being executed has a unique ID 
     2859                // Make sure that the handler has a unique ID, used to find/remove it later 
    26102860                if ( !handler.guid ) { 
    26112861                        handler.guid = jQuery.guid++; 
    26122862                } 
    26132863 
    2614                 // Init the element's event structure 
    2615                 var elemData = jQuery._data( elem ); 
    2616  
    2617                 // If no elemData is found then we must be trying to bind to one of the 
    2618                 // banned noData elements 
    2619                 if ( !elemData ) { 
    2620                         return; 
    2621                 } 
    2622  
    2623                 var events = elemData.events, 
    2624                         eventHandle = elemData.handle; 
    2625  
     2864                // Init the element's event structure and main handler, if this is the first 
     2865                events = elemData.events; 
    26262866                if ( !events ) { 
    26272867                        elemData.events = events = {}; 
    26282868                } 
    2629  
     2869                eventHandle = elemData.handle; 
    26302870                if ( !eventHandle ) { 
    26312871                        elemData.handle = eventHandle = function( e ) { 
     
    26332873                                // when an event is called after a page has unloaded 
    26342874                                return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ? 
    2635                                         jQuery.event.handle.apply( eventHandle.elem, arguments ) : 
     2875                                        jQuery.event.dispatch.apply( eventHandle.elem, arguments ) : 
    26362876                                        undefined; 
    26372877                        }; 
    2638                 } 
    2639  
    2640                 // Add elem as a property of the handle function 
    2641                 // This is to prevent a memory leak with non-native events in IE. 
    2642                 eventHandle.elem = elem; 
     2878                        // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events 
     2879                        eventHandle.elem = elem; 
     2880                } 
    26432881 
    26442882                // Handle multiple events separated by a space 
    26452883                // jQuery(...).bind("mouseover mouseout", fn); 
    2646                 types = types.split(" "); 
    2647  
    2648                 var type, i = 0, namespaces; 
    2649  
    2650                 while ( (type = types[ i++ ]) ) { 
    2651                         handleObj = handleObjIn ? 
    2652                                 jQuery.extend({}, handleObjIn) : 
    2653                                 { handler: handler, data: data }; 
    2654  
    2655                         // Namespaced event handlers 
    2656                         if ( type.indexOf(".") > -1 ) { 
    2657                                 namespaces = type.split("."); 
    2658                                 type = namespaces.shift(); 
    2659                                 handleObj.namespace = namespaces.slice(0).sort().join("."); 
    2660  
    2661                         } else { 
    2662                                 namespaces = []; 
    2663                                 handleObj.namespace = ""; 
    2664                         } 
    2665  
    2666                         handleObj.type = type; 
    2667                         if ( !handleObj.guid ) { 
    2668                                 handleObj.guid = handler.guid; 
    2669                         } 
    2670  
    2671                         // Get the current list of functions bound to this event 
    2672                         var handlers = events[ type ], 
    2673                                 special = jQuery.event.special[ type ] || {}; 
    2674  
    2675                         // Init the event handler queue 
     2884                types = jQuery.trim( hoverHack(types) ).split( " " ); 
     2885                for ( t = 0; t < types.length; t++ ) { 
     2886 
     2887                        tns = rtypenamespace.exec( types[t] ) || []; 
     2888                        type = tns[1]; 
     2889                        namespaces = ( tns[2] || "" ).split( "." ).sort(); 
     2890 
     2891                        // If event changes its type, use the special event handlers for the changed type 
     2892                        special = jQuery.event.special[ type ] || {}; 
     2893 
     2894                        // If selector defined, determine special event api type, otherwise given type 
     2895                        type = ( selector ? special.delegateType : special.bindType ) || type; 
     2896 
     2897                        // Update special based on newly reset type 
     2898                        special = jQuery.event.special[ type ] || {}; 
     2899 
     2900                        // handleObj is passed to all event handlers 
     2901                        handleObj = jQuery.extend({ 
     2902                                type: type, 
     2903                                origType: tns[1], 
     2904                                data: data, 
     2905                                handler: handler, 
     2906                                guid: handler.guid, 
     2907                                selector: selector, 
     2908                                quick: quickParse( selector ), 
     2909                                namespace: namespaces.join(".") 
     2910                        }, handleObjIn ); 
     2911 
     2912                        // Init the event handler queue if we're the first 
     2913                        handlers = events[ type ]; 
    26762914                        if ( !handlers ) { 
    26772915                                handlers = events[ type ] = []; 
    2678  
    2679                                 // Check for a special event handler 
    2680                                 // Only use addEventListener/attachEvent if the special 
    2681                                 // events handler returns false 
     2916                                handlers.delegateCount = 0; 
     2917 
     2918                                // Only use addEventListener/attachEvent if the special events handler returns false 
    26822919                                if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { 
    26832920                                        // Bind the global event handler to the element 
     
    26992936                        } 
    27002937 
    2701                         // Add the function to the element's handler list 
    2702                         handlers.push( handleObj ); 
    2703  
    2704                         // Keep track of which events have been used, for event optimization 
     2938                        // Add to the element's handler list, delegates in front 
     2939                        if ( selector ) { 
     2940                                handlers.splice( handlers.delegateCount++, 0, handleObj ); 
     2941                        } else { 
     2942                                handlers.push( handleObj ); 
     2943                        } 
     2944 
     2945                        // Keep track of which events have ever been used, for event optimization 
    27052946                        jQuery.event.global[ type ] = true; 
    27062947                } 
     
    27132954 
    27142955        // Detach an event or set of events from an element 
    2715         remove: function( elem, types, handler, pos ) { 
    2716                 // don't do events on text and comment nodes 
    2717                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 
     2956        remove: function( elem, types, handler, selector, mappedTypes ) { 
     2957 
     2958                var elemData = jQuery.hasData( elem ) && jQuery._data( elem ), 
     2959                        t, tns, type, origType, namespaces, origCount, 
     2960                        j, events, special, handle, eventType, handleObj; 
     2961 
     2962                if ( !elemData || !(events = elemData.events) ) { 
    27182963                        return; 
    27192964                } 
    27202965 
    2721                 if ( handler === false ) { 
    2722                         handler = returnFalse; 
    2723                 } 
    2724  
    2725                 var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType, 
    2726                         elemData = jQuery.hasData( elem ) && jQuery._data( elem ), 
    2727                         events = elemData && elemData.events; 
    2728  
    2729                 if ( !elemData || !events ) { 
    2730                         return; 
    2731                 } 
    2732  
    2733                 // types is actually an event object here 
    2734                 if ( types && types.type ) { 
    2735                         handler = types.handler; 
    2736                         types = types.type; 
    2737                 } 
    2738  
    2739                 // Unbind all events for the element 
    2740                 if ( !types || typeof types === "string" && types.charAt(0) === "." ) { 
    2741                         types = types || ""; 
    2742  
    2743                         for ( type in events ) { 
    2744                                 jQuery.event.remove( elem, type + types ); 
    2745                         } 
    2746  
    2747                         return; 
    2748                 } 
    2749  
    2750                 // Handle multiple events separated by a space 
    2751                 // jQuery(...).unbind("mouseover mouseout", fn); 
    2752                 types = types.split(" "); 
    2753  
    2754                 while ( (type = types[ i++ ]) ) { 
    2755                         origType = type; 
    2756                         handleObj = null; 
    2757                         all = type.indexOf(".") < 0; 
    2758                         namespaces = []; 
    2759  
    2760                         if ( !all ) { 
    2761                                 // Namespaced event handlers 
    2762                                 namespaces = type.split("."); 
    2763                                 type = namespaces.shift(); 
    2764  
    2765                                 namespace = new RegExp("(^|\\.)" + 
    2766                                         jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)"); 
    2767                         } 
    2768  
    2769                         eventType = events[ type ]; 
    2770  
    2771                         if ( !eventType ) { 
     2966                // Once for each type.namespace in types; type may be omitted 
     2967                types = jQuery.trim( hoverHack( types || "" ) ).split(" "); 
     2968                for ( t = 0; t < types.length; t++ ) { 
     2969                        tns = rtypenamespace.exec( types[t] ) || []; 
     2970                        type = origType = tns[1]; 
     2971                        namespaces = tns[2]; 
     2972 
     2973                        // Unbind all events (on this namespace, if provided) for the element 
     2974                        if ( !type ) { 
     2975                                for ( type in events ) { 
     2976                                        jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); 
     2977                                } 
    27722978                                continue; 
    27732979                        } 
    27742980 
    2775                         if ( !handler ) { 
    2776                                 for ( j = 0; j < eventType.length; j++ ) { 
    2777                                         handleObj = eventType[ j ]; 
    2778  
    2779                                         if ( all || namespace.test( handleObj.namespace ) ) { 
    2780                                                 jQuery.event.remove( elem, origType, handleObj.handler, j ); 
    2781                                                 eventType.splice( j--, 1 ); 
    2782                                         } 
    2783                                 } 
    2784  
    2785                                 continue; 
    2786                         } 
    2787  
    27882981                        special = jQuery.event.special[ type ] || {}; 
    2789  
    2790                         for ( j = pos || 0; j < eventType.length; j++ ) { 
     2982                        type = ( selector? special.delegateType : special.bindType ) || type; 
     2983                        eventType = events[ type ] || []; 
     2984                        origCount = eventType.length; 
     2985                        namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null; 
     2986 
     2987                        // Remove matching events 
     2988                        for ( j = 0; j < eventType.length; j++ ) { 
    27912989                                handleObj = eventType[ j ]; 
    27922990 
    2793                                 if ( handler.guid === handleObj.guid ) { 
    2794                                         // remove the given handler for the given type 
    2795                                         if ( all || namespace.test( handleObj.namespace ) ) { 
    2796                                                 if ( pos == null ) { 
    2797                                                         eventType.splice( j--, 1 ); 
    2798                                                 } 
    2799  
    2800                                                 if ( special.remove ) { 
    2801                                                         special.remove.call( elem, handleObj ); 
    2802                                                 } 
    2803                                         } 
    2804  
    2805                                         if ( pos != null ) { 
    2806                                                 break; 
    2807                                         } 
    2808                                 } 
    2809                         } 
    2810  
    2811                         // remove generic event handler if no more handlers exist 
    2812                         if ( eventType.length === 0 || pos != null && eventType.length === 1 ) { 
     2991                                if ( ( mappedTypes || origType === handleObj.origType ) && 
     2992                                         ( !handler || handler.guid === handleObj.guid ) && 
     2993                                         ( !namespaces || namespaces.test( handleObj.namespace ) ) && 
     2994                                         ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { 
     2995                                        eventType.splice( j--, 1 ); 
     2996 
     2997                                        if ( handleObj.selector ) { 
     2998                                                eventType.delegateCount--; 
     2999                                        } 
     3000                                        if ( special.remove ) { 
     3001                                                special.remove.call( elem, handleObj ); 
     3002                                        } 
     3003                                } 
     3004                        } 
     3005 
     3006                        // Remove generic event handler if we removed something and no more handlers exist 
     3007                        // (avoids potential for endless recursion during removal of special event handlers) 
     3008                        if ( eventType.length === 0 && origCount !== eventType.length ) { 
    28133009                                if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) { 
    28143010                                        jQuery.removeEvent( elem, type, elemData.handle ); 
    28153011                                } 
    28163012 
    2817                                 ret = null; 
    28183013                                delete events[ type ]; 
    28193014                        } 
     
    28223017                // Remove the expando if it's no longer used 
    28233018                if ( jQuery.isEmptyObject( events ) ) { 
    2824                         var handle = elemData.handle; 
     3019                        handle = elemData.handle; 
    28253020                        if ( handle ) { 
    28263021                                handle.elem = null; 
    28273022                        } 
    28283023 
    2829                         delete elemData.events; 
    2830                         delete elemData.handle; 
    2831  
    2832                         if ( jQuery.isEmptyObject( elemData ) ) { 
    2833                                 jQuery.removeData( elem, undefined, true ); 
    2834                         } 
    2835                 } 
    2836         }, 
    2837          
     3024                        // removeData also checks for emptiness and clears the expando if empty 
     3025                        // so use it instead of delete 
     3026                        jQuery.removeData( elem, [ "events", "handle" ], true ); 
     3027                } 
     3028        }, 
     3029 
    28383030        // Events that are safe to short-circuit if no handlers are attached. 
    28393031        // Native DOM events should not be added, they may have inline handlers. 
     
    28453037 
    28463038        trigger: function( event, data, elem, onlyHandlers ) { 
     3039                // Don't do events on text and comment nodes 
     3040                if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) { 
     3041                        return; 
     3042                } 
     3043 
    28473044                // Event object or event type 
    28483045                var type = event.type || event, 
    28493046                        namespaces = [], 
    2850                         exclusive; 
    2851  
    2852                 if ( type.indexOf("!") >= 0 ) { 
     3047                        cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType; 
     3048 
     3049                // focus/blur morphs to focusin/out; ensure we're not firing them right now 
     3050                if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { 
     3051                        return; 
     3052                } 
     3053 
     3054                if ( type.indexOf( "!" ) >= 0 ) { 
    28533055                        // Exclusive events trigger only for the exact event (no namespaces) 
    28543056                        type = type.slice(0, -1); 
     
    28563058                } 
    28573059 
    2858                 if ( type.indexOf(".") >= 0 ) { 
     3060                if ( type.indexOf( "." ) >= 0 ) { 
    28593061                        // Namespaced trigger; create a regexp to match event type in handle() 
    28603062                        namespaces = type.split("."); 
     
    28783080 
    28793081                event.type = type; 
     3082                event.isTrigger = true; 
    28803083                event.exclusive = exclusive; 
    2881                 event.namespace = namespaces.join("."); 
    2882                 event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)"); 
    2883                  
    2884                 // triggerHandler() and global events don't bubble or run the default action 
    2885                 if ( onlyHandlers || !elem ) { 
    2886                         event.preventDefault(); 
    2887                         event.stopPropagation(); 
    2888                 } 
     3084                event.namespace = namespaces.join( "." ); 
     3085                event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null; 
     3086                ontype = type.indexOf( ":" ) < 0 ? "on" + type : ""; 
    28893087 
    28903088                // Handle a global trigger 
    28913089                if ( !elem ) { 
     3090 
    28923091                        // TODO: Stop taunting the data cache; remove global events and always attach to document 
    2893                         jQuery.each( jQuery.cache, function() { 
    2894                                 // internalKey variable is just used to make it easier to find 
    2895                                 // and potentially change this stuff later; currently it just 
    2896                                 // points to jQuery.expando 
    2897                                 var internalKey = jQuery.expando, 
    2898                                         internalCache = this[ internalKey ]; 
    2899                                 if ( internalCache && internalCache.events && internalCache.events[ type ] ) { 
    2900                                         jQuery.event.trigger( event, data, internalCache.handle.elem ); 
    2901                                 } 
    2902                         }); 
    2903                         return; 
    2904                 } 
    2905  
    2906                 // Don't do events on text and comment nodes 
    2907                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 
     3092                        cache = jQuery.cache; 
     3093                        for ( i in cache ) { 
     3094                                if ( cache[ i ].events && cache[ i ].events[ type ] ) { 
     3095                                        jQuery.event.trigger( event, data, cache[ i ].handle.elem, true ); 
     3096                                } 
     3097                        } 
    29083098                        return; 
    29093099                } 
     
    29113101                // Clean up the event in case it is being reused 
    29123102                event.result = undefined; 
    2913                 event.target = elem; 
     3103                if ( !event.target ) { 
     3104                        event.target = elem; 
     3105                } 
    29143106 
    29153107                // Clone any incoming data and prepend the event, creating the handler arg list 
     
    29173109                data.unshift( event ); 
    29183110 
    2919                 var cur = elem, 
    2920                         // IE doesn't like method names with a colon (#3533, #8272) 
    2921                         ontype = type.indexOf(":") < 0 ? "on" + type : ""; 
    2922  
    2923                 // Fire event on the current element, then bubble up the DOM tree 
    2924                 do { 
    2925                         var handle = jQuery._data( cur, "handle" ); 
    2926  
    2927                         event.currentTarget = cur; 
     3111                // Allow special events to draw outside the lines 
     3112                special = jQuery.event.special[ type ] || {}; 
     3113                if ( special.trigger && special.trigger.apply( elem, data ) === false ) { 
     3114                        return; 
     3115                } 
     3116 
     3117                // Determine event propagation path in advance, per W3C events spec (#9951) 
     3118                // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) 
     3119                eventPath = [[ elem, special.bindType || type ]]; 
     3120                if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { 
     3121 
     3122                        bubbleType = special.delegateType || type; 
     3123                        cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode; 
     3124                        old = null; 
     3125                        for ( ; cur; cur = cur.parentNode ) { 
     3126                                eventPath.push([ cur, bubbleType ]); 
     3127                                old = cur; 
     3128                        } 
     3129 
     3130                        // Only add window if we got to document (e.g., not plain obj or detached DOM) 
     3131                        if ( old && old === elem.ownerDocument ) { 
     3132                                eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]); 
     3133                        } 
     3134                } 
     3135 
     3136                // Fire handlers on the event path 
     3137                for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) { 
     3138 
     3139                        cur = eventPath[i][0]; 
     3140                        event.type = eventPath[i][1]; 
     3141 
     3142                        handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" ); 
    29283143                        if ( handle ) { 
    29293144                                handle.apply( cur, data ); 
    29303145                        } 
    2931  
    2932                         // Trigger an inline bound script 
    2933                         if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) { 
    2934                                 event.result = false; 
     3146                        // Note that this is a bare JS function and not a jQuery handler 
     3147                        handle = ontype && cur[ ontype ]; 
     3148                        if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) { 
    29353149                                event.preventDefault(); 
    29363150                        } 
    2937  
    2938                         // Bubble up to document, then to window 
    2939                         cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window; 
    2940                 } while ( cur && !event.isPropagationStopped() ); 
     3151                } 
     3152                event.type = type; 
    29413153 
    29423154                // If nobody prevented the default action, do it now 
    2943                 if ( !event.isDefaultPrevented() ) { 
    2944                         var old, 
    2945                                 special = jQuery.event.special[ type ] || {}; 
    2946  
    2947                         if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) && 
     3155                if ( !onlyHandlers && !event.isDefaultPrevented() ) { 
     3156 
     3157                        if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) && 
    29483158                                !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) { 
    29493159 
    29503160                                // Call a native DOM method on the target with the same name name as the event. 
    2951                                 // Can't use an .isFunction)() check here because IE6/7 fails that test. 
    2952                                 // IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch. 
    2953                                 try { 
    2954                                         if ( ontype && elem[ type ] ) { 
    2955                                                 // Don't re-trigger an onFOO event when we call its FOO() method 
    2956                                                 old = elem[ ontype ]; 
    2957  
    2958                                                 if ( old ) { 
    2959                                                         elem[ ontype ] = null; 
     3161                                // Can't use an .isFunction() check here because IE6/7 fails that test. 
     3162                                // Don't do default actions on window, that's where global variables be (#6170) 
     3163                                // IE<9 dies on focus/blur to hidden element (#1486) 
     3164                                if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) { 
     3165 
     3166                                        // Don't re-trigger an onFOO event when we call its FOO() method 
     3167                                        old = elem[ ontype ]; 
     3168 
     3169                                        if ( old ) { 
     3170                                                elem[ ontype ] = null; 
     3171                                        } 
     3172 
     3173                                        // Prevent re-triggering of the same event, since we already bubbled it above 
     3174                                        jQuery.event.triggered = type; 
     3175                                        elem[ type ](); 
     3176                                        jQuery.event.triggered = undefined; 
     3177 
     3178                                        if ( old ) { 
     3179                                                elem[ ontype ] = old; 
     3180                                        } 
     3181                                } 
     3182                        } 
     3183                } 
     3184 
     3185                return event.result; 
     3186        }, 
     3187 
     3188        dispatch: function( event ) { 
     3189 
     3190                // Make a writable jQuery.Event from the native event object 
     3191                event = jQuery.event.fix( event || window.event ); 
     3192 
     3193                var handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []), 
     3194                        delegateCount = handlers.delegateCount, 
     3195                        args = [].slice.call( arguments, 0 ), 
     3196                        run_all = !event.exclusive && !event.namespace, 
     3197                        handlerQueue = [], 
     3198                        i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related; 
     3199 
     3200                // Use the fix-ed jQuery.Event rather than the (read-only) native event 
     3201                args[0] = event; 
     3202                event.delegateTarget = this; 
     3203 
     3204                // Determine handlers that should run if there are delegated events 
     3205                // Avoid disabled elements in IE (#6911) and non-left-click bubbling in Firefox (#3861) 
     3206                if ( delegateCount && !event.target.disabled && !(event.button && event.type === "click") ) { 
     3207 
     3208                        // Pregenerate a single jQuery object for reuse with .is() 
     3209                        jqcur = jQuery(this); 
     3210                        jqcur.context = this.ownerDocument || this; 
     3211 
     3212                        for ( cur = event.target; cur != this; cur = cur.parentNode || this ) { 
     3213                                selMatch = {}; 
     3214                                matches = []; 
     3215                                jqcur[0] = cur; 
     3216                                for ( i = 0; i < delegateCount; i++ ) { 
     3217                                        handleObj = handlers[ i ]; 
     3218                                        sel = handleObj.selector; 
     3219 
     3220                                        if ( selMatch[ sel ] === undefined ) { 
     3221                                                selMatch[ sel ] = ( 
     3222                                                        handleObj.quick ? quickIs( cur, handleObj.quick ) : jqcur.is( sel ) 
     3223                                                ); 
     3224                                        } 
     3225                                        if ( selMatch[ sel ] ) { 
     3226                                                matches.push( handleObj ); 
     3227                                        } 
     3228                                } 
     3229                                if ( matches.length ) { 
     3230                                        handlerQueue.push({ elem: cur, matches: matches }); 
     3231                                } 
     3232                        } 
     3233                } 
     3234 
     3235                // Add the remaining (directly-bound) handlers 
     3236                if ( handlers.length > delegateCount ) { 
     3237                        handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) }); 
     3238                } 
     3239 
     3240                // Run delegates first; they may want to stop propagation beneath us 
     3241                for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) { 
     3242                        matched = handlerQueue[ i ]; 
     3243                        event.currentTarget = matched.elem; 
     3244 
     3245                        for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) { 
     3246                                handleObj = matched.matches[ j ]; 
     3247 
     3248                                // Triggered event must either 1) be non-exclusive and have no namespace, or 
     3249                                // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). 
     3250                                if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) { 
     3251 
     3252                                        event.data = handleObj.data; 
     3253                                        event.handleObj = handleObj; 
     3254 
     3255                                        ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) 
     3256                                                        .apply( matched.elem, args ); 
     3257 
     3258                                        if ( ret !== undefined ) { 
     3259                                                event.result = ret; 
     3260                                                if ( ret === false ) { 
     3261                                                        event.preventDefault(); 
     3262                                                        event.stopPropagation(); 
    29603263                                                } 
    2961  
    2962                                                 jQuery.event.triggered = type; 
    2963                                                 elem[ type ](); 
    2964                                         } 
    2965                                 } catch ( ieError ) {} 
    2966  
    2967                                 if ( old ) { 
    2968                                         elem[ ontype ] = old; 
    2969                                 } 
    2970  
    2971                                 jQuery.event.triggered = undefined; 
    2972                         } 
    2973                 } 
    2974                  
     3264                                        } 
     3265                                } 
     3266                        } 
     3267                } 
     3268 
    29753269                return event.result; 
    29763270        }, 
    29773271 
    2978         handle: function( event ) { 
    2979                 event = jQuery.event.fix( event || window.event ); 
    2980                 // Snapshot the handlers list since a called handler may add/remove events. 
    2981                 var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0), 
    2982                         run_all = !event.exclusive && !event.namespace, 
    2983                         args = Array.prototype.slice.call( arguments, 0 ); 
    2984  
    2985                 // Use the fix-ed Event rather than the (read-only) native event 
    2986                 args[0] = event; 
    2987                 event.currentTarget = this; 
    2988  
    2989                 for ( var j = 0, l = handlers.length; j < l; j++ ) { 
    2990                         var handleObj = handlers[ j ]; 
    2991  
    2992                         // Triggered event must 1) be non-exclusive and have no namespace, or 
    2993                         // 2) have namespace(s) a subset or equal to those in the bound event. 
    2994                         if ( run_all || event.namespace_re.test( handleObj.namespace ) ) { 
    2995                                 // Pass in a reference to the handler function itself 
    2996                                 // So that we can later remove it 
    2997                                 event.handler = handleObj.handler; 
    2998                                 event.data = handleObj.data; 
    2999                                 event.handleObj = handleObj; 
    3000  
    3001                                 var ret = handleObj.handler.apply( this, args ); 
    3002  
    3003                                 if ( ret !== undefined ) { 
    3004                                         event.result = ret; 
    3005                                         if ( ret === false ) { 
    3006                                                 event.preventDefault(); 
    3007                                                 event.stopPropagation(); 
    3008                                         } 
    3009                                 } 
    3010  
    3011                                 if ( event.isImmediatePropagationStopped() ) { 
    3012                                         break; 
    3013                                 } 
    3014                         } 
    3015                 } 
    3016                 return event.result; 
    3017         }, 
    3018  
    3019         props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "), 
     3272        // Includes some event props shared by KeyEvent and MouseEvent 
     3273        // *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 *** 
     3274        props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), 
     3275 
     3276        fixHooks: {}, 
     3277 
     3278        keyHooks: { 
     3279                props: "char charCode key keyCode".split(" "), 
     3280                filter: function( event, original ) { 
     3281 
     3282                        // Add which for key events 
     3283                        if ( event.which == null ) { 
     3284                                event.which = original.charCode != null ? original.charCode : original.keyCode; 
     3285                        } 
     3286 
     3287                        return event; 
     3288                } 
     3289        }, 
     3290 
     3291        mouseHooks: { 
     3292                props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "), 
     3293                filter: function( event, original ) { 
     3294                        var eventDoc, doc, body, 
     3295                                button = original.button, 
     3296                                fromElement = original.fromElement; 
     3297 
     3298                        // Calculate pageX/Y if missing and clientX/Y available 
     3299                        if ( event.pageX == null && original.clientX != null ) { 
     3300                                eventDoc = event.target.ownerDocument || document; 
     3301                                doc = eventDoc.documentElement; 
     3302                                body = eventDoc.body; 
     3303 
     3304                                event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 ); 
     3305                                event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 ); 
     3306                        } 
     3307 
     3308                        // Add relatedTarget, if necessary 
     3309                        if ( !event.relatedTarget && fromElement ) { 
     3310                                event.relatedTarget = fromElement === event.target ? original.toElement : fromElement; 
     3311                        } 
     3312 
     3313                        // Add which for click: 1 === left; 2 === middle; 3 === right 
     3314                        // Note: button is not normalized, so don't use it 
     3315                        if ( !event.which && button !== undefined ) { 
     3316                                event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) ); 
     3317                        } 
     3318 
     3319                        return event; 
     3320                } 
     3321        }, 
    30203322 
    30213323        fix: function( event ) { 
     
    30243326                } 
    30253327 
    3026                 // store a copy of the original event object 
    3027                 // and "clone" to set read-only properties 
    3028                 var originalEvent = event; 
     3328                // Create a writable copy of the event object and normalize some properties 
     3329                var i, prop, 
     3330                        originalEvent = event, 
     3331                        fixHook = jQuery.event.fixHooks[ event.type ] || {}, 
     3332                        copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; 
     3333 
    30293334                event = jQuery.Event( originalEvent ); 
    30303335 
    3031                 for ( var i = this.props.length, prop; i; ) { 
    3032                         prop = this.props[ --i ]; 
     3336                for ( i = copy.length; i; ) { 
     3337                        prop = copy[ --i ]; 
    30333338                        event[ prop ] = originalEvent[ prop ]; 
    30343339                } 
    30353340 
    3036                 // Fix target property, if necessary 
     3341                // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2) 
    30373342                if ( !event.target ) { 
    3038                         // Fixes #1925 where srcElement might not be defined either 
    3039                         event.target = event.srcElement || document; 
    3040                 } 
    3041  
    3042                 // check if target is a textnode (safari) 
     3343                        event.target = originalEvent.srcElement || document; 
     3344                } 
     3345 
     3346                // Target should not be a text node (#504, Safari) 
    30433347                if ( event.target.nodeType === 3 ) { 
    30443348                        event.target = event.target.parentNode; 
    30453349                } 
    30463350 
    3047                 // Add relatedTarget, if necessary 
    3048                 if ( !event.relatedTarget && event.fromElement ) { 
    3049                         event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement; 
    3050                 } 
    3051  
    3052                 // Calculate pageX/Y if missing and clientX/Y available 
    3053                 if ( event.pageX == null && event.clientX != null ) { 
    3054                         var eventDocument = event.target.ownerDocument || document, 
    3055                                 doc = eventDocument.documentElement, 
    3056                                 body = eventDocument.body; 
    3057  
    3058                         event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0); 
    3059                         event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0); 
    3060                 } 
    3061  
    3062                 // Add which for key events 
    3063                 if ( event.which == null && (event.charCode != null || event.keyCode != null) ) { 
    3064                         event.which = event.charCode != null ? event.charCode : event.keyCode; 
    3065                 } 
    3066  
    3067                 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs) 
    3068                 if ( !event.metaKey && event.ctrlKey ) { 
     3351                // For mouse/key events; add metaKey if it's not there (#3368, IE6/7/8) 
     3352                if ( event.metaKey === undefined ) { 
    30693353                        event.metaKey = event.ctrlKey; 
    30703354                } 
    30713355 
    3072                 // Add which for click: 1 === left; 2 === middle; 3 === right 
    3073                 // Note: button is not normalized, so don't use it 
    3074                 if ( !event.which && event.button !== undefined ) { 
    3075                         event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) )); 
    3076                 } 
    3077  
    3078                 return event; 
    3079         }, 
    3080  
    3081         // Deprecated, use jQuery.guid instead 
    3082         guid: 1E8, 
    3083  
    3084         // Deprecated, use jQuery.proxy instead 
    3085         proxy: jQuery.proxy, 
     3356                return fixHook.filter? fixHook.filter( event, originalEvent ) : event; 
     3357        }, 
    30863358 
    30873359        special: { 
    30883360                ready: { 
    30893361                        // Make sure the ready event is setup 
    3090                         setup: jQuery.bindReady, 
    3091                         teardown: jQuery.noop 
     3362                        setup: jQuery.bindReady 
    30923363                }, 
    30933364 
    3094                 live: { 
    3095                         add: function( handleObj ) { 
    3096                                 jQuery.event.add( this, 
    3097                                         liveConvert( handleObj.origType, handleObj.selector ), 
    3098                                         jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) ); 
    3099                         }, 
    3100  
    3101                         remove: function( handleObj ) { 
    3102                                 jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj ); 
    3103                         } 
     3365                load: { 
     3366                        // Prevent triggered image.load events from bubbling to window.load 
     3367                        noBubble: true 
     3368                }, 
     3369 
     3370                focus: { 
     3371                        delegateType: "focusin" 
     3372                }, 
     3373                blur: { 
     3374                        delegateType: "focusout" 
    31043375                }, 
    31053376 
     
    31183389                        } 
    31193390                } 
     3391        }, 
     3392 
     3393        simulate: function( type, elem, event, bubble ) { 
     3394                // Piggyback on a donor event to simulate a different one. 
     3395                // Fake originalEvent to avoid donor's stopPropagation, but if the 
     3396                // simulated event prevents default then we do the same on the donor. 
     3397                var e = jQuery.extend( 
     3398                        new jQuery.Event(), 
     3399                        event, 
     3400                        { type: type, 
     3401                                isSimulated: true, 
     3402                                originalEvent: {} 
     3403                        } 
     3404                ); 
     3405                if ( bubble ) { 
     3406                        jQuery.event.trigger( e, null, elem ); 
     3407                } else { 
     3408                        jQuery.event.dispatch.call( elem, e ); 
     3409                } 
     3410                if ( e.isDefaultPrevented() ) { 
     3411                        event.preventDefault(); 
     3412                } 
    31203413        } 
    31213414}; 
     3415 
     3416// Some plugins are using, but it's undocumented/deprecated and will be removed. 
     3417// The 1.7 special event interface should provide all the hooks needed now. 
     3418jQuery.event.handle = jQuery.event.dispatch; 
    31223419 
    31233420jQuery.removeEvent = document.removeEventListener ? 
     
    31353432jQuery.Event = function( src, props ) { 
    31363433        // Allow instantiation without the 'new' keyword 
    3137         if ( !this.preventDefault ) { 
     3434        if ( !(this instanceof jQuery.Event) ) { 
    31383435                return new jQuery.Event( src, props ); 
    31393436        } 
     
    31463443                // Events bubbling up the document may have been marked as prevented 
    31473444                // by a handler lower down the tree; reflect the correct value. 
    3148                 this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false || 
    3149                         src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse; 
     3445                this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false || 
     3446                        src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse; 
    31503447 
    31513448        // Event type 
     
    31593456        } 
    31603457 
    3161         // timeStamp is buggy for some events on Firefox(#3843) 
    3162         // So we won't rely on the native value 
    3163         this.timeStamp = jQuery.now(); 
     3458        // Create a timestamp if incoming event doesn't have one 
     3459        this.timeStamp = src && src.timeStamp || jQuery.now(); 
    31643460 
    31653461        // Mark it as fixed 
     
    32173513}; 
    32183514 
    3219 // Checks if an event happened on an element within another element 
    3220 // Used in jQuery.event.special.mouseenter and mouseleave handlers 
    3221 var withinElement = function( event ) { 
    3222  
    3223         // Check if mouse(over|out) are still within the same parent element 
    3224         var related = event.relatedTarget, 
    3225                 inside = false, 
    3226                 eventType = event.type; 
    3227  
    3228         event.type = event.data; 
    3229  
    3230         if ( related !== this ) { 
    3231  
    3232                 if ( related ) { 
    3233                         inside = jQuery.contains( this, related ); 
    3234                 } 
    3235  
    3236                 if ( !inside ) { 
    3237  
    3238                         jQuery.event.handle.apply( this, arguments ); 
    3239  
    3240                         event.type = eventType; 
    3241                 } 
    3242         } 
    3243 }, 
    3244  
    3245 // In case of event delegation, we only need to rename the event.type, 
    3246 // liveHandler will take care of the rest. 
    3247 delegate = function( event ) { 
    3248         event.type = event.data; 
    3249         jQuery.event.handle.apply( this, arguments ); 
    3250 }; 
    3251  
    3252 // Create mouseenter and mouseleave events 
     3515// Create mouseenter/leave events using mouseover/out and event-time checks 
    32533516jQuery.each({ 
    32543517        mouseenter: "mouseover", 
     
    32563519}, function( orig, fix ) { 
    32573520        jQuery.event.special[ orig ] = { 
    3258                 setup: function( data ) { 
    3259                         jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig ); 
    3260                 }, 
    3261                 teardown: function( data ) { 
    3262                         jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement ); 
     3521                delegateType: fix, 
     3522                bindType: fix, 
     3523 
     3524                handle: function( event ) { 
     3525                        var target = this, 
     3526                                related = event.relatedTarget, 
     3527                                handleObj = event.handleObj, 
     3528                                selector = handleObj.selector, 
     3529                                ret; 
     3530 
     3531                        // For mousenter/leave call the handler if related is outside the target. 
     3532                        // NB: No relatedTarget if the mouse left/entered the browser window 
     3533                        if ( !related || (related !== target && !jQuery.contains( target, related )) ) { 
     3534                                event.type = handleObj.origType; 
     3535                                ret = handleObj.handler.apply( this, arguments ); 
     3536                                event.type = fix; 
     3537                        } 
     3538                        return ret; 
    32633539                } 
    32643540        }; 
    32653541}); 
    32663542 
    3267 // submit delegation 
     3543// IE submit delegation 
    32683544if ( !jQuery.support.submitBubbles ) { 
    32693545 
    32703546        jQuery.event.special.submit = { 
    3271                 setup: function( data, namespaces ) { 
    3272                         if ( !jQuery.nodeName( this, "form" ) ) { 
    3273                                 jQuery.event.add(this, "click.specialSubmit", function( e ) { 
    3274                                         // Avoid triggering error on non-existent type attribute in IE VML (#7071) 
    3275                                         var elem = e.target, 
    3276                                                 type = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.type : ""; 
    3277  
    3278                                         if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) { 
    3279                                                 trigger( "submit", this, arguments ); 
    3280                                         } 
    3281                                 }); 
    3282  
    3283                                 jQuery.event.add(this, "keypress.specialSubmit", function( e ) { 
    3284                                         var elem = e.target, 
    3285                                                 type = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.type : ""; 
    3286  
    3287                                         if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) { 
    3288                                                 trigger( "submit", this, arguments ); 
    3289                                         } 
    3290                                 }); 
    3291  
    3292                         } else { 
     3547                setup: function() { 
     3548                        // Only need this for delegated form submit events 
     3549                        if ( jQuery.nodeName( this, "form" ) ) { 
    32933550                                return false; 
    32943551                        } 
     3552 
     3553                        // Lazy-add a submit handler when a descendant form may potentially be submitted 
     3554                        jQuery.event.add( this, "click._submit keypress._submit", function( e ) { 
     3555                                // Node name check avoids a VML-related crash in IE (#9807) 
     3556                                var elem = e.target, 
     3557                                        form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined; 
     3558                                if ( form && !form._submit_attached ) { 
     3559                                        jQuery.event.add( form, "submit._submit", function( event ) { 
     3560                                                // If form was submitted by the user, bubble the event up the tree 
     3561                                                if ( this.parentNode && !event.isTrigger ) { 
     3562                                                        jQuery.event.simulate( "submit", this.parentNode, event, true ); 
     3563                                                } 
     3564                                        }); 
     3565                                        form._submit_attached = true; 
     3566                                } 
     3567                        }); 
     3568                        // return undefined since we don't need an event listener 
    32953569                }, 
    32963570 
    3297                 teardown: function( namespaces ) { 
    3298                         jQuery.event.remove( this, ".specialSubmit" ); 
     3571                teardown: function() { 
     3572                        // Only need this for delegated form submit events 
     3573                        if ( jQuery.nodeName( this, "form" ) ) { 
     3574                                return false; 
     3575                        } 
     3576 
     3577                        // Remove delegated handlers; cleanData eventually reaps submit handlers attached above 
     3578                        jQuery.event.remove( this, "._submit" ); 
    32993579                } 
    33003580        }; 
    3301  
    33023581} 
    33033582 
    3304 // change delegation, happens here so we have bind. 
     3583// IE change delegation and checkbox/radio fix 
    33053584if ( !jQuery.support.changeBubbles ) { 
    33063585 
    3307         var changeFilters, 
    3308  
    3309         getVal = function( elem ) { 
    3310                 var type = jQuery.nodeName( elem, "input" ) ? elem.type : "", 
    3311                         val = elem.value; 
    3312  
    3313                 if ( type === "radio" || type === "checkbox" ) { 
    3314                         val = elem.checked; 
    3315  
    3316                 } else if ( type === "select-multiple" ) { 
    3317                         val = elem.selectedIndex > -1 ? 
    3318                                 jQuery.map( elem.options, function( elem ) { 
    3319                                         return elem.selected; 
    3320                                 }).join("-") : 
    3321                                 ""; 
    3322  
    3323                 } else if ( jQuery.nodeName( elem, "select" ) ) { 
    3324                         val = elem.selectedIndex; 
    3325                 } 
    3326  
    3327                 return val; 
    3328         }, 
    3329  
    3330         testChange = function testChange( e ) { 
    3331                 var elem = e.target, data, val; 
    3332  
    3333                 if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) { 
    3334                         return; 
    3335                 } 
    3336  
    3337                 data = jQuery._data( elem, "_change_data" ); 
    3338                 val = getVal(elem); 
    3339  
    3340                 // the current data will be also retrieved by beforeactivate 
    3341                 if ( e.type !== "focusout" || elem.type !== "radio" ) { 
    3342                         jQuery._data( elem, "_change_data", val ); 
    3343                 } 
    3344  
    3345                 if ( data === undefined || val === data ) { 
    3346                         return; 
    3347                 } 
    3348  
    3349                 if ( data != null || val ) { 
    3350                         e.type = "change"; 
    3351                         e.liveFired = undefined; 
    3352                         jQuery.event.trigger( e, arguments[1], elem ); 
     3586        jQuery.event.special.change = { 
     3587 
     3588                setup: function() { 
     3589 
     3590                        if ( rformElems.test( this.nodeName ) ) { 
     3591                                // IE doesn't fire change on a check/radio until blur; trigger it on click 
     3592                                // after a propertychange. Eat the blur-change in special.change.handle. 
     3593                                // This still fires onchange a second time for check/radio after blur. 
     3594                                if ( this.type === "checkbox" || this.type === "radio" ) { 
     3595                                        jQuery.event.add( this, "propertychange._change", function( event ) { 
     3596                                                if ( event.originalEvent.propertyName === "checked" ) { 
     3597                                                        this._just_changed = true; 
     3598                                                } 
     3599                                        }); 
     3600                                        jQuery.event.add( this, "click._change", function( event ) { 
     3601                                                if ( this._just_changed && !event.isTrigger ) { 
     3602                                                        this._just_changed = false; 
     3603                                                        jQuery.event.simulate( "change", this, event, true ); 
     3604                                                } 
     3605                                        }); 
     3606                                } 
     3607                                return false; 
     3608                        } 
     3609                        // Delegated event; lazy-add a change handler on descendant inputs 
     3610                        jQuery.event.add( this, "beforeactivate._change", function( e ) { 
     3611                                var elem = e.target; 
     3612 
     3613                                if ( rformElems.test( elem.nodeName ) && !elem._change_attached ) { 
     3614                                        jQuery.event.add( elem, "change._change", function( event ) { 
     3615                                                if ( this.parentNode && !event.isSimulated && !event.isTrigger ) { 
     3616                                                        jQuery.event.simulate( "change", this.parentNode, event, true ); 
     3617                                                } 
     3618                                        }); 
     3619                                        elem._change_attached = true; 
     3620                                } 
     3621                        }); 
     3622                }, 
     3623 
     3624                handle: function( event ) { 
     3625                        var elem = event.target; 
     3626 
     3627                        // Swallow native change events from checkbox/radio, we already triggered them above 
     3628                        if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) { 
     3629                                return event.handleObj.handler.apply( this, arguments ); 
     3630                        } 
     3631                }, 
     3632 
     3633                teardown: function() { 
     3634                        jQuery.event.remove( this, "._change" ); 
     3635 
     3636                        return rformElems.test( this.nodeName ); 
    33533637                } 
    33543638        }; 
    3355  
    3356         jQuery.event.special.change = { 
    3357                 filters: { 
    3358                         focusout: testChange, 
    3359  
    3360                         beforedeactivate: testChange, 
    3361  
    3362                         click: function( e ) { 
    3363                                 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : ""; 
    3364  
    3365                                 if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) { 
    3366                                         testChange.call( this, e ); 
    3367                                 } 
    3368                         }, 
    3369  
    3370                         // Change has to be called before submit 
    3371                         // Keydown will be called before keypress, which is used in submit-event delegation 
    3372                         keydown: function( e ) { 
    3373                                 var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : ""; 
    3374  
    3375                                 if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) || 
    3376                                         (e.keyCode === 32 && (type === "checkbox" || type === "radio")) || 
    3377                                         type === "select-multiple" ) { 
    3378                                         testChange.call( this, e ); 
    3379                                 } 
    3380                         }, 
    3381  
    3382                         // Beforeactivate happens also before the previous element is blurred 
    3383                         // with this event you can't trigger a change event, but you can store 
    3384                         // information 
    3385                         beforeactivate: function( e ) { 
    3386                                 var elem = e.target; 
    3387                                 jQuery._data( elem, "_change_data", getVal(elem) ); 
    3388                         } 
    3389                 }, 
    3390  
    3391                 setup: function( data, namespaces ) { 
    3392                         if ( this.type === "file" ) { 
    3393                                 return false; 
    3394                         } 
    3395  
    3396                         for ( var type in changeFilters ) { 
    3397                                 jQuery.event.add( this, type + ".specialChange", changeFilters[type] ); 
    3398                         } 
    3399  
    3400                         return rformElems.test( this.nodeName ); 
    3401                 }, 
    3402  
    3403                 teardown: function( namespaces ) { 
    3404                         jQuery.event.remove( this, ".specialChange" ); 
    3405  
    3406                         return rformElems.test( this.nodeName ); 
    3407                 } 
    3408         }; 
    3409  
    3410         changeFilters = jQuery.event.special.change.filters; 
    3411  
    3412         // Handle when the input is .focus()'d 
    3413         changeFilters.focus = changeFilters.beforeactivate; 
    3414 } 
    3415  
    3416 function trigger( type, elem, args ) { 
    3417         // Piggyback on a donor event to simulate a different one. 
    3418         // Fake originalEvent to avoid donor's stopPropagation, but if the 
    3419         // simulated event prevents default then we do the same on the donor. 
    3420         // Don't pass args or remember liveFired; they apply to the donor event. 
    3421         var event = jQuery.extend( {}, args[ 0 ] ); 
    3422         event.type = type; 
    3423         event.originalEvent = {}; 
    3424         event.liveFired = undefined; 
    3425         jQuery.event.handle.call( elem, event ); 
    3426         if ( event.isDefaultPrevented() ) { 
    3427                 args[ 0 ].preventDefault(); 
    3428         } 
    34293639} 
    34303640 
     
    34343644 
    34353645                // Attach a single capturing handler while someone wants focusin/focusout 
    3436                 var attaches = 0; 
     3646                var attaches = 0, 
     3647                        handler = function( event ) { 
     3648                                jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true ); 
     3649                        }; 
    34373650 
    34383651                jQuery.event.special[ fix ] = { 
     
    34483661                        } 
    34493662                }; 
    3450  
    3451                 function handler( donor ) { 
    3452                         // Donor event is always a native one; fix it and switch its type. 
    3453                         // Let focusin/out handler cancel the donor focus/blur event. 
    3454                         var e = jQuery.event.fix( donor ); 
    3455                         e.type = fix; 
    3456                         e.originalEvent = {}; 
    3457                         jQuery.event.trigger( e, null, e.target ); 
    3458                         if ( e.isDefaultPrevented() ) { 
    3459                                 donor.preventDefault(); 
    3460                         } 
    3461                 } 
    34623663        }); 
    34633664} 
    34643665 
    3465 jQuery.each(["bind", "one"], function( i, name ) { 
    3466         jQuery.fn[ name ] = function( type, data, fn ) { 
    3467                 var handler; 
    3468  
    3469                 // Handle object literals 
    3470                 if ( typeof type === "object" ) { 
    3471                         for ( var key in type ) { 
    3472                                 this[ name ](key, data, type[key], fn); 
     3666jQuery.fn.extend({ 
     3667 
     3668        on: function( types, selector, data, fn, /*INTERNAL*/ one ) { 
     3669                var origFn, type; 
     3670 
     3671                // Types can be a map of types/handlers 
     3672                if ( typeof types === "object" ) { 
     3673                        // ( types-Object, selector, data ) 
     3674                        if ( typeof selector !== "string" ) { 
     3675                                // ( types-Object, data ) 
     3676                                data = selector; 
     3677                                selector = undefined; 
     3678                        } 
     3679                        for ( type in types ) { 
     3680                                this.on( type, selector, data, types[ type ], one ); 
    34733681                        } 
    34743682                        return this; 
    34753683                } 
    34763684 
    3477                 if ( arguments.length === 2 || data === false ) { 
    3478                         fn = data; 
    3479                         data = undefined; 
    3480                 } 
    3481  
    3482                 if ( name === "one" ) { 
    3483                         handler = function( event ) { 
    3484                                 jQuery( this ).unbind( event, handler ); 
    3485                                 return fn.apply( this, arguments ); 
     3685                if ( data == null && fn == null ) { 
     3686                        // ( types, fn ) 
     3687                        fn = selector; 
     3688                        data = selector = undefined; 
     3689                } else if ( fn == null ) { 
     3690                        if ( typeof selector === "string" ) { 
     3691                                // ( types, selector, fn ) 
     3692                                fn = data; 
     3693                                data = undefined; 
     3694                        } else { 
     3695                                // ( types, data, fn ) 
     3696                                fn = data; 
     3697                                data = selector; 
     3698                                selector = undefined; 
     3699                        } 
     3700                } 
     3701                if ( fn === false ) { 
     3702                        fn = returnFalse; 
     3703                } else if ( !fn ) { 
     3704                        return this; 
     3705                } 
     3706 
     3707                if ( one === 1 ) { 
     3708                        origFn = fn; 
     3709                        fn = function( event ) { 
     3710                                // Can use an empty set, since event contains the info 
     3711                                jQuery().off( event ); 
     3712                                return origFn.apply( this, arguments ); 
    34863713                        }; 
    3487                         handler.guid = fn.guid || jQuery.guid++; 
    3488                 } else { 
    3489                         handler = fn; 
    3490                 } 
    3491  
    3492                 if ( type === "unload" && name !== "one" ) { 
    3493                         this.one( type, data, fn ); 
    3494  
    3495                 } else { 
    3496                         for ( var i = 0, l = this.length; i < l; i++ ) { 
    3497                                 jQuery.event.add( this[i], type, handler, data ); 
    3498                         } 
    3499                 } 
    3500  
     3714                        // Use same guid so caller can remove using origFn 
     3715                        fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); 
     3716                } 
     3717                return this.each( function() { 
     3718                        jQuery.event.add( this, types, fn, data, selector ); 
     3719                }); 
     3720        }, 
     3721        one: function( types, selector, data, fn ) { 
     3722                return this.on.call( this, types, selector, data, fn, 1 ); 
     3723        }, 
     3724        off: function( types, selector, fn ) { 
     3725                if ( types && types.preventDefault && types.handleObj ) { 
     3726                        // ( event )  dispatched jQuery.Event 
     3727                        var handleObj = types.handleObj; 
     3728                        jQuery( types.delegateTarget ).off( 
     3729                                handleObj.namespace? handleObj.type + "." + handleObj.namespace : handleObj.type, 
     3730                                handleObj.selector, 
     3731                                handleObj.handler 
     3732                        ); 
     3733                        return this; 
     3734                } 
     3735                if ( typeof types === "object" ) { 
     3736                        // ( types-object [, selector] ) 
     3737                        for ( var type in types ) { 
     3738                                this.off( type, selector, types[ type ] ); 
     3739                        } 
     3740                        return this; 
     3741                } 
     3742                if ( selector === false || typeof selector === "function" ) { 
     3743                        // ( types [, fn] ) 
     3744                        fn = selector; 
     3745                        selector = undefined; 
     3746                } 
     3747                if ( fn === false ) { 
     3748                        fn = returnFalse; 
     3749                } 
     3750                return this.each(function() { 
     3751                        jQuery.event.remove( this, types, fn, selector ); 
     3752                }); 
     3753        }, 
     3754 
     3755        bind: function( types, data, fn ) { 
     3756                return this.on( types, null, data, fn ); 
     3757        }, 
     3758        unbind: function( types, fn ) { 
     3759                return this.off( types, null, fn ); 
     3760        }, 
     3761 
     3762        live: function( types, data, fn ) { 
     3763                jQuery( this.context ).on( types, this.selector, data, fn ); 
    35013764                return this; 
    3502         }; 
    3503 }); 
    3504  
    3505 jQuery.fn.extend({ 
    3506         unbind: function( type, fn ) { 
    3507                 // Handle object literals 
    3508                 if ( typeof type === "object" && !type.preventDefault ) { 
    3509                         for ( var key in type ) { 
    3510                                 this.unbind(key, type[key]); 
    3511                         } 
    3512  
    3513                 } else { 
    3514                         for ( var i = 0, l = this.length; i < l; i++ ) { 
    3515                                 jQuery.event.remove( this[i], type, fn ); 
    3516                         } 
    3517                 } 
    3518  
     3765        }, 
     3766        die: function( types, fn ) { 
     3767                jQuery( this.context ).off( types, this.selector || "**", fn ); 
    35193768                return this; 
    35203769        }, 
    35213770 
    35223771        delegate: function( selector, types, data, fn ) { 
    3523                 return this.live( types, data, fn, selector ); 
    3524         }, 
    3525  
     3772                return this.on( types, selector, data, fn ); 
     3773        }, 
    35263774        undelegate: function( selector, types, fn ) { 
    3527                 if ( arguments.length === 0 ) { 
    3528                         return this.unbind( "live" ); 
    3529  
    3530                 } else { 
    3531                         return this.die( types, null, fn, selector ); 
    3532                 } 
     3775                // ( namespace ) or ( selector, types [, fn] ) 
     3776                return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn ); 
    35333777        }, 
    35343778 
     
    35383782                }); 
    35393783        }, 
    3540  
    35413784        triggerHandler: function( type, data ) { 
    35423785                if ( this[0] ) { 
     
    35523795                        toggler = function( event ) { 
    35533796                                // Figure out which function to execute 
    3554                                 var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i; 
    3555                                 jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 ); 
     3797                                var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i; 
     3798                                jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 ); 
    35563799 
    35573800                                // Make sure that clicks stop 
     
    35763819}); 
    35773820 
    3578 var liveMap = { 
    3579         focus: "focusin", 
    3580         blur: "focusout", 
    3581         mouseenter: "mouseover", 
    3582         mouseleave: "mouseout" 
    3583 }; 
    3584  
    3585 jQuery.each(["live", "die"], function( i, name ) { 
    3586         jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) { 
    3587                 var type, i = 0, match, namespaces, preType, 
    3588                         selector = origSelector || this.selector, 
    3589                         context = origSelector ? this : jQuery( this.context ); 
    3590  
    3591                 if ( typeof types === "object" && !types.preventDefault ) { 
    3592                         for ( var key in types ) { 
    3593                                 context[ name ]( key, data, types[key], selector ); 
    3594                         } 
    3595  
    3596                         return this; 
    3597                 } 
    3598  
    3599                 if ( name === "die" && !types && 
    3600                                         origSelector && origSelector.charAt(0) === "." ) { 
    3601  
    3602                         context.unbind( origSelector ); 
    3603  
    3604                         return this; 
    3605                 } 
    3606  
    3607                 if ( data === false || jQuery.isFunction( data ) ) { 
    3608                         fn = data || returnFalse; 
    3609                         data = undefined; 
    3610                 } 
    3611  
    3612                 types = (types || "").split(" "); 
    3613  
    3614                 while ( (type = types[ i++ ]) != null ) { 
    3615                         match = rnamespaces.exec( type ); 
    3616                         namespaces = ""; 
    3617  
    3618                         if ( match )  { 
    3619                                 namespaces = match[0]; 
    3620                                 type = type.replace( rnamespaces, "" ); 
    3621                         } 
    3622  
    3623                         if ( type === "hover" ) { 
    3624                                 types.push( "mouseenter" + namespaces, "mouseleave" + namespaces ); 
    3625                                 continue; 
    3626                         } 
    3627  
    3628                         preType = type; 
    3629  
    3630                         if ( liveMap[ type ] ) { 
    3631                                 types.push( liveMap[ type ] + namespaces ); 
    3632                                 type = type + namespaces; 
    3633  
    3634                         } else { 
    3635                                 type = (liveMap[ type ] || type) + namespaces; 
    3636                         } 
    3637  
    3638                         if ( name === "live" ) { 
    3639                                 // bind live handler 
    3640                                 for ( var j = 0, l = context.length; j < l; j++ ) { 
    3641                                         jQuery.event.add( context[j], "live." + liveConvert( type, selector ), 
    3642                                                 { data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } ); 
    3643                                 } 
    3644  
    3645                         } else { 
    3646                                 // unbind live handler 
    3647                                 context.unbind( "live." + liveConvert( type, selector ), fn ); 
    3648                         } 
    3649                 } 
    3650  
    3651                 return this; 
    3652         }; 
    3653 }); 
    3654  
    3655 function liveHandler( event ) { 
    3656         var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret, 
    3657                 elems = [], 
    3658                 selectors = [], 
    3659                 events = jQuery._data( this, "events" ); 
    3660  
    3661         // Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911) 
    3662         if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) { 
    3663                 return; 
    3664         } 
    3665  
    3666         if ( event.namespace ) { 
    3667                 namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)"); 
    3668         } 
    3669  
    3670         event.liveFired = this; 
    3671  
    3672         var live = events.live.slice(0); 
    3673  
    3674         for ( j = 0; j < live.length; j++ ) { 
    3675                 handleObj = live[j]; 
    3676  
    3677                 if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) { 
    3678                         selectors.push( handleObj.selector ); 
    3679  
    3680                 } else { 
    3681                         live.splice( j--, 1 ); 
    3682                 } 
    3683         } 
    3684  
    3685         match = jQuery( event.target ).closest( selectors, event.currentTarget ); 
    3686  
    3687         for ( i = 0, l = match.length; i < l; i++ ) { 
    3688                 close = match[i]; 
    3689  
    3690                 for ( j = 0; j < live.length; j++ ) { 
    3691                         handleObj = live[j]; 
    3692  
    3693                         if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) { 
    3694                                 elem = close.elem; 
    3695                                 related = null; 
    3696  
    3697                                 // Those two events require additional checking 
    3698                                 if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) { 
    3699                                         event.type = handleObj.preType; 
    3700                                         related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0]; 
    3701  
    3702                                         // Make sure not to accidentally match a child element with the same selector 
    3703                                         if ( related && jQuery.contains( elem, related ) ) { 
    3704                                                 related = elem; 
    3705                                         } 
    3706                                 } 
    3707  
    3708                                 if ( !related || related !== elem ) { 
    3709                                         elems.push({ elem: elem, handleObj: handleObj, level: close.level }); 
    3710                                 } 
    3711                         } 
    3712                 } 
    3713         } 
    3714  
    3715         for ( i = 0, l = elems.length; i < l; i++ ) { 
    3716                 match = elems[i]; 
    3717  
    3718                 if ( maxLevel && match.level > maxLevel ) { 
    3719                         break; 
    3720                 } 
    3721  
    3722                 event.currentTarget = match.elem; 
    3723                 event.data = match.handleObj.data; 
    3724                 event.handleObj = match.handleObj; 
    3725  
    3726                 ret = match.handleObj.origHandler.apply( match.elem, arguments ); 
    3727  
    3728                 if ( ret === false || event.isPropagationStopped() ) { 
    3729                         maxLevel = match.level; 
    3730  
    3731                         if ( ret === false ) { 
    3732                                 stop = false; 
    3733                         } 
    3734                         if ( event.isImmediatePropagationStopped() ) { 
    3735                                 break; 
    3736                         } 
    3737                 } 
    3738         } 
    3739  
    3740         return stop; 
    3741 } 
    3742  
    3743 function liveConvert( type, selector ) { 
    3744         return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&"); 
    3745 } 
    3746  
    37473821jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " + 
    37483822        "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 
    3749         "change select submit keydown keypress keyup error").split(" "), function( i, name ) { 
     3823        "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) { 
    37503824 
    37513825        // Handle event binding 
     
    37573831 
    37583832                return arguments.length > 0 ? 
    3759                         this.bind( name, data, fn ) : 
     3833                        this.on( name, null, data, fn ) : 
    37603834                        this.trigger( name ); 
    37613835        }; 
     
    37633837        if ( jQuery.attrFn ) { 
    37643838                jQuery.attrFn[ name ] = true; 
     3839        } 
     3840 
     3841        if ( rkeyEvent.test( name ) ) { 
     3842                jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks; 
     3843        } 
     3844 
     3845        if ( rmouseEvent.test( name ) ) { 
     3846                jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks; 
    37653847        } 
    37663848}); 
     
    37773859 
    37783860var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, 
     3861        expando = "sizcache" + (Math.random() + '').replace('.', ''), 
    37793862        done = 0, 
    37803863        toString = Object.prototype.toString, 
     
    37823865        baseHasDuplicate = true, 
    37833866        rBackslash = /\\/g, 
     3867        rReturn = /\r\n/g, 
    37843868        rNonWord = /\W/; 
    37853869 
     
    38333917 
    38343918                if ( parts.length === 2 && Expr.relative[ parts[0] ] ) { 
    3835                         set = posProcess( parts[0] + parts[1], context ); 
     3919                        set = posProcess( parts[0] + parts[1], context, seed ); 
    38363920 
    38373921                } else { 
     
    38473931                                } 
    38483932                                 
    3849                                 set = posProcess( selector, set ); 
     3933                                set = posProcess( selector, set, seed ); 
    38503934                        } 
    38513935                } 
     
    39664050 
    39674051Sizzle.find = function( expr, context, isXML ) { 
    3968         var set; 
     4052        var set, i, len, match, type, left; 
    39694053 
    39704054        if ( !expr ) { 
     
    39724056        } 
    39734057 
    3974         for ( var i = 0, l = Expr.order.length; i < l; i++ ) { 
    3975                 var match, 
    3976                         type = Expr.order[i]; 
     4058        for ( i = 0, len = Expr.order.length; i < len; i++ ) { 
     4059                type = Expr.order[i]; 
    39774060                 
    39784061                if ( (match = Expr.leftMatch[ type ].exec( expr )) ) { 
    3979                         var left = match[1]; 
     4062                        left = match[1]; 
    39804063                        match.splice( 1, 1 ); 
    39814064 
     
    40034086Sizzle.filter = function( expr, set, inplace, not ) { 
    40044087        var match, anyFound, 
     4088                type, found, item, filter, left, 
     4089                i, pass, 
    40054090                old = expr, 
    40064091                result = [], 
     
    40094094 
    40104095        while ( expr && set.length ) { 
    4011                 for ( var type in Expr.filter ) { 
     4096                for ( type in Expr.filter ) { 
    40124097                        if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) { 
    4013                                 var found, item, 
    4014                                         filter = Expr.filter[ type ], 
    4015                                         left = match[1]; 
     4098                                filter = Expr.filter[ type ]; 
     4099                                left = match[1]; 
    40164100 
    40174101                                anyFound = false; 
     
    40394123 
    40404124                                if ( match ) { 
    4041                                         for ( var i = 0; (item = curLoop[i]) != null; i++ ) { 
     4125                                        for ( i = 0; (item = curLoop[i]) != null; i++ ) { 
    40424126                                                if ( item ) { 
    40434127                                                        found = filter( item, match, i, curLoop ); 
    4044                                                         var pass = not ^ !!found; 
     4128                                                        pass = not ^ found; 
    40454129 
    40464130                                                        if ( inplace && found != null ) { 
     
    40934177 
    40944178Sizzle.error = function( msg ) { 
    4095         throw "Syntax error, unrecognized expression: " + msg; 
     4179        throw new Error( "Syntax error, unrecognized expression: " + msg ); 
     4180}; 
     4181 
     4182/** 
     4183 * Utility function for retreiving the text value of an array of DOM nodes 
     4184 * @param {Array|Element} elem 
     4185 */ 
     4186var getText = Sizzle.getText = function( elem ) { 
     4187    var i, node, 
     4188                nodeType = elem.nodeType, 
     4189                ret = ""; 
     4190 
     4191        if ( nodeType ) { 
     4192                if ( nodeType === 1 || nodeType === 9 ) { 
     4193                        // Use textContent || innerText for elements 
     4194                        if ( typeof elem.textContent === 'string' ) { 
     4195                                return elem.textContent; 
     4196                        } else if ( typeof elem.innerText === 'string' ) { 
     4197                                // Replace IE's carriage returns 
     4198                                return elem.innerText.replace( rReturn, '' ); 
     4199                        } else { 
     4200                                // Traverse it's children 
     4201                                for ( elem = elem.firstChild; elem; elem = elem.nextSibling) { 
     4202                                        ret += getText( elem ); 
     4203                                } 
     4204                        } 
     4205                } else if ( nodeType === 3 || nodeType === 4 ) { 
     4206                        return elem.nodeValue; 
     4207                } 
     4208        } else { 
     4209 
     4210                // If no nodeType, this is expected to be an array 
     4211                for ( i = 0; (node = elem[i]); i++ ) { 
     4212                        // Do not traverse comment nodes 
     4213                        if ( node.nodeType !== 8 ) { 
     4214                                ret += getText( node ); 
     4215                        } 
     4216                } 
     4217        } 
     4218        return ret; 
    40964219}; 
    40974220 
     
    44834606 
    44844607                        } else if ( name === "contains" ) { 
    4485                                 return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0; 
     4608                                return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0; 
    44864609 
    44874610                        } else if ( name === "not" ) { 
     
    45024625 
    45034626                CHILD: function( elem, match ) { 
    4504                         var type = match[1], 
     4627                        var first, last, 
     4628                                doneName, parent, cache, 
     4629                                count, diff, 
     4630                                type = match[1], 
    45054631                                node = elem; 
    45064632 
     
    45304656 
    45314657                                case "nth": 
    4532                                         var first = match[2], 
    4533                                                 last = match[3]; 
     4658                                        first = match[2]; 
     4659                                        last = match[3]; 
    45344660 
    45354661                                        if ( first === 1 && last === 0 ) { 
     
    45374663                                        } 
    45384664                                         
    4539                                         var doneName = match[0], 
    4540                                                 parent = elem.parentNode; 
     4665                                        doneName = match[0]; 
     4666                                        parent = elem.parentNode; 
    45414667         
    4542                                         if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) { 
    4543                                                 var count = 0; 
     4668                                        if ( parent && (parent[ expando ] !== doneName || !elem.nodeIndex) ) { 
     4669                                                count = 0; 
    45444670                                                 
    45454671                                                for ( node = parent.firstChild; node; node = node.nextSibling ) { 
     
    45494675                                                }  
    45504676 
    4551                                                 parent.sizcache = doneName; 
     4677                                                parent[ expando ] = doneName; 
    45524678                                        } 
    45534679                                         
    4554                                         var diff = elem.nodeIndex - last; 
     4680                                        diff = elem.nodeIndex - last; 
    45554681 
    45564682                                        if ( first === 0 ) { 
     
    45684694 
    45694695                TAG: function( elem, match ) { 
    4570                         return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match; 
     4696                        return (match === "*" && elem.nodeType === 1) || !!elem.nodeName && elem.nodeName.toLowerCase() === match; 
    45714697                }, 
    45724698                 
     
    45784704                ATTR: function( elem, match ) { 
    45794705                        var name = match[1], 
    4580                                 result = Expr.attrHandle[ name ] ? 
     4706                                result = Sizzle.attr ? 
     4707                                        Sizzle.attr( elem, name ) : 
     4708                                        Expr.attrHandle[ name ] ? 
    45814709                                        Expr.attrHandle[ name ]( elem ) : 
    45824710                                        elem[ name ] != null ? 
     
    45894717                        return result == null ? 
    45904718                                type === "!=" : 
     4719                                !type && Sizzle.attr ? 
     4720                                result != null : 
    45914721                                type === "=" ? 
    45924722                                value === check : 
     
    47694899} 
    47704900 
    4771 // Utility function for retreiving the text value of an array of DOM nodes 
    4772 Sizzle.getText = function( elems ) { 
    4773         var ret = "", elem; 
    4774  
    4775         for ( var i = 0; elems[i]; i++ ) { 
    4776                 elem = elems[i]; 
    4777  
    4778                 // Get the text from text nodes and CDATA nodes 
    4779                 if ( elem.nodeType === 3 || elem.nodeType === 4 ) { 
    4780                         ret += elem.nodeValue; 
    4781  
    4782                 // Traverse everything else, except comment nodes 
    4783                 } else if ( elem.nodeType !== 8 ) { 
    4784                         ret += Sizzle.getText( elem.childNodes ); 
    4785                 } 
    4786         } 
    4787  
    4788         return ret; 
    4789 }; 
    4790  
    47914901// Check to see if the browser returns elements by name when 
    47924902// querying by getElementById (and provide a workaround) 
     
    50665176 
    50675177                        while ( elem ) { 
    5068                                 if ( elem.sizcache === doneName ) { 
     5178                                if ( elem[ expando ] === doneName ) { 
    50695179                                        match = checkSet[elem.sizset]; 
    50705180                                        break; 
     
    50725182 
    50735183                                if ( elem.nodeType === 1 && !isXML ){ 
    5074                                         elem.sizcache = doneName; 
     5184                                        elem[ expando ] = doneName; 
    50755185                                        elem.sizset = i; 
    50765186                                } 
     
    50995209 
    51005210                        while ( elem ) { 
    5101                                 if ( elem.sizcache === doneName ) { 
     5211                                if ( elem[ expando ] === doneName ) { 
    51025212                                        match = checkSet[elem.sizset]; 
    51035213                                        break; 
     
    51065216                                if ( elem.nodeType === 1 ) { 
    51075217                                        if ( !isXML ) { 
    5108                                                 elem.sizcache = doneName; 
     5218                                                elem[ expando ] = doneName; 
    51095219                                                elem.sizset = i; 
    51105220                                        } 
     
    51545264}; 
    51555265 
    5156 var posProcess = function( selector, context ) { 
     5266var posProcess = function( selector, context, seed ) { 
    51575267        var match, 
    51585268                tmpSet = [], 
     
    51705280 
    51715281        for ( var i = 0, l = root.length; i < l; i++ ) { 
    5172                 Sizzle( selector, root[i], tmpSet ); 
     5282                Sizzle( selector, root[i], tmpSet, seed ); 
    51735283        } 
    51745284 
     
    51775287 
    51785288// EXPOSE 
     5289// Override sizzle attribute retrieval 
     5290Sizzle.attr = jQuery.attr; 
     5291Sizzle.selectors.attrMap = {}; 
    51795292jQuery.find = Sizzle; 
    51805293jQuery.expr = Sizzle.selectors; 
     
    52625375 
    52635376        is: function( selector ) { 
    5264                 return !!selector && ( typeof selector === "string" ? 
    5265                         jQuery.filter( selector, this ).length > 0 : 
    5266                         this.filter( selector ).length > 0 ); 
     5377                return !!selector && (  
     5378                        typeof selector === "string" ? 
     5379                                // If this is a positional selector, check membership in the returned set 
     5380                                // so $("p:first").is("p:last") won't return true for a doc with two "p". 
     5381                                POS.test( selector ) ?  
     5382                                        jQuery( selector, this.context ).index( this[0] ) >= 0 : 
     5383                                        jQuery.filter( selector, this ).length > 0 : 
     5384                                this.filter( selector ).length > 0 ); 
    52675385        }, 
    52685386 
     
    52705388                var ret = [], i, l, cur = this[0]; 
    52715389                 
    5272                 // Array 
     5390                // Array (deprecated as of jQuery 1.7) 
    52735391                if ( jQuery.isArray( selectors ) ) { 
    5274                         var match, selector, 
    5275                                 matches = {}, 
    5276                                 level = 1; 
    5277  
    5278                         if ( cur && selectors.length ) { 
    5279                                 for ( i = 0, l = selectors.length; i < l; i++ ) { 
    5280                                         selector = selectors[i]; 
    5281  
    5282                                         if ( !matches[ selector ] ) { 
    5283                                                 matches[ selector ] = POS.test( selector ) ? 
    5284                                                         jQuery( selector, context || this.context ) : 
    5285                                                         selector; 
    5286                                         } 
    5287                                 } 
    5288  
    5289                                 while ( cur && cur.ownerDocument && cur !== context ) { 
    5290                                         for ( selector in matches ) { 
    5291                                                 match = matches[ selector ]; 
    5292  
    5293                                                 if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) { 
    5294                                                         ret.push({ selector: selector, elem: cur, level: level }); 
    5295                                                 } 
    5296                                         } 
    5297  
    5298                                         cur = cur.parentNode; 
    5299                                         level++; 
    5300                                 } 
     5392                        var level = 1; 
     5393 
     5394                        while ( cur && cur.ownerDocument && cur !== context ) { 
     5395                                for ( i = 0; i < selectors.length; i++ ) { 
     5396 
     5397                                        if ( jQuery( cur ).is( selectors[ i ] ) ) { 
     5398                                                ret.push({ selector: selectors[ i ], elem: cur, level: level }); 
     5399                                        } 
     5400                                } 
     5401 
     5402                                cur = cur.parentNode; 
     5403                                level++; 
    53015404                        } 
    53025405 
     
    54155518}, function( name, fn ) { 
    54165519        jQuery.fn[ name ] = function( until, selector ) { 
    5417                 var ret = jQuery.map( this, fn, until ), 
    5418                         // The variable 'args' was introduced in 
    5419                         // https://github.com/jquery/jquery/commit/52a0238 
    5420                         // to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed. 
    5421                         // http://code.google.com/p/v8/issues/detail?id=1050 
    5422                         args = slice.call(arguments); 
     5520                var ret = jQuery.map( this, fn, until ); 
    54235521 
    54245522                if ( !runtil.test( name ) ) { 
     
    54365534                } 
    54375535 
    5438                 return this.pushStack( ret, name, args.join(",") ); 
     5536                return this.pushStack( ret, name, slice.call( arguments ).join(",") ); 
    54395537        }; 
    54405538}); 
     
    55055603        } else if ( qualifier.nodeType ) { 
    55065604                return jQuery.grep(elements, function( elem, i ) { 
    5507                         return (elem === qualifier) === keep; 
     5605                        return ( elem === qualifier ) === keep; 
    55085606                }); 
    55095607 
     
    55215619 
    55225620        return jQuery.grep(elements, function( elem, i ) { 
    5523                 return (jQuery.inArray( elem, qualifier ) >= 0) === keep; 
     5621                return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep; 
    55245622        }); 
    55255623} 
     
    55285626 
    55295627 
    5530 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g, 
     5628function createSafeFragment( document ) { 
     5629        var list = nodeNames.split( "|" ), 
     5630        safeFrag = document.createDocumentFragment(); 
     5631 
     5632        if ( safeFrag.createElement ) { 
     5633                while ( list.length ) { 
     5634                        safeFrag.createElement( 
     5635                                list.pop() 
     5636                        ); 
     5637                } 
     5638        } 
     5639        return safeFrag; 
     5640} 
     5641 
     5642var nodeNames = "abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|" + 
     5643                "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", 
     5644        rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g, 
    55315645        rleadingWhitespace = /^\s+/, 
    55325646        rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig, 
     
    55345648        rtbody = /<tbody/i, 
    55355649        rhtml = /<|&#?\w+;/, 
     5650        rnoInnerhtml = /<(?:script|style)/i, 
    55365651        rnocache = /<(?:script|object|embed|option|style)/i, 
     5652        rnoshimcache = new RegExp("<(?:" + nodeNames + ")", "i"), 
    55375653        // checked="checked" or checked 
    55385654        rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 
     
    55485664                area: [ 1, "<map>", "</map>" ], 
    55495665                _default: [ 0, "", "" ] 
    5550         }; 
     5666        }, 
     5667        safeFragment = createSafeFragment( document ); 
    55515668 
    55525669wrapMap.optgroup = wrapMap.option; 
     
    56265743 
    56275744        wrap: function( html ) { 
    5628                 return this.each(function() { 
    5629                         jQuery( this ).wrapAll( html ); 
     5745                var isFunction = jQuery.isFunction( html ); 
     5746 
     5747                return this.each(function(i) { 
     5748                        jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html ); 
    56305749                }); 
    56315750        }, 
     
    56615780                        }); 
    56625781                } else if ( arguments.length ) { 
    5663                         var set = jQuery(arguments[0]); 
     5782                        var set = jQuery.clean( arguments ); 
    56645783                        set.push.apply( set, this.toArray() ); 
    56655784                        return this.pushStack( set, "before", arguments ); 
     
    56745793                } else if ( arguments.length ) { 
    56755794                        var set = this.pushStack( this, "after", arguments ); 
    5676                         set.push.apply( set, jQuery(arguments[0]).toArray() ); 
     5795                        set.push.apply( set, jQuery.clean(arguments) ); 
    56775796                        return set; 
    56785797                } 
     
    57295848 
    57305849                // See if we can take a shortcut and just use innerHTML 
    5731                 } else if ( typeof value === "string" && !rnocache.test( value ) && 
     5850                } else if ( typeof value === "string" && !rnoInnerhtml.test( value ) && 
    57325851                        (jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) && 
    57335852                        !wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) { 
     
    58555974                                                // Fragments from the fragment cache must always be cloned and never used 
    58565975                                                // in place. 
    5857                                                 results.cacheable || (l > 1 && i < lastIndex) ? 
     5976                                                results.cacheable || ( l > 1 && i < lastIndex ) ? 
    58585977                                                        jQuery.clone( fragment, true, true ) : 
    58595978                                                        fragment 
     
    58846003        } 
    58856004 
    5886         var internalKey = jQuery.expando, 
    5887                 oldData = jQuery.data( src ), 
    5888                 curData = jQuery.data( dest, oldData ); 
    5889  
    5890         // Switch to use the internal data object, if it exists, for the next 
    5891         // stage of data copying 
    5892         if ( (oldData = oldData[ internalKey ]) ) { 
    5893                 var events = oldData.events; 
    5894                                 curData = curData[ internalKey ] = jQuery.extend({}, oldData); 
    5895  
    5896                 if ( events ) { 
    5897                         delete curData.handle; 
    5898                         curData.events = {}; 
    5899  
    5900                         for ( var type in events ) { 
    5901                                 for ( var i = 0, l = events[ type ].length; i < l; i++ ) { 
    5902                                         jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data ); 
    5903                                 } 
    5904                         } 
    5905                 } 
     6005        var type, i, l, 
     6006                oldData = jQuery._data( src ), 
     6007                curData = jQuery._data( dest, oldData ), 
     6008                events = oldData.events; 
     6009 
     6010        if ( events ) { 
     6011                delete curData.handle; 
     6012                curData.events = {}; 
     6013 
     6014                for ( type in events ) { 
     6015                        for ( i = 0, l = events[ type ].length; i < l; i++ ) { 
     6016                                jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data ); 
     6017                        } 
     6018                } 
     6019        } 
     6020 
     6021        // make the cloned public data object a copy from the original 
     6022        if ( curData.data ) { 
     6023                curData.data = jQuery.extend( {}, curData.data ); 
    59066024        } 
    59076025} 
     
    59666084 
    59676085jQuery.buildFragment = function( args, nodes, scripts ) { 
    5968         var fragment, cacheable, cacheresults, doc; 
    5969  
    5970   // nodes may contain either an explicit document object, 
    5971   // a jQuery collection or context object. 
    5972   // If nodes[0] contains a valid object to assign to doc 
    5973   if ( nodes && nodes[0] ) { 
    5974     doc = nodes[0].ownerDocument || nodes[0]; 
    5975   } 
    5976  
    5977   // Ensure that an attr object doesn't incorrectly stand in as a document object 
     6086        var fragment, cacheable, cacheresults, doc, 
     6087        first = args[ 0 ]; 
     6088 
     6089        // nodes may contain either an explicit document object, 
     6090        // a jQuery collection or context object. 
     6091        // If nodes[0] contains a valid object to assign to doc 
     6092        if ( nodes && nodes[0] ) { 
     6093                doc = nodes[0].ownerDocument || nodes[0]; 
     6094        } 
     6095 
     6096        // Ensure that an attr object doesn't incorrectly stand in as a document object 
    59786097        // Chrome and Firefox seem to allow this to occur and will throw exception 
    59796098        // Fixes #8950 
     
    59866105        // IE 6 doesn't like it when you put <object> or <embed> elements in a fragment 
    59876106        // Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache 
    5988         if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document && 
    5989                 args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) { 
     6107        // Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501 
     6108        if ( args.length === 1 && typeof first === "string" && first.length < 512 && doc === document && 
     6109                first.charAt(0) === "<" && !rnocache.test( first ) && 
     6110                (jQuery.support.checkClone || !rchecked.test( first )) && 
     6111                (jQuery.support.html5Clone || !rnoshimcache.test( first )) ) { 
    59906112 
    59916113                cacheable = true; 
    59926114 
    5993                 cacheresults = jQuery.fragments[ args[0] ]; 
     6115                cacheresults = jQuery.fragments[ first ]; 
    59946116                if ( cacheresults && cacheresults !== 1 ) { 
    59956117                        fragment = cacheresults; 
     
    60036125 
    60046126        if ( cacheable ) { 
    6005                 jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1; 
     6127                jQuery.fragments[ first ] = cacheresults ? fragment : 1; 
    60066128        } 
    60076129 
     
    60296151                } else { 
    60306152                        for ( var i = 0, l = insert.length; i < l; i++ ) { 
    6031                                 var elems = (i > 0 ? this.clone(true) : this).get(); 
     6153                                var elems = ( i > 0 ? this.clone(true) : this ).get(); 
    60326154                                jQuery( insert[i] )[ original ]( elems ); 
    60336155                                ret = ret.concat( elems ); 
     
    60406162 
    60416163function getAll( elem ) { 
    6042         if ( "getElementsByTagName" in elem ) { 
     6164        if ( typeof elem.getElementsByTagName !== "undefined" ) { 
    60436165                return elem.getElementsByTagName( "*" ); 
    60446166 
    6045         } else if ( "querySelectorAll" in elem ) { 
     6167        } else if ( typeof elem.querySelectorAll !== "undefined" ) { 
    60466168                return elem.querySelectorAll( "*" ); 
    60476169 
     
    60596181// Finds all inputs and passes them to fixDefaultChecked 
    60606182function findInputs( elem ) { 
    6061         if ( jQuery.nodeName( elem, "input" ) ) { 
     6183        var nodeName = ( elem.nodeName || "" ).toLowerCase(); 
     6184        if ( nodeName === "input" ) { 
    60626185                fixDefaultChecked( elem ); 
    6063         } else if ( "getElementsByTagName" in elem ) { 
     6186        // Skip scripts, get other children 
     6187        } else if ( nodeName !== "script" && typeof elem.getElementsByTagName !== "undefined" ) { 
    60646188                jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked ); 
    60656189        } 
     6190} 
     6191 
     6192// Derived From: http://www.iecss.com/shimprove/javascript/shimprove.1-0-1.js 
     6193function shimCloneNode( elem ) { 
     6194        var div = document.createElement( "div" ); 
     6195        safeFragment.appendChild( div ); 
     6196 
     6197        div.innerHTML = elem.outerHTML; 
     6198        return div.firstChild; 
    60666199} 
    60676200 
    60686201jQuery.extend({ 
    60696202        clone: function( elem, dataAndEvents, deepDataAndEvents ) { 
    6070                 var clone = elem.cloneNode(true), 
    6071                                 srcElements, 
    6072                                 destElements, 
    6073                                 i; 
     6203                var srcElements, 
     6204                        destElements, 
     6205                        i, 
     6206                        // IE<=8 does not properly clone detached, unknown element nodes 
     6207                        clone = jQuery.support.html5Clone || !rnoshimcache.test( "<" + elem.nodeName ) ? 
     6208                                elem.cloneNode( true ) : 
     6209                                shimCloneNode( elem ); 
    60746210 
    60756211                if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) && 
     
    60836219                        cloneFixAttributes( elem, clone ); 
    60846220 
    6085                         // Using Sizzle here is crazy slow, so we use getElementsByTagName 
    6086                         // instead 
     6221                        // Using Sizzle here is crazy slow, so we use getElementsByTagName instead 
    60876222                        srcElements = getAll( elem ); 
    60886223                        destElements = getAll( clone ); 
     
    61496284 
    61506285                                        // Trim whitespace, otherwise indexOf won't work as expected 
    6151                                         var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(), 
     6286                                        var tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase(), 
    61526287                                                wrap = wrapMap[ tag ] || wrapMap._default, 
    61536288                                                depth = wrap[0], 
    61546289                                                div = context.createElement("div"); 
     6290 
     6291                                        // Append wrapper element to unknown element safe doc fragment 
     6292                                        if ( context === document ) { 
     6293                                                // Use the fragment we've already created for this document 
     6294                                                safeFragment.appendChild( div ); 
     6295                                        } else { 
     6296                                                // Use a fragment created with the owner document 
     6297                                                createSafeFragment( context ).appendChild( div ); 
     6298                                        } 
    61556299 
    61566300                                        // Go to html and back, then peel off extra wrappers 
     
    62346378 
    62356379        cleanData: function( elems ) { 
    6236                 var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special, 
     6380                var data, id, 
     6381                        cache = jQuery.cache, 
     6382                        special = jQuery.event.special, 
    62376383                        deleteExpando = jQuery.support.deleteExpando; 
    62386384 
     
    62456391 
    62466392                        if ( id ) { 
    6247                                 data = cache[ id ] && cache[ id ][ internalKey ]; 
     6393                                data = cache[ id ]; 
    62486394 
    62496395                                if ( data && data.events ) { 
     
    65076653                        var style = elem.style, 
    65086654                                currentStyle = elem.currentStyle, 
    6509                                 opacity = jQuery.isNaN( value ) ? "" : "alpha(opacity=" + value * 100 + ")", 
     6655                                opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "", 
    65106656                                filter = currentStyle && currentStyle.filter || style.filter || ""; 
    65116657 
     
    65646710                name = name.replace( rupper, "-$1" ).toLowerCase(); 
    65656711 
    6566                 if ( !(defaultView = elem.ownerDocument.defaultView) ) { 
    6567                         return undefined; 
    6568                 } 
    6569  
    6570                 if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) { 
     6712                if ( (defaultView = elem.ownerDocument.defaultView) && 
     6713                                (computedStyle = defaultView.getComputedStyle( elem, null )) ) { 
    65716714                        ret = computedStyle.getPropertyValue( name ); 
    65726715                        if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) { 
     
    65816724if ( document.documentElement.currentStyle ) { 
    65826725        currentStyle = function( elem, name ) { 
    6583                 var left, 
     6726                var left, rsLeft, uncomputed, 
    65846727                        ret = elem.currentStyle && elem.currentStyle[ name ], 
    6585                         rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ], 
    65866728                        style = elem.style; 
     6729 
     6730                // Avoid setting ret to empty string here 
     6731                // so we don't default to auto 
     6732                if ( ret === null && style && (uncomputed = style[ name ]) ) { 
     6733                        ret = uncomputed; 
     6734                } 
    65876735 
    65886736                // From the awesome hack by Dean Edwards 
     
    65926740                // but a number that has a weird ending, we need to convert it to pixels 
    65936741                if ( !rnumpx.test( ret ) && rnum.test( ret ) ) { 
     6742 
    65946743                        // Remember the original values 
    65956744                        left = style.left; 
     6745                        rsLeft = elem.runtimeStyle && elem.runtimeStyle.left; 
    65966746 
    65976747                        // Put in the new values to get a computed value out 
     
    65996749                                elem.runtimeStyle.left = elem.currentStyle.left; 
    66006750                        } 
    6601                         style.left = name === "fontSize" ? "1em" : (ret || 0); 
     6751                        style.left = name === "fontSize" ? "1em" : ( ret || 0 ); 
    66026752                        ret = style.pixelLeft + "px"; 
    66036753 
     
    66196769        // Start with offset property 
    66206770        var val = name === "width" ? elem.offsetWidth : elem.offsetHeight, 
    6621                 which = name === "width" ? cssWidth : cssHeight; 
     6771                which = name === "width" ? cssWidth : cssHeight, 
     6772                i = 0, 
     6773                len = which.length; 
    66226774 
    66236775        if ( val > 0 ) { 
    66246776                if ( extra !== "border" ) { 
    6625                         jQuery.each( which, function() { 
     6777                        for ( ; i < len; i++ ) { 
    66266778                                if ( !extra ) { 
    6627                                         val -= parseFloat( jQuery.css( elem, "padding" + this ) ) || 0; 
     6779                                        val -= parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0; 
    66286780                                } 
    66296781                                if ( extra === "margin" ) { 
    6630                                         val += parseFloat( jQuery.css( elem, extra + this ) ) || 0; 
     6782                                        val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0; 
    66316783                                } else { 
    6632                                         val -= parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0; 
    6633                                 } 
    6634                         }); 
     6784                                        val -= parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0; 
     6785                                } 
     6786                        } 
    66356787                } 
    66366788 
     
    66486800        // Add padding, border, margin 
    66496801        if ( extra ) { 
    6650                 jQuery.each( which, function() { 
    6651                         val += parseFloat( jQuery.css( elem, "padding" + this ) ) || 0; 
     6802                for ( ; i < len; i++ ) { 
     6803                        val += parseFloat( jQuery.css( elem, "padding" + which[ i ] ) ) || 0; 
    66526804                        if ( extra !== "padding" ) { 
    6653                                 val += parseFloat( jQuery.css( elem, "border" + this + "Width" ) ) || 0; 
     6805                                val += parseFloat( jQuery.css( elem, "border" + which[ i ] + "Width" ) ) || 0; 
    66546806                        } 
    66556807                        if ( extra === "margin" ) { 
    6656                                 val += parseFloat( jQuery.css( elem, extra + this ) ) || 0; 
    6657                         } 
    6658                 }); 
     6808                                val += parseFloat( jQuery.css( elem, extra + which[ i ] ) ) || 0; 
     6809                        } 
     6810                } 
    66596811        } 
    66606812 
     
    66676819                        height = elem.offsetHeight; 
    66686820 
    6669                 return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none"); 
     6821                return ( width === 0 && height === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none"); 
    66706822        }; 
    66716823 
     
    67216873        // Document location segments 
    67226874        ajaxLocParts, 
    6723          
     6875 
    67246876        // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression 
    67256877        allTypes = ["*/"] + ["*"]; 
     
    67606912 
    67616913                        // For each dataType in the dataTypeExpression 
    6762                         for(; i < length; i++ ) { 
     6914                        for ( ; i < length; i++ ) { 
    67636915                                dataType = dataTypes[ i ]; 
    67646916                                // We control if we're asked to add before 
     
    67916943                selection; 
    67926944 
    6793         for(; i < length && ( executeOnly || !selection ); i++ ) { 
     6945        for ( ; i < length && ( executeOnly || !selection ); i++ ) { 
    67946946                selection = list[ i ]( options, originalOptions, jqXHR ); 
    67956947                // If we got redirected to another dataType 
     
    68226974        var key, deep, 
    68236975                flatOptions = jQuery.ajaxSettings.flatOptions || {}; 
    6824         for( key in src ) { 
     6976        for ( key in src ) { 
    68256977                if ( src[ key ] !== undefined ) { 
    68266978                        ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; 
     
    69397091jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){ 
    69407092        jQuery.fn[ o ] = function( f ){ 
    6941                 return this.bind( o, f ); 
     7093                return this.on( o, f ); 
    69427094        }; 
    69437095}); 
     
    70817233                        // Deferreds 
    70827234                        deferred = jQuery.Deferred(), 
    7083                         completeDeferred = jQuery._Deferred(), 
     7235                        completeDeferred = jQuery.Callbacks( "once memory" ), 
    70847236                        // Status-dependent callbacks 
    70857237                        statusCode = s.statusCode || {}, 
     
    72317383                                // then normalize statusText and status for non-aborts 
    72327384                                error = statusText; 
    7233                                 if( !statusText || status ) { 
     7385                                if ( !statusText || status ) { 
    72347386                                        statusText = "error"; 
    72357387                                        if ( status < 0 ) { 
     
    72607412 
    72617413                        // Complete 
    7262                         completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] ); 
     7414                        completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); 
    72637415 
    72647416                        if ( fireGlobals ) { 
     
    72757427                jqXHR.success = jqXHR.done; 
    72767428                jqXHR.error = jqXHR.fail; 
    7277                 jqXHR.complete = completeDeferred.done; 
     7429                jqXHR.complete = completeDeferred.add; 
    72787430 
    72797431                // Status-dependent callbacks 
     
    72827434                                var tmp; 
    72837435                                if ( state < 2 ) { 
    7284                                         for( tmp in map ) { 
     7436                                        for ( tmp in map ) { 
    72857437                                                statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ]; 
    72867438                                        } 
     
    73597511 
    73607512                                // if nothing was replaced, add timestamp to the end 
    7361                                 s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" ); 
     7513                                s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" ); 
    73627514                        } 
    73637515                } 
     
    74337585                                // Simply rethrow otherwise 
    74347586                                } else { 
    7435                                         jQuery.error( e ); 
     7587                                        throw e; 
    74367588                                } 
    74377589                        } 
     
    75377689 
    75387690        // Fill responseXXX fields 
    7539         for( type in responseFields ) { 
     7691        for ( type in responseFields ) { 
    75407692                if ( type in responses ) { 
    75417693                        jqXHR[ responseFields[type] ] = responses[ type ]; 
     
    76167768 
    76177769        // For each dataType in the chain 
    7618         for( i = 1; i < length; i++ ) { 
     7770        for ( i = 1; i < length; i++ ) { 
    76197771 
    76207772                // Create converters map 
    76217773                // with lowercased keys 
    76227774                if ( i === 1 ) { 
    7623                         for( key in s.converters ) { 
    7624                                 if( typeof key === "string" ) { 
     7775                        for ( key in s.converters ) { 
     7776                                if ( typeof key === "string" ) { 
    76257777                                        converters[ key.toLowerCase() ] = s.converters[ key ]; 
    76267778                                } 
     
    76337785 
    76347786                // If current is auto dataType, update it to prev 
    7635                 if( current === "*" ) { 
     7787                if ( current === "*" ) { 
    76367788                        current = prev; 
    76377789                // If no auto and dataTypes are actually different 
     
    76457797                        if ( !conv ) { 
    76467798                                conv2 = undefined; 
    7647                                 for( conv1 in converters ) { 
     7799                                for ( conv1 in converters ) { 
    76487800                                        tmp = conv1.split( " " ); 
    76497801                                        if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) { 
     
    80848236 
    80858237                if ( speed || speed === 0 ) { 
    8086                         return this.animate( genFx("show", 3), speed, easing, callback); 
     8238                        return this.animate( genFx("show", 3), speed, easing, callback ); 
    80878239 
    80888240                } else { 
    80898241                        for ( var i = 0, j = this.length; i < j; i++ ) { 
    8090                                 elem = this[i]; 
     8242                                elem = this[ i ]; 
    80918243 
    80928244                                if ( elem.style ) { 
     
    81028254                                        // in a stylesheet to whatever the default browser style is 
    81038255                                        // for such an element 
    8104                                         if ( display === "" && jQuery.css( elem, "display" ) === "none" ) { 
    8105                                                 jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName)); 
     8256                                        if ( display === "" && jQuery.css(elem, "display") === "none" ) { 
     8257                                                jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) ); 
    81068258                                        } 
    81078259                                } 
     
    81118263                        // to avoid the constant reflow 
    81128264                        for ( i = 0; i < j; i++ ) { 
    8113                                 elem = this[i]; 
     8265                                elem = this[ i ]; 
    81148266 
    81158267                                if ( elem.style ) { 
     
    81178269 
    81188270                                        if ( display === "" || display === "none" ) { 
    8119                                                 elem.style.display = jQuery._data(elem, "olddisplay") || ""; 
     8271                                                elem.style.display = jQuery._data( elem, "olddisplay" ) || ""; 
    81208272                                        } 
    81218273                                } 
     
    81318283 
    81328284                } else { 
    8133                         for ( var i = 0, j = this.length; i < j; i++ ) { 
    8134                                 if ( this[i].style ) { 
    8135                                         var display = jQuery.css( this[i], "display" ); 
    8136  
    8137                                         if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) { 
    8138                                                 jQuery._data( this[i], "olddisplay", display ); 
     8285                        var elem, display, 
     8286                                i = 0, 
     8287                                j = this.length; 
     8288 
     8289                        for ( ; i < j; i++ ) { 
     8290                                elem = this[i]; 
     8291                                if ( elem.style ) { 
     8292                                        display = jQuery.css( elem, "display" ); 
     8293 
     8294                                        if ( display !== "none" && !jQuery._data( elem, "olddisplay" ) ) { 
     8295                                                jQuery._data( elem, "olddisplay", display ); 
    81398296                                        } 
    81408297                                } 
     
    81818338 
    81828339        animate: function( prop, speed, easing, callback ) { 
    8183                 var optall = jQuery.speed(speed, easing, callback); 
     8340                var optall = jQuery.speed( speed, easing, callback ); 
    81848341 
    81858342                if ( jQuery.isEmptyObject( prop ) ) { 
     
    81908347                prop = jQuery.extend( {}, prop ); 
    81918348 
    8192                 return this[ optall.queue === false ? "each" : "queue" ](function() { 
     8349                function doAnimation() { 
    81938350                        // XXX 'this' does not always have a nodeName when running the 
    81948351                        // test suite 
     
    82018358                                isElement = this.nodeType === 1, 
    82028359                                hidden = isElement && jQuery(this).is(":hidden"), 
    8203                                 name, val, p, 
    8204                                 display, e, 
    8205                                 parts, start, end, unit; 
     8360                                name, val, p, e, 
     8361                                parts, start, end, unit, 
     8362                                method; 
    82068363 
    82078364                        // will store per property easing and be used to determine when an animation is complete 
     
    82398396 
    82408397                                        // Set display property to inline-block for height/width 
    8241                                         // animations on inline elements that are having width/height 
    8242                                         // animated 
     8398                                        // animations on inline elements that are having width/height animated 
    82438399            &nbs