resources/jquery/jquery.tablesorter.js

   1 /**
   2  * TableSorter for MediaWiki
   3  *
   4  * Written 2011 Leo Koppelkamm
   5  * Based on tablesorter.com plugin, written (c) 2007 Christian Bach.
   6  *
   7  * Dual licensed under the MIT and GPL licenses:
   8  * http://www.opensource.org/licenses/mit-license.php
   9  * http://www.gnu.org/licenses/gpl.html
  10  *
  11  * Depends on mw.config (wgDigitTransformTable, wgMonthNames, wgMonthNamesShort,
  12  * wgDefaultDateFormat, wgContentLanguage)
  13  * Uses 'tableSorterCollation' in mw.config (if available)
  14  */
  15 /**
  16  *
  17  * @description Create a sortable table with multi-column sorting capabilitys
  18  *
  19  * @example $( 'table' ).tablesorter();
  20  * @desc Create a simple tablesorter interface.
  21  *
  22  * @option String cssHeader ( optional ) A string of the class name to be appended
  23  *         to sortable tr elements in the thead of the table. Default value:
  24  *         "header"
  25  *
  26  * @option String cssAsc ( optional ) A string of the class name to be appended to
  27  *         sortable tr elements in the thead on a ascending sort. Default value:
  28  *         "headerSortUp"
  29  *
  30  * @option String cssDesc ( optional ) A string of the class name to be appended
  31  *         to sortable tr elements in the thead on a descending sort. Default
  32  *         value: "headerSortDown"
  33  *
  34  * @option String sortInitialOrder ( optional ) A string of the inital sorting
  35  *         order can be asc or desc. Default value: "asc"
  36  *
  37  * @option String sortMultisortKey ( optional ) A string of the multi-column sort
  38  *         key. Default value: "shiftKey"
  39  *
  40  * @option Boolean sortLocaleCompare ( optional ) Boolean flag indicating whatever
  41  *         to use String.localeCampare method or not. Set to false.
  42  *
  43  * @option Boolean cancelSelection ( optional ) Boolean flag indicating if
  44  *         tablesorter should cancel selection of the table headers text.
  45  *         Default value: true
  46  *
  47  * @option Boolean debug ( optional ) Boolean flag indicating if tablesorter
  48  *         should display debuging information usefull for development.
  49  *
  50  * @type jQuery
  51  *
  52  * @name tablesorter
  53  *
  54  * @cat Plugins/Tablesorter
  55  *
  56  * @author Christian Bach/christian.bach@polyester.se
  57  */
  58
  59 ( function( $ ) {
  60
  61         /* Local scope */
  62
  63         var     ts,
  64                 parsers = [];
  65
  66         /* Parser utility functions */
  67
  68         function getParserById( name ) {
  69                 var len = parsers.length;
  70                 for ( var i = 0; i < len; i++ ) {
  71                         if ( parsers[i].id.toLowerCase() === name.toLowerCase() ) {
  72                                 return parsers[i];
  73                         }
  74                 }
  75                 return false;
  76         }
  77
  78         function getElementText( node ) {
  79                 var $node = $( node ),
  80                         data = $node.attr( 'data-sort-value' );
  81                 if ( data !== undefined ) {
  82                         return data;
  83                 } else {
  84                         return $node.text();
  85                 }
  86         }
  87
  88         function getTextFromRowAndCellIndex( rows, rowIndex, cellIndex ) {
  89                 if ( rows[rowIndex] && rows[rowIndex].cells[cellIndex] ) {
  90                         return $.trim( getElementText( rows[rowIndex].cells[cellIndex] ) );
  91                 } else {
  92                         return '';
  93                 }
  94         }
  95
  96         function detectParserForColumn( table, rows, cellIndex ) {
  97                 var     l = parsers.length,
  98                         nodeValue,
  99                         // Start with 1 because 0 is the fallback parser
 100                         i = 1,
 101                         rowIndex = 0,
 102                         concurrent = 0,
 103                         needed = ( rows.length > 4 ) ? 5 : rows.length;
 104
 105                 while( i < l ) {
 106                         nodeValue = getTextFromRowAndCellIndex( rows, rowIndex, cellIndex );
 107                         if ( nodeValue !== '') {
 108                                 if ( parsers[i].is( nodeValue, table ) ) {
 109                                         concurrent++;
 110                                         rowIndex++;
 111                                         if ( concurrent >= needed ) {
 112                                                 // Confirmed the parser for multiple cells, let's return it
 113                                                 return parsers[i];
 114                                         }
 115                                 } else {
 116                                         // Check next parser, reset rows
 117                                         i++;
 118                                         rowIndex = 0;
 119                                         concurrent = 0;
 120                                 }
 121                         } else {
 122                                 // Empty cell
 123                                 rowIndex++;
 124                                 if ( rowIndex > rows.length ) {
 125                                         rowIndex = 0;
 126                                         i++;
 127                                 }
 128                         }
 129                 }
 130
 131                 // 0 is always the generic parser (text)
 132                 return parsers[0];
 133         }
 134
 135         function buildParserCache( table, $headers ) {
 136                 var     rows = table.tBodies[0].rows,
 137                         sortType,
 138                         parsers = [];
 139
 140                 if ( rows[0] ) {
 141
 142                         var     cells = rows[0].cells,
 143                                 len = cells.length,
 144                                 i, parser;
 145
 146                         for ( i = 0; i < len; i++ ) {
 147                                 parser = false;
 148                                 sortType = $headers.eq( i ).data( 'sort-type' );
 149                                 if ( sortType !== undefined ) {
 150                                         parser = getParserById( sortType );
 151                                 }
 152
 153                                 if ( parser === false ) {
 154                                         parser = detectParserForColumn( table, rows, i );
 155                                 }
 156
 157                                 parsers.push( parser );
 158                         }
 159                 }
 160                 return parsers;
 161         }
 162
 163         /* Other utility functions */
 164
 165         function buildCache( table ) {
 166                 var     totalRows = ( table.tBodies[0] && table.tBodies[0].rows.length ) || 0,
 167                         totalCells = ( table.tBodies[0].rows[0] && table.tBodies[0].rows[0].cells.length ) || 0,
 168                         parsers = table.config.parsers,
 169                         cache = {
 170                                 row: [],
 171                                 normalized: []
 172                         };
 173
 174                 for ( var i = 0; i < totalRows; ++i ) {
 175
 176                         // Add the table data to main data array
 177                         var     $row = $( table.tBodies[0].rows[i] ),
 178                                 cols = [];
 179
 180                         // if this is a child row, add it to the last row's children and
 181                         // continue to the next row
 182                         if ( $row.hasClass( table.config.cssChildRow ) ) {
 183                                 cache.row[cache.row.length - 1] = cache.row[cache.row.length - 1].add( $row );
 184                                 // go to the next for loop
 185                                 continue;
 186                         }
 187
 188                         cache.row.push( $row );
 189
 190                         for ( var j = 0; j < totalCells; ++j ) {
 191                                 cols.push( parsers[j].format( getElementText( $row[0].cells[j] ), table, $row[0].cells[j] ) );
 192                         }
 193
 194                         cols.push( cache.normalized.length ); // add position for rowCache
 195                         cache.normalized.push( cols );
 196                         cols = null;
 197                 }
 198
 199                 return cache;
 200         }
 201
 202         function appendToTable( table, cache ) {
 203                 var     row = cache.row,
 204                         normalized = cache.normalized,
 205                         totalRows = normalized.length,
 206                         checkCell = ( normalized[0].length - 1 ),
 207                         fragment = document.createDocumentFragment();
 208
 209                 for ( var i = 0; i < totalRows; i++ ) {
 210                         var pos = normalized[i][checkCell];
 211
 212                         var l = row[pos].length;
 213
 214                         for ( var j = 0; j < l; j++ ) {
 215                                 fragment.appendChild( row[pos][j] );
 216                         }
 217
 218                 }
 219                 table.tBodies[0].appendChild( fragment );
 220         }
 221
 222         /**
 223          * Find all header rows in a thead-less table and put them in a <thead> tag.
 224          * This only treats a row as a header row if it contains only <th>s (no <td>s)
 225          * and if it is preceded entirely by header rows. The algorithm stops when
 226          * it encounters the first non-header row.
 227          *
 228          * After this, it will look at all rows at the bottom for footer rows
 229          * And place these in a tfoot using similar rules.
 230          * @param $table jQuery object for a <table>
 231          */
 232         function emulateTHeadAndFoot( $table ) {
 233                 var $rows = $table.find( '> tbody > tr' );
 234                 if( !$table.get(0).tHead ) {
 235                         var $thead = $( '<thead>' );
 236                         $rows.each( function() {
 237                                 if ( $(this).children( 'td' ).length > 0 ) {
 238                                         // This row contains a <td>, so it's not a header row
 239                                         // Stop here
 240                                         return false;
 241                                 }
 242                                 $thead.append( this );
 243                         } );
 244                         $table.find(' > tbody:first').before( $thead );
 245                 }
 246                 if( !$table.get(0).tFoot ) {
 247                         var $tfoot = $( '<tfoot>' );
 248                         var len = $rows.length;
 249                         for ( var i = len-1; i >= 0; i-- ) {
 250                                 if( $( $rows[i] ).children( 'td' ).length > 0 ){
 251                                         break;
 252                                 }
 253                                 $tfoot.prepend( $( $rows[i] ));
 254                         }
 255                         $table.append( $tfoot );
 256                 }
 257         }
 258
 259         function buildHeaders( table, msg ) {
 260                 var     maxSeen = 0,
 261                         longest,
 262                         realCellIndex = 0,
 263                         $tableHeaders = $( 'thead:eq(0) > tr', table );
 264                 if ( $tableHeaders.length > 1 ) {
 265                         $tableHeaders.each( function() {
 266                                 if ( this.cells.length > maxSeen ) {
 267                                         maxSeen = this.cells.length;
 268                                         longest = this;
 269                                 }
 270                         });
 271                         $tableHeaders = $( longest );
 272                 }
 273                 $tableHeaders = $tableHeaders.children( 'th' ).each( function( index ) {
 274                         this.column = realCellIndex;
 275
 276                         var colspan = this.colspan;
 277                         colspan = colspan ? parseInt( colspan, 10 ) : 1;
 278                         realCellIndex += colspan;
 279
 280                         this.order = 0;
 281                         this.count = 0;
 282
 283                         if ( $( this ).is( '.unsortable' ) ) {
 284                                 this.sortDisabled = true;
 285                         }
 286
 287                         if ( !this.sortDisabled ) {
 288                                 var $th = $( this ).addClass( table.config.cssHeader ).attr( 'title', msg[1] );
 289                         }
 290
 291                         // add cell to headerList
 292                         table.config.headerList[index] = this;
 293                 } );
 294
 295                 return $tableHeaders;
 296
 297         }
 298
 299         function isValueInArray( v, a ) {
 300                 var l = a.length;
 301                 for ( var i = 0; i < l; i++ ) {
 302                         if ( a[i][0] == v ) {
 303                                 return true;
 304                         }
 305                 }
 306                 return false;
 307         }
 308
 309         function setHeadersCss( table, $headers, list, css, msg ) {
 310                 // Remove all header information
 311                 $headers.removeClass( css[0] ).removeClass( css[1] );
 312
 313                 var h = [];
 314                 $headers.each( function( offset ) {
 315                         if ( !this.sortDisabled ) {
 316                                 h[this.column] = $( this );
 317                         }
 318                 } );
 319
 320                 var l = list.length;
 321                 for ( var i = 0; i < l; i++ ) {
 322                         h[ list[i][0] ].addClass( css[ list[i][1] ] ).attr( 'title', msg[ list[i][1] ] );
 323                 }
 324         }
 325
 326         function sortText( a, b ) {
 327                 return ( (a < b) ? false : ((a > b) ? true : 0) );
 328         }
 329
 330         function sortTextDesc( a, b ) {
 331                 return ( (b < a) ? false : ((b > a) ? true : 0) );
 332         }
 333
 334         function checkSorting( array1, array2, sortList ) {
 335                 var col, fn, ret;
 336                 for ( var i = 0, len = sortList.length; i < len; i++ ) {
 337                         col = sortList[i][0];
 338                         fn = ( sortList[i][1] ) ? sortTextDesc : sortText;
 339                         ret = fn.call( this, array1[col], array2[col] );
 340                         if ( ret !== 0 ) {
 341                                 return ret;
 342                         }
 343                 }
 344                 return ret;
 345         }
 346
 347         // Merge sort algorithm
 348         // Based on http://en.literateprograms.org/Merge_sort_(JavaScript)
 349         function mergeSortHelper( array, begin, beginRight, end, sortList ) {
 350                 for ( ; begin < beginRight; ++begin ) {
 351                         if ( checkSorting( array[begin], array[beginRight], sortList ) ) {
 352                                 var v = array[begin];
 353                                 array[begin] = array[beginRight];
 354                                 var begin2 = beginRight;
 355                                 while ( begin2 + 1 < end && checkSorting( v, array[begin2 + 1], sortList ) ) {
 356                                         var tmp = array[begin2];
 357                                         array[begin2] = array[begin2 + 1];
 358                                         array[begin2 + 1] = tmp;
 359                                         ++begin2;
 360                                 }
 361                                 array[begin2] = v;
 362                         }
 363                 }
 364         }
 365
 366         function mergeSort(array, begin, end, sortList) {
 367                 var size = end - begin;
 368                 if ( size < 2 ) {
 369                         return;
 370                 }
 371
 372                 var beginRight = begin + Math.floor(size / 2);
 373
 374                 mergeSort( array, begin, beginRight, sortList );
 375                 mergeSort( array, beginRight, end, sortList );
 376                 mergeSortHelper( array, begin, beginRight, end, sortList );
 377         }
 378
 379         function multisort( table, sortList, cache ) {
 380                 var i = sortList.length;
 381                 mergeSort( cache.normalized, 0, cache.normalized.length, sortList );
 382
 383                 return cache;
 384         }
 385
 386         function buildTransformTable() {
 387                 var digits = '0123456789,.'.split( '' );
 388                 var separatorTransformTable = mw.config.get( 'wgSeparatorTransformTable' );
 389                 var digitTransformTable = mw.config.get( 'wgDigitTransformTable' );
 390                 if ( separatorTransformTable === null || ( separatorTransformTable[0] === '' && digitTransformTable[2] === '' ) ) {
 391                         ts.transformTable = false;
 392                 } else {
 393                         ts.transformTable = {};
 394
 395                         // Unpack the transform table
 396                         var ascii = separatorTransformTable[0].split( "\t" ).concat( digitTransformTable[0].split( "\t" ) );
 397                         var localised = separatorTransformTable[1].split( "\t" ).concat( digitTransformTable[1].split( "\t" ) );
 398
 399                         // Construct regex for number identification
 400                         for ( var i = 0; i < ascii.length; i++ ) {
 401                                 ts.transformTable[localised[i]] = ascii[i];
 402                                 digits.push( $.escapeRE( localised[i] ) );
 403                         }
 404                 }
 405                 ts.digitClass = '[' + digits.join( '', digits ) + ']';
 406
 407                 // We allow a trailing percent sign, which we just strip. This works fine
 408                 // if percents and regular numbers aren't being mixed.
 409                 ts.numberRegex = new RegExp("^(" + "[-+\u2212]?[0-9][0-9,]*(\\.[0-9,]*)?(E[-+\u2212]?[0-9][0-9,]*)?" + // Fortran-style scientific
 410                 "|" + "[-+\u2212]?" + ts.digitClass + "+[\\s\\xa0]*%?" + // Generic localised
 411                 "|([-+\u2212]?" + ts.digitClass + "+[\\s\\xa0]+)*" + ts.digitClass + "+[\\s\\xa0]*[\\/][\\s\\xa0]*" + ts.digitClass + "+" + // Fractions
 412                 ")$", "i");
 413         }
 414
 415         function buildDateTable() {
 416                 var regex = [];
 417                 ts.monthNames = [
 418                         [],
 419                         []
 420                 ];
 421
 422                 for ( var i = 1; i < 13; i++ ) {
 423                         ts.monthNames[0][i] = mw.config.get( 'wgMonthNames' )[i].toLowerCase();
 424                         ts.monthNames[1][i] = mw.config.get( 'wgMonthNamesShort' )[i].toLowerCase().replace( '.', '' );
 425                         regex.push( $.escapeRE( ts.monthNames[0][i] ) );
 426                         regex.push( $.escapeRE( ts.monthNames[1][i] ) );
 427                 }
 428
 429                 // Build piped string
 430                 regex = regex.join( '|' );
 431
 432                 // Build RegEx
 433                 // Any date formated with . , ' - or /
 434                 ts.dateRegex[0] = new RegExp( /^\s*\d{1,2}[\,\.\-\/'\s]{1,2}\d{1,2}[\,\.\-\/'\s]{1,2}\d{2,4}\s*?/i);
 435
 436                 // Written Month name, dmy
 437                 ts.dateRegex[1] = new RegExp( '^\\s*\\d{1,2}[\\,\\.\\-\\/\'\\s]*(' + regex + ')' + '[\\,\\.\\-\\/\'\\s]*\\d{2,4}\\s*$', 'i' );
 438
 439                 // Written Month name, mdy
 440                 ts.dateRegex[2] = new RegExp( '^\\s*(' + regex + ')' + '[\\,\\.\\-\\/\'\\s]*\\d{1,2}[\\,\\.\\-\\/\'\\s]*\\d{2,4}\\s*$', 'i' );
 441
 442         }
 443
 444         function explodeRowspans( $table ) {
 445                 // Split multi row cells into multiple cells with the same content
 446                 $table.find( '> tbody > tr > [rowspan]' ).each(function() {
 447                         var rowSpan = this.rowSpan;
 448                         this.rowSpan = 1;
 449                         var cell = $( this );
 450                         var next = cell.parent().nextAll();
 451                         for ( var i = 0; i < rowSpan - 1; i++ ) {
 452                                 var td = next.eq( i ).children( 'td' );
 453                                 if ( !td.length ) {
 454                                         next.eq( i ).append( cell.clone() );
 455                                 } else if ( this.cellIndex === 0 ) {
 456                                         td.eq( this.cellIndex ).before( cell.clone() );
 457                                 } else {
 458                                         td.eq( this.cellIndex - 1 ).after( cell.clone() );
 459                                 }
 460                         }
 461                 });
 462         }
 463
 464         function buildCollationTable() {
 465                 ts.collationTable = mw.config.get( 'tableSorterCollation' );
 466                 ts.collationRegex = null;
 467                 if ( ts.collationTable ) {
 468                         var keys = [];
 469
 470                         // Build array of key names
 471                         for ( var key in ts.collationTable ) {
 472                                 if ( ts.collationTable.hasOwnProperty(key) ) { //to be safe
 473                                         keys.push(key);
 474                                 }
 475                         }
 476                         if (keys.length) {
 477                                 ts.collationRegex = new RegExp( '[' + keys.join( '' ) + ']', 'ig' );
 478                         }
 479                 }
 480         }
 481
 482         function cacheRegexs() {
 483                 if ( ts.rgx ) {
 484                         return;
 485                 }
 486                 ts.rgx = {
 487                         IPAddress: [
 488                                 new RegExp( /^\d{1,3}[\.]\d{1,3}[\.]\d{1,3}[\.]\d{1,3}(\/\d{1,3})?$/)
 489                         ],
 490                         currency: [
 491                                 new RegExp( /^[£$€?.]/),
 492                                 new RegExp( /[£$€]/g)
 493                         ],
 494                         url: [
 495                                 new RegExp( /^(https?|ftp|file):\/\/$/),
 496                                 new RegExp( /(https?|ftp|file):\/\//)
 497                         ],
 498                         isoDate: [
 499                                 new RegExp( /^\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2}$/)
 500                         ],
 501                         usLongDate: [
 502                                 new RegExp( /^[A-Za-z]{3,10}\.? [0-9]{1,2}, ([0-9]{4}|'?[0-9]{2}) (([0-2]?[0-9]:[0-5][0-9])|([0-1]?[0-9]:[0-5][0-9]\s(AM|PM)))$/)
 503                         ],
 504                         time: [
 505                                 new RegExp( /^(([0-2]?[0-9]:[0-5][0-9])|([0-1]?[0-9]:[0-5][0-9]\s(am|pm)))$/)
 506                         ],
 507                         fractions: [
 508                                 new RegExp( "^(?:([-+\u2212]?" + ts.digitClass + "+)[\\s\\xa0]+)*(" + ts.digitClass + "+)[\\s\\xa0]*[\\/][\\s\\xa0]*(" + ts.digitClass + "+)" )
 509                         ]
 510                 };
 511         }
 512
 513         /* Public scope */
 514
 515         $.tablesorter = {
 516
 517                         defaultOptions: {
 518                                 cssHeader: 'headerSort',
 519                                 cssAsc: 'headerSortUp',
 520                                 cssDesc: 'headerSortDown',
 521                                 cssChildRow: 'expand-child',
 522                                 sortInitialOrder: 'asc',
 523                                 sortMultiSortKey: 'shiftKey',
 524                                 sortLocaleCompare: false,
 525                                 parsers: {},
 526                                 widgets: [],
 527                                 headers: {},
 528                                 cancelSelection: true,
 529                                 sortList: [],
 530                                 headerList: [],
 531                                 selectorHeaders: 'thead tr:eq(0) th',
 532                                 debug: false
 533                         },
 534
 535                         dateRegex: [],
 536                         monthNames: [],
 537
 538                         /**
 539                          * @param $tables {jQuery}
 540                          * @param settings {Object} (optional)
 541                          */
 542                         construct: function( $tables, settings ) {
 543                                 return $tables.each( function( i, table ) {
 544                                         // Declare and cache.
 545                                         var     $document, $headers, cache, config, sortOrder,
 546                                                 $table = $( table ),
 547                                                 shiftDown = 0,
 548                                                 firstTime = true;
 549
 550                                         // Quit if no tbody
 551                                         if ( !table.tBodies ) {
 552                                                 return;
 553                                         }
 554                                         if ( !table.tHead ) {
 555                                                 // No thead found. Look for rows with <th>s and
 556                                                 // move them into a <thead> tag or a <tfoot> tag
 557                                                 emulateTHeadAndFoot( $table );
 558
 559                                                 // Still no thead? Then quit
 560                                                 if ( !table.tHead ) {
 561                                                         return;
 562                                                 }
 563                                         }
 564                                         $table.addClass( "jquery-tablesorter" );
 565
 566                                         // New config object.
 567                                         table.config = {};
 568
 569                                         // Merge and extend.
 570                                         config = $.extend( table.config, $.tablesorter.defaultOptions, settings );
 571
 572                                         // Save the settings where they read
 573                                         $.data( table, 'tablesorter', config );
 574
 575                                         // Get the CSS class names, could be done else where.
 576                                         var sortCSS = [ config.cssDesc, config.cssAsc ];
 577                                         var sortMsg = [ mw.msg( 'sort-descending' ), mw.msg( 'sort-ascending' ) ];
 578
 579                                         // Build headers
 580                                         $headers = buildHeaders( table, sortMsg );
 581
 582                                         // Grab and process locale settings
 583                                         buildTransformTable();
 584                                         buildDateTable();
 585                                         buildCollationTable();
 586
 587                                         // Precaching regexps can bring 10 fold
 588                                         // performance improvements in some browsers.
 589                                         cacheRegexs();
 590
 591                                         // Apply event handling to headers
 592                                         // this is too big, perhaps break it out?
 593                                         $headers.click( function( e ) {
 594                                                 if ( e.target.nodeName.toLowerCase() == 'a' ) {
 595                                                         // The user clicked on a link inside a table header
 596                                                         // Do nothing and let the default link click action continue
 597                                                         return true;
 598                                                 }
 599
 600                                                 if ( firstTime ) {
 601                                                         firstTime = false;
 602
 603                                                         // Legacy fix of .sortbottoms
 604                                                         // Wrap them inside inside a tfoot (because that's what they actually want to be) &
 605                                                         // and put the <tfoot> at the end of the <table>
 606                                                         var $sortbottoms = $table.find( '> tbody > tr.sortbottom' );
 607                                                         if ( $sortbottoms.length ) {
 608                                                                 var $tfoot = $table.children( 'tfoot' );
 609                                                                 if ( $tfoot.length ) {
 610                                                                         $tfoot.eq(0).prepend( $sortbottoms );
 611                                                                 } else {
 612                                                                         $table.append( $( '<tfoot>' ).append( $sortbottoms ) );
 613                                                                 }
 614                                                         }
 615
 616                                                         explodeRowspans( $table );
 617                                                         // try to auto detect column type, and store in tables config
 618                                                         table.config.parsers = buildParserCache( table, $headers );
 619                                                         // build the cache for the tbody cells
 620                                                         cache = buildCache( table );
 621                                                 }
 622                                                 var totalRows = ( $table[0].tBodies[0] && $table[0].tBodies[0].rows.length ) || 0;
 623                                                 if ( !table.sortDisabled && totalRows > 0 ) {
 624
 625                                                         // Cache jQuery object
 626                                                         var $cell = $( this );
 627
 628                                                         // Get current column index
 629                                                         var i = this.column;
 630
 631                                                         // Get current column sort order
 632                                                         this.order = this.count % 2;
 633                                                         this.count++;
 634
 635                                                         // User only wants to sort on one column
 636                                                         if ( !e[config.sortMultiSortKey] ) {
 637                                                                 // Flush the sort list
 638                                                                 config.sortList = [];
 639                                                                 // Add column to sort list
 640                                                                 config.sortList.push( [i, this.order] );
 641
 642                                                         // Multi column sorting
 643                                                         } else {
 644                                                                 // The user has clicked on an already sorted column.
 645                                                                 if ( isValueInArray( i, config.sortList ) ) {
 646                                                                         // Reverse the sorting direction for all tables.
 647                                                                         for ( var j = 0; j < config.sortList.length; j++ ) {
 648                                                                                 var s = config.sortList[j],
 649                                                                                         o = config.headerList[s[0]];
 650                                                                                 if ( s[0] == i ) {
 651                                                                                         o.count = s[1];
 652                                                                                         o.count++;
 653                                                                                         s[1] = o.count % 2;
 654                                                                                 }
 655                                                                         }
 656                                                                 } else {
 657                                                                         // Add column to sort list array
 658                                                                         config.sortList.push( [i, this.order] );
 659                                                                 }
 660                                                         }
 661
 662                                                         // Set CSS for headers
 663                                                         setHeadersCss( $table[0], $headers, config.sortList, sortCSS, sortMsg );
 664                                                         appendToTable(
 665                                                                 $table[0], multisort( $table[0], config.sortList, cache )
 666                                                         );
 667
 668                                                         // Stop normal event by returning false
 669                                                         return false;
 670                                                 }
 671
 672                                         // Cancel selection
 673                                         } ).mousedown( function() {
 674                                                 if ( config.cancelSelection ) {
 675                                                         this.onselectstart = function() {
 676                                                                 return false;
 677                                                         };
 678                                                         return false;
 679                                                 }
 680                                         } );
 681                                 } );
 682                         },
 683
 684                         addParser: function( parser ) {
 685                                 var     l = parsers.length,
 686                                         a = true;
 687                                 for ( var i = 0; i < l; i++ ) {
 688                                         if ( parsers[i].id.toLowerCase() == parser.id.toLowerCase() ) {
 689                                                 a = false;
 690                                         }
 691                                 }
 692                                 if ( a ) {
 693                                         parsers.push( parser );
 694                                 }
 695                         },
 696
 697                         formatDigit: function( s ) {
 698                                 if ( ts.transformTable !== false ) {
 699                                         var     out = '',
 700                                                 c;
 701                                         for ( var p = 0; p < s.length; p++ ) {
 702                                                 c = s.charAt(p);
 703                                                 if ( c in ts.transformTable ) {
 704                                                         out += ts.transformTable[c];
 705                                                 } else {
 706                                                         out += c;
 707                                                 }
 708                                         }
 709                                         s = out;
 710                                 }
 711                                 var i = parseFloat( s.replace( /[, ]/g, '' ).replace( "\u2212", '-' ) );
 712                                 return ( isNaN(i)) ? 0 : i;
 713                         },
 714
 715                         formatFloat: function( s ) {
 716                                 var i = parseFloat(s);
 717                                 return ( isNaN(i)) ? 0 : i;
 718                         },
 719
 720                         formatInt: function( s ) {
 721                                 var i = parseInt( s, 10 );
 722                                 return ( isNaN(i)) ? 0 : i;
 723                         },
 724
 725                         clearTableBody: function( table ) {
 726                                 if ( $.browser.msie ) {
 727                                         var empty = function( el ) {
 728                                                 while ( el.firstChild ) {
 729                                                         el.removeChild( el.firstChild );
 730                                                 }
 731                                         };
 732                                         empty( table.tBodies[0] );
 733                                 } else {
 734                                         table.tBodies[0].innerHTML = '';
 735                                 }
 736                         }
 737                 };
 738
 739         // Shortcut
 740         ts = $.tablesorter;
 741
 742         // Register as jQuery prototype method
 743         $.fn.tablesorter = function( settings ) {
 744                 return ts.construct( this, settings );
 745         };
 746
 747         // Add default parsers
 748         ts.addParser( {
 749                 id: 'text',
 750                 is: function( s ) {
 751                         return true;
 752                 },
 753                 format: function( s ) {
 754                         s = $.trim( s.toLowerCase() );
 755                         if ( ts.collationRegex ) {
 756                                 var tsc = ts.collationTable;
 757                                 s = s.replace( ts.collationRegex, function( match ) {
 758                                         var r = tsc[match] ? tsc[match] : tsc[match.toUpperCase()];
 759                                         return r.toLowerCase();
 760                                 } );
 761                         }
 762                         return s;
 763                 },
 764                 type: 'text'
 765         } );
 766
 767         ts.addParser( {
 768                 id: 'IPAddress',
 769                 is: function( s ) {
 770                         return ts.rgx.IPAddress[0].test(s);
 771                 },
 772                 format: function( s ) {
 773                         var     a = s.split( '.' ),
 774                                 r = '';
 775                         if( a.length == 4 ) {
 776                                 var cidr = a[3].split('/');
 777                                 if (cidr.length > 1 ) {
 778                                         a[3] = cidr[0];
 779                                         a[4] = cidr[1];
 780                                 } else a[4] = '000';
 781                         }
 782                         for ( var i = 0; i < a.length; i++ ) {
 783                                 var item = a[i];
 784                                 if ( item.length == 1 ) {
 785                                         r += '00' + item;
 786                                 } else if ( item.length == 2 ) {
 787                                         r += '0' + item;
 788                                 } else {
 789                                         r += item;
 790                                 }
 791                         }
 792                         return $.tablesorter.formatFloat(r);
 793                 },
 794                 type: 'numeric'
 795         } );
 796
 797         ts.addParser( {
 798                 id: 'currency',
 799                 is: function( s ) {
 800                         return ts.rgx.currency[0].test(s);
 801                 },
 802                 format: function( s ) {
 803                         return $.tablesorter.formatDigit( s.replace( ts.rgx.currency[1], '' ) );
 804                 },
 805                 type: 'numeric'
 806         } );
 807
 808         ts.addParser( {
 809                 id: 'url',
 810                 is: function( s ) {
 811                         return ts.rgx.url[0].test(s);
 812                 },
 813                 format: function( s ) {
 814                         return $.trim( s.replace( ts.rgx.url[1], '' ) );
 815                 },
 816                 type: 'text'
 817         } );
 818
 819         ts.addParser( {
 820                 id: 'isoDate',
 821                 is: function( s ) {
 822                         return ts.rgx.isoDate[0].test(s);
 823                 },
 824                 format: function( s ) {
 825                         return $.tablesorter.formatFloat((s !== '') ? new Date(s.replace(
 826                         new RegExp( /-/g), '/')).getTime() : '0' );
 827                 },
 828                 type: 'numeric'
 829         } );
 830
 831         ts.addParser( {
 832                 id: 'usLongDate',
 833                 is: function( s ) {
 834                         return ts.rgx.usLongDate[0].test(s);
 835                 },
 836                 format: function( s ) {
 837                         return $.tablesorter.formatFloat( new Date(s).getTime() );
 838                 },
 839                 type: 'numeric'
 840         } );
 841
 842         ts.addParser( {
 843                 id: 'date',
 844                 is: function( s ) {
 845                         return ( ts.dateRegex[0].test(s) || ts.dateRegex[1].test(s) || ts.dateRegex[2].test(s ));
 846                 },
 847                 format: function( s, table ) {
 848                         s = $.trim( s.toLowerCase() );
 849
 850                         for ( var i = 1, j = 0; i < 13 && j < 2; i++ ) {
 851                                 s = s.replace( ts.monthNames[j][i], i );
 852                                 if ( i == 12 ) {
 853                                         j++;
 854                                         i = 0;
 855                                 }
 856                         }
 857
 858                         s = s.replace( /[\-\.\,' ]/g, '/' );
 859
 860                         // Replace double slashes
 861                         s = s.replace( /\/\//g, '/' );
 862                         s = s.replace( /\/\//g, '/' );
 863                         s = s.split( '/' );
 864
 865                         // Pad Month and Day
 866                         if ( s[0] && s[0].length == 1 ) {
 867                                 s[0] = '0' + s[0];
 868                         }
 869                         if ( s[1] && s[1].length == 1 ) {
 870                                 s[1] = '0' + s[1];
 871                         }
 872                         var y;
 873
 874                         if ( !s[2] ) {
 875                                 // Fix yearless dates
 876                                 s[2] = 2000;
 877                         } else if ( ( y = parseInt( s[2], 10) ) < 100 ) {
 878                                 // Guestimate years without centuries
 879                                 if ( y < 30 ) {
 880                                         s[2] = 2000 + y;
 881                                 } else {
 882                                         s[2] = 1900 + y;
 883                                 }
 884                         }
 885                         // Resort array depending on preferences
 886                         if ( mw.config.get( 'wgDefaultDateFormat' ) == 'mdy' || mw.config.get( 'wgContentLanguage' ) == 'en' ) {
 887                                 s.push( s.shift() );
 888                                 s.push( s.shift() );
 889                         } else if ( mw.config.get( 'wgDefaultDateFormat' ) == 'dmy' ) {
 890                                 var d = s.shift();
 891                                 s.push( s.shift() );
 892                                 s.push(d);
 893                         }
 894                         return parseInt( s.join( '' ), 10 );
 895                 },
 896                 type: 'numeric'
 897         } );
 898
 899         ts.addParser( {
 900                 id: 'time',
 901                 is: function( s ) {
 902                         return ts.rgx.time[0].test(s);
 903                 },
 904                 format: function( s ) {
 905                         return $.tablesorter.formatFloat( new Date( '2000/01/01 ' + s ).getTime() );
 906                 },
 907                 type: 'numeric'
 908         } );
 909
 910         ts.addParser( {
 911                 id: 'number',
 912                 is: function( s, table ) {
 913                         return $.tablesorter.numberRegex.test( $.trim( s ));
 914                 },
 915                 format: function( s ) {
 916                         var values = ts.rgx.fractions[0].exec($.trim(s));
 917                         if( values != null ) {
 918                                 // A fraction
 919                                 var retVal = 0;
 920                                 var decimal = $.tablesorter.formatDigit(values[2]) / $.tablesorter.formatDigit(values[3]);
 921                                 if( values[1] != undefined ) {
 922                                         retVal = $.tablesorter.formatDigit(values[1]);
 923                                 }
 924                                 if( !isNaN(decimal) && isFinite(decimal) ) {
 925                                         retVal += decimal;
 926                                 }
 927                                 return retVal;
 928                         }
 929                         return $.tablesorter.formatDigit(s);
 930                 },
 931                 type: 'numeric'
 932         } );
 933
 934 } )( jQuery );