diff --git a/resources/src/jquery/jquery.tablesorter.js b/resources/src/jquery/jquery.tablesorter.js
index 6d67ade9783..d712c0c4a1d 100644
--- a/resources/src/jquery/jquery.tablesorter.js
+++ b/resources/src/jquery/jquery.tablesorter.js
@@ -1,1277 +1,1277 @@
 /*!
  * TableSorter for MediaWiki
  *
  * Written 2011 Leo Koppelkamm
  * Based on tablesorter.com plugin, written (c) 2007 Christian Bach.
  *
  * Dual licensed under the MIT and GPL licenses:
  * http://www.opensource.org/licenses/mit-license.php
  * http://www.gnu.org/licenses/gpl.html
  *
  * Depends on mw.config (wgDigitTransformTable, wgDefaultDateFormat, wgPageContentLanguage)
  * and mw.language.months.
  *
  * Uses 'tableSorterCollation' in mw.config (if available)
  *
  * Create a sortable table with multi-column sorting capabilities
  *
  *      // Create a simple tablesorter interface
  *      $( 'table' ).tablesorter();
  *
  *      // Create a tablesorter interface, initially sorting on the first and second column
  *      $( 'table' ).tablesorter( { sortList: [ { 0: 'desc' }, { 1: 'asc' } ] } );
  *
  * @param {string} [cssHeader="header"] A string of the class name to be appended to sortable
  *         tr elements in the thead of the table.
  *
  * @param {string} [cssAsc="headerSortUp"] A string of the class name to be appended to
  *         sortable tr elements in the thead on a ascending sort.
  *
  * @param {string} [cssDesc="headerSortDown"] A string of the class name to be appended to
  *         sortable tr elements in the thead on a descending sort.
  *
  * @param {string} [sortMultisortKey="shiftKey"] A string of the multi-column sort key.
  *
  * @param {boolean} [cancelSelection=true] Boolean flag indicating iftablesorter should cancel
  *         selection of the table headers text.
  *
  * @param {Array} [sortList] An array containing objects specifying sorting. By passing more
  *         than one object, multi-sorting will be applied. Object structure:
  *         { <Integer column index>: <String 'asc' or 'desc'> }
  *
  * @event sortEnd.tablesorter: Triggered as soon as any sorting has been applied.
  *
  * @author Christian Bach/christian.bach@polyester.se
  */
 ( function ( $, mw ) {
 	var ts,
 		parsers = [];
 
 	/* Parser utility functions */
 
 	function getParserById( name ) {
 		var i;
 		for ( i = 0; i < parsers.length; i++ ) {
 			if ( parsers[ i ].id.toLowerCase() === name.toLowerCase() ) {
 				return parsers[ i ];
 			}
 		}
 		return false;
 	}
 
 	function getElementSortKey( node ) {
 		var $node = $( node ),
 			// Use data-sort-value attribute.
 			// Use data() instead of attr() so that live value changes
 			// are processed as well (T40152).
 			data = $node.data( 'sortValue' );
 
 		if ( data !== null && data !== undefined ) {
 			// Cast any numbers or other stuff to a string, methods
 			// like charAt, toLowerCase and split are expected.
 			return String( data );
 		}
 		if ( !node ) {
 			return $node.text();
 		}
 		if ( node.tagName.toLowerCase() === 'img' ) {
 			return $node.attr( 'alt' ) || ''; // handle undefined alt
 		}
 		return $.makeArray( node.childNodes ).map( function ( elem ) {
 			if ( elem.nodeType === Node.ELEMENT_NODE ) {
 				return getElementSortKey( elem );
 			}
 			return $.text( elem );
 		} ).join( '' );
 	}
 
 	function detectParserForColumn( table, rows, column ) {
 		var l = parsers.length,
 			config = $( table ).data( 'tablesorter' ).config,
 			cellIndex,
 			nodeValue,
 			nextRow = false,
 			// Start with 1 because 0 is the fallback parser
 			i = 1,
 			lastRowIndex = -1,
 			rowIndex = 0,
 			concurrent = 0,
 			empty = 0,
 			needed = ( rows.length > 4 ) ? 5 : rows.length;
 
 		while ( i < l ) {
 			// if this is a child row, continue to the next row (as buildCache())
 			if ( rows[ rowIndex ] && !$( rows[ rowIndex ] ).hasClass( config.cssChildRow ) ) {
 				if ( rowIndex !== lastRowIndex ) {
 					lastRowIndex = rowIndex;
 					cellIndex = $( rows[ rowIndex ] ).data( 'columnToCell' )[ column ];
 					nodeValue = $.trim( getElementSortKey( rows[ rowIndex ].cells[ cellIndex ] ) );
 				}
 			} else {
 				nodeValue = '';
 			}
 
 			if ( nodeValue !== '' ) {
 				if ( parsers[ i ].is( nodeValue, table ) ) {
 					concurrent++;
 					nextRow = true;
 					if ( concurrent >= needed ) {
 						// Confirmed the parser for multiple cells, let's return it
 						return parsers[ i ];
 					}
 				} else if ( parsers[ i ].id.match( /isoDate/ ) && /^\D*(\d{1,4}) ?(\[.+\])?$/.test( nodeValue ) ) {
 					// For 1-4 digits and maybe reference(s) parser "isoDate" or "number" is possible, check next row
 					empty++;
 					nextRow = true;
 				} else {
 					// Check next parser, reset rows
 					i++;
 					rowIndex = 0;
 					concurrent = 0;
 					empty = 0;
 					nextRow = false;
 				}
 			} else {
 				// Empty cell
 				empty++;
 				nextRow = true;
 			}
 
 			if ( nextRow ) {
 				nextRow = false;
 				rowIndex++;
 				if ( rowIndex >= rows.length ) {
 					if ( concurrent > 0 && concurrent >= rows.length - empty ) {
 						// Confirmed the parser for all filled cells
 						return parsers[ i ];
 					}
 					// Check next parser, reset rows
 					i++;
 					rowIndex = 0;
 					concurrent = 0;
 					empty = 0;
 				}
 			}
 		}
 
 		// 0 is always the generic parser (text)
 		return parsers[ 0 ];
 	}
 
 	function buildParserCache( table, $headers ) {
 		var sortType, len, j, parser,
 			rows = table.tBodies[ 0 ].rows,
 			config = $( table ).data( 'tablesorter' ).config,
 			parsers = [];
 
 		if ( rows[ 0 ] ) {
 			len = config.columns;
 			for ( j = 0; j < len; j++ ) {
 				parser = false;
 				sortType = $headers.eq( config.columnToHeader[ j ] ).data( 'sortType' );
 				if ( sortType !== undefined ) {
 					parser = getParserById( sortType );
 				}
 
 				if ( parser === false ) {
 					parser = detectParserForColumn( table, rows, j );
 				}
 
 				parsers.push( parser );
 			}
 		}
 		return parsers;
 	}
 
 	/* Other utility functions */
 
 	function buildCache( table ) {
 		var i, j, $row, cols,
 			totalRows = ( table.tBodies[ 0 ] && table.tBodies[ 0 ].rows.length ) || 0,
 			config = $( table ).data( 'tablesorter' ).config,
 			parsers = config.parsers,
 			len = parsers.length,
 			cellIndex,
 			cache = {
 				row: [],
 				normalized: []
 			};
 
 		for ( i = 0; i < totalRows; i++ ) {
 
 			// Add the table data to main data array
 			$row = $( table.tBodies[ 0 ].rows[ i ] );
 			cols = [];
 
 			// if this is a child row, add it to the last row's children and
 			// continue to the next row
 			if ( $row.hasClass( config.cssChildRow ) ) {
 				cache.row[ cache.row.length - 1 ] = cache.row[ cache.row.length - 1 ].add( $row );
 				// go to the next for loop
 				continue;
 			}
 
 			cache.row.push( $row );
 
 			for ( j = 0; j < len; j++ ) {
 				cellIndex = $row.data( 'columnToCell' )[ j ];
 				cols.push( parsers[ j ].format( getElementSortKey( $row[ 0 ].cells[ cellIndex ] ) ) );
 			}
 
 			cols.push( cache.normalized.length ); // add position for rowCache
 			cache.normalized.push( cols );
 			cols = null;
 		}
 
 		return cache;
 	}
 
 	function appendToTable( table, cache ) {
 		var i, pos, l, j,
 			row = cache.row,
 			normalized = cache.normalized,
 			totalRows = normalized.length,
 			checkCell = ( normalized[ 0 ].length - 1 ),
 			fragment = document.createDocumentFragment();
 
 		for ( i = 0; i < totalRows; i++ ) {
 			pos = normalized[ i ][ checkCell ];
 
 			l = row[ pos ].length;
 			for ( j = 0; j < l; j++ ) {
 				fragment.appendChild( row[ pos ][ j ] );
 			}
 
 		}
 		table.tBodies[ 0 ].appendChild( fragment );
 
 		$( table ).trigger( 'sortEnd.tablesorter' );
 	}
 
 	/**
 	 * Find all header rows in a thead-less table and put them in a <thead> tag.
 	 * This only treats a row as a header row if it contains only <th>s (no <td>s)
 	 * and if it is preceded entirely by header rows. The algorithm stops when
 	 * it encounters the first non-header row.
 	 *
 	 * After this, it will look at all rows at the bottom for footer rows
 	 * And place these in a tfoot using similar rules.
 	 *
 	 * @param {jQuery} $table object for a <table>
 	 */
 	function emulateTHeadAndFoot( $table ) {
 		var $thead, $tfoot, i, len,
 			$rows = $table.find( '> tbody > tr' );
 		if ( !$table.get( 0 ).tHead ) {
 			$thead = $( '<thead>' );
 			$rows.each( function () {
 				if ( $( this ).children( 'td' ).length ) {
 					// This row contains a <td>, so it's not a header row
 					// Stop here
 					return false;
 				}
 				$thead.append( this );
 			} );
 			$table.find( ' > tbody:first' ).before( $thead );
 		}
 		if ( !$table.get( 0 ).tFoot ) {
 			$tfoot = $( '<tfoot>' );
 			len = $rows.length;
 			for ( i = len - 1; i >= 0; i-- ) {
 				if ( $( $rows[ i ] ).children( 'td' ).length ) {
 					break;
 				}
 				$tfoot.prepend( $( $rows[ i ] ) );
 			}
 			$table.append( $tfoot );
 		}
 	}
 
 	function uniqueElements( array ) {
 		var uniques = [];
 		array.forEach( function ( elem ) {
 			if ( elem !== undefined && uniques.indexOf( elem ) === -1 ) {
 				uniques.push( elem );
 			}
 		} );
 		return uniques;
 	}
 
 	function buildHeaders( table, msg ) {
 		var config = $( table ).data( 'tablesorter' ).config,
 			maxSeen = 0,
 			colspanOffset = 0,
 			columns,
 			k,
 			$cell,
 			rowspan,
 			colspan,
 			headerCount,
 			longestTR,
 			headerIndex,
 			exploded,
 			$tableHeaders = $( [] ),
 			$tableRows = $( 'thead:eq(0) > tr', table );
 
 		if ( $tableRows.length <= 1 ) {
 			$tableHeaders = $tableRows.children( 'th' );
 		} else {
 			exploded = [];
 
 			// Loop through all the dom cells of the thead
 			$tableRows.each( function ( rowIndex, row ) {
 				$.each( row.cells, function ( columnIndex, cell ) {
 					var matrixRowIndex,
 						matrixColumnIndex;
 
 					rowspan = Number( cell.rowSpan );
 					colspan = Number( cell.colSpan );
 
 					// Skip the spots in the exploded matrix that are already filled
 					while ( exploded[ rowIndex ] && exploded[ rowIndex ][ columnIndex ] !== undefined ) {
 						++columnIndex;
 					}
 
 					// Find the actual dimensions of the thead, by placing each cell
 					// in the exploded matrix rowspan times colspan times, with the proper offsets
 					for ( matrixColumnIndex = columnIndex; matrixColumnIndex < columnIndex + colspan; ++matrixColumnIndex ) {
 						for ( matrixRowIndex = rowIndex; matrixRowIndex < rowIndex + rowspan; ++matrixRowIndex ) {
 							if ( !exploded[ matrixRowIndex ] ) {
 								exploded[ matrixRowIndex ] = [];
 							}
 							exploded[ matrixRowIndex ][ matrixColumnIndex ] = cell;
 						}
 					}
 				} );
 			} );
 			// We want to find the row that has the most columns (ignoring colspan)
 			exploded.forEach( function ( cellArray, index ) {
 				headerCount = $( uniqueElements( cellArray ) ).filter( 'th' ).length;
 				if ( headerCount >= maxSeen ) {
 					maxSeen = headerCount;
 					longestTR = index;
 				}
 			} );
 			// We cannot use $.unique() here because it sorts into dom order, which is undesirable
 			$tableHeaders = $( uniqueElements( exploded[ longestTR ] ) ).filter( 'th' );
 		}
 
 		// as each header can span over multiple columns (using colspan=N),
 		// we have to bidirectionally map headers to their columns and columns to their headers
 		config.columnToHeader = [];
 		config.headerToColumns = [];
 		config.headerList = [];
 		headerIndex = 0;
 		$tableHeaders.each( function () {
 			$cell = $( this );
 			columns = [];
 
 			if ( !$cell.hasClass( config.unsortableClass ) ) {
 				$cell
 					.addClass( config.cssHeader )
 					.prop( 'tabIndex', 0 )
 					.attr( {
 						role: 'columnheader button',
 						title: msg[ 1 ]
 					} );
 
 				for ( k = 0; k < this.colSpan; k++ ) {
 					config.columnToHeader[ colspanOffset + k ] = headerIndex;
 					columns.push( colspanOffset + k );
 				}
 
 				config.headerToColumns[ headerIndex ] = columns;
 
 				$cell.data( {
 					headerIndex: headerIndex,
 					order: 0,
 					count: 0
 				} );
 
 				// add only sortable cells to headerList
 				config.headerList[ headerIndex ] = this;
 				headerIndex++;
 			}
 
 			colspanOffset += this.colSpan;
 		} );
 
 		// number of columns with extended colspan, inclusive unsortable
 		// parsers[j], cache[][j], columnToHeader[j], columnToCell[j] have so many elements
 		config.columns = colspanOffset;
 
 		return $tableHeaders.not( '.' + config.unsortableClass );
 	}
 
 	function isValueInArray( v, a ) {
 		var i;
 		for ( i = 0; i < a.length; i++ ) {
 			if ( a[ i ][ 0 ] === v ) {
 				return true;
 			}
 		}
 		return false;
 	}
 
 	/**
 	 * Sets the sort count of the columns that are not affected by the sorting to have them sorted
 	 * in default (ascending) order when their header cell is clicked the next time.
 	 *
 	 * @param {jQuery} $headers
 	 * @param {Array} sortList 2D number array
 	 * @param {Array} headerToColumns 2D number array
 	 */
 	function setHeadersOrder( $headers, sortList, headerToColumns ) {
 		// Loop through all headers to retrieve the indices of the columns the header spans across:
 		headerToColumns.forEach( function ( columns, headerIndex ) {
 
 			columns.forEach( function ( columnIndex, i ) {
 				var header = $headers[ headerIndex ],
 					$header = $( header );
 
 				if ( !isValueInArray( columnIndex, sortList ) ) {
 					// Column shall not be sorted: Reset header count and order.
 					$header.data( {
 						order: 0,
 						count: 0
 					} );
 				} else {
 					// Column shall be sorted: Apply designated count and order.
 					sortList.forEach( function ( sortColumn ) {
 						if ( sortColumn[ 0 ] === i ) {
 							$header.data( {
 								order: sortColumn[ 1 ],
 								count: sortColumn[ 1 ] + 1
 							} );
 							return false;
 						}
 					} );
 				}
 			} );
 
 		} );
 	}
 
 	function setHeadersCss( table, $headers, list, css, msg, columnToHeader ) {
 		var i, len;
 		// Remove all header information and reset titles to default message
 		$headers.removeClass( css[ 0 ] ).removeClass( css[ 1 ] ).attr( 'title', msg[ 1 ] );
 
 		for ( i = 0, len = list.length; i < len; i++ ) {
 			$headers
 				.eq( columnToHeader[ list[ i ][ 0 ] ] )
 				.addClass( css[ list[ i ][ 1 ] ] )
 				.attr( 'title', msg[ list[ i ][ 1 ] ] );
 		}
 	}
 
 	function sortText( a, b ) {
 		return ( ( a < b ) ? -1 : ( ( a > b ) ? 1 : 0 ) );
 	}
 
 	function sortTextDesc( a, b ) {
 		return ( ( b < a ) ? -1 : ( ( b > a ) ? 1 : 0 ) );
 	}
 
 	function multisort( table, sortList, cache ) {
 		var i,
 			sortFn = [];
 
 		for ( i = 0; i < sortList.length; i++ ) {
 			sortFn[ i ] = ( sortList[ i ][ 1 ] ) ? sortTextDesc : sortText;
 		}
 		cache.normalized.sort( function ( array1, array2 ) {
 			var i, col, ret;
 			for ( i = 0; i < sortList.length; i++ ) {
 				col = sortList[ i ][ 0 ];
 				ret = sortFn[ i ].call( this, array1[ col ], array2[ col ] );
 				if ( ret !== 0 ) {
 					return ret;
 				}
 			}
 			// Fall back to index number column to ensure stable sort
 			return sortText.call( this, array1[ array1.length - 1 ], array2[ array2.length - 1 ] );
 		} );
 		return cache;
 	}
 
 	function buildTransformTable() {
 		var ascii, localised, i, digitClass,
 			digits = '0123456789,.'.split( '' ),
 			separatorTransformTable = mw.config.get( 'wgSeparatorTransformTable' ),
 			digitTransformTable = mw.config.get( 'wgDigitTransformTable' );
 
 		if ( separatorTransformTable === null || ( separatorTransformTable[ 0 ] === '' && digitTransformTable[ 2 ] === '' ) ) {
 			ts.transformTable = false;
 		} else {
 			ts.transformTable = {};
 
 			// Unpack the transform table
 			ascii = separatorTransformTable[ 0 ].split( '\t' ).concat( digitTransformTable[ 0 ].split( '\t' ) );
 			localised = separatorTransformTable[ 1 ].split( '\t' ).concat( digitTransformTable[ 1 ].split( '\t' ) );
 
 			// Construct regexes for number identification
 			for ( i = 0; i < ascii.length; i++ ) {
 				ts.transformTable[ localised[ i ] ] = ascii[ i ];
 				digits.push( mw.RegExp.escape( localised[ i ] ) );
 			}
 		}
 		digitClass = '[' + digits.join( '', digits ) + ']';
 
 		// We allow a trailing percent sign, which we just strip. This works fine
 		// if percents and regular numbers aren't being mixed.
 		ts.numberRegex = new RegExp(
 			'^(' +
 				'[-+\u2212]?[0-9][0-9,]*(\\.[0-9,]*)?(E[-+\u2212]?[0-9][0-9,]*)?' + // Fortran-style scientific
 				'|' +
 				'[-+\u2212]?' + digitClass + '+[\\s\\xa0]*%?' + // Generic localised
 			')$',
 			'i'
 		);
 	}
 
 	function buildDateTable() {
 		var i, name,
 			regex = [];
 
 		ts.monthNames = {};
 
 		for ( i = 0; i < 12; i++ ) {
 			name = mw.language.months.names[ i ].toLowerCase();
 			ts.monthNames[ name ] = i + 1;
 			regex.push( mw.RegExp.escape( name ) );
 			name = mw.language.months.genitive[ i ].toLowerCase();
 			ts.monthNames[ name ] = i + 1;
 			regex.push( mw.RegExp.escape( name ) );
 			name = mw.language.months.abbrev[ i ].toLowerCase().replace( '.', '' );
 			ts.monthNames[ name ] = i + 1;
 			regex.push( mw.RegExp.escape( name ) );
 		}
 
 		// Build piped string
 		regex = regex.join( '|' );
 
 		// Build RegEx
 		// Any date formated with . , ' - or /
 		ts.dateRegex[ 0 ] = new RegExp( /^\s*(\d{1,2})[,.\-/'\s]{1,2}(\d{1,2})[,.\-/'\s]{1,2}(\d{2,4})\s*?/i );
 
 		// Written Month name, dmy
 		ts.dateRegex[ 1 ] = new RegExp(
 			'^\\s*(\\d{1,2})[\\,\\.\\-\\/\'\\s]+(' +
 				regex +
 			')' +
 			'[\\,\\.\\-\\/\'\\s]+(\\d{2,4})\\s*$',
 			'i'
 		);
 
 		// Written Month name, mdy
 		ts.dateRegex[ 2 ] = new RegExp(
 			'^\\s*(' + regex + ')' +
 			'[\\,\\.\\-\\/\'\\s]+(\\d{1,2})[\\,\\.\\-\\/\'\\s]+(\\d{2,4})\\s*$',
 			'i'
 		);
 
 	}
 
 	/**
 	 * Replace all rowspanned cells in the body with clones in each row, so sorting
 	 * need not worry about them.
 	 *
 	 * @param {jQuery} $table jQuery object for a <table>
 	 */
 	function explodeRowspans( $table ) {
 		var spanningRealCellIndex, rowSpan, colSpan,
 			cell, cellData, i, $tds, $clone, $nextRows,
 			rowspanCells = $table.find( '> tbody > tr > [rowspan]' ).get();
 
 		// Short circuit
 		if ( !rowspanCells.length ) {
 			return;
 		}
 
 		// First, we need to make a property like cellIndex but taking into
 		// account colspans. We also cache the rowIndex to avoid having to take
 		// cell.parentNode.rowIndex in the sorting function below.
 		$table.find( '> tbody > tr' ).each( function () {
 			var i,
 				col = 0,
 				len = this.cells.length;
 			for ( i = 0; i < len; i++ ) {
 				$( this.cells[ i ] ).data( 'tablesorter', {
 					realCellIndex: col,
 					realRowIndex: this.rowIndex
 				} );
 				col += this.cells[ i ].colSpan;
 			}
 		} );
 
 		// Split multi row cells into multiple cells with the same content.
 		// Sort by column then row index to avoid problems with odd table structures.
 		// Re-sort whenever a rowspanned cell's realCellIndex is changed, because it
 		// might change the sort order.
 		function resortCells() {
 			var cellAData,
 				cellBData,
 				ret;
 			rowspanCells = rowspanCells.sort( function ( a, b ) {
 				cellAData = $.data( a, 'tablesorter' );
 				cellBData = $.data( b, 'tablesorter' );
 				ret = cellAData.realCellIndex - cellBData.realCellIndex;
 				if ( !ret ) {
 					ret = cellAData.realRowIndex - cellBData.realRowIndex;
 				}
 				return ret;
 			} );
 			rowspanCells.forEach( function ( cell ) {
 				$.data( cell, 'tablesorter' ).needResort = false;
 			} );
 		}
 		resortCells();
 
 		function filterfunc() {
 			return $.data( this, 'tablesorter' ).realCellIndex >= spanningRealCellIndex;
 		}
 
 		function fixTdCellIndex() {
 			$.data( this, 'tablesorter' ).realCellIndex += colSpan;
 			if ( this.rowSpan > 1 ) {
 				$.data( this, 'tablesorter' ).needResort = true;
 			}
 		}
 
 		while ( rowspanCells.length ) {
 			if ( $.data( rowspanCells[ 0 ], 'tablesorter' ).needResort ) {
 				resortCells();
 			}
 
 			cell = rowspanCells.shift();
 			cellData = $.data( cell, 'tablesorter' );
 			rowSpan = cell.rowSpan;
 			colSpan = cell.colSpan;
 			spanningRealCellIndex = cellData.realCellIndex;
 			cell.rowSpan = 1;
 			$nextRows = $( cell ).parent().nextAll();
 			for ( i = 0; i < rowSpan - 1; i++ ) {
 				$tds = $( $nextRows[ i ].cells ).filter( filterfunc );
 				$clone = $( cell ).clone();
 				$clone.data( 'tablesorter', {
 					realCellIndex: spanningRealCellIndex,
 					realRowIndex: cellData.realRowIndex + i,
 					needResort: true
 				} );
 				if ( $tds.length ) {
 					$tds.each( fixTdCellIndex );
 					$tds.first().before( $clone );
 				} else {
 					$nextRows.eq( i ).append( $clone );
 				}
 			}
 		}
 	}
 
 	/**
 	 * Build index to handle colspanned cells in the body.
 	 * Set the cell index for each column in an array,
 	 * so that colspaned cells set multiple in this array.
 	 * columnToCell[collumnIndex] point at the real cell in this row.
 	 *
 	 * @param {jQuery} $table object for a <table>
 	 */
 	function manageColspans( $table ) {
 		var i, j, k, $row,
 			$rows = $table.find( '> tbody > tr' ),
 			totalRows = $rows.length || 0,
 			config = $table.data( 'tablesorter' ).config,
 			columns = config.columns,
 			columnToCell, cellsInRow, index;
 
 		for ( i = 0; i < totalRows; i++ ) {
 
 			$row = $rows.eq( i );
 			// if this is a child row, continue to the next row (as buildCache())
 			if ( $row.hasClass( config.cssChildRow ) ) {
 				// go to the next for loop
 				continue;
 			}
 
 			columnToCell = [];
 			cellsInRow = ( $row[ 0 ].cells.length ) || 0; // all cells in this row
 			index = 0; // real cell index in this row
 			for ( j = 0; j < columns; index++ ) {
 				if ( index === cellsInRow ) {
 					// Row with cells less than columns: add empty cell
 					$row.append( '<td>' );
 					cellsInRow++;
 				}
 				for ( k = 0; k < $row[ 0 ].cells[ index ].colSpan; k++ ) {
 					columnToCell[ j++ ] = index;
 				}
 			}
 			// Store it in $row
 			$row.data( 'columnToCell', columnToCell );
 		}
 	}
 
 	function buildCollationTable() {
 		var key, keys = [];
 		ts.collationTable = mw.config.get( 'tableSorterCollation' );
 		ts.collationRegex = null;
 		if ( ts.collationTable ) {
 			// Build array of key names
 			for ( key in ts.collationTable ) {
 				// Check hasOwn to be safe
 				if ( ts.collationTable.hasOwnProperty( key ) ) {
 					keys.push( mw.RegExp.escape( key ) );
 				}
 			}
 			if ( keys.length ) {
 				ts.collationRegex = new RegExp( keys.join( '|' ), 'ig' );
 			}
 		}
 	}
 
 	function cacheRegexs() {
 		if ( ts.rgx ) {
 			return;
 		}
 		ts.rgx = {
 			IPAddress: [
 				new RegExp( /^\d{1,3}[.]\d{1,3}[.]\d{1,3}[.]\d{1,3}$/ )
 			],
 			currency: [
 				new RegExp( /(^[£$€¥]|[£$€¥]$)/ ),
 				new RegExp( /[£$€¥]/g )
 			],
 			url: [
 				new RegExp( /^(https?|ftp|file):\/\/$/ ),
 				new RegExp( /(https?|ftp|file):\/\// )
 			],
 			isoDate: [
 				new RegExp( /^[^-\d]*(-?\d{1,4})-(0\d|1[0-2])(-([0-3]\d))?([T\s]([01]\d|2[0-4]):?(([0-5]\d):?(([0-5]\d|60)([.,]\d{1,3})?)?)?([zZ]|([-+])([01]\d|2[0-3]):?([0-5]\d)?)?)?/ ),
 				new RegExp( /^[^-\d]*(-?\d{1,4})-?(\d\d)?(-?(\d\d))?([T\s](\d\d):?((\d\d)?:?((\d\d)?([.,]\d{1,3})?)?)?([zZ]|([-+])(\d\d):?(\d\d)?)?)?/ )
 			],
 			usLongDate: [
 				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)))$/ )
 			],
 			time: [
 				new RegExp( /^(([0-2]?[0-9]:[0-5][0-9])|([0-1]?[0-9]:[0-5][0-9]\s(am|pm)))$/ )
 			]
 		};
 	}
 
 	/**
 	 * Converts sort objects [ { Integer: String }, ... ] to the internally used nested array
-	 * structure [ [ Integer , Integer ], ... ]
+	 * structure [ [ Integer, Integer ], ... ]
 	 *
 	 * @param {Array} sortObjects List of sort objects.
 	 * @return {Array} List of internal sort definitions.
 	 */
 	function convertSortList( sortObjects ) {
 		var sortList = [];
-		$.each( sortObjects, function ( i, sortObject ) {
+		sortObjects.forEach( function ( sortObject ) {
 			$.each( sortObject, function ( columnIndex, order ) {
 				var orderIndex = ( order === 'desc' ) ? 1 : 0;
 				sortList.push( [ parseInt( columnIndex, 10 ), orderIndex ] );
 			} );
 		} );
 		return sortList;
 	}
 
 	/* Public scope */
 
 	$.tablesorter = {
 		defaultOptions: {
 			cssHeader: 'headerSort',
 			cssAsc: 'headerSortUp',
 			cssDesc: 'headerSortDown',
 			cssChildRow: 'expand-child',
 			sortMultiSortKey: 'shiftKey',
 			unsortableClass: 'unsortable',
 			parsers: [],
 			cancelSelection: true,
 			sortList: [],
 			headerList: [],
 			headerToColumns: [],
 			columnToHeader: [],
 			columns: 0
 		},
 
 		dateRegex: [],
 		monthNames: {},
 
 		/**
 		 * @param {jQuery} $tables
 		 * @param {Object} [settings]
 		 * @return {jQuery}
 		 */
 		construct: function ( $tables, settings ) {
 			return $tables.each( function ( i, table ) {
 				// Declare and cache.
 				var $headers, cache, config, sortCSS, sortMsg,
 					$table = $( table ),
 					firstTime = true;
 
 				// Quit if no tbody
 				if ( !table.tBodies ) {
 					return;
 				}
 				if ( !table.tHead ) {
 					// No thead found. Look for rows with <th>s and
 					// move them into a <thead> tag or a <tfoot> tag
 					emulateTHeadAndFoot( $table );
 
 					// Still no thead? Then quit
 					if ( !table.tHead ) {
 						return;
 					}
 				}
 				$table.addClass( 'jquery-tablesorter' );
 
 				// Merge and extend
 				config = $.extend( {}, $.tablesorter.defaultOptions, settings );
 
 				// Save the settings where they read
 				$.data( table, 'tablesorter', { config: config } );
 
 				// Get the CSS class names, could be done elsewhere
 				sortCSS = [ config.cssAsc, config.cssDesc ];
 				// Messages tell the the user what the *next* state will be
 				// so are in reverse order to the CSS classes.
 				sortMsg = [ mw.msg( 'sort-descending' ), mw.msg( 'sort-ascending' ) ];
 
 				// Build headers
 				$headers = buildHeaders( table, sortMsg );
 
 				// Grab and process locale settings.
 				buildTransformTable();
 				buildDateTable();
 
 				// Precaching regexps can bring 10 fold
 				// performance improvements in some browsers.
 				cacheRegexs();
 
 				function setupForFirstSort() {
 					var $tfoot, $sortbottoms;
 
 					firstTime = false;
 
 					// Defer buildCollationTable to first sort. As user and site scripts
 					// may customize tableSorterCollation but load after $.ready(), other
 					// scripts may call .tablesorter() before they have done the
 					// tableSorterCollation customizations.
 					buildCollationTable();
 
 					// Legacy fix of .sortbottoms
 					// Wrap them inside a tfoot (because that's what they actually want to be)
 					// and put the <tfoot> at the end of the <table>
 					$sortbottoms = $table.find( '> tbody > tr.sortbottom' );
 					if ( $sortbottoms.length ) {
 						$tfoot = $table.children( 'tfoot' );
 						if ( $tfoot.length ) {
 							$tfoot.eq( 0 ).prepend( $sortbottoms );
 						} else {
 							$table.append( $( '<tfoot>' ).append( $sortbottoms ) );
 						}
 					}
 
 					explodeRowspans( $table );
 					manageColspans( $table );
 
 					// Try to auto detect column type, and store in tables config
 					config.parsers = buildParserCache( table, $headers );
 				}
 
 				// Apply event handling to headers
 				// this is too big, perhaps break it out?
 				$headers.on( 'keypress click', function ( e ) {
 					var cell, $cell, columns, newSortList, i,
 						totalRows,
 						j, s, o;
 
 					if ( e.type === 'click' && e.target.nodeName.toLowerCase() === 'a' ) {
 						// The user clicked on a link inside a table header.
 						// Do nothing and let the default link click action continue.
 						return true;
 					}
 
 					if ( e.type === 'keypress' && e.which !== 13 ) {
 						// Only handle keypresses on the "Enter" key.
 						return true;
 					}
 
 					if ( firstTime ) {
 						setupForFirstSort();
 					}
 
 					// Build the cache for the tbody cells
 					// to share between calculations for this sort action.
 					// Re-calculated each time a sort action is performed due to possiblity
 					// that sort values change. Shouldn't be too expensive, but if it becomes
 					// too slow an event based system should be implemented somehow where
 					// cells get event .change() and bubbles up to the <table> here
 					cache = buildCache( table );
 
 					totalRows = ( $table[ 0 ].tBodies[ 0 ] && $table[ 0 ].tBodies[ 0 ].rows.length ) || 0;
 					if ( totalRows > 0 ) {
 						cell = this;
 						$cell = $( cell );
 
 						// Get current column sort order
 						$cell.data( {
 							order: $cell.data( 'count' ) % 2,
 							count: $cell.data( 'count' ) + 1
 						} );
 
 						cell = this;
 						// Get current column index
 						columns = config.headerToColumns[ $cell.data( 'headerIndex' ) ];
 						newSortList = columns.map( function ( c ) {
 							return [ c, $cell.data( 'order' ) ];
 						} );
 						// Index of first column belonging to this header
 						i = columns[ 0 ];
 
 						if ( !e[ config.sortMultiSortKey ] ) {
 							// User only wants to sort on one column set
 							// Flush the sort list and add new columns
 							config.sortList = newSortList;
 						} else {
 							// Multi column sorting
 							// It is not possible for one column to belong to multiple headers,
 							// so this is okay - we don't need to check for every value in the columns array
 							if ( isValueInArray( i, config.sortList ) ) {
 								// The user has clicked on an already sorted column.
 								// Reverse the sorting direction for all tables.
 								for ( j = 0; j < config.sortList.length; j++ ) {
 									s = config.sortList[ j ];
 									o = config.headerList[ config.columnToHeader[ s[ 0 ] ] ];
 									if ( isValueInArray( s[ 0 ], newSortList ) ) {
 										$( o ).data( 'count', s[ 1 ] + 1 );
 										s[ 1 ] = $( o ).data( 'count' ) % 2;
 									}
 								}
 							} else {
 								// Add columns to sort list array
 								config.sortList = config.sortList.concat( newSortList );
 							}
 						}
 
 						// Reset order/counts of cells not affected by sorting
 						setHeadersOrder( $headers, config.sortList, config.headerToColumns );
 
 						// Set CSS for headers
 						setHeadersCss( $table[ 0 ], $headers, config.sortList, sortCSS, sortMsg, config.columnToHeader );
 						appendToTable(
 							$table[ 0 ], multisort( $table[ 0 ], config.sortList, cache )
 						);
 
 						// Stop normal event by returning false
 						return false;
 					}
 
 				// Cancel selection
 				} ).mousedown( function () {
 					if ( config.cancelSelection ) {
 						this.onselectstart = function () {
 							return false;
 						};
 						return false;
 					}
 				} );
 
 				/**
 				 * Sorts the table. If no sorting is specified by passing a list of sort
 				 * objects, the table is sorted according to the initial sorting order.
 				 * Passing an empty array will reset sorting (basically just reset the headers
 				 * making the table appear unsorted).
 				 *
 				 * @param {Array} [sortList] List of sort objects.
 				 */
 				$table.data( 'tablesorter' ).sort = function ( sortList ) {
 
 					if ( firstTime ) {
 						setupForFirstSort();
 					}
 
 					if ( sortList === undefined ) {
 						sortList = config.sortList;
 					} else if ( sortList.length > 0 ) {
 						sortList = convertSortList( sortList );
 					}
 
 					// Set each column's sort count to be able to determine the correct sort
 					// order when clicking on a header cell the next time
 					setHeadersOrder( $headers, sortList, config.headerToColumns );
 
 					// re-build the cache for the tbody cells
 					cache = buildCache( table );
 
 					// set css for headers
 					setHeadersCss( table, $headers, sortList, sortCSS, sortMsg, config.columnToHeader );
 
 					// sort the table and append it to the dom
 					appendToTable( table, multisort( table, sortList, cache ) );
 				};
 
 				// sort initially
 				if ( config.sortList.length > 0 ) {
 					config.sortList = convertSortList( config.sortList );
 					$table.data( 'tablesorter' ).sort();
 				}
 
 			} );
 		},
 
 		addParser: function ( parser ) {
 			if ( !getParserById( parser.id ) ) {
 				parsers.push( parser );
 			}
 		},
 
 		formatDigit: function ( s ) {
 			var out, c, p, i;
 			if ( ts.transformTable !== false ) {
 				out = '';
 				for ( p = 0; p < s.length; p++ ) {
 					c = s.charAt( p );
 					if ( c in ts.transformTable ) {
 						out += ts.transformTable[ c ];
 					} else {
 						out += c;
 					}
 				}
 				s = out;
 			}
 			i = parseFloat( s.replace( /[, ]/g, '' ).replace( '\u2212', '-' ) );
 			return isNaN( i ) ? -Infinity : i;
 		},
 
 		formatFloat: function ( s ) {
 			var i = parseFloat( s );
 			return isNaN( i ) ? -Infinity : i;
 		},
 
 		formatInt: function ( s ) {
 			var i = parseInt( s, 10 );
 			return isNaN( i ) ? -Infinity : i;
 		},
 
 		clearTableBody: function ( table ) {
 			$( table.tBodies[ 0 ] ).empty();
 		},
 
 		getParser: function ( id ) {
 			buildTransformTable();
 			buildDateTable();
 			cacheRegexs();
 			buildCollationTable();
 
 			return getParserById( id );
 		},
 
 		getParsers: function () { // for table diagnosis
 			return parsers;
 		}
 	};
 
 	// Shortcut
 	ts = $.tablesorter;
 
 	// Register as jQuery prototype method
 	$.fn.tablesorter = function ( settings ) {
 		return ts.construct( this, settings );
 	};
 
 	// Add default parsers
 	ts.addParser( {
 		id: 'text',
 		is: function () {
 			return true;
 		},
 		format: function ( s ) {
 			var tsc;
 			s = $.trim( s.toLowerCase() );
 			if ( ts.collationRegex ) {
 				tsc = ts.collationTable;
 				s = s.replace( ts.collationRegex, function ( match ) {
 					var r = tsc[ match ] ? tsc[ match ] : tsc[ match.toUpperCase() ];
 					return r.toLowerCase();
 				} );
 			}
 			return s;
 		},
 		type: 'text'
 	} );
 
 	ts.addParser( {
 		id: 'IPAddress',
 		is: function ( s ) {
 			return ts.rgx.IPAddress[ 0 ].test( s );
 		},
 		format: function ( s ) {
 			var i, item,
 				a = s.split( '.' ),
 				r = '';
 			for ( i = 0; i < a.length; i++ ) {
 				item = a[ i ];
 				if ( item.length === 1 ) {
 					r += '00' + item;
 				} else if ( item.length === 2 ) {
 					r += '0' + item;
 				} else {
 					r += item;
 				}
 			}
 			return $.tablesorter.formatFloat( r );
 		},
 		type: 'numeric'
 	} );
 
 	ts.addParser( {
 		id: 'currency',
 		is: function ( s ) {
 			return ts.rgx.currency[ 0 ].test( s );
 		},
 		format: function ( s ) {
 			return $.tablesorter.formatDigit( s.replace( ts.rgx.currency[ 1 ], '' ) );
 		},
 		type: 'numeric'
 	} );
 
 	ts.addParser( {
 		id: 'url',
 		is: function ( s ) {
 			return ts.rgx.url[ 0 ].test( s );
 		},
 		format: function ( s ) {
 			return $.trim( s.replace( ts.rgx.url[ 1 ], '' ) );
 		},
 		type: 'text'
 	} );
 
 	ts.addParser( {
 		id: 'isoDate',
 		is: function ( s ) {
 			return ts.rgx.isoDate[ 0 ].test( s );
 		},
 		format: function ( s ) {
 			var match, i, isodate, ms, hOffset, mOffset;
 			match = s.match( ts.rgx.isoDate[ 0 ] );
 			if ( match === null ) {
 				// Otherwise a signed number with 1-4 digit is parsed as isoDate
 				match = s.match( ts.rgx.isoDate[ 1 ] );
 			}
 			if ( !match ) {
 				return -Infinity;
 			}
 			// Month and day
 			for ( i = 2; i <= 4; i += 2 ) {
 				if ( !match[ i ] || match[ i ].length === 0 ) {
 					match[ i ] = 1;
 				}
 			}
 			// Time
 			for ( i = 6; i <= 15; i++ ) {
 				if ( !match[ i ] || match[ i ].length === 0 ) {
 					match[ i ] = '0';
 				}
 			}
 			ms = parseFloat( match[ 11 ].replace( /,/, '.' ) ) * 1000;
 			hOffset = $.tablesorter.formatInt( match[ 13 ] + match[ 14 ] );
 			mOffset = $.tablesorter.formatInt( match[ 13 ] + match[ 15 ] );
 
 			isodate = new Date( 0 );
 			// Because Date constructor changes year 0-99 to 1900-1999, use setUTCFullYear()
 			isodate.setUTCFullYear( match[ 1 ], match[ 2 ] - 1, match[ 4 ] );
 			isodate.setUTCHours( match[ 6 ] - hOffset, match[ 8 ] - mOffset, match[ 10 ], ms );
 			return isodate.getTime();
 		},
 		type: 'numeric'
 	} );
 
 	ts.addParser( {
 		id: 'usLongDate',
 		is: function ( s ) {
 			return ts.rgx.usLongDate[ 0 ].test( s );
 		},
 		format: function ( s ) {
 			return $.tablesorter.formatFloat( new Date( s ).getTime() );
 		},
 		type: 'numeric'
 	} );
 
 	ts.addParser( {
 		id: 'date',
 		is: function ( s ) {
 			return ( ts.dateRegex[ 0 ].test( s ) || ts.dateRegex[ 1 ].test( s ) || ts.dateRegex[ 2 ].test( s ) );
 		},
 		format: function ( s ) {
 			var match, y;
 			s = $.trim( s.toLowerCase() );
 
 			if ( ( match = s.match( ts.dateRegex[ 0 ] ) ) !== null ) {
 				if ( mw.config.get( 'wgDefaultDateFormat' ) === 'mdy' || mw.config.get( 'wgPageContentLanguage' ) === 'en' ) {
 					s = [ match[ 3 ], match[ 1 ], match[ 2 ] ];
 				} else if ( mw.config.get( 'wgDefaultDateFormat' ) === 'dmy' ) {
 					s = [ match[ 3 ], match[ 2 ], match[ 1 ] ];
 				} else {
 					// If we get here, we don't know which order the dd-dd-dddd
 					// date is in. So return something not entirely invalid.
 					return '99999999';
 				}
 			} else if ( ( match = s.match( ts.dateRegex[ 1 ] ) ) !== null ) {
 				s = [ match[ 3 ], String( ts.monthNames[ match[ 2 ] ] ), match[ 1 ] ];
 			} else if ( ( match = s.match( ts.dateRegex[ 2 ] ) ) !== null ) {
 				s = [ match[ 3 ], String( ts.monthNames[ match[ 1 ] ] ), match[ 2 ] ];
 			} else {
 				// Should never get here
 				return '99999999';
 			}
 
 			// Pad Month and Day
 			if ( s[ 1 ].length === 1 ) {
 				s[ 1 ] = '0' + s[ 1 ];
 			}
 			if ( s[ 2 ].length === 1 ) {
 				s[ 2 ] = '0' + s[ 2 ];
 			}
 
 			if ( ( y = parseInt( s[ 0 ], 10 ) ) < 100 ) {
 				// Guestimate years without centuries
 				if ( y < 30 ) {
 					s[ 0 ] = 2000 + y;
 				} else {
 					s[ 0 ] = 1900 + y;
 				}
 			}
 			while ( s[ 0 ].length < 4 ) {
 				s[ 0 ] = '0' + s[ 0 ];
 			}
 			return parseInt( s.join( '' ), 10 );
 		},
 		type: 'numeric'
 	} );
 
 	ts.addParser( {
 		id: 'time',
 		is: function ( s ) {
 			return ts.rgx.time[ 0 ].test( s );
 		},
 		format: function ( s ) {
 			return $.tablesorter.formatFloat( new Date( '2000/01/01 ' + s ).getTime() );
 		},
 		type: 'numeric'
 	} );
 
 	ts.addParser( {
 		id: 'number',
 		is: function ( s ) {
 			return $.tablesorter.numberRegex.test( $.trim( s ) );
 		},
 		format: function ( s ) {
 			return $.tablesorter.formatDigit( s );
 		},
 		type: 'numeric'
 	} );
 
 }( jQuery, mediaWiki ) );
diff --git a/resources/src/mediawiki.action/mediawiki.action.edit.preview.js b/resources/src/mediawiki.action/mediawiki.action.edit.preview.js
index ab1ce2770eb..b86f5c811d3 100644
--- a/resources/src/mediawiki.action/mediawiki.action.edit.preview.js
+++ b/resources/src/mediawiki.action/mediawiki.action.edit.preview.js
@@ -1,334 +1,330 @@
 /*!
  * Live edit preview.
  */
 ( function ( mw, $ ) {
 
 	/**
 	 * @ignore
 	 * @param {jQuery.Event} e
 	 */
 	function doLivePreview( e ) {
 		var isDiff, api, parseRequest, diffRequest, postData, copySelectors, section, summary,
 			$wikiPreview, $wikiDiff, $editform, $textbox, $copyElements, $spinner, $errorBox;
 
 		isDiff = ( e.target.name === 'wpDiff' );
 		$wikiPreview = $( '#wikiPreview' );
 		$wikiDiff = $( '#wikiDiff' );
 		$editform = $( '#editform' );
 		$textbox = $editform.find( '#wpTextbox1' );
 
 		summary = OO.ui.infuse( $( '#wpSummaryWidget' ) );
 
 		$spinner = $( '.mw-spinner-preview' );
 		$errorBox = $( '.errorbox' );
 		section = $editform.find( '[name="wpSection"]' ).val();
 
 		if ( $textbox.length === 0 ) {
 			return;
 		}
 		// Show changes for a new section is not yet supported
 		if ( isDiff && section === 'new' ) {
 			return;
 		}
 		e.preventDefault();
 
 		// Remove any previously displayed errors
 		$errorBox.remove();
 		// Show #wikiPreview if it's hidden to be able to scroll to it
 		// (if it is hidden, it's also empty, so nothing changes in the rendering)
 		$wikiPreview.show();
 
 		// Jump to where the preview will appear
 		$wikiPreview[ 0 ].scrollIntoView();
 
 		copySelectors = [
 			// Main
 			'.mw-indicators',
 			'#firstHeading',
 			'#wikiPreview',
 			'#wikiDiff',
 			'#catlinks',
 			'#p-lang',
 			// Editing-related
 			'.templatesUsed',
 			'.limitreport',
 			'.mw-summary-preview'
 		];
 		$copyElements = $( copySelectors.join( ',' ) );
 
 		// Not shown during normal preview, to be removed if present
 		$( '.mw-newarticletext' ).remove();
 
 		if ( $spinner.length === 0 ) {
 			$spinner = $.createSpinner( {
 				size: 'large',
 				type: 'block'
 			} )
 				.addClass( 'mw-spinner-preview' )
 				.css( 'margin-top', '1em' );
 			$wikiPreview.before( $spinner );
 		} else {
 			$spinner.show();
 		}
 
 		// Can't use fadeTo because it calls show(), and we might want to keep some elements hidden
 		// (e.g. empty #catlinks)
 		$copyElements.animate( { opacity: 0.4 }, 'fast' );
 
 		api = new mw.Api();
 		postData = {
 			formatversion: 2,
 			action: 'parse',
 			title: mw.config.get( 'wgPageName' ),
 			summary: summary.getValue(),
 			prop: ''
 		};
 
 		if ( isDiff ) {
 			$wikiPreview.hide();
 
 			if ( postData.summary ) {
 				parseRequest = api.post( postData );
 			}
 
 			diffRequest = api.post( {
 				formatversion: 2,
 				action: 'query',
 				prop: 'revisions',
 				titles: mw.config.get( 'wgPageName' ),
 				rvdifftotext: $textbox.textSelection( 'getContents' ),
 				rvdifftotextpst: true,
 				rvprop: '',
 				rvsection: section === '' ? undefined : section
 			} );
 
 			// Wait for the summary before showing the diff so the page doesn't jump twice
 			$.when( diffRequest, parseRequest ).done( function ( response ) {
 				var diffHtml;
 				try {
 					diffHtml = response[ 0 ].query.pages[ 0 ]
 						.revisions[ 0 ].diff.body;
 					$wikiDiff.find( 'table.diff tbody' ).html( diffHtml );
 					mw.hook( 'wikipage.diff' ).fire( $wikiDiff.find( 'table.diff' ) );
 				} catch ( err ) {
 					// "result.blah is undefined" error, ignore
 					mw.log.warn( err );
 				}
 				$wikiDiff.show();
 			} );
 		} else {
 			$wikiDiff.hide();
 
 			$.extend( postData, {
 				prop: 'text|indicators|displaytitle|modules|jsconfigvars|categorieshtml|templates|langlinks|limitreporthtml',
 				text: $textbox.textSelection( 'getContents' ),
 				pst: true,
 				preview: true,
 				sectionpreview: section !== '',
 				disableeditsection: true,
 				useskin: mw.config.get( 'skin' ),
 				uselang: mw.config.get( 'wgUserLanguage' )
 			} );
 			if ( section === 'new' ) {
 				postData.section = 'new';
 				postData.sectiontitle = postData.summary;
 			}
 
 			parseRequest = api.post( postData );
 			parseRequest.done( function ( response ) {
-				var li, newList, $displaytitle, $content, $parent, $list;
+				var newList, $displaytitle, $content, $parent, $list;
 				if ( response.parse.jsconfigvars ) {
 					mw.config.set( response.parse.jsconfigvars );
 				}
 				if ( response.parse.modules ) {
 					mw.loader.load( response.parse.modules.concat(
 						response.parse.modulescripts,
 						response.parse.modulestyles
 					) );
 				}
 
 				newList = [];
 				$.each( response.parse.indicators, function ( name, indicator ) {
 					newList.push(
 						$( '<div>' )
 							.addClass( 'mw-indicator' )
 							.attr( 'id', mw.util.escapeIdForAttribute( 'mw-indicator-' + name ) )
 							.html( indicator )
 							.get( 0 ),
 						// Add a whitespace between the <div>s because
 						// they get displayed with display: inline-block
 						document.createTextNode( '\n' )
 					);
 				} );
 				$( '.mw-indicators' ).empty().append( newList );
 
 				if ( response.parse.displaytitle ) {
 					$displaytitle = $( $.parseHTML( response.parse.displaytitle ) );
 					$( '#firstHeading' ).msg(
 						mw.config.get( 'wgEditMessage', 'editing' ),
 						$displaytitle
 					);
 					document.title = mw.msg(
 						'pagetitle',
 						mw.msg(
 							mw.config.get( 'wgEditMessage', 'editing' ),
 							$displaytitle.text()
 						)
 					);
 				}
 				if ( response.parse.categorieshtml ) {
 					$content = $( $.parseHTML( response.parse.categorieshtml ) );
 					mw.hook( 'wikipage.categories' ).fire( $content );
 					$( '.catlinks[data-mw="interface"]' ).replaceWith( $content );
 				}
 				if ( response.parse.templates ) {
-					newList = [];
-					$.each( response.parse.templates, function ( i, template ) {
-						li = $( '<li>' )
+					newList = response.parse.templates.map( function ( template ) {
+						return $( '<li>' )
 							.append( $( '<a>' )
 								.attr( {
 									href: mw.util.getUrl( template.title ),
 									'class': ( template.exists ? '' : 'new' )
 								} )
 								.text( template.title )
 							);
-						newList.push( li );
 					} );
 
 					$editform.find( '.templatesUsed .mw-editfooter-list' ).detach().empty().append( newList ).appendTo( '.templatesUsed' );
 				}
 				if ( response.parse.limitreporthtml ) {
 					$( '.limitreport' ).html( response.parse.limitreporthtml );
 				}
 				if ( response.parse.langlinks && mw.config.get( 'skin' ) === 'vector' ) {
-					newList = [];
-					$.each( response.parse.langlinks, function ( i, langlink ) {
+					newList = response.parse.langlinks.map( function ( langlink ) {
 						var bcp47 = mw.language.bcp47( langlink.lang );
-						li = $( '<li>' )
+						return $( '<li>' )
 							.addClass( 'interlanguage-link interwiki-' + langlink.lang )
 							.append( $( '<a>' )
 								.attr( {
 									href: langlink.url,
 									title: langlink.title + ' - ' + langlink.langname,
 									lang: bcp47,
 									hreflang: bcp47
 								} )
 								.text( langlink.autonym )
 							);
-						newList.push( li );
 					} );
 					$list = $( '#p-lang ul' );
 					$parent = $list.parent();
 					$list.detach().empty().append( newList ).prependTo( $parent );
 				}
 
 				if ( response.parse.text ) {
 					$content = $wikiPreview.children( '.mw-content-ltr,.mw-content-rtl' );
 					$content
 						.detach()
 						.html( response.parse.text );
 
 					mw.hook( 'wikipage.content' ).fire( $content );
 
 					// Reattach
 					$wikiPreview.append( $content );
 
 					$wikiPreview.show();
 				}
 			} );
 		}
 		$.when( parseRequest, diffRequest ).done( function ( parseResp ) {
 			var parse = parseResp && parseResp[ 0 ].parse,
 				isSubject = ( section === 'new' ),
 				summaryMsg = isSubject ? 'subject-preview' : 'summary-preview',
 				$summaryPreview = $editform.find( '.mw-summary-preview' ).empty();
 			if ( parse && parse.parsedsummary ) {
 				$summaryPreview.append(
 					mw.message( summaryMsg ).parse(),
 					' ',
 					$( '<span>' ).addClass( 'comment' ).html(
 						// There is no equivalent to rawParams
 						mw.message( 'parentheses' ).escaped()
 							// .replace() use $ as start of a pattern.
 							// $$ is the pattern for '$'.
 							// The inner .replace() duplicates any $ and
 							// the outer .replace() simplifies the $$.
 							.replace( '$1', parse.parsedsummary.replace( /\$/g, '$$$$' ) )
 					)
 				);
 			}
 			mw.hook( 'wikipage.editform' ).fire( $editform );
 		} ).always( function () {
 			$spinner.hide();
 			$copyElements.animate( {
 				opacity: 1
 			}, 'fast' );
 		} ).fail( function ( code, result ) {
 			// This just shows the error for whatever request failed first
 			var errorMsg = 'API error: ' + code;
 			if ( code === 'http' ) {
 				errorMsg = 'HTTP error: ';
 				if ( result.exception ) {
 					errorMsg += result.exception;
 				} else {
 					errorMsg += result.textStatus;
 				}
 			}
 			$errorBox = $( '<div>' )
 				.addClass( 'errorbox' )
 				.html( '<strong>' + mw.message( 'previewerrortext' ).escaped() + '</strong><br>' )
 				.append( document.createTextNode( errorMsg ) );
 			$wikiDiff.hide();
 			$wikiPreview.hide().before( $errorBox );
 		} );
 	}
 
 	$( function () {
 		// Do not enable on user .js/.css pages, as there's no sane way of "previewing"
 		// the scripts or styles without reloading the page.
 		if ( $( '#mw-userjsyoucanpreview' ).length || $( '#mw-usercssyoucanpreview' ).length ) {
 			return;
 		}
 
 		// The following elements can change in a preview but are not output
 		// by the server when they're empty until the preview response.
 		// TODO: Make the server output these always (in a hidden state), so we don't
 		// have to fish and (hopefully) put them in the right place (since skins
 		// can change where they are output).
 
 		if ( !document.getElementById( 'p-lang' ) && document.getElementById( 'p-tb' ) && mw.config.get( 'skin' ) === 'vector' ) {
 			$( '.portal:last' ).after(
 				$( '<div>' ).attr( {
 					'class': 'portal',
 					id: 'p-lang',
 					role: 'navigation',
 					'aria-labelledby': 'p-lang-label'
 				} )
 					.append( $( '<h3>' ).attr( 'id', 'p-lang-label' ).text( mw.msg( 'otherlanguages' ) ) )
 					.append( $( '<div>' ).addClass( 'body' ).append( '<ul>' ) )
 			);
 		}
 
 		if ( !$( '.mw-summary-preview' ).length ) {
 			$( '#wpSummaryWidget' ).after(
 				$( '<div>' ).addClass( 'mw-summary-preview' )
 			);
 		}
 
 		if ( !document.getElementById( 'wikiDiff' ) && document.getElementById( 'wikiPreview' ) ) {
 			$( '#wikiPreview' ).after(
 				$( '<div>' )
 					.hide()
 					.attr( 'id', 'wikiDiff' )
 					.html( '<table class="diff"><col class="diff-marker"/><col class="diff-content"/>' +
 						'<col class="diff-marker"/><col class="diff-content"/><tbody/></table>' )
 			);
 		}
 
 		// This should be moved down to '#editform', but is kept on the body for now
 		// because the LiquidThreads extension is re-using this module with only half
 		// the EditPage (doesn't include #editform presumably, T57463).
 		$( document.body ).on( 'click', '#wpPreview, #wpDiff', doLivePreview );
 	} );
 
 }( mediaWiki, jQuery ) );
diff --git a/resources/src/mediawiki.toolbar/toolbar.js b/resources/src/mediawiki.toolbar/toolbar.js
index d55ed80ca3c..4707f782a9c 100644
--- a/resources/src/mediawiki.toolbar/toolbar.js
+++ b/resources/src/mediawiki.toolbar/toolbar.js
@@ -1,208 +1,208 @@
 /**
  * Interface for the classic edit toolbar.
  *
  * @class mw.toolbar
  * @singleton
  */
 ( function ( mw, $ ) {
 	var toolbar, isReady, $toolbar, queue, slice, $currentFocused;
 
 	/**
 	 * Internal helper that does the actual insertion of the button into the toolbar.
 	 *
 	 * For backwards-compatibility, passing `imageFile`, `speedTip`, `tagOpen`, `tagClose`,
 	 * `sampleText` and `imageId` as separate arguments (in this order) is also supported.
 	 *
 	 * @private
 	 *
 	 * @param {Object} button Object with the following properties.
 	 *  You are required to provide *either* the `onClick` parameter, or the three parameters
 	 *  `tagOpen`, `tagClose` and `sampleText`, but not both (they're mutually exclusive).
 	 * @param {string} [button.imageFile] Image to use for the button.
 	 * @param {string} button.speedTip Tooltip displayed when user mouses over the button.
 	 * @param {Function} [button.onClick] Function to be executed when the button is clicked.
 	 * @param {string} [button.tagOpen]
 	 * @param {string} [button.tagClose]
 	 * @param {string} [button.sampleText] Alternative to `onClick`. `tagOpen`, `tagClose` and
 	 *  `sampleText` together provide the markup that should be inserted into page text at
 	 *  current cursor position.
 	 * @param {string} [button.imageId] `id` attribute of the button HTML element. Can be
 	 *  used to define the image with CSS if it's not provided as `imageFile`.
 	 * @param {string} [speedTip]
 	 * @param {string} [tagOpen]
 	 * @param {string} [tagClose]
 	 * @param {string} [sampleText]
 	 * @param {string} [imageId]
 	 */
 	function insertButton( button, speedTip, tagOpen, tagClose, sampleText, imageId ) {
 		var $button;
 
 		// Backwards compatibility
 		if ( typeof button !== 'object' ) {
 			button = {
 				imageFile: button,
 				speedTip: speedTip,
 				tagOpen: tagOpen,
 				tagClose: tagClose,
 				sampleText: sampleText,
 				imageId: imageId
 			};
 		}
 
 		if ( button.imageFile ) {
 			$button = $( '<img>' ).attr( {
 				src: button.imageFile,
 				alt: button.speedTip,
 				title: button.speedTip,
 				id: button.imageId || undefined,
 				'class': 'mw-toolbar-editbutton'
 			} );
 		} else {
 			$button = $( '<div>' ).attr( {
 				title: button.speedTip,
 				id: button.imageId || undefined,
 				'class': 'mw-toolbar-editbutton'
 			} );
 		}
 
 		$button.click( function ( e ) {
 			if ( button.onClick !== undefined ) {
 				button.onClick( e );
 			} else {
 				toolbar.insertTags( button.tagOpen, button.tagClose, button.sampleText );
 			}
 
 			return false;
 		} );
 
 		$toolbar.append( $button );
 	}
 
 	isReady = false;
 	$toolbar = false;
 
 	/**
 	 * @private
 	 * @property {Array}
 	 * Contains button objects (and for backwards compatibilty, it can
 	 * also contains an arguments array for insertButton).
 	 */
 	queue = [];
 	slice = queue.slice;
 
 	toolbar = {
 
 		/**
 		 * Add buttons to the toolbar.
 		 *
 		 * Takes care of race conditions and time-based dependencies by placing buttons in a queue if
 		 * this method is called before the toolbar is created.
 		 *
 		 * For backwards-compatibility, passing `imageFile`, `speedTip`, `tagOpen`, `tagClose`,
 		 * `sampleText` and `imageId` as separate arguments (in this order) is also supported.
 		 *
 		 * @inheritdoc #insertButton
 		 */
 		addButton: function () {
 			if ( isReady ) {
 				insertButton.apply( toolbar, arguments );
 			} else {
 				// Convert arguments list to array
 				queue.push( slice.call( arguments ) );
 			}
 		},
 
 		/**
 		 * Add multiple buttons to the toolbar (see also #addButton).
 		 *
 		 * Example usage:
 		 *
 		 *     addButtons( [ { .. }, { .. }, { .. } ] );
 		 *     addButtons( { .. }, { .. } );
 		 *
 		 * @param {...Object|Array} [buttons] An array of button objects or the first
 		 *  button object in a list of variadic arguments.
 		 */
 		addButtons: function ( buttons ) {
 			if ( !Array.isArray( buttons ) ) {
 				buttons = slice.call( arguments );
 			}
 			if ( isReady ) {
-				$.each( buttons, function () {
-					insertButton( this );
+				buttons.forEach( function ( button ) {
+					insertButton( button );
 				} );
 			} else {
 				// Push each button into the queue
 				queue.push.apply( queue, buttons );
 			}
 		},
 
 		/**
 		 * Apply tagOpen/tagClose to selection in currently focused textarea.
 		 *
 		 * Uses `sampleText` if selection is empty.
 		 *
 		 * @param {string} tagOpen
 		 * @param {string} tagClose
 		 * @param {string} sampleText
 		 */
 		insertTags: function ( tagOpen, tagClose, sampleText ) {
 			if ( $currentFocused && $currentFocused.length ) {
 				$currentFocused.textSelection(
 					'encapsulateSelection', {
 						pre: tagOpen,
 						peri: sampleText,
 						post: tagClose
 					}
 				);
 			}
 		}
 	};
 
 	// Legacy (for compatibility with the code previously in skins/common.edit.js)
 	mw.log.deprecate( window, 'addButton', toolbar.addButton, 'Use mw.toolbar.addButton instead.' );
 	mw.log.deprecate( window, 'insertTags', toolbar.insertTags, 'Use mw.toolbar.insertTags instead.' );
 
 	// For backwards compatibility. Used to be called from EditPage.php, maybe other places as well.
 	toolbar.init = $.noop;
 
 	// Expose API publicly
 	// @deprecated since MW 1.29
 	mw.log.deprecate( mw, 'toolbar', toolbar, null, 'mw.toolbar' );
 
 	$( function () {
 		var i, button;
 
 		// Used to determine where to insert tags
 		$currentFocused = $( '#wpTextbox1' );
 
 		// Populate the selector cache for $toolbar
 		$toolbar = $( '#toolbar' );
 
 		for ( i = 0; i < queue.length; i++ ) {
 			button = queue[ i ];
 			if ( Array.isArray( button ) ) {
 				// Forwarded arguments array from mw.toolbar.addButton
 				insertButton.apply( toolbar, button );
 			} else {
 				// Raw object from mw.toolbar.addButtons
 				insertButton( button );
 			}
 		}
 
 		// Clear queue
 		queue.length = 0;
 
 		// This causes further calls to addButton to go to insertion directly
 		// instead of to the queue.
 		// It is important that this is after the one and only loop through
 		// the queue
 		isReady = true;
 
 		// Apply to dynamically created textboxes as well as normal ones
 		$( document ).on( 'focus', 'textarea, input:text', function () {
 			$currentFocused = $( this );
 		} );
 	} );
 
 }( mediaWiki, jQuery ) );
diff --git a/resources/src/mediawiki/api/messages.js b/resources/src/mediawiki/api/messages.js
index a1a499960f3..688f0b24357 100644
--- a/resources/src/mediawiki/api/messages.js
+++ b/resources/src/mediawiki/api/messages.js
@@ -1,78 +1,78 @@
 /**
  * Allows to retrieve a specific or a set of
  * messages to be added to mw.messages and returned
  * by the Api.
  *
  * @class mw.Api.plugin.messages
  * @since 1.27
  */
 ( function ( mw, $ ) {
 	'use strict';
 
 	$.extend( mw.Api.prototype, {
 		/**
 		 * Get a set of messages.
 		 *
 		 * @param {Array} messages Messages to retrieve
 		 * @param {Object} [options] Additional parameters for the API call
 		 * @return {jQuery.Promise}
 		 */
 		getMessages: function ( messages, options ) {
 			options = options || {};
 			return this.get( $.extend( {
 				action: 'query',
 				meta: 'allmessages',
 				ammessages: messages,
 				amlang: mw.config.get( 'wgUserLanguage' ),
 				formatversion: 2
 			}, options ) ).then( function ( data ) {
 				var result = {};
 
-				$.each( data.query.allmessages, function ( i, obj ) {
+				data.query.allmessages.forEach( function ( obj ) {
 					if ( !obj.missing ) {
 						result[ obj.name ] = obj.content;
 					}
 				} );
 
 				return result;
 			} );
 		},
 
 		/**
 		 * Loads a set of messages and add them to mw.messages.
 		 *
 		 * @param {Array} messages Messages to retrieve
 		 * @param {Object} [options] Additional parameters for the API call
 		 * @return {jQuery.Promise}
 		 */
 		loadMessages: function ( messages, options ) {
 			return this.getMessages( messages, options ).then( $.proxy( mw.messages, 'set' ) );
 		},
 
 		/**
 		 * Loads a set of messages and add them to mw.messages. Only messages that are not already known
 		 * are loaded. If all messages are known, the returned promise is resolved immediately.
 		 *
 		 * @param {Array} messages Messages to retrieve
 		 * @param {Object} [options] Additional parameters for the API call
 		 * @return {jQuery.Promise}
 		 */
 		loadMessagesIfMissing: function ( messages, options ) {
 			var missing = messages.filter( function ( msg ) {
 				return !mw.message( msg ).exists();
 			} );
 
 			if ( missing.length === 0 ) {
 				return $.Deferred().resolve();
 			}
 
 			return this.getMessages( missing, options ).then( $.proxy( mw.messages, 'set' ) );
 		}
 	} );
 
 	/**
 	 * @class mw.Api
 	 * @mixins mw.Api.plugin.messages
 	 */
 
 }( mediaWiki, jQuery ) );
diff --git a/resources/src/mediawiki/mediawiki.Upload.BookletLayout.js b/resources/src/mediawiki/mediawiki.Upload.BookletLayout.js
index 3ade332c88b..06788f58e8f 100644
--- a/resources/src/mediawiki/mediawiki.Upload.BookletLayout.js
+++ b/resources/src/mediawiki/mediawiki.Upload.BookletLayout.js
@@ -1,711 +1,711 @@
 /* global moment */
 ( function ( $, mw, moment ) {
 
 	/**
 	 * mw.Upload.BookletLayout encapsulates the process of uploading a file
 	 * to MediaWiki using the {@link mw.Upload upload model}.
 	 * The booklet emits events that can be used to get the stashed
 	 * upload and the final file. It can be extended to accept
 	 * additional fields from the user for specific scenarios like
 	 * for Commons, or campaigns.
 	 *
 	 * ## Structure
 	 *
 	 * The {@link OO.ui.BookletLayout booklet layout} has three steps:
 	 *
 	 *  - **Upload**: Has a {@link OO.ui.SelectFileWidget field} to get the file object.
 	 *
 	 * - **Information**: Has a {@link OO.ui.FormLayout form} to collect metadata. This can be
 	 *   extended.
 	 *
 	 * - **Insert**: Has details on how to use the file that was uploaded.
 	 *
 	 * Each step has a form associated with it defined in
 	 * {@link #renderUploadForm renderUploadForm},
 	 * {@link #renderInfoForm renderInfoForm}, and
 	 * {@link #renderInsertForm renderInfoForm}. The
 	 * {@link #getFile getFile},
 	 * {@link #getFilename getFilename}, and
 	 * {@link #getText getText} methods are used to get
 	 * the information filled in these forms, required to call
 	 * {@link mw.Upload mw.Upload}.
 	 *
 	 * ## Usage
 	 *
 	 * See the {@link mw.Upload.Dialog upload dialog}.
 	 *
 	 * The {@link #event-fileUploaded fileUploaded},
 	 * and {@link #event-fileSaved fileSaved} events can
 	 * be used to get details of the upload.
 	 *
 	 * ## Extending
 	 *
 	 * To extend using {@link mw.Upload mw.Upload}, override
 	 * {@link #renderInfoForm renderInfoForm} to render
 	 * the form required for the specific use-case. Update the
 	 * {@link #getFilename getFilename}, and
 	 * {@link #getText getText} methods to return data
 	 * from your newly created form. If you added new fields you'll also have
 	 * to update the {@link #clear} method.
 	 *
 	 * If you plan to use a different upload model, apart from what is mentioned
 	 * above, you'll also have to override the
 	 * {@link #createUpload createUpload} method to
 	 * return the new model. The {@link #saveFile saveFile}, and
 	 * the {@link #uploadFile uploadFile} methods need to be
 	 * overridden to use the new model and data returned from the forms.
 	 *
 	 * @class
 	 * @extends OO.ui.BookletLayout
 	 *
 	 * @constructor
 	 * @param {Object} config Configuration options
 	 * @cfg {jQuery} [$overlay] Overlay to use for widgets in the booklet
 	 * @cfg {string} [filekey] Sets the stashed file to finish uploading. Overrides most of the file selection process, and fetches a thumbnail from the server.
 	 */
 	mw.Upload.BookletLayout = function ( config ) {
 		// Parent constructor
 		mw.Upload.BookletLayout.parent.call( this, config );
 
 		this.$overlay = config.$overlay;
 
 		this.filekey = config.filekey;
 
 		this.renderUploadForm();
 		this.renderInfoForm();
 		this.renderInsertForm();
 
 		this.addPages( [
 			new OO.ui.PageLayout( 'upload', {
 				scrollable: true,
 				padded: true,
 				content: [ this.uploadForm ]
 			} ),
 			new OO.ui.PageLayout( 'info', {
 				scrollable: true,
 				padded: true,
 				content: [ this.infoForm ]
 			} ),
 			new OO.ui.PageLayout( 'insert', {
 				scrollable: true,
 				padded: true,
 				content: [ this.insertForm ]
 			} )
 		] );
 	};
 
 	/* Setup */
 
 	OO.inheritClass( mw.Upload.BookletLayout, OO.ui.BookletLayout );
 
 	/* Events */
 
 	/**
 	 * Progress events for the uploaded file
 	 *
 	 * @event fileUploadProgress
 	 * @param {number} progress In percentage
 	 * @param {Object} duration Duration object from `moment.duration()`
 	 */
 
 	/**
 	 * The file has finished uploading
 	 *
 	 * @event fileUploaded
 	 */
 
 	/**
 	 * The file has been saved to the database
 	 *
 	 * @event fileSaved
 	 * @param {Object} imageInfo See mw.Upload#getImageInfo
 	 */
 
 	/**
 	 * The upload form has changed
 	 *
 	 * @event uploadValid
 	 * @param {boolean} isValid The form is valid
 	 */
 
 	/**
 	 * The info form has changed
 	 *
 	 * @event infoValid
 	 * @param {boolean} isValid The form is valid
 	 */
 
 	/* Properties */
 
 	/**
 	 * @property {OO.ui.FormLayout} uploadForm
 	 * The form rendered in the first step to get the file object.
 	 * Rendered in {@link #renderUploadForm renderUploadForm}.
 	 */
 
 	/**
 	 * @property {OO.ui.FormLayout} infoForm
 	 * The form rendered in the second step to get metadata.
 	 * Rendered in {@link #renderInfoForm renderInfoForm}
 	 */
 
 	/**
 	 * @property {OO.ui.FormLayout} insertForm
 	 * The form rendered in the third step to show usage
 	 * Rendered in {@link #renderInsertForm renderInsertForm}
 	 */
 
 	/* Methods */
 
 	/**
 	 * Initialize for a new upload
 	 *
 	 * @return {jQuery.Promise} Promise resolved when everything is initialized
 	 */
 	mw.Upload.BookletLayout.prototype.initialize = function () {
 		var booklet = this;
 
 		this.clear();
 		this.upload = this.createUpload();
 
 		this.setPage( 'upload' );
 
 		if ( this.filekey ) {
 			this.setFilekey( this.filekey );
 		}
 
 		return this.upload.getApi().then(
 			function ( api ) {
 				// If the user can't upload anything, don't give them the option to.
 				return api.getUserInfo().then(
 					function ( userInfo ) {
 						if ( userInfo.rights.indexOf( 'upload' ) === -1 ) {
 							if ( mw.user.isAnon() ) {
 								booklet.getPage( 'upload' ).$element.msg( 'apierror-mustbeloggedin', mw.msg( 'action-upload' ) );
 							} else {
 								booklet.getPage( 'upload' ).$element.msg( 'apierror-permissiondenied', mw.msg( 'action-upload' ) );
 							}
 						}
 						return $.Deferred().resolve();
 					},
 					// Always resolve, never reject
 					function () { return $.Deferred().resolve(); }
 				);
 			},
 			function ( errorMsg ) {
 				booklet.getPage( 'upload' ).$element.msg( errorMsg );
 				return $.Deferred().resolve();
 			}
 		);
 	};
 
 	/**
 	 * Create a new upload model
 	 *
 	 * @protected
 	 * @return {mw.Upload} Upload model
 	 */
 	mw.Upload.BookletLayout.prototype.createUpload = function () {
 		return new mw.Upload( {
 			parameters: {
 				errorformat: 'html',
 				errorlang: mw.config.get( 'wgUserLanguage' ),
 				errorsuselocal: 1,
 				formatversion: 2
 			}
 		} );
 	};
 
 	/* Uploading */
 
 	/**
 	 * Uploads the file that was added in the upload form. Uses
 	 * {@link #getFile getFile} to get the HTML5
 	 * file object.
 	 *
 	 * @protected
 	 * @fires fileUploadProgress
 	 * @fires fileUploaded
 	 * @return {jQuery.Promise}
 	 */
 	mw.Upload.BookletLayout.prototype.uploadFile = function () {
 		var deferred = $.Deferred(),
 			startTime = mw.now(),
 			layout = this,
 			file = this.getFile();
 
 		this.setPage( 'info' );
 
 		if ( this.filekey ) {
 			if ( file === null ) {
 				// Someone gonna get-a hurt real bad
 				throw new Error( 'filekey not passed into file select widget, which is impossible. Quitting while we\'re behind.' );
 			}
 
 			// Stashed file already uploaded.
 			deferred.resolve();
 			this.uploadPromise = deferred;
 			this.emit( 'fileUploaded' );
 			return deferred;
 		}
 
 		this.setFilename( file.name );
 
 		this.upload.setFile( file );
 		// The original file name might contain invalid characters, so use our sanitized one
 		this.upload.setFilename( this.getFilename() );
 
 		this.uploadPromise = this.upload.uploadToStash();
 		this.uploadPromise.then( function () {
 			deferred.resolve();
 			layout.emit( 'fileUploaded' );
 		}, function () {
 			// These errors will be thrown while the user is on the info page.
 			layout.getErrorMessageForStateDetails().then( function ( errorMessage ) {
 				deferred.reject( errorMessage );
 			} );
 		}, function ( progress ) {
 			var elapsedTime = mw.now() - startTime,
 				estimatedTotalTime = ( 1 / progress ) * elapsedTime,
 				estimatedRemainingTime = moment.duration( estimatedTotalTime - elapsedTime );
 			layout.emit( 'fileUploadProgress', progress, estimatedRemainingTime );
 		} );
 
 		// If there is an error in uploading, come back to the upload page
 		deferred.fail( function () {
 			layout.setPage( 'upload' );
 		} );
 
 		return deferred;
 	};
 
 	/**
 	 * Saves the stash finalizes upload. Uses
 	 * {@link #getFilename getFilename}, and
 	 * {@link #getText getText} to get details from
 	 * the form.
 	 *
 	 * @protected
 	 * @fires fileSaved
 	 * @return {jQuery.Promise} Rejects the promise with an
 	 * {@link OO.ui.Error error}, or resolves if the upload was successful.
 	 */
 	mw.Upload.BookletLayout.prototype.saveFile = function () {
 		var layout = this,
 			deferred = $.Deferred();
 
 		this.upload.setFilename( this.getFilename() );
 		this.upload.setText( this.getText() );
 
 		this.uploadPromise.then( function () {
 			layout.upload.finishStashUpload().then( function () {
 				var name;
 
 				// Normalize page name and localise the 'File:' prefix
 				name = new mw.Title( 'File:' + layout.upload.getFilename() ).toString();
 				layout.filenameUsageWidget.setValue( '[[' + name + ']]' );
 				layout.setPage( 'insert' );
 
 				deferred.resolve();
 				layout.emit( 'fileSaved', layout.upload.getImageInfo() );
 			}, function () {
 				layout.getErrorMessageForStateDetails().then( function ( errorMessage ) {
 					deferred.reject( errorMessage );
 				} );
 			} );
 		} );
 
 		return deferred.promise();
 	};
 
 	/**
 	 * Get an error message (as OO.ui.Error object) that should be displayed to the user for current
 	 * state and state details.
 	 *
 	 * @protected
 	 * @return {jQuery.Promise} A Promise that will be resolved with an OO.ui.Error.
 	 */
 	mw.Upload.BookletLayout.prototype.getErrorMessageForStateDetails = function () {
 		var state = this.upload.getState(),
 			stateDetails = this.upload.getStateDetails(),
 			error = stateDetails.errors ? stateDetails.errors[ 0 ] : false,
 			warnings = stateDetails.upload && stateDetails.upload.warnings,
 			$ul = $( '<ul>' ),
 			errorText;
 
 		if ( state === mw.Upload.State.ERROR ) {
 			if ( !error ) {
 				if ( stateDetails.textStatus === 'timeout' ) {
 					// in case of $.ajax.fail(), there is no response json
 					errorText = mw.message( 'apierror-timeout' ).parse();
 				} else if ( stateDetails.xhr && stateDetails.xhr.status === 0 ) {
 					// failed to even connect to server
 					errorText = mw.message( 'apierror-offline' ).parse();
 				} else if ( stateDetails.textStatus ) {
 					errorText = stateDetails.textStatus;
 				} else {
 					errorText = mw.message( 'apierror-unknownerror', JSON.stringify( stateDetails ) ).parse();
 				}
 
 				// If there's an 'exception' key, this might be a timeout, or other connection problem
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).html( errorText ),
 					{ recoverable: false }
 				) );
 			}
 
 			return $.Deferred().resolve( new OO.ui.Error(
 				$( '<p>' ).html( error.html ),
 				{ recoverable: false }
 			) );
 		}
 
 		if ( state === mw.Upload.State.WARNING ) {
 			// We could get more than one of these errors, these are in order
 			// of importance. For example fixing the thumbnail like file name
 			// won't help the fact that the file already exists.
 			if ( warnings.exists !== undefined ) {
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).msg( 'fileexists', 'File:' + warnings.exists ),
 					{ recoverable: false }
 				) );
 			} else if ( warnings[ 'exists-normalized' ] !== undefined ) {
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).msg( 'fileexists', 'File:' + warnings[ 'exists-normalized' ] ),
 					{ recoverable: false }
 				) );
 			} else if ( warnings[ 'page-exists' ] !== undefined ) {
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).msg( 'filepageexists', 'File:' + warnings[ 'page-exists' ] ),
 					{ recoverable: false }
 				) );
-			} else if ( warnings.duplicate !== undefined ) {
-				$.each( warnings.duplicate, function ( i, filename ) {
+			} else if ( Array.isArray( warnings.duplicate ) ) {
+				warnings.duplicate.forEach( function ( filename ) {
 					var $a = $( '<a>' ).text( filename ),
 						href = mw.Title.makeTitle( mw.config.get( 'wgNamespaceIds' ).file, filename ).getUrl( {} );
 
 					$a.attr( { href: href, target: '_blank' } );
 					$ul.append( $( '<li>' ).append( $a ) );
 				} );
 
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).msg( 'file-exists-duplicate', warnings.duplicate.length ).append( $ul ),
 					{ recoverable: false }
 				) );
 			} else if ( warnings[ 'thumb-name' ] !== undefined ) {
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).msg( 'filename-thumb-name' ),
 					{ recoverable: false }
 				) );
 			} else if ( warnings[ 'bad-prefix' ] !== undefined ) {
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).msg( 'filename-bad-prefix', warnings[ 'bad-prefix' ] ),
 					{ recoverable: false }
 				) );
 			} else if ( warnings[ 'duplicate-archive' ] !== undefined ) {
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).msg( 'file-deleted-duplicate', 'File:' + warnings[ 'duplicate-archive' ] ),
 					{ recoverable: false }
 				) );
 			} else if ( warnings[ 'was-deleted' ] !== undefined ) {
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).msg( 'filewasdeleted', 'File:' + warnings[ 'was-deleted' ] ),
 					{ recoverable: false }
 				) );
 			} else if ( warnings.badfilename !== undefined ) {
 				// Change the name if the current name isn't acceptable
 				// TODO This might not really be the best place to do this
 				this.setFilename( warnings.badfilename );
 				return $.Deferred().resolve( new OO.ui.Error(
 					$( '<p>' ).msg( 'badfilename', warnings.badfilename )
 				) );
 			} else {
 				return $.Deferred().resolve( new OO.ui.Error(
 					// Let's get all the help we can if we can't pin point the error
 					$( '<p>' ).msg( 'api-error-unknown-warning', JSON.stringify( stateDetails ) ),
 					{ recoverable: false }
 				) );
 			}
 		}
 	};
 
 	/* Form renderers */
 
 	/**
 	 * Renders and returns the upload form and sets the
 	 * {@link #uploadForm uploadForm} property.
 	 *
 	 * @protected
 	 * @fires selectFile
 	 * @return {OO.ui.FormLayout}
 	 */
 	mw.Upload.BookletLayout.prototype.renderUploadForm = function () {
 		var fieldset,
 			layout = this;
 
 		this.selectFileWidget = this.getFileWidget();
 		fieldset = new OO.ui.FieldsetLayout();
 		fieldset.addItems( [ this.selectFileWidget ] );
 		this.uploadForm = new OO.ui.FormLayout( { items: [ fieldset ] } );
 
 		// Validation (if the SFW is for a stashed file, this never fires)
 		this.selectFileWidget.on( 'change', this.onUploadFormChange.bind( this ) );
 
 		this.selectFileWidget.on( 'change', function () {
 			layout.updateFilePreview();
 		} );
 
 		return this.uploadForm;
 	};
 
 	/**
 	 * Gets the widget for displaying or inputting the file to upload.
 	 *
 	 * @return {OO.ui.SelectFileWidget|mw.widgets.StashedFileWidget}
 	 */
 	mw.Upload.BookletLayout.prototype.getFileWidget = function () {
 		if ( this.filekey ) {
 			return new mw.widgets.StashedFileWidget( {
 				filekey: this.filekey
 			} );
 		}
 
 		return new OO.ui.SelectFileWidget( {
 			showDropTarget: true
 		} );
 	};
 
 	/**
 	 * Updates the file preview on the info form when a file is added.
 	 *
 	 * @protected
 	 */
 	mw.Upload.BookletLayout.prototype.updateFilePreview = function () {
 		this.selectFileWidget.loadAndGetImageUrl().done( function ( url ) {
 			this.filePreview.$element.find( 'p' ).remove();
 			this.filePreview.$element.css( 'background-image', 'url(' + url + ')' );
 			this.infoForm.$element.addClass( 'mw-upload-bookletLayout-hasThumbnail' );
 		}.bind( this ) ).fail( function () {
 			this.filePreview.$element.find( 'p' ).remove();
 			if ( this.selectFileWidget.getValue() ) {
 				this.filePreview.$element.append(
 					$( '<p>' ).text( this.selectFileWidget.getValue().name )
 				);
 			}
 			this.filePreview.$element.css( 'background-image', '' );
 			this.infoForm.$element.removeClass( 'mw-upload-bookletLayout-hasThumbnail' );
 		}.bind( this ) );
 	};
 
 	/**
 	 * Handle change events to the upload form
 	 *
 	 * @protected
 	 * @fires uploadValid
 	 */
 	mw.Upload.BookletLayout.prototype.onUploadFormChange = function () {
 		this.emit( 'uploadValid', !!this.selectFileWidget.getValue() );
 	};
 
 	/**
 	 * Renders and returns the information form for collecting
 	 * metadata and sets the {@link #infoForm infoForm}
 	 * property.
 	 *
 	 * @protected
 	 * @return {OO.ui.FormLayout}
 	 */
 	mw.Upload.BookletLayout.prototype.renderInfoForm = function () {
 		var fieldset;
 
 		this.filePreview = new OO.ui.Widget( {
 			classes: [ 'mw-upload-bookletLayout-filePreview' ]
 		} );
 		this.progressBarWidget = new OO.ui.ProgressBarWidget( {
 			progress: 0
 		} );
 		this.filePreview.$element.append( this.progressBarWidget.$element );
 
 		this.filenameWidget = new OO.ui.TextInputWidget( {
 			indicator: 'required',
 			required: true,
 			validate: /.+/
 		} );
 		this.descriptionWidget = new OO.ui.MultilineTextInputWidget( {
 			indicator: 'required',
 			required: true,
 			validate: /\S+/,
 			autosize: true
 		} );
 
 		fieldset = new OO.ui.FieldsetLayout( {
 			label: mw.msg( 'upload-form-label-infoform-title' )
 		} );
 		fieldset.addItems( [
 			new OO.ui.FieldLayout( this.filenameWidget, {
 				label: mw.msg( 'upload-form-label-infoform-name' ),
 				align: 'top',
 				help: mw.msg( 'upload-form-label-infoform-name-tooltip' )
 			} ),
 			new OO.ui.FieldLayout( this.descriptionWidget, {
 				label: mw.msg( 'upload-form-label-infoform-description' ),
 				align: 'top',
 				help: mw.msg( 'upload-form-label-infoform-description-tooltip' )
 			} )
 		] );
 		this.infoForm = new OO.ui.FormLayout( {
 			classes: [ 'mw-upload-bookletLayout-infoForm' ],
 			items: [ this.filePreview, fieldset ]
 		} );
 
 		this.on( 'fileUploadProgress', function ( progress ) {
 			this.progressBarWidget.setProgress( progress * 100 );
 		}.bind( this ) );
 
 		this.filenameWidget.on( 'change', this.onInfoFormChange.bind( this ) );
 		this.descriptionWidget.on( 'change', this.onInfoFormChange.bind( this ) );
 
 		return this.infoForm;
 	};
 
 	/**
 	 * Handle change events to the info form
 	 *
 	 * @protected
 	 * @fires infoValid
 	 */
 	mw.Upload.BookletLayout.prototype.onInfoFormChange = function () {
 		var layout = this;
 		$.when(
 			this.filenameWidget.getValidity(),
 			this.descriptionWidget.getValidity()
 		).done( function () {
 			layout.emit( 'infoValid', true );
 		} ).fail( function () {
 			layout.emit( 'infoValid', false );
 		} );
 	};
 
 	/**
 	 * Renders and returns the insert form to show file usage and
 	 * sets the {@link #insertForm insertForm} property.
 	 *
 	 * @protected
 	 * @return {OO.ui.FormLayout}
 	 */
 	mw.Upload.BookletLayout.prototype.renderInsertForm = function () {
 		var fieldset;
 
 		this.filenameUsageWidget = new OO.ui.TextInputWidget();
 		fieldset = new OO.ui.FieldsetLayout( {
 			label: mw.msg( 'upload-form-label-usage-title' )
 		} );
 		fieldset.addItems( [
 			new OO.ui.FieldLayout( this.filenameUsageWidget, {
 				label: mw.msg( 'upload-form-label-usage-filename' ),
 				align: 'top'
 			} )
 		] );
 		this.insertForm = new OO.ui.FormLayout( { items: [ fieldset ] } );
 
 		return this.insertForm;
 	};
 
 	/* Getters */
 
 	/**
 	 * Gets the file object from the
 	 * {@link #uploadForm upload form}.
 	 *
 	 * @protected
 	 * @return {File|null}
 	 */
 	mw.Upload.BookletLayout.prototype.getFile = function () {
 		return this.selectFileWidget.getValue();
 	};
 
 	/**
 	 * Gets the file name from the
 	 * {@link #infoForm information form}.
 	 *
 	 * @protected
 	 * @return {string}
 	 */
 	mw.Upload.BookletLayout.prototype.getFilename = function () {
 		var filename = this.filenameWidget.getValue();
 		if ( this.filenameExtension ) {
 			filename += '.' + this.filenameExtension;
 		}
 		return filename;
 	};
 
 	/**
 	 * Prefills the {@link #infoForm information form} with the given filename.
 	 *
 	 * @protected
 	 * @param {string} filename
 	 */
 	mw.Upload.BookletLayout.prototype.setFilename = function ( filename ) {
 		var title = mw.Title.newFromFileName( filename );
 
 		if ( title ) {
 			this.filenameWidget.setValue( title.getNameText() );
 			this.filenameExtension = mw.Title.normalizeExtension( title.getExtension() );
 		} else {
 			// Seems to happen for files with no extension, which should fail some checks anyway...
 			this.filenameWidget.setValue( filename );
 			this.filenameExtension = null;
 		}
 	};
 
 	/**
 	 * Gets the page text from the
 	 * {@link #infoForm information form}.
 	 *
 	 * @protected
 	 * @return {string}
 	 */
 	mw.Upload.BookletLayout.prototype.getText = function () {
 		return this.descriptionWidget.getValue();
 	};
 
 	/* Setters */
 
 	/**
 	 * Sets the file object
 	 *
 	 * @protected
 	 * @param {File|null} file File to select
 	 */
 	mw.Upload.BookletLayout.prototype.setFile = function ( file ) {
 		this.selectFileWidget.setValue( file );
 	};
 
 	/**
 	 * Sets the filekey of a file already stashed on the server
 	 * as the target of this upload operation.
 	 *
 	 * @protected
 	 * @param {string} filekey
 	 */
 	mw.Upload.BookletLayout.prototype.setFilekey = function ( filekey ) {
 		this.upload.setFilekey( this.filekey );
 		this.selectFileWidget.setValue( filekey );
 
 		this.onUploadFormChange();
 	};
 
 	/**
 	 * Clear the values of all fields
 	 *
 	 * @protected
 	 */
 	mw.Upload.BookletLayout.prototype.clear = function () {
 		this.selectFileWidget.setValue( null );
 		this.progressBarWidget.setProgress( 0 );
 		this.filenameWidget.setValue( null ).setValidityFlag( true );
 		this.descriptionWidget.setValue( null ).setValidityFlag( true );
 		this.filenameUsageWidget.setValue( null );
 	};
 
 }( jQuery, mediaWiki, moment ) );