datatables.net 2.0.3 → 2.0.4

package/js/dataTables.mjs

@@ -1,4 +1,4 @@
-/*! DataTables 2.0.3
+/*! DataTables 2.0.4
  * © SpryMedia Ltd - datatables.net/license
  */
 
@@ -1043,7 +1043,8 @@ var _api_registerPlural; // DataTable.Api.registerPlural
 
 var _re_dic = {};
 var _re_new_lines = /[\r\n\u2028]/g;
-var _re_html = /<.*?>/g;
+var _re_html = /<([^>]*>)/g;
+var _max_str_len = Math.pow(2, 28);
 
 // This is not strict ISO8601 - Date.parse() is quite lax, although
 // implementations differ between browsers.
@@ -1231,10 +1232,24 @@ var _removeEmpty = function ( a )
 };
 
 // Replaceable function in api.util
-var _stripHtml = function ( d ) {
-	return d
-		.replace( _re_html, '' ) // Complete tags
-		.replace(/<script/i, ''); // Safety for incomplete script tag
+var _stripHtml = function (input) {
+	// Irrelevant check to workaround CodeQL's false positive on the regex
+	if (input.length > _max_str_len) {
+		throw new Error('Exceeded max str len');
+	}
+
+	var previous;
+
+	input = input.replace(_re_html, ''); // Complete tags
+
+	// Safety for incomplete script tag - use do / while to ensure that
+	// we get all instances
+	do {
+		previous = input;
+		input = input.replace(/<script/i, '');
+	} while (input !== previous);
+
+	return previous;
 };
 
 // Replaceable function in api.util
@@ -1949,7 +1964,7 @@ function _fnAddColumn( oSettings )
 		"mData": oDefaults.mData ? oDefaults.mData : iCol,
 		idx: iCol,
 		searchFixed: {},
-		colEl: $('<col>')
+		colEl: $('<col>').attr('data-dt-column', iCol)
 	} );
 	oSettings.aoColumns.push( oCol );
 
@@ -3834,7 +3849,7 @@ function _fnDetectHeader ( settings, thead, write )
 							}
 
 							if (! columnDef.sTitle && unique) {
-								columnDef.sTitle = cell.innerHTML.replace( /<.*?>/g, "" );
+								columnDef.sTitle = _stripHtml(cell.innerHTML);
 								columnDef.autoTitle = true;
 							}
 						}
@@ -4455,7 +4470,7 @@ function _fnFilterCreateSearch( search, inOpts )
 				word = '';
 			}
 
-			return word.replace('"', '');
+			return word.replace(/"/g, '');
 		} );
 
 		var match = not.length
@@ -4987,20 +5002,27 @@ function _fnScrollDraw ( settings )
 	// uses a cell which has a longer string, but isn't the widest! For example 
 	// "Chief Executive Officer (CEO)" is the longest string in the demo, but
 	// "Systems Administrator" is actually the widest string since it doesn't collapse.
+	// Note the use of translating into a column index to get the `col` element. This
+	// is because of Responsive which might remove `col` elements, knocking the alignment
+	// of the indexes out.
 	if (settings.aiDisplay.length) {
 		// Get the column sizes from the first row in the table
-		var colSizes = table.find('tbody tr').eq(0).find('th, td').map(function () {
-			return $(this).outerWidth();
+		var colSizes = table.find('tbody tr').eq(0).find('th, td').map(function (vis) {
+			return {
+				idx: _fnVisibleToColumnIndex(settings, vis),
+				width: $(this).outerWidth()
+			}
 		});
 
 		// Check against what the colgroup > col is set to and correct if needed
-		$('col', settings.colgroup).each(function (i) {
-			var colWidth = this.style.width.replace('px', '');
+		for (var i=0 ; i<colSizes.length ; i++) {
+			var colEl = settings.aoColumns[ colSizes[i].idx ].colEl[0];
+			var colWidth = colEl.style.width.replace('px', '');
 
-			if (colWidth !== colSizes[i]) {
-				this.style.width = colSizes[i] + 'px';
+			if (colWidth !== colSizes[i].width) {
+				colEl.style.width = colSizes[i].width + 'px';
 			}
-		});
+		}
 	}
 
 	// 3. Copy the colgroup over to the header and footer
@@ -6796,6 +6818,10 @@ _Api.extend = function ( scope, obj, ext )
 	for ( i=0, ien=ext.length ; i<ien ; i++ ) {
 		struct = ext[i];
 
+		if (struct.name === '__proto__') {
+			continue;
+		}
+
 		// Value
 		obj[ struct.name ] = struct.type === 'function' ?
 			_api_scope( scope, struct.val, struct ) :
@@ -7458,16 +7484,7 @@ var _selector_row_indexes = function ( settings, opts )
 		order  = opts.order,   // applied, current, index (original - compatibility with 1.9)
 		page   = opts.page;    // all, current
 
-	if ( _fnDataSource( settings ) == 'ssp' ) {
-		// In server-side processing mode, most options are irrelevant since
-		// rows not shown don't exist and the index order is the applied order
-		// Removed is a special case - for consistency just return an empty
-		// array
-		return search === 'removed' ?
-			[] :
-			_range( 0, displayMaster.length );
-	}
-	else if ( page == 'current' ) {
+	if ( page == 'current' ) {
 		// Current page implies that order=current and filter=applied, since it is
 		// fairly senseless otherwise, regardless of what order and search actually
 		// are
@@ -7890,8 +7907,9 @@ var __details_state_load = function (api, state)
 {
 	if ( state && state.childRows ) {
 		api
-			.rows( state.childRows.map(function (id){
-				return id.replace(/:/g, '\\:')
+			.rows( state.childRows.map(function (id) {
+				// Escape any `:` characters from the row id, unless previously escaped
+				return id.replace(/(?<!\\):/g, '\\:');
 			}) )
 			.every( function () {
 				_fnCallbackFire( api.settings()[0], null, 'requestChild', [ this ] )
@@ -8172,6 +8190,17 @@ var __columnData = function ( settings, column, r1, r2, rows, type ) {
 };
 
 
+var __column_header = function ( settings, column, row ) {
+	var header = settings.aoHeader;
+	var target = row !== undefined
+		? row
+		: settings.bSortCellsTop // legacy support
+			? 0
+			: header.length - 1;
+
+	return header[target][column].cell;
+};
+
 var __column_selector = function ( settings, selector, opts )
 {
 	var
@@ -8204,7 +8233,8 @@ var __column_selector = function ( settings, selector, opts )
 			return columns.map(function (col, idx) {
 				return s(
 						idx,
-						__columnData( settings, idx, 0, 0, rows )
+						__columnData( settings, idx, 0, 0, rows ),
+						__column_header( settings, idx )
 					) ? idx : null;
 			});
 		}
@@ -8349,15 +8379,8 @@ _api_register( 'columns()', function ( selector, opts ) {
 } );
 
 _api_registerPlural( 'columns().header()', 'column().header()', function ( row ) {
-	return this.iterator( 'column', function ( settings, column ) {
-		var header = settings.aoHeader;
-		var target = row !== undefined
-			? row
-			: settings.bSortCellsTop // legacy support
-				? 0
-				: header.length - 1;
-
-		return header[target][column].cell;
+	return this.iterator( 'column', function (settings, column) {
+		return __column_header(settings, column, row);
 	}, 1 );
 } );
 
@@ -9510,7 +9533,7 @@ _api_register( 'i18n()', function ( token, def, plural ) {
  *  @type string
  *  @default Version number
  */
-DataTable.version = "2.0.3";
+DataTable.version = "2.0.4";
 
 /**
  * Private data store, containing all of the settings objects that are
@@ -10365,24 +10388,24 @@ DataTable.defaults = {
 		 */
 		"oPaginate": {
 			/**
-			 * Label and character for first page button
+			 * Label and character for first page button («)
 			 */
-			"sFirst": "«",
+			"sFirst": "\u00AB",
 
 			/**
-			 * Last page button
+			 * Last page button (»)
 			 */
-			"sLast": "»",
+			"sLast": "\u00BB",
 
 			/**
-			 * Next page button
+			 * Next page button (›)
 			 */
-			"sNext": "›",
+			"sNext": "\u203A",
 
 			/**
-			 * Previous page button
+			 * Previous page button (‹)
 			 */
-			"sPrevious": "‹",
+			"sPrevious": "\u2039",
 		},
 
 		/**
@@ -11611,657 +11634,95 @@ DataTable.models.oSettings = {
  */
 
 
-/**
- * DataTables extensions
- * 
- * This namespace acts as a collection area for plug-ins that can be used to
- * extend DataTables capabilities. Indeed many of the build in methods
- * use this method to provide their own capabilities (sorting methods for
- * example).
- *
- * Note that this namespace is aliased to `jQuery.fn.dataTableExt` for legacy
- * reasons
- *
- *  @namespace
- */
-DataTable.ext = _ext = {
-	/**
-	 * Buttons. For use with the Buttons extension for DataTables. This is
-	 * defined here so other extensions can define buttons regardless of load
-	 * order. It is _not_ used by DataTables core.
-	 *
-	 *  @type object
-	 *  @default {}
-	 */
-	buttons: {},
+var extPagination = DataTable.ext.pager;
 
+// Paging buttons configuration
+$.extend( extPagination, {
+	simple: function () {
+		return [ 'previous', 'next' ];
+	},
 
-	/**
-	 * Element class names
-	 *
-	 *  @type object
-	 *  @default {}
-	 */
-	classes: {},
+	full: function () {
+		return [  'first', 'previous', 'next', 'last' ];
+	},
 
+	numbers: function () {
+		return [ 'numbers' ];
+	},
 
-	/**
-	 * DataTables build type (expanded by the download builder)
-	 *
-	 *  @type string
-	 */
-	builder: "-source-",
+	simple_numbers: function () {
+		return [ 'previous', 'numbers', 'next' ];
+	},
 
+	full_numbers: function () {
+		return [ 'first', 'previous', 'numbers', 'next', 'last' ];
+	},
+	
+	first_last: function () {
+		return ['first', 'last'];
+	},
+	
+	first_last_numbers: function () {
+		return ['first', 'numbers', 'last'];
+	},
 
-	/**
-	 * Error reporting.
-	 * 
-	 * How should DataTables report an error. Can take the value 'alert',
-	 * 'throw', 'none' or a function.
-	 *
-	 *  @type string|function
-	 *  @default alert
-	 */
-	errMode: "alert",
+	// For testing and plug-ins to use
+	_numbers: _pagingNumbers,
 
+	// Number of number buttons - legacy, use `numbers` option for paging feature
+	numbers_length: 7
+} );
 
-	/**
-	 * Legacy so v1 plug-ins don't throw js errors on load
-	 */
-	feature: [],
 
-	/**
-	 * Feature plug-ins.
-	 * 
-	 * This is an object of callbacks which provide the features for DataTables
-	 * to be initialised via the `layout` option.
-	 */
-	features: {},
+$.extend( true, DataTable.ext.renderer, {
+	pagingButton: {
+		_: function (settings, buttonType, content, active, disabled) {
+			var classes = settings.oClasses.paging;
+			var btnClasses = [classes.button];
+			var btn;
 
+			if (active) {
+				btnClasses.push(classes.active);
+			}
 
-	/**
-	 * Row searching.
-	 * 
-	 * This method of searching is complimentary to the default type based
-	 * searching, and a lot more comprehensive as it allows you complete control
-	 * over the searching logic. Each element in this array is a function
-	 * (parameters described below) that is called for every row in the table,
-	 * and your logic decides if it should be included in the searching data set
-	 * or not.
-	 *
-	 * Searching functions have the following input parameters:
-	 *
-	 * 1. `{object}` DataTables settings object: see
-	 *    {@link DataTable.models.oSettings}
-	 * 2. `{array|object}` Data for the row to be processed (same as the
-	 *    original format that was passed in as the data source, or an array
-	 *    from a DOM data source
-	 * 3. `{int}` Row index ({@link DataTable.models.oSettings.aoData}), which
-	 *    can be useful to retrieve the `TR` element if you need DOM interaction.
-	 *
-	 * And the following return is expected:
-	 *
-	 * * {boolean} Include the row in the searched result set (true) or not
-	 *   (false)
-	 *
-	 * Note that as with the main search ability in DataTables, technically this
-	 * is "filtering", since it is subtractive. However, for consistency in
-	 * naming we call it searching here.
-	 *
-	 *  @type array
-	 *  @default []
-	 *
-	 *  @example
-	 *    // The following example shows custom search being applied to the
-	 *    // fourth column (i.e. the data[3] index) based on two input values
-	 *    // from the end-user, matching the data in a certain range.
-	 *    $.fn.dataTable.ext.search.push(
-	 *      function( settings, data, dataIndex ) {
-	 *        var min = document.getElementById('min').value * 1;
-	 *        var max = document.getElementById('max').value * 1;
-	 *        var version = data[3] == "-" ? 0 : data[3]*1;
-	 *
-	 *        if ( min == "" && max == "" ) {
-	 *          return true;
-	 *        }
-	 *        else if ( min == "" && version < max ) {
-	 *          return true;
-	 *        }
-	 *        else if ( min < version && "" == max ) {
-	 *          return true;
-	 *        }
-	 *        else if ( min < version && version < max ) {
-	 *          return true;
-	 *        }
-	 *        return false;
-	 *      }
-	 *    );
-	 */
-	search: [],
+			if (disabled) {
+				btnClasses.push(classes.disabled)
+			}
 
+			if (buttonType === 'ellipsis') {
+				btn = $('<span class="ellipsis"></span>').html(content)[0];
+			}
+			else {
+				btn = $('<button>', {
+					class: btnClasses.join(' '),
+					role: 'link',
+					type: 'button'
+				}).html(content);
+			}
 
-	/**
-	 * Selector extensions
-	 *
-	 * The `selector` option can be used to extend the options available for the
-	 * selector modifier options (`selector-modifier` object data type) that
-	 * each of the three built in selector types offer (row, column and cell +
-	 * their plural counterparts). For example the Select extension uses this
-	 * mechanism to provide an option to select only rows, columns and cells
-	 * that have been marked as selected by the end user (`{selected: true}`),
-	 * which can be used in conjunction with the existing built in selector
-	 * options.
-	 *
-	 * Each property is an array to which functions can be pushed. The functions
-	 * take three attributes:
-	 *
-	 * * Settings object for the host table
-	 * * Options object (`selector-modifier` object type)
-	 * * Array of selected item indexes
-	 *
-	 * The return is an array of the resulting item indexes after the custom
-	 * selector has been applied.
-	 *
-	 *  @type object
-	 */
-	selector: {
-		cell: [],
-		column: [],
-		row: []
+			return {
+				display: btn,
+				clicker: btn
+			}
+		}
 	},
 
+	pagingContainer: {
+		_: function (settings, buttons) {
+			// No wrapping element - just append directly to the host
+			return buttons;
+		}
+	}
+} );
 
-	/**
-	 * Legacy configuration options. Enable and disable legacy options that
-	 * are available in DataTables.
-	 *
-	 *  @type object
-	 */
-	legacy: {
-		/**
-		 * Enable / disable DataTables 1.9 compatible server-side processing
-		 * requests
-		 *
-		 *  @type boolean
-		 *  @default null
-		 */
-		ajax: null
-	},
+// Common function to remove new lines, strip HTML and diacritic control
+var _filterString = function (stripHtml, normalize) {
+	return function (str) {
+		if (_empty(str) || typeof str !== 'string') {
+			return str;
+		}
 
-
-	/**
-	 * Pagination plug-in methods.
-	 * 
-	 * Each entry in this object is a function and defines which buttons should
-	 * be shown by the pagination rendering method that is used for the table:
-	 * {@link DataTable.ext.renderer.pageButton}. The renderer addresses how the
-	 * buttons are displayed in the document, while the functions here tell it
-	 * what buttons to display. This is done by returning an array of button
-	 * descriptions (what each button will do).
-	 *
-	 * Pagination types (the four built in options and any additional plug-in
-	 * options defined here) can be used through the `paginationType`
-	 * initialisation parameter.
-	 *
-	 * The functions defined take two parameters:
-	 *
-	 * 1. `{int} page` The current page index
-	 * 2. `{int} pages` The number of pages in the table
-	 *
-	 * Each function is expected to return an array where each element of the
-	 * array can be one of:
-	 *
-	 * * `first` - Jump to first page when activated
-	 * * `last` - Jump to last page when activated
-	 * * `previous` - Show previous page when activated
-	 * * `next` - Show next page when activated
-	 * * `{int}` - Show page of the index given
-	 * * `{array}` - A nested array containing the above elements to add a
-	 *   containing 'DIV' element (might be useful for styling).
-	 *
-	 * Note that DataTables v1.9- used this object slightly differently whereby
-	 * an object with two functions would be defined for each plug-in. That
-	 * ability is still supported by DataTables 1.10+ to provide backwards
-	 * compatibility, but this option of use is now decremented and no longer
-	 * documented in DataTables 1.10+.
-	 *
-	 *  @type object
-	 *  @default {}
-	 *
-	 *  @example
-	 *    // Show previous, next and current page buttons only
-	 *    $.fn.dataTableExt.oPagination.current = function ( page, pages ) {
-	 *      return [ 'previous', page, 'next' ];
-	 *    };
-	 */
-	pager: {},
-
-
-	renderer: {
-		pageButton: {},
-		header: {}
-	},
-
-
-	/**
-	 * Ordering plug-ins - custom data source
-	 * 
-	 * The extension options for ordering of data available here is complimentary
-	 * to the default type based ordering that DataTables typically uses. It
-	 * allows much greater control over the the data that is being used to
-	 * order a column, but is necessarily therefore more complex.
-	 * 
-	 * This type of ordering is useful if you want to do ordering based on data
-	 * live from the DOM (for example the contents of an 'input' element) rather
-	 * than just the static string that DataTables knows of.
-	 * 
-	 * The way these plug-ins work is that you create an array of the values you
-	 * wish to be ordering for the column in question and then return that
-	 * array. The data in the array much be in the index order of the rows in
-	 * the table (not the currently ordering order!). Which order data gathering
-	 * function is run here depends on the `dt-init columns.orderDataType`
-	 * parameter that is used for the column (if any).
-	 *
-	 * The functions defined take two parameters:
-	 *
-	 * 1. `{object}` DataTables settings object: see
-	 *    {@link DataTable.models.oSettings}
-	 * 2. `{int}` Target column index
-	 *
-	 * Each function is expected to return an array:
-	 *
-	 * * `{array}` Data for the column to be ordering upon
-	 *
-	 *  @type array
-	 *
-	 *  @example
-	 *    // Ordering using `input` node values
-	 *    $.fn.dataTable.ext.order['dom-text'] = function  ( settings, col )
-	 *    {
-	 *      return this.api().column( col, {order:'index'} ).nodes().map( function ( td, i ) {
-	 *        return $('input', td).val();
-	 *      } );
-	 *    }
-	 */
-	order: {},
-
-
-	/**
-	 * Type based plug-ins.
-	 *
-	 * Each column in DataTables has a type assigned to it, either by automatic
-	 * detection or by direct assignment using the `type` option for the column.
-	 * The type of a column will effect how it is ordering and search (plug-ins
-	 * can also make use of the column type if required).
-	 *
-	 * @namespace
-	 */
-	type: {
-		/**
-		 * Automatic column class assignment
-		 */
-		className: {},
-
-		/**
-		 * Type detection functions.
-		 *
-		 * The functions defined in this object are used to automatically detect
-		 * a column's type, making initialisation of DataTables super easy, even
-		 * when complex data is in the table.
-		 *
-		 * The functions defined take two parameters:
-		 *
-	     *  1. `{*}` Data from the column cell to be analysed
-	     *  2. `{settings}` DataTables settings object. This can be used to
-	     *     perform context specific type detection - for example detection
-	     *     based on language settings such as using a comma for a decimal
-	     *     place. Generally speaking the options from the settings will not
-	     *     be required
-		 *
-		 * Each function is expected to return:
-		 *
-		 * * `{string|null}` Data type detected, or null if unknown (and thus
-		 *   pass it on to the other type detection functions.
-		 *
-		 *  @type array
-		 *
-		 *  @example
-		 *    // Currency type detection plug-in:
-		 *    $.fn.dataTable.ext.type.detect.push(
-		 *      function ( data, settings ) {
-		 *        // Check the numeric part
-		 *        if ( ! data.substring(1).match(/[0-9]/) ) {
-		 *          return null;
-		 *        }
-		 *
-		 *        // Check prefixed by currency
-		 *        if ( data.charAt(0) == '$' || data.charAt(0) == '&pound;' ) {
-		 *          return 'currency';
-		 *        }
-		 *        return null;
-		 *      }
-		 *    );
-		 */
-		detect: [],
-
-		/**
-		 * Automatic renderer assignment
-		 */
-		render: {},
-
-
-		/**
-		 * Type based search formatting.
-		 *
-		 * The type based searching functions can be used to pre-format the
-		 * data to be search on. For example, it can be used to strip HTML
-		 * tags or to de-format telephone numbers for numeric only searching.
-		 *
-		 * Note that is a search is not defined for a column of a given type,
-		 * no search formatting will be performed.
-		 * 
-		 * Pre-processing of searching data plug-ins - When you assign the sType
-		 * for a column (or have it automatically detected for you by DataTables
-		 * or a type detection plug-in), you will typically be using this for
-		 * custom sorting, but it can also be used to provide custom searching
-		 * by allowing you to pre-processing the data and returning the data in
-		 * the format that should be searched upon. This is done by adding
-		 * functions this object with a parameter name which matches the sType
-		 * for that target column. This is the corollary of <i>afnSortData</i>
-		 * for searching data.
-		 *
-		 * The functions defined take a single parameter:
-		 *
-	     *  1. `{*}` Data from the column cell to be prepared for searching
-		 *
-		 * Each function is expected to return:
-		 *
-		 * * `{string|null}` Formatted string that will be used for the searching.
-		 *
-		 *  @type object
-		 *  @default {}
-		 *
-		 *  @example
-		 *    $.fn.dataTable.ext.type.search['title-numeric'] = function ( d ) {
-		 *      return d.replace(/\n/g," ").replace( /<.*?>/g, "" );
-		 *    }
-		 */
-		search: {},
-
-
-		/**
-		 * Type based ordering.
-		 *
-		 * The column type tells DataTables what ordering to apply to the table
-		 * when a column is sorted upon. The order for each type that is defined,
-		 * is defined by the functions available in this object.
-		 *
-		 * Each ordering option can be described by three properties added to
-		 * this object:
-		 *
-		 * * `{type}-pre` - Pre-formatting function
-		 * * `{type}-asc` - Ascending order function
-		 * * `{type}-desc` - Descending order function
-		 *
-		 * All three can be used together, only `{type}-pre` or only
-		 * `{type}-asc` and `{type}-desc` together. It is generally recommended
-		 * that only `{type}-pre` is used, as this provides the optimal
-		 * implementation in terms of speed, although the others are provided
-		 * for compatibility with existing Javascript sort functions.
-		 *
-		 * `{type}-pre`: Functions defined take a single parameter:
-		 *
-	     *  1. `{*}` Data from the column cell to be prepared for ordering
-		 *
-		 * And return:
-		 *
-		 * * `{*}` Data to be sorted upon
-		 *
-		 * `{type}-asc` and `{type}-desc`: Functions are typical Javascript sort
-		 * functions, taking two parameters:
-		 *
-	     *  1. `{*}` Data to compare to the second parameter
-	     *  2. `{*}` Data to compare to the first parameter
-		 *
-		 * And returning:
-		 *
-		 * * `{*}` Ordering match: <0 if first parameter should be sorted lower
-		 *   than the second parameter, ===0 if the two parameters are equal and
-		 *   >0 if the first parameter should be sorted height than the second
-		 *   parameter.
-		 * 
-		 *  @type object
-		 *  @default {}
-		 *
-		 *  @example
-		 *    // Numeric ordering of formatted numbers with a pre-formatter
-		 *    $.extend( $.fn.dataTable.ext.type.order, {
-		 *      "string-pre": function(x) {
-		 *        a = (a === "-" || a === "") ? 0 : a.replace( /[^\d\-\.]/g, "" );
-		 *        return parseFloat( a );
-		 *      }
-		 *    } );
-		 *
-		 *  @example
-		 *    // Case-sensitive string ordering, with no pre-formatting method
-		 *    $.extend( $.fn.dataTable.ext.order, {
-		 *      "string-case-asc": function(x,y) {
-		 *        return ((x < y) ? -1 : ((x > y) ? 1 : 0));
-		 *      },
-		 *      "string-case-desc": function(x,y) {
-		 *        return ((x < y) ? 1 : ((x > y) ? -1 : 0));
-		 *      }
-		 *    } );
-		 */
-		order: {}
-	},
-
-	/**
-	 * Unique DataTables instance counter
-	 *
-	 * @type int
-	 * @private
-	 */
-	_unique: 0,
-
-
-	//
-	// Depreciated
-	// The following properties are retained for backwards compatibility only.
-	// The should not be used in new projects and will be removed in a future
-	// version
-	//
-
-	/**
-	 * Version check function.
-	 *  @type function
-	 *  @depreciated Since 1.10
-	 */
-	fnVersionCheck: DataTable.fnVersionCheck,
-
-
-	/**
-	 * Index for what 'this' index API functions should use
-	 *  @type int
-	 *  @deprecated Since v1.10
-	 */
-	iApiIndex: 0,
-
-
-	/**
-	 * Software version
-	 *  @type string
-	 *  @deprecated Since v1.10
-	 */
-	sVersion: DataTable.version
-};
-
-
-//
-// Backwards compatibility. Alias to pre 1.10 Hungarian notation counter parts
-//
-$.extend( _ext, {
-	afnFiltering: _ext.search,
-	aTypes:       _ext.type.detect,
-	ofnSearch:    _ext.type.search,
-	oSort:        _ext.type.order,
-	afnSortData:  _ext.order,
-	aoFeatures:   _ext.feature,
-	oStdClasses:  _ext.classes,
-	oPagination:  _ext.pager
-} );
-
-
-$.extend( DataTable.ext.classes, {
-	container: 'dt-container',
-	empty: {
-		row: 'dt-empty'
-	},
-	info: {
-		container: 'dt-info'
-	},
-	length: {
-		container: 'dt-length',
-		select: 'dt-input'
-	},
-	order: {
-		canAsc: 'dt-orderable-asc',
-		canDesc: 'dt-orderable-desc',
-		isAsc: 'dt-ordering-asc',
-		isDesc: 'dt-ordering-desc',
-		none: 'dt-orderable-none',
-		position: 'sorting_'
-	},
-	processing: {
-		container: 'dt-processing'
-	},
-	scrolling: {
-		body: 'dt-scroll-body',
-		container: 'dt-scroll',
-		footer: {
-			self: 'dt-scroll-foot',
-			inner: 'dt-scroll-footInner'
-		},
-		header: {
-			self: 'dt-scroll-head',
-			inner: 'dt-scroll-headInner'
-		}
-	},
-	search: {
-		container: 'dt-search',
-		input: 'dt-input'
-	},
-	table: 'dataTable',	
-	tbody: {
-		cell: '',
-		row: ''
-	},
-	thead: {
-		cell: '',
-		row: ''
-	},
-	tfoot: {
-		cell: '',
-		row: ''
-	},
-	paging: {
-		active: 'current',
-		button: 'dt-paging-button',
-		container: 'dt-paging',
-		disabled: 'disabled'
-	}
-} );
-
-
-var extPagination = DataTable.ext.pager;
-
-// Paging buttons configuration
-$.extend( extPagination, {
-	simple: function () {
-		return [ 'previous', 'next' ];
-	},
-
-	full: function () {
-		return [  'first', 'previous', 'next', 'last' ];
-	},
-
-	numbers: function () {
-		return [ 'numbers' ];
-	},
-
-	simple_numbers: function () {
-		return [ 'previous', 'numbers', 'next' ];
-	},
-
-	full_numbers: function () {
-		return [ 'first', 'previous', 'numbers', 'next', 'last' ];
-	},
-	
-	first_last: function () {
-		return ['first', 'last'];
-	},
-	
-	first_last_numbers: function () {
-		return ['first', 'numbers', 'last'];
-	},
-
-	// For testing and plug-ins to use
-	_numbers: _pagingNumbers,
-
-	// Number of number buttons - legacy, use `numbers` option for paging feature
-	numbers_length: 7
-} );
-
-
-$.extend( true, DataTable.ext.renderer, {
-	pagingButton: {
-		_: function (settings, buttonType, content, active, disabled) {
-			var classes = settings.oClasses.paging;
-			var btnClasses = [classes.button];
-			var btn;
-
-			if (active) {
-				btnClasses.push(classes.active);
-			}
-
-			if (disabled) {
-				btnClasses.push(classes.disabled)
-			}
-
-			if (buttonType === 'ellipsis') {
-				btn = $('<span class="ellipsis"></span>').html(content)[0];
-			}
-			else {
-				btn = $('<button>', {
-					class: btnClasses.join(' '),
-					role: 'link',
-					type: 'button'
-				}).html(content);
-			}
-
-			return {
-				display: btn,
-				clicker: btn
-			}
-		}
-	},
-
-	pagingContainer: {
-		_: function (settings, buttons) {
-			// No wrapping element - just append directly to the host
-			return buttons;
-		}
-	}
-} );
-
-// Common function to remove new lines, strip HTML and diacritic control
-var _filterString = function (stripHtml, normalize) {
-	return function (str) {
-		if (_empty(str) || typeof str !== 'string') {
-			return str;
-		}
-
-		str = str.replace( _re_new_lines, " " );
+		str = str.replace( _re_new_lines, " " );
 
 		if (stripHtml) {
 			str = _stripHtml(str);
@@ -13036,7 +12497,7 @@ DataTable.feature.register( 'info', function ( settings, opts ) {
 	});
 
 	// For the first info display in the table, we add a callback and aria information.
-	if (! $('#' + tid+'_info', settings.nWrapper).length) {
+	if (! settings._infoEl) {
 		n.attr({
 			'aria-live': 'polite',
 			id: tid+'_info',
@@ -13045,6 +12506,8 @@ DataTable.feature.register( 'info', function ( settings, opts ) {
 
 		// Table is described by our info div
 		$(settings.nTable).attr( 'aria-describedby', tid+'_info' );
+
+		settings._infoEl = n;
 	}
 
 	return n;
@@ -13202,7 +12665,7 @@ DataTable.feature.register( 'search', function ( settings, opts ) {
 
 // opts
 // - type - button configuration
-// - numbers - number of buttons to show - must be odd
+// - buttons - number of buttons to show - must be odd
 DataTable.feature.register( 'paging', function ( settings, opts ) {
 	// Don't show the paging input if the table doesn't have paging enabled
 	if (! settings.oFeatures.bPaginate) {
@@ -13210,9 +12673,15 @@ DataTable.feature.register( 'paging', function ( settings, opts ) {
 	}
 
 	opts = $.extend({
-		numbers: DataTable.ext.pager.numbers_length,
-		type: settings.sPaginationType
-	}, opts)
+		buttons: DataTable.ext.pager.numbers_length,
+		type: settings.sPaginationType,
+		boundaryNumbers: true
+	}, opts);
+
+	// To be removed in 2.1
+	if (opts.numbers) {
+		opts.buttons = opts.numbers;
+	}
 
 	var host = $('<div/>').addClass( settings.oClasses.paging.container + ' paging_' + opts.type );
 	var draw = function () {
@@ -13244,7 +12713,7 @@ function _pagingDraw(settings, host, opts) {
 		buttons = plugin()
 			.map(function (val) {
 				return val === 'numbers'
-					? _pagingNumbers(page, pages, opts.numbers)
+					? _pagingNumbers(page, pages, opts.buttons, opts.boundaryNumbers)
 					: val;
 			})
 			.flat();
@@ -13386,12 +12855,15 @@ function _pagingButtonInfo(settings, button, page, pages) {
  * @param {*} page Current page
  * @param {*} pages Total number of pages
  * @param {*} buttons Target number of number buttons
+ * @param {boolean} addFirstLast Indicate if page 1 and end should be included
  * @returns Buttons to show
  */
-function _pagingNumbers ( page, pages, buttons ) {
+function _pagingNumbers ( page, pages, buttons, addFirstLast ) {
 	var
 		numbers = [],
-		half = Math.floor(buttons / 2);
+		half = Math.floor(buttons / 2),
+		before = addFirstLast ? 2 : 1,
+		after = addFirstLast ? 1 : 0;
 
 	if ( pages <= buttons ) {
 		numbers = _range(0, pages);
@@ -13414,17 +12886,30 @@ function _pagingNumbers ( page, pages, buttons ) {
 		}
 	}
 	else if ( page <= half ) {
-		numbers = _range(0, buttons-2);
-		numbers.push('ellipsis', pages-1);
+		numbers = _range(0, buttons-before);
+		numbers.push('ellipsis');
+
+		if (addFirstLast) {
+			numbers.push(pages-1);
+		}
 	}
 	else if ( page >= pages - 1 - half ) {
-		numbers = _range(pages-(buttons-2), pages);
-		numbers.unshift(0, 'ellipsis');
+		numbers = _range(pages-(buttons-before), pages);
+		numbers.unshift('ellipsis');
+
+		if (addFirstLast) {
+			numbers.unshift(0);
+		}
 	}
 	else {
-		numbers = _range(page-half+2, page+half-1);
-		numbers.push('ellipsis', pages-1);
-		numbers.unshift(0, 'ellipsis');
+		numbers = _range(page-half+before, page+half-after);
+		numbers.push('ellipsis');
+		numbers.unshift('ellipsis');
+
+		if (addFirstLast) {
+			numbers.push(pages-1);
+			numbers.unshift(0);
+		}
 	}
 
 	return numbers;