https://tec.mx/libraries/datatables.net/js/jquery.dataTables.js?tmme9z

57 factory( jq, window, window.document );
58		}
59	}
60	else {
61		// Browser
62		window.DataTable = factory( jQuery, window, document );
63	}
64}
65(function( $, window, document, undefined ) {
66	"use strict";
67
68	
69	var DataTable = function ( selector, options )
70	{
71		// Check if called with a window or jQuery object for DOM less applications
72		// This is for backwards compatibility
73		if (DataTable.factory(selector, options)) {
74			return DataTable;
75		}
76	
77		// When creating with `new`, create a new DataTable, returning the API instance
78		if (this instanceof DataTable) {
79			return $(selector).DataTable(options);
80		}
81		else {
82			// Argument switching
83			options = selector;
84		}
85	
86		/**
87		 * Perform a jQuery selector action on the table's TR elements (from the tbody) and
88		 * return the resulting jQuery object.
89		 *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on
90		 *  @param {object} [oOpts] Optional parameters for modifying the rows to be included
91		 *  @param {string} [oOpts.filter=none] Select TR elements that meet the current filter
92		 *    criterion ("applied") or all TR elements (i.e. no filter).
93		 *  @param {string} [oOpts.order=current] Order of the TR elements in the processed array.
94		 *    Can be either 'current', whereby the current sorting of the table is used, or
95		 *    'original' whereby the original order the data was read into the table is used.
96		 *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page
97		 *    ("current") or not ("all"). If 'current' is given, then order is assumed to be
98		 *    'current' and filter is 'applied', regardless of what they might be given as.
99		 *  @returns {object} jQuery object, filtered by the given selector.
100		 *  @dtopt API
101		 *  @deprecated Since v1.10
102		 *
103		 *  @example
104		 *    $(document).ready(function() {
105		 *      var oTable = $('#example').dataTable();
106		 *
107		 *      // Highlight every second row
108		 *      oTable.$('tr:odd').css('backgroundColor', 'blue');
109		 *    } );
110		 *
111		 *  @example
112		 *    $(document).ready(function() {
113		 *      var oTable = $('#example').dataTable();
114		 *
115		 *      // Filter to rows with 'Webkit' in them, add a background colour and then
116		 *      // remove the filter, thus highlighting the 'Webkit' rows only.
117		 *      oTable.fnFilter('Webkit');
118		 *      oTable.$('tr', {"search": "applied"}).css('backgroundColor', 'blue');
119		 *      oTable.fnFilter('');
120		 *    } );
121		 */
122		this.$ = function ( sSelector, oOpts )
123		{
124			return this.api(true).$( sSelector, oOpts );
125		};
126		
127		
128		/**
129		 * Almost identical to $ in operation, but in this case returns the data for the matched
130		 * rows - as such, the jQuery selector used should match TR row nodes or TD/TH cell nodes
131		 * rather than any descendants, so the data can be obtained for the row/cell. If matching
132		 * rows are found, the data returned is the original data array/object that was used to
133		 * create the row (or a generated array if from a DOM source).
134		 *
135		 * This method is often useful in-combination with $ where both functions are given the
136		 * same parameters and the array indexes will match identically.
137		 *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on
138		 *  @param {object} [oOpts] Optional parameters for modifying the rows to be included
139		 *  @param {string} [oOpts.filter=none] Select elements that meet the current filter
140		 *    criterion ("applied") or all elements (i.e. no filter).
141		 *  @param {string} [oOpts.order=current] Order of the data in the processed array.
142		 *    Can be either 'current', whereby the current sorting of the table is used, or
143		 *    'original' whereby the original order the data was read into the table is used.
144		 *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page
145		 *    ("current") or not ("all"). If 'current' is given, then order is assumed to be
146		 *    'current' and filter is 'applied', regardless of what they might be given as.
147		 *  @returns {array} Data for the matched elements. If any elements, as a result of the
148		 *    selector, were not TR, TD or TH elements in the DataTable, they will have a null
149		 *    entry in the array.
150		 *  @dtopt API
151		 *  @deprecated Since v1.10
152		 *
153		 *  @example
154		 *    $(document).ready(function() {
155		 *      var oTable = $('#example').dataTable();
156		 *
157		 *      // Get the data from the first row in the table
158		 *      var data = oTable._('tr:first');
159		 *
160		 *      // Do something useful with the data
161		 *      alert( "First cell is: "+data[0] );
162		 *    } );
163		 *
164		 *  @example
165		 *    $(document).ready(function() {
166		 *      var oTable = $('#example').dataTable();
167		 *
168		 *      // Filter to 'Webkit' and get all data for
169		 *      oTable.fnFilter('Webkit');
170		 *      var data = oTable._('tr', {"search": "applied"});
171		 *
172		 *      // Do something with the data
173		 *      alert( data.length+" rows matched the search" );
174		 *    } );
175		 */
176		this._ = function ( sSelector, oOpts )
177		{
178			return this.api(true).rows( sSelector, oOpts ).data();
179		};
180		
181		
182		/**
183		 * Create a DataTables Api instance, with the currently selected tables for
184		 * the Api's context.
185		 * @param {boolean} [traditional=false] Set the API instance's context to be
186		 *   only the table referred to by the `DataTable.ext.iApiIndex` option, as was
187		 *   used in the API presented by DataTables 1.9- (i.e. the traditional mode),
188		 *   or if all tables captured in the jQuery object should be used.
189		 * @return {DataTables.Api}
190		 */
191		this.api = function ( traditional )
192		{
193			return traditional ?
194				new _Api(
195					_fnSettingsFromNode( this[ _ext.iApiIndex ] )
196				) :
197				new _Api( this );
198		};
199		
200		
201		/**
202		 * Add a single new row or multiple rows of data to the table. Please note
203		 * that this is suitable for client-side processing only - if you are using
204		 * server-side processing (i.e. "bServerSide": true), then to add data, you
205		 * must add it to the data source, i.e. the server-side, through an Ajax call.
206		 *  @param {array|object} data The data to be added to the table. This can be:
207		 *    <ul>
208		 *      <li>1D array of data - add a single row with the data provided</li>
209		 *      <li>2D array of arrays - add multiple rows in a single call</li>
210		 *      <li>object - data object when using <i>mData</i></li>
211		 *      <li>array of objects - multiple data objects when using <i>mData</i></li>
212		 *    </ul>
213		 *  @param {bool} [redraw=true] redraw the table or not
214		 *  @returns {array} An array of integers, representing the list of indexes in
215		 *    <i>aoData</i> ({@link DataTable.models.oSettings}) that have been added to
216		 *    the table.
217		 *  @dtopt API
218		 *  @deprecated Since v1.10
219		 *
220		 *  @example
221		 *    // Global var for counter
222		 *    var giCount = 2;
223		 *
224		 *    $(document).ready(function() {
225		 *      $('#example').dataTable();
226		 *    } );
227		 *
228		 *    function fnClickAddRow() {
229		 *      $('#example').dataTable().fnAddData( [
230		 *        giCount+".1",
231		 *        giCount+".2",
232		 *        giCount+".3",
233		 *        giCount+".4" ]
234		 *      );
235		 *
236		 *      giCount++;
237		 *    }
238		 */
239		this.fnAddData = function( data, redraw )
240		{
241			var api = this.api( true );
242		
243			/* Check if we want to add multiple rows or not */
244			var rows = Array.isArray(data) && ( Array.isArray(data[0]) || $.isPlainObject(data[0]) ) ?
245				api.rows.add( data ) :
246				api.row.add( data );
247		
248			if ( redraw === undefined || redraw ) {
249				api.draw();
250			}
251		
252			return rows.flatten().toArray();
253		};
254		
255		
256		/**
257		 * This function will make DataTables recalculate the column sizes, based on the data
258		 * contained in the table and the sizes applied to the columns (in the DOM, CSS or
259		 * through the sWidth parameter). This can be useful when the width of the table's
260		 * parent element changes (for example a window resize).
261		 *  @param {boolean} [bRedraw=true] Redraw the table or not, you will typically want to
262		 *  @dtopt API
263		 *  @deprecated Since v1.10
264		 *
265		 *  @example
266		 *    $(document).ready(function() {
267		 *      var oTable = $('#example').dataTable( {
268		 *        "sScrollY": "200px",
269		 *        "bPaginate": false
270		 *      } );
271		 *
272		 *      $(window).on('resize', function () {
273		 *        oTable.fnAdjustColumnSizing();
274		 *      } );
275		 *    } );
276		 */
277		this.fnAdjustColumnSizing = function ( bRedraw )
278		{
279			var api = this.api( true ).columns.adjust();
280			var settings = api.settings()[0];
281			var scroll = settings.oScroll;
282		
283			if ( bRedraw === undefined || bRedraw ) {
284				api.draw( false );
285			}
286			else if ( scroll.sX !== "" || scroll.sY !== "" ) {
287				/* If not redrawing, but scrolling, we want to apply the new column sizes anyway */
288				_fnScrollDraw( settings );
289			}
290		};
291		
292		
293		/**
294		 * Quickly and simply clear a table
295		 *  @param {bool} [bRedraw=true] redraw the table or not
296		 *  @dtopt API
297		 *  @deprecated Since v1.10
298		 *
299		 *  @example
300		 *    $(document).ready(function() {
301		 *      var oTable = $('#example').dataTable();
302		 *
303		 *      // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...)
304		 *      oTable.fnClearTable();
305		 *    } );
306		 */
307		this.fnClearTable = function( bRedraw )
308		{
309			var api = this.api( true ).clear();
310		
311			if ( bRedraw === undefined || bRedraw ) {
312				api.draw();
313			}
314		};
315		
316		
317		/**
318		 * The exact opposite of 'opening' a row, this function will close any rows which
319		 * are currently 'open'.
320		 *  @param {node} nTr the table row to 'close'
321		 *  @returns {int} 0 on success, or 1 if failed (can't find the row)
322		 *  @dtopt API
323		 *  @deprecated Since v1.10
324		 *
325		 *  @example
326		 *    $(document).ready(function() {
327		 *      var oTable;
328		 *
329		 *      // 'open' an information row when a row is clicked on
330		 *      $('#example tbody tr').click( function () {
331		 *        if ( oTable.fnIsOpen(this) ) {
332		 *          oTable.fnClose( this );
333		 *        } else {
334		 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );
335		 *        }
336		 *      } );
337		 *
338		 *      oTable = $('#example').dataTable();
339		 *    } );
340		 */
341		this.fnClose = function( nTr )
342		{
343			this.api( true ).row( nTr ).child.hide();
344		};
345		
346		
347		/**
348		 * Remove a row for the table
349		 *  @param {mixed} target The index of the row from aoData to be deleted, or
350		 *    the TR element you want to delete
351		 *  @param {function|null} [callBack] Callback function
352		 *  @param {bool} [redraw=true] Redraw the table or not
353		 *  @returns {array} The row that was deleted
354		 *  @dtopt API
355		 *  @deprecated Since v1.10
356		 *
357		 *  @example
358		 *    $(document).ready(function() {
359		 *      var oTable = $('#example').dataTable();
360		 *
361		 *      // Immediately remove the first row
362		 *      oTable.fnDeleteRow( 0 );
363		 *    } );
364		 */
365		this.fnDeleteRow = function( target, callback, redraw )
366		{
367			var api = this.api( true );
368			var rows = api.rows( target );
369			var settings = rows.settings()[0];
370			var data = settings.aoData[ rows[0][0] ];
371		
372			rows.remove();
373		
374			if ( callback ) {
375				callback.call( this, settings, data );
376			}
377		
378			if ( redraw === undefined || redraw ) {
379				api.draw();
380			}
381		
382			return data;
383		};
384		
385		
386		/**
387		 * Restore the table to it's original state in the DOM by removing all of DataTables
388		 * enhancements, alterations to the DOM structure of the table and event listeners.
389		 *  @param {boolean} [remove=false] Completely remove the table from the DOM
390		 *  @dtopt API
391		 *  @deprecated Since v1.10
392		 *
393		 *  @example
394		 *    $(document).ready(function() {
395		 *      // This example is fairly pointless in reality, but shows how fnDestroy can be used
396		 *      var oTable = $('#example').dataTable();
397		 *      oTable.fnDestroy();
398		 *    } );
399		 */
400		this.fnDestroy = function ( remove )
401		{
402			this.api( true ).destroy( remove );
403		};
404		
405		
406		/**
407		 * Redraw the table
408		 *  @param {bool} [complete=true] Re-filter and resort (if enabled) the table before the draw.
409		 *  @dtopt API
410		 *  @deprecated Since v1.10
411		 *
412		 *  @example
413		 *    $(document).ready(function() {
414		 *      var oTable = $('#example').dataTable();
415		 *
416		 *      // Re-draw the table - you wouldn't want to do it here, but it's an example :-)
417		 *      oTable.fnDraw();
418		 *    } );
419		 */
420		this.fnDraw = function( complete )
421		{
422			// Note that this isn't an exact match to the old call to _fnDraw - it takes
423			// into account the new data, but can hold position.
424			this.api( true ).draw( complete );
425		};
426		
427		
428		/**
429		 * Filter the input based on data
430		 *  @param {string} sInput String to filter the table on
431		 *  @param {int|null} [iColumn] Column to limit filtering to
432		 *  @param {bool} [bRegex=false] Treat as regular expression or not
433		 *  @param {bool} [bSmart=true] Perform smart filtering or not
434		 *  @param {bool} [bShowGlobal=true] Show the input global filter in it's input box(es)
435		 *  @param {bool} [bCaseInsensitive=true] Do case-insensitive matching (true) or not (false)
436		 *  @dtopt API
437		 *  @deprecated Since v1.10
438		 *
439		 *  @example
440		 *    $(document).ready(function() {
441		 *      var oTable = $('#example').dataTable();
442		 *
443		 *      // Sometime later - filter...
444		 *      oTable.fnFilter( 'test string' );
445		 *    } );
446		 */
447		this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive )
448		{
449			var api = this.api( true );
450		
451			if ( iColumn === null || iColumn === undefined ) {
452				api.search( sInput, bRegex, bSmart, bCaseInsensitive );
453			}
454			else {
455				api.column( iColumn ).search( sInput, bRegex, bSmart, bCaseInsensitive );
456			}
457		
458			api.draw();
459		};
460		
461		
462		/**
463		 * Get the data for the whole table, an individual row or an individual cell based on the
464		 * provided parameters.
465		 *  @param {int|node} [src] A TR row node, TD/TH cell node or an integer. If given as
466		 *    a TR node then the data source for the whole row will be returned. If given as a
467		 *    TD/TH cell node then iCol will be automatically calculated and the data for the
468		 *    cell returned. If given as an integer, then this is treated as the aoData internal
469		 *    data index for the row (see fnGetPosition) and the data for that row used.
470		 *  @param {int} [col] Optional column index that you want the data of.
471		 *  @returns {array|object|string} If mRow is undefined, then the data for all rows is
472		 *    returned. If mRow is defined, just data for that row, and is iCol is
473		 *    defined, only data for the designated cell is returned.
474		 *  @dtopt API
475		 *  @deprecated Since v1.10
476		 *
477		 *  @example
478		 *    // Row data
479		 *    $(document).ready(function() {
480		 *      oTable = $('#example').dataTable();
481		 *
482		 *      oTable.$('tr').click( function () {
483		 *        var data = oTable.fnGetData( this );
484		 *        // ... do something with the array / object of data for the row
485		 *      } );
486		 *    } );
487		 *
488		 *  @example
489		 *    // Individual cell data
490		 *    $(document).ready(function() {
491		 *      oTable = $('#example').dataTable();
492		 *
493		 *      oTable.$('td').click( function () {
494		 *        var sData = oTable.fnGetData( this );
495		 *        alert( 'The cell clicked on had the value of '+sData );
496		 *      } );
497		 *    } );
498		 */
499		this.fnGetData = function( src, col )
500		{
501			var api = this.api( true );
502		
503			if ( src !== undefined ) {
504				var type = src.nodeName ? src.nodeName.toLowerCase() : '';
505		
506				return col !== undefined || type == 'td' || type == 'th' ?
507					api.cell( src, col ).data() :
508					api.row( src ).data() || null;
509			}
510		
511			return api.data().toArray();
512		};
513		
514		
515		/**
516		 * Get an array of the TR nodes that are used in the table's body. Note that you will
517		 * typically want to use the '$' API method in preference to this as it is more
518		 * flexible.
519		 *  @param {int} [iRow] Optional row index for the TR element you want
520		 *  @returns {array|node} If iRow is undefined, returns an array of all TR elements
521		 *    in the table's body, or iRow is defined, just the TR element requested.
522		 *  @dtopt API
523		 *  @deprecated Since v1.10
524		 *
525		 *  @example
526		 *    $(document).ready(function() {
527		 *      var oTable = $('#example').dataTable();
528		 *
529		 *      // Get the nodes from the table
530		 *      var nNodes = oTable.fnGetNodes( );
531		 *    } );
532		 */
533		this.fnGetNodes = function( iRow )
534		{
535			var api = this.api( true );
536		
537			return iRow !== undefined ?
538				api.row( iRow ).node() :
539				api.rows().nodes().flatten().toArray();
540		};
541		
542		
543		/**
544		 * Get the array indexes of a particular cell from it's DOM element
545		 * and column index including hidden columns
546		 *  @param {node} node this can either be a TR, TD or TH in the table's body
547		 *  @returns {int} If nNode is given as a TR, then a single index is returned, or
548		 *    if given as a cell, an array of [row index, column index (visible),
549		 *    column index (all)] is given.
550		 *  @dtopt API
551		 *  @deprecated Since v1.10
552		 *
553		 *  @example
554		 *    $(document).ready(function() {
555		 *      $('#example tbody td').click( function () {
556		 *        // Get the position of the current data from the node
557		 *        var aPos = oTable.fnGetPosition( this );
558		 *
559		 *        // Get the data array for this row
560		 *        var aData = oTable.fnGetData( aPos[0] );
561		 *
562		 *        // Update the data array and return the value
563		 *        aData[ aPos[1] ] = 'clicked';
564		 *        this.innerHTML = 'clicked';
565		 *      } );
566		 *
567		 *      // Init DataTables
568		 *      oTable = $('#example').dataTable();
569		 *    } );
570		 */
571		this.fnGetPosition = function( node )
572		{
573			var api = this.api( true );
574			var nodeName = node.nodeName.toUpperCase();
575		
576			if ( nodeName == 'TR' ) {
577				return api.row( node ).index();
578			}
579			else if ( nodeName == 'TD' || nodeName == 'TH' ) {
580				var cell = api.cell( node ).index();
581		
582				return [
583					cell.row,
584					cell.columnVisible,
585					cell.column
586				];
587			}
588			return null;
589		};
590		
591		
592		/**
593		 * Check to see if a row is 'open' or not.
594		 *  @param {node} nTr the table row to check
595		 *  @returns {boolean} true if the row is currently open, false otherwise
596		 *  @dtopt API
597		 *  @deprecated Since v1.10
598		 *
599		 *  @example
600		 *    $(document).ready(function() {
601		 *      var oTable;
602		 *
603		 *      // 'open' an information row when a row is clicked on
604		 *      $('#example tbody tr').click( function () {
605		 *        if ( oTable.fnIsOpen(this) ) {
606		 *          oTable.fnClose( this );
607		 *        } else {
608		 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );
609		 *        }
610		 *      } );
611		 *
612		 *      oTable = $('#example').dataTable();
613		 *    } );
614		 */
615		this.fnIsOpen = function( nTr )
616		{
617			return this.api( true ).row( nTr ).child.isShown();
618		};
619		
620		
621		/**
622		 * This function will place a new row directly after a row which is currently
623		 * on display on the page, with the HTML contents that is passed into the
624		 * function. This can be used, for example, to ask for confirmation that a
625		 * particular record should be deleted.
626		 *  @param {node} nTr The table row to 'open'
627		 *  @param {string|node|jQuery} mHtml The HTML to put into the row
628		 *  @param {string} sClass Class to give the new TD cell
629		 *  @returns {node} The row opened. Note that if the table row passed in as the
630		 *    first parameter, is not found in the table, this method will silently
631		 *    return.
632		 *  @dtopt API
633		 *  @deprecated Since v1.10
634		 *
635		 *  @example
636		 *    $(document).ready(function() {
637		 *      var oTable;
638		 *
639		 *      // 'open' an information row when a row is clicked on
640		 *      $('#example tbody tr').click( function () {
641		 *        if ( oTable.fnIsOpen(this) ) {
642		 *          oTable.fnClose( this );
643		 *        } else {
644		 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );
645		 *        }
646		 *      } );
647		 *
648		 *      oTable = $('#example').dataTable();
649		 *    } );
650		 */
651		this.fnOpen = function( nTr, mHtml, sClass )
652		{
653			return this.api( true )
654				.row( nTr )
655				.child( mHtml, sClass )
656				.show()
657				.child()[0];
658		};
659		
660		
661		/**
662		 * Change the pagination - provides the internal logic for pagination in a simple API
663		 * function. With this function you can have a DataTables table go to the next,
664		 * previous, first or last pages.
665		 *  @param {string|int} mAction Paging action to take: "first", "previous", "next" or "last"
666		 *    or page number to jump to (integer), note that page 0 is the first page.
667		 *  @param {bool} [bRedraw=true] Redraw the table or not
668		 *  @dtopt API
669		 *  @deprecated Since v1.10
670		 *
671		 *  @example
672		 *    $(document).ready(function() {
673		 *      var oTable = $('#example').dataTable();
674		 *      oTable.fnPageChange( 'next' );
675		 *    } );
676		 */
677		this.fnPageChange = function ( mAction, bRedraw )
678		{
679			var api = this.api( true ).page( mAction );
680		
681			if ( bRedraw === undefined || bRedraw ) {
682				api.draw(false);
683			}
684		};
685		
686		
687		/**
688		 * Show a particular column
689		 *  @param {int} iCol The column whose display should be changed
690		 *  @param {bool} bShow Show (true) or hide (false) the column
691		 *  @param {bool} [bRedraw=true] Redraw the table or not
692		 *  @dtopt API
693		 *  @deprecated Since v1.10
694		 *
695		 *  @example
696		 *    $(document).ready(function() {
697		 *      var oTable = $('#example').dataTable();
698		 *
699		 *      // Hide the second column after initialisation
700		 *      oTable.fnSetColumnVis( 1, false );
701		 *    } );
702		 */
703		this.fnSetColumnVis = function ( iCol, bShow, bRedraw )
704		{
705			var api = this.api( true ).column( iCol ).visible( bShow );
706		
707			if ( bRedraw === undefined || bRedraw ) {
708				api.columns.adjust().draw();
709			}
710		};
711		
712		
713		/**
714		 * Get the settings for a particular table for external manipulation
715		 *  @returns {object} DataTables settings object. See
716		 *    {@link DataTable.models.oSettings}
717		 *  @dtopt API
718		 *  @deprecated Since v1.10
719		 *
720		 *  @example
721		 *    $(document).ready(function() {
722		 *      var oTable = $('#example').dataTable();
723		 *      var oSettings = oTable.fnSettings();
724		 *
725		 *      // Show an example parameter from the settings
726		 *      alert( oSettings._iDisplayStart );
727		 *    } );
728		 */
729		this.fnSettings = function()
730		{
731			return _fnSettingsFromNode( this[_ext.iApiIndex] );
732		};
733		
734		
735		/**
736		 * Sort the table by a particular column
737		 *  @param {int} iCol the data index to sort on. Note that this will not match the
738		 *    'display index' if you have hidden data entries
739		 *  @dtopt API
740		 *  @deprecated Since v1.10
741		 *
742		 *  @example
743		 *    $(document).ready(function() {
744		 *      var oTable = $('#example').dataTable();
745		 *
746		 *      // Sort immediately with columns 0 and 1
747		 *      oTable.fnSort( [ [0,'asc'], [1,'asc'] ] );
748		 *    } );
749		 */
750		this.fnSort = function( aaSort )
751		{
752			this.api( true ).order( aaSort ).draw();
753		};
754		
755		
756		/**
757		 * Attach a sort listener to an element for a given column
758		 *  @param {node} nNode the element to attach the sort listener to
759		 *  @param {int} iColumn the column that a click on this node will sort on
760		 *  @param {function} [fnCallback] callback function when sort is run
761		 *  @dtopt API
762		 *  @deprecated Since v1.10
763		 *
764		 *  @example
765		 *    $(document).ready(function() {
766		 *      var oTable = $('#example').dataTable();
767		 *
768		 *      // Sort on column 1, when 'sorter' is clicked on
769		 *      oTable.fnSortListener( document.getElementById('sorter'), 1 );
770		 *    } );
771		 */
772		this.fnSortListener = function( nNode, iColumn, fnCallback )
773		{
774			this.api( true ).order.listener( nNode, iColumn, fnCallback );
775		};
776		
777		
778		/**
779		 * Update a table cell or row - this method will accept either a single value to
780		 * update the cell with, an array of values with one element for each column or
781		 * an object in the same format as the original data source. The function is
782		 * self-referencing in order to make the multi column updates easier.
783		 *  @param {object|array|string} mData Data to update the cell/row with
784		 *  @param {node|int} mRow TR element you want to update or the aoData index
785		 *  @param {int} [iColumn] The column to update, give as null or undefined to
786		 *    update a whole row.
787		 *  @param {bool} [bRedraw=true] Redraw the table or not
788		 *  @param {bool} [bAction=true] Perform pre-draw actions or not
789		 *  @returns {int} 0 on success, 1 on error
790		 *  @dtopt API
791		 *  @deprecated Since v1.10
792		 *
793		 *  @example
794		 *    $(document).ready(function() {
795		 *      var oTable = $('#example').dataTable();
796		 *      oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell
797		 *      oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], $('tbody tr')[0] ); // Row
798		 *    } );
799		 */
800		this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )
801		{
802			var api = this.api( true );
803		
804			if ( iColumn === undefined || iColumn === null ) {
805				api.row( mRow ).data( mData );
806			}
807			else {
808				api.cell( mRow, iColumn ).data( mData );
809			}
810		
811			if ( bAction === undefined || bAction ) {
812				api.columns.adjust();
813			}
814		
815			if ( bRedraw === undefined || bRedraw ) {
816				api.draw();
817			}
818			return 0;
819		};
820		
821		
822		/**
823		 * Provide a common method for plug-ins to check the version of DataTables being used, in order
824		 * to ensure compatibility.
825		 *  @param {string} sVersion Version string to check for, in the format "X.Y.Z". Note that the
826		 *    formats "X" and "X.Y" are also acceptable.
827		 *  @returns {boolean} true if this version of DataTables is greater or equal to the required
828		 *    version, or false if this version of DataTales is not suitable
829		 *  @method
830		 *  @dtopt API
831		 *  @deprecated Since v1.10
832		 *
833		 *  @example
834		 *    $(document).ready(function() {
835		 *      var oTable = $('#example').dataTable();
836		 *      alert( oTable.fnVersionCheck( '1.9.0' ) );
837		 *    } );
838		 */
839		this.fnVersionCheck = _ext.fnVersionCheck;
840		
841	
842		var _that = this;
843		var emptyInit = options === undefined;
844		var len = this.length;
845	
846		if ( emptyInit ) {
847			options = {};
848		}
849	
850		this.oApi = this.internal = _ext.internal;
851	
852		// Extend with old style plug-in API methods
853		for ( var fn in DataTable.ext.internal ) {
854			if ( fn ) {
855				this[fn] = _fnExternApiFunc(fn);
856			}
857		}
858	
859		this.each(function() {
860			// For each initialisation we want to give it a clean initialisation
861			// object that can be bashed around
862			var o = {};
863			var oInit = len > 1 ? // optimisation for single table case
864				_fnExtend( o, options, true ) :
865				options;
866	
867			/*global oInit,_that,emptyInit*/
868			var i=0, iLen, j, jLen, k, kLen;
869			var sId = this.getAttribute( 'id' );
870			var bInitHandedOff = false;
871			var defaults = DataTable.defaults;
872			var $this = $(this);
873			
874			
875			/* Sanity check */
876			if ( this.nodeName.toLowerCase() != 'table' )
877			{
878				_fnLog( null, 0, 'Non-table node initialisation ('+this.nodeName+')', 2 );
879				return;
880			}
881			
882			/* Backwards compatibility for the defaults */
883			_fnCompatOpts( defaults );
884			_fnCompatCols( defaults.column );
885			
886			/* Convert the camel-case defaults to Hungarian */
887			_fnCamelToHungarian( defaults, defaults, true );
888			_fnCamelToHungarian( defaults.column, defaults.column, true );
889			
890			/* Setting up the initialisation object */
891			_fnCamelToHungarian( defaults, $.extend( oInit, $this.data() ), true );
892			
893			
894			
895			/* Check to see if we are re-initialising a table */
896			var allSettings = DataTable.settings;
897			for ( i=0, iLen=allSettings.length ; i<iLen ; i++ )
898			{
899				var s = allSettings[i];
900			
901				/* Base check on table node */
902				if (
903					s.nTable == this ||
904					(s.nTHead && s.nTHead.parentNode == this) ||
905					(s.nTFoot && s.nTFoot.parentNode == this)
906				) {
907					var bRetrieve = oInit.bRetrieve !== undefined ? oInit.bRetrieve : defaults.bRetrieve;
908					var bDestroy = oInit.bDestroy !== undefined ? oInit.bDestroy : defaults.bDestroy;
909			
910					if ( emptyInit || bRetrieve )
911					{
912						return s.oInstance;
913					}
914					else if ( bDestroy )
915					{
916						s.oInstance.fnDestroy();
917						break;
918					}
919					else
920					{
921						_fnLog( s, 0, 'Cannot reinitialise DataTable', 3 );
922						return;
923					}
924				}
925			
926				/* If the element we are initialising has the same ID as a table which was previously
927				 * initialised, but the table nodes don't match (from before) then we destroy the old
928				 * instance by simply deleting it. This is under the assumption that the table has been
929				 * destroyed by other methods. Anyone using non-id selectors will need to do this manually
930				 */
931				if ( s.sTableId == this.id )
932				{
933					allSettings.splice( i, 1 );
934					break;
935				}
936			}
937			
938			/* Ensure the table has an ID - required for accessibility */
939			if ( sId === null || sId === "" )
940			{
941				sId = "DataTables_Table_"+(DataTable.ext._unique++);
942				this.id = sId;
943			}
944			
945			/* Create the settings object for this table and set some of the default parameters */
946			var oSettings = $.extend( true, {}, DataTable.models.oSettings, {
947				"sDestroyWidth": $this[0].style.width,
948				"sInstance":     sId,
949				"sTableId":      sId
950			} );
951			oSettings.nTable = this;
952			oSettings.oApi   = _that.internal;
953			oSettings.oInit  = oInit;
954			
955			allSettings.push( oSettings );
956			
957			// Need to add the instance after the instance after the settings object has been added
958			// to the settings array, so we can self reference the table instance if more than one
959			oSettings.oInstance = (_that.length===1) ? _that : $this.dataTable();
960			
961			// Backwards compatibility, before we apply all the defaults
962			_fnCompatOpts( oInit );
963			_fnLanguageCompat( oInit.oLanguage );
964			
965			// If the length menu is given, but the init display length is not, use the length menu
966			if ( oInit.aLengthMenu && ! oInit.iDisplayLength )
967			{
968				oInit.iDisplayLength = Array.isArray( oInit.aLengthMenu[0] ) ?
969					oInit.aLengthMenu[0][0] : oInit.aLengthMenu[0];
970			}
971			
972			// Apply the defaults and init options to make a single init object will all
973			// options defined from defaults and instance options.
974			oInit = _fnExtend( $.extend( true, {}, defaults ), oInit );
975			
976			
977			// Map the initialisation options onto the settings object
978			_fnMap( oSettings.oFeatures, oInit, [
979				"bPaginate",
980				"bLengthChange",
981				"bFilter",
982				"bSort",
983				"bSortMulti",
984				"bInfo",
985				"bProcessing",
986				"bAutoWidth",
987				"bSortClasses",
988				"bServerSide",
989				"bDeferRender"
990			] );
991			_fnMap( oSettings, oInit, [
992				"asStripeClasses",
993				"ajax",
994				"fnServerData",
995				"fnFormatNumber",
996				"sServerMethod",
997				"aaSorting",
998				"aaSortingFixed",
999				"aLengthMenu",
1000				"sPaginationType",
1001				"sAjaxSource",
1002				"sAjaxDataProp",
1003				"iStateDuration",
1004				"sDom",
1005				"bSortCellsTop",
1006				"iTabIndex",
1007				"fnStateLoadCallback",
1008				"fnStateSaveCallback",
1009				"renderer",
1010				"searchDelay",
1011				"rowId",
1012				[ "iCookieDuration", "iStateDuration" ], // backwards compat
1013				[ "oSearch", "oPreviousSearch" ],
1014				[ "aoSearchCols", "aoPreSearchCols" ],
1015				[ "iDisplayLength", "_iDisplayLength" ]
1016			] );
1017			_fnMap( oSettings.oScroll, oInit, [
1018				[ "sScrollX", "sX" ],
1019				[ "sScrollXInner", "sXInner" ],
1020				[ "sScrollY", "sY" ],
1021				[ "bScrollCollapse", "bCollapse" ]
1022			] );
1023			_fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" );
1024			
1025			/* Callback functions which are array driven */
1026			_fnCallbackReg( oSettings, 'aoDrawCallback',       oInit.fnDrawCallback,      'user' );
1027			_fnCallbackReg( oSettings, 'aoServerParams',       oInit.fnServerParams,      'user' );
1028			_fnCallbackReg( oSettings, 'aoStateSaveParams',    oInit.fnStateSaveParams,   'user' );
1029			_fnCallbackReg( oSettings, 'aoStateLoadParams',    oInit.fnStateLoadParams,   'user' );
1030			_fnCallbackReg( oSettings, 'aoStateLoaded',        oInit.fnStateLoaded,       'user' );
1031			_fnCallbackReg( oSettings, 'aoRowCallback',        oInit.fnRowCallback,       'user' );
1032			_fnCallbackReg( oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow,        'user' );
1033			_fnCallbackReg( oSettings, 'aoHeaderCallback',     oInit.fnHeaderCallback,    'user' );
1034			_fnCallbackReg( oSettings, 'aoFooterCallback',     oInit.fnFooterCallback,    'user' );
1035			_fnCallbackReg( oSettings, 'aoInitComplete',       oInit.fnInitComplete,      'user' );
1036			_fnCallbackReg( oSettings, 'aoPreDrawCallback',    oInit.fnPreDrawCallback,   'user' );
1037			
1038			oSettings.rowIdFn = _fnGetObjectDataFn( oInit.rowId );
1039			
1040			/* Browser support detection */
1041			_fnBrowserDetect( oSettings );
1042			
1043			var oClasses = oSettings.oClasses;
1044			
1045			$.extend( oClasses, DataTable.ext.classes, oInit.oClasses );
1046			$this.addClass( oClasses.sTable );
1047			
1048			
1049			if ( oSettings.iInitDisplayStart === undefined )
1050			{
1051				/* Display start point, taking into account the save saving */
1052				oSettings.iInitDisplayStart = oInit.iDisplayStart;
1053				oSettings._iDisplayStart = oInit.iDisplayStart;
1054			}
1055			
1056			if ( oInit.iDeferLoading !== null )
1057			{
1058				oSettings.bDeferLoading = true;
1059				var tmp = Array.isArray( oInit.iDeferLoading );
1060				oSettings._iRecordsDisplay = tmp ? oInit.iDeferLoading[0] : oInit.iDeferLoading;
1061				oSettings._iRecordsTotal = tmp ? oInit.iDeferLoading[1] : oInit.iDeferLoading;
1062			}
1063			
1064			/* Language definitions */
1065			var oLanguage = oSettings.oLanguage;
1066			$.extend( true, oLanguage, oInit.oLanguage );
1067			
1068			if ( oLanguage.sUrl )
1069			{
1070				/* Get the language definitions from a file - because this Ajax call makes the language
1071				 * get async to the remainder of this function we use bInitHandedOff to indicate that
1072				 * _fnInitialise will be fired by the returned Ajax handler, rather than the constructor
1073				 */
1074				$.ajax( {
1075					dataType: 'json',
1076					url: oLanguage.sUrl,
1077					success: function ( json ) {
1078						_fnCamelToHungarian( defaults.oLanguage, json );
1079						_fnLanguageCompat( json );
1080						$.extend( true, oLanguage, json, oSettings.oInit.oLanguage );
1081			
1082						_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);
1083						_fnInitialise( oSettings );
1084					},
1085					error: function () {
1086						// Error occurred loading language file, continue on as best we can
1087						_fnInitialise( oSettings );
1088					}
1089				} );
1090				bInitHandedOff = true;
1091			}
1092			else {
1093				_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);
1094			}
1095			
1096			/*
1097			 * Stripes
1098			 */
1099			if ( oInit.asStripeClasses === null )
1100			{
1101				oSettings.asStripeClasses =[
1102					oClasses.sStripeOdd,
1103					oClasses.sStripeEven
1104				];
1105			}
1106			
1107			/* Remove row stripe classes if they are already on the table row */
1108			var stripeClasses = oSettings.asStripeClasses;
1109			var rowOne = $this.children('tbody').find('tr').eq(0);
1110			if ( $.inArray( true, $.map( stripeClasses, function(el, i) {
1111				return rowOne.hasClass(el);
1112			} ) ) !== -1 ) {
1113				$('tbody tr', this).removeClass( stripeClasses.join(' ') );
1114				oSettings.asDestroyStripes = stripeClasses.slice();
1115			}
1116			
1117			/*
1118			 * Columns
1119			 * See if we should load columns automatically or use defined ones
1120			 */
1121			var anThs = [];
1122			var aoColumnsInit;
1123			var nThead = this.getElementsByTagName('thead');
1124			if ( nThead.length !== 0 )
1125			{
1126				_fnDetectHeader( oSettings.aoHeader, nThead[0] );
1127				anThs = _fnGetUniqueThs( oSettings );
1128			}
1129			
1130			/* If not given a column array, generate one with nulls */
1131			if ( oInit.aoColumns === null )
1132			{
1133				aoColumnsInit = [];
1134				for ( i=0, iLen=anThs.length ; i<iLen ; i++ )
1135				{
1136					aoColumnsInit.push( null );
1137				}
1138			}
1139			else
1140			{
1141				aoColumnsInit = oInit.aoColumns;
1142			}
1143			
1144			/* Add the columns */
1145			for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
1146			{
1147				_fnAddColumn( oSettings, anThs ? anThs[i] : null );
1148			}
1149			
1150			/* Apply the column definitions */
1151			_fnApplyColumnDefs( oSettings, oInit.aoColumnDefs, aoColumnsInit, function (iCol, oDef) {
1152				_fnColumnOptions( oSettings, iCol, oDef );
1153			} );
1154			
1155			/* HTML5 attribute detection - build an mData object automatically if the
1156			 * attributes are found
1157			 */
1158			if ( rowOne.length ) {
1159				var a = function ( cell, name ) {
1160					return cell.getAttribute( 'data-'+name ) !== null ? name : null;
1161				};
1162			
1163				$( rowOne[0] ).children('th, td').each( function (i, cell) {
1164					var col = oSettings.aoColumns[i];
1165			
1166					if (! col) {
1167						_fnLog( oSettings, 0, 'Incorrect column count', 18 );
1168					}
1169			
1170					if ( col.mData === i ) {
1171						var sort = a( cell, 'sort' ) || a( cell, 'order' );
1172						var filter = a( cell, 'filter' ) || a( cell, 'search' );
1173			
1174						if ( sort !== null || filter !== null ) {
1175							col.mData = {
1176								_:      i+'.display',
1177								sort:   sort !== null   ? i+'.@data-'+sort   : undefined,
1178								type:   sort !== null   ? i+'.@data-'+sort   : undefined,
1179								filter: filter !== null ? i+'.@data-'+filter : undefined
1180							};
1181							col._isArrayHost = true;
1182			
1183							_fnColumnOptions( oSettings, i );
1184						}
1185					}
1186				} );
1187			}
1188			
1189			var features = oSettings.oFeatures;
1190			var loadedInit = function () {
1191				/*
1192				 * Sorting
1193				 * @todo For modularisation (1.11) this needs to do into a sort start up handler
1194				 */
1195			
1196				// If aaSorting is not defined, then we use the first indicator in asSorting
1197				// in case that has been altered, so the default sort reflects that option
1198				if ( oInit.aaSorting === undefined ) {
1199					var sorting = oSettings.aaSorting;
1200					for ( i=0, iLen=sorting.length ; i<iLen ; i++ ) {
1201						sorting[i][1] = oSettings.aoColumns[ i ].asSorting[0];
1202					}
1203				}
1204			
1205				/* Do a first pass on the sorting classes (allows any size changes to be taken into
1206				 * account, and also will apply sorting disabled classes if disabled
1207				 */
1208				_fnSortingClasses( oSettings );
1209			
1210				if ( features.bSort ) {
1211					_fnCallbackReg( oSettings, 'aoDrawCallback', function () {
1212						if ( oSettings.bSorted ) {
1213							var aSort = _fnSortFlatten( oSettings );
1214							var sortedColumns = {};
1215			
1216							$.each( aSort, function (i, val) {
1217								sortedColumns[ val.src ] = val.dir;
1218							} );
1219			
1220							_fnCallbackFire( oSettings, null, 'order', [oSettings, aSort, sortedColumns] );
1221							_fnSortAria( oSettings );
1222						}
1223					} );
1224				}
1225			
1226				_fnCallbackReg( oSettings, 'aoDrawCallback', function () {
1227					if ( oSettings.bSorted || _fnDataSource( oSettings ) === 'ssp' || features.bDeferRender ) {
1228						_fnSortingClasses( oSettings );
1229					}
1230				}, 'sc' );
1231			
1232			
1233				/*
1234				 * Final init
1235				 * Cache the header, body and footer as required, creating them if needed
1236				 */
1237			
1238				// Work around for Webkit bug 83867 - store the caption-side before removing from doc
1239				var captions = $this.children('caption').each( function () {
1240					this._captionSide = $(this).css('caption-side');
1241				} );
1242			
1243				var thead = $this.children('thead');
1244				if ( thead.length === 0 ) {
1245					thead = $('<thead/>').appendTo($this);
1246				}
1247				oSettings.nTHead = thead[0];
1248			
1249				var tbody = $this.children('tbody');
1250				if ( tbody.length === 0 ) {
1251					tbody = $('<tbody/>').insertAfter(thead);
1252				}
1253				oSettings.nTBody = tbody[0];
1254			
1255				var tfoot = $this.children('tfoot');
1256				if ( tfoot.length === 0 && captions.length > 0 && (oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "") ) {
1257					// If we are a scrolling table, and no footer has been given, then we need to create
1258					// a tfoot element for the caption element to be appended to
1259					tfoot = $('<tfoot/>').appendTo($this);
1260				}
1261			
1262				if ( tfoot.length === 0 || tfoot.children().length === 0 ) {
1263					$this.addClass( oClasses.sNoFooter );
1264				}
1265				else if ( tfoot.length > 0 ) {
1266					oSettings.nTFoot = tfoot[0];
1267					_fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot );
1268				}
1269			
1270				/* Check if there is data passing into the constructor */
1271				if ( oInit.aaData ) {
1272					for ( i=0 ; i<oInit.aaData.length ; i++ ) {
1273						_fnAddData( oSettings, oInit.aaData[ i ] );
1274					}
1275				}
1276				else if ( oSettings.bDeferLoading || _fnDataSource( oSettings ) == 'dom' ) {
1277					/* Grab the data from the page - only do this when deferred loading or no Ajax
1278					 * source since there is no point in reading the DOM data if we are then going
1279					 * to replace it with Ajax data
1280					 */
1281					_fnAddTr( oSettings, $(oSettings.nTBody).children('tr') );
1282				}
1283			
1284				/* Copy the data index array */
1285				oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
1286			
1287				/* Initialisation complete - table can be drawn */
1288				oSettings.bInitialised = true;
1289			
1290				/* Check if we need to initialise the table (it might not have been handed off to the
1291				 * language processor)
1292				 */
1293				if ( bInitHandedOff === false ) {
1294					_fnInitialise( oSettings );
1295				}
1296			};
1297			
1298			/* Must be done after everything which can be overridden by the state saving! */
1299			_fnCallbackReg( oSettings, 'aoDrawCallback', _fnSaveState, 'state_save' );
1300			
1301			if ( oInit.bStateSave )
1302			{
1303				features.bStateSave = true;
1304				_fnLoadState( oSettings, oInit, loadedInit );
1305			}
1306			else {
1307				loadedInit();
1308			}
1309			
1310		} );
1311		_that = null;
1312		return this;
1313	};
1314	
1315	
1316	/*
1317	 * It is useful to have variables which are scoped locally so only the
1318	 * DataTables functions can access them and they don't leak into global space.
1319	 * At the same time these functions are often useful over multiple files in the
1320	 * core and API, so we list, or at least document, all variables which are used
1321	 * by DataTables as private variables here. This also ensures that there is no
1322	 * clashing of variable names and that they can easily referenced for reuse.
1323	 */
1324	
1325	
1326	// Defined else where
1327	//  _selector_run
1328	//  _selector_opts
1329	//  _selector_first
1330	//  _selector_row_indexes
1331	
1332	var _ext; // DataTable.ext
1333	var _Api; // DataTable.Api
1334	var _api_register; // DataTable.Api.register
1335	var _api_registerPlural; // DataTable.Api.registerPlural
1336	
1337	var _re_dic = {};
1338	var _re_new_lines = /[\r\n\u2028]/g;
1339	var _re_html = /<.*?>/g;
1340	
1341	// This is not strict ISO8601 - Date.parse() is quite lax, although
1342	// implementations differ between browsers.
1343	var _re_date = /^\d{2,4}[\.\/\-]\d{1,2}[\.\/\-]\d{1,2}([T ]{1}\d{1,2}[:\.]\d{2}([\.:]\d{2})?)?$/;
1344	
1345	// Escape regular expression special characters
1346	var _re_escape_regex = new RegExp( '(\\' + [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^', '-' ].join('|\\') + ')', 'g' );
1347	
1348	// http

1348://en.wikipedia.org/wiki/Foreign_exchange_market
1349	// - \u20BD - Russian ruble.
1350	// - \u20a9 - South Korean Won
1351	// - \u20BA - Turkish Lira
1352	// - \u20B9 - Indian Rupee
1353	// - R - Brazil (R$) and South Africa
1354	// - fr - Swiss Franc
1355	// - kr - Swedish krona, Norwegian krone and Danish krone
1356	// - \u2009 is thin space and \u202F is narrow no-break space, both used in many
1357	// - Ƀ - Bitcoin
1358	// - Ξ - Ethereum
1359	//   standards as thousands separators.
1360	var _re_formatted_numeric = /['\u00A0,$£€¥%\u2009\u202F\u20BD\u20a9\u20BArfkɃΞ]/gi;
1361	
1362	
1363	var _empty = function ( d ) {
1364		return !d || d === true || d === '-' ? true : false;
1365	};
1366	
1367	
1368	var _intVal = function ( s ) {
1369		var integer = parseInt( s, 10 );
1370		return !isNaN(integer) && isFinite(s) ? integer : null;
1371	};
1372	
1373	// Convert from a formatted number with characters other than `.` as the
1374	// decimal place, to a Javascript number
1375	var _numToDecimal = function ( num, decimalPoint ) {
1376		// Cache created regular expressions for speed as this function is called often
1377		if ( ! _re_dic[ decimalPoint ] ) {
1378			_re_dic[ decimalPoint ] = new RegExp( _fnEscapeRegex( decimalPoint ), 'g' );
1379		}
1380		return typeof num === 'string' && decimalPoint !== '.' ?
1381			num.replace( /\./g, '' ).replace( _re_dic[ decimalPoint ], '.' ) :
1382			num;
1383	};
1384	
1385	
1386	var _isNumber = function ( d, decimalPoint, formatted ) {
1387		var type = typeof d;
1388		var strType = type === 'string';
1389	
1390		if ( type === 'number' || type === 'bigint') {
1391			return true;
1392		}
1393	
1394		// If empty return immediately so there must be a number if it is a
1395		// formatted string (this stops the string "k", or "kr", etc being detected
1396		// as a formatted number for currency
1397		if ( _empty( d ) ) {
1398			return true;
1399		}
1400	
1401		if ( decimalPoint && strType ) {
1402			d = _numToDecimal( d, decimalPoint );
1403		}
1404	
1405		if ( formatted && strType ) {
1406			d = d.replace( _re_formatted_numeric, '' );
1407		}
1408	
1409		return !isNaN( parseFloat(d) ) && isFinite( d );
1410	};
1411	
1412	
1413	// A string without HTML in it can be considered to be HTML still
1414	var _isHtml = function ( d ) {
1415		return _empty( d ) || typeof d === 'string';
1416	};
1417	
1418	
1419	var _htmlNumeric = function ( d, decimalPoint, formatted ) {
1420		if ( _empty( d ) ) {
1421			return true;
1422		}
1423	
1424		var html = _isHtml( d );
1425		return ! html ?
1426			null :
1427			_isNumber( _stripHtml( d ), decimalPoint, formatted ) ?
1428				true :
1429				null;
1430	};
1431	
1432	
1433	var _pluck = function ( a, prop, prop2 ) {
1434		var out = [];
1435		var i=0, ien=a.length;
1436	
1437		// Could have the test in the loop for slightly smaller code, but speed
1438		// is essential here
1439		if ( prop2 !== undefined ) {
1440			for ( ; i<ien ; i++ ) {
1441				if ( a[i] && a[i][ prop ] ) {
1442					out.push( a[i][ prop ][ prop2 ] );
1443				}
1444			}
1445		}
1446		else {
1447			for ( ; i<ien ; i++ ) {
1448				if ( a[i] ) {
1449					out.push( a[i][ prop ] );
1450				}
1451			}
1452		}
1453	
1454		return out;
1455	};
1456	
1457	
1458	// Basically the same as _pluck, but rather than looping over `a` we use `order`
1459	// as the indexes to pick from `a`
1460	var _pluck_order = function ( a, order, prop, prop2 )
1461	{
1462		var out = [];
1463		var i=0, ien=order.length;
1464	
1465		// Could have the test in the loop for slightly smaller code, but speed
1466		// is essential here
1467		if ( prop2 !== undefined ) {
1468			for ( ; i<ien ; i++ ) {
1469				if ( a[ order[i] ][ prop ] ) {
1470					out.push( a[ order[i] ][ prop ][ prop2 ] );
1471				}
1472			}
1473		}
1474		else {
1475			for ( ; i<ien ; i++ ) {
1476				out.push( a[ order[i] ][ prop ] );
1477			}
1478		}
1479	
1480		return out;
1481	};
1482	
1483	
1484	var _range = function ( len, start )
1485	{
1486		var out = [];
1487		var end;
1488	
1489		if ( start === undefined ) {
1490			start = 0;
1491			end = len;
1492		}
1493		else {
1494			end = start;
1495			start = len;
1496		}
1497	
1498		for ( var i=start ; i<end ; i++ ) {
1499			out.push( i );
1500		}
1501	
1502		return out;
1503	};
1504	
1505	
1506	var _removeEmpty = function ( a )
1507	{
1508		var out = [];
1509	
1510		for ( var i=0, ien=a.length ; i<ien ; i++ ) {
1511			if ( a[i] ) { // careful - will remove all falsy values!
1512				out.push( a[i] );
1513			}
1514		}
1515	
1516		return out;
1517	};
1518	
1519	
1520	var _stripHtml = function ( d ) {
1521		return d
1522			.replace( _re_html, '' ) // Complete tags
1523			.replace(/<script/i, ''); // Safety for incomplete script tag
1524	};
1525	
1526	
1527	/**
1528	 * Determine if all values in the array are unique. This means we can short
1529	 * cut the _unique method at the cost of a single loop. A sorted array is used
1530	 * to easily check the values.
1531	 *
1532	 * @param  {array} src Source array
1533	 * @return {boolean} true if all unique, false otherwise
1534	 * @ignore
1535	 */
1536	var _areAllUnique = function ( src ) {
1537		if ( src.length < 2 ) {
1538			return true;
1539		}
1540	
1541		var sorted = src.slice().sort();
1542		var last = sorted[0];
1543	
1544		for ( var i=1, ien=sorted.length ; i<ien ; i++ ) {
1545			if ( sorted[i] === last ) {
1546				return false;
1547			}
1548	
1549			last = sorted[i];
1550		}
1551	
1552		return true;
1553	};
1554	
1555	
1556	/**
1557	 * Find the unique elements in a source array.
1558	 *
1559	 * @param  {array} src Source array
1560	 * @return {array} Array of unique items
1561	 * @ignore
1562	 */
1563	var _unique = function ( src )
1564	{
1565		if ( _areAllUnique( src ) ) {
1566			return src.slice();
1567		}
1568	
1569		// A faster unique method is to use object keys to identify used values,
1570		// but this doesn't work with arrays or objects, which we must also
1571		// consider. See jsperf.com/compare-array-unique-versions/4 for more
1572		// information.
1573		var
1574			out = [],
1575			val,
1576			i, ien=src.length,
1577			j, k=0;
1578	
1579		again: for ( i=0 ; i<ien ; i++ ) {
1580			val = src[i];
1581	
1582			for ( j=0 ; j<k ; j++ ) {
1583				if ( out[j] === val ) {
1584					continue again;
1585				}
1586			}
1587	
1588			out.push( val );
1589			k++;
1590		}
1591	
1592		return out;
1593	};
1594	
1595	// Surprisingly this is faster than [].concat.apply
1596	// https://jsperf.com/flatten-an-array-loop-vs-reduce/2
1597	var _flatten = function (out, val) {
1598		if (Array.isArray(val)) {
1599			for (var i=0 ; i<val.length ; i++) {
1600				_flatten(out, val[i]);
1601			}
1602		}
1603		else {
1604			out.push(val);
1605		}
1606	  
1607		return out;
1608	}
1609	
1610	var _includes = function (search, start) {
1611		if (start === undefined) {
1612			start = 0;
1613		}
1614	
1615		return this.indexOf(search, start) !== -1;	
1616	};
1617	
1618	// Array.isArray polyfill.
1619	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
1620	if (! Array.isArray) {
1621	    Array.isArray = function(arg) {
1622	        return Object.prototype.toString.call(arg) === '[object Array]';
1623	    };
1624	}
1625	
1626	if (! Array.prototype.includes) {
1627		Array.prototype.includes = _includes;
1628	}
1629	
1630	// .trim() polyfill
1631	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim
1632	if (!String.prototype.trim) {
1633	  String.prototype.trim = function () {
1634	    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
1635	  };
1636	}
1637	
1638	if (! String.prototype.includes) {
1639		String.prototype.includes = _includes;
1640	}
1641	
1642	/**
1643	 * DataTables utility methods
1644	 * 
1645	 * This namespace provides helper methods that DataTables uses internally to
1646	 * create a DataTable, but which are not exclusively used only for DataTables.
1647	 * These methods can be used by extension authors to save the duplication of
1648	 * code.
1649	 *
1650	 *  @namespace
1651	 */
1652	DataTable.util = {
1653		/**
1654		 * Throttle the calls to a function. Arguments and context are maintained
1655		 * for the throttled function.
1656		 *
1657		 * @param {function} fn Function to be called
1658		 * @param {integer} freq Call frequency in mS
1659		 * @return {function} Wrapped function
1660		 */
1661		throttle: function ( fn, freq ) {
1662			var
1663				frequency = freq !== undefined ? freq : 200,
1664				last,
1665				timer;
1666	
1667			return function () {
1668				var
1669					that = this,
1670					now  = +new Date(),
1671					args = arguments;
1672	
1673				if ( last && now < last + frequency ) {
1674					clearTimeout( timer );
1675	
1676					timer = setTimeout( function () {
1677						last = undefined;
1678						fn.apply( that, args );
1679					}, frequency );
1680				}
1681				else {
1682					last = now;
1683					fn.apply( that, args );
1684				}
1685			};
1686		},
1687	
1688	
1689		/**
1690		 * Escape a string such that it can be used in a regular expression
1691		 *
1692		 *  @param {string} val string to escape
1693		 *  @returns {string} escaped string
1694		 */
1695		escapeRegex: function ( val ) {
1696			return val.replace( _re_escape_regex, '\\$1' );
1697		},
1698	
1699		/**
1700		 * Create a function that will write to a nested object or array
1701		 * @param {*} source JSON notation string
1702		 * @returns Write function
1703		 */
1704		set: function ( source ) {
1705			if ( $.isPlainObject( source ) ) {
1706				/* Unlike get, only the underscore (global) option is used for for
1707				 * setting data since we don't know the type here. This is why an object
1708				 * option is not documented for `mData` (which is read/write), but it is
1709				 * for `mRender` which is read only.
1710				 */
1711				return DataTable.util.set( source._ );
1712			}
1713			else if ( source === null ) {
1714				// Nothing to do when the data source is null
1715				return function () {};
1716			}
1717			else if ( typeof source === 'function' ) {
1718				return function (data, val, meta) {
1719					source( data, 'set', val, meta );
1720				};
1721			}
1722			else if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||
1723					  source.indexOf('[') !== -1 || source.indexOf('(') !== -1) )
1724			{
1725				// Like the get, we need to get data from a nested object
1726				var setData = function (data, val, src) {
1727					var a = _fnSplitObjNotation( src ), b;
1728					var aLast = a[a.length-1];
1729					var arrayNotation, funcNotation, o, innerSrc;
1730		
1731					for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ ) {
1732						// Protect against prototype pollution
1733						if (a[i] === '__proto__' || a[i] === 'constructor') {
1734							throw new Error('Cannot set prototype values');
1735						}
1736		
1737						// Check if we are dealing with an array notation request
1738						arrayNotation = a[i].match(__reArray);
1739						funcNotation = a[i].match(__reFn);
1740		
1741						if ( arrayNotation ) {
1742							a[i] = a[i].replace(__reArray, '');
1743							data[ a[i] ] = [];
1744		
1745							// Get the remainder of the nested object to set so we can recurse
1746							b = a.slice();
1747							b.splice( 0, i+1 );
1748							innerSrc = b.join('.');
1749		
1750							// Traverse each entry in the array setting the properties requested
1751							if ( Array.isArray( val ) ) {
1752								for ( var j=0, jLen=val.length ; j<jLen ; j++ ) {
1753									o = {};
1754									setData( o, val[j], innerSrc );
1755									data[ a[i] ].push( o );
1756								}
1757							}
1758							else {
1759								// We've been asked to save data to an array, but it
1760								// isn't array data to be saved. Best that can be done
1761								// is to just save the value.
1762								data[ a[i] ] = val;
1763							}
1764		
1765							// The inner call to setData has already traversed through the remainder
1766							// of the source and has set the data, thus we can exit here
1767							return;
1768						}
1769						else if ( funcNotation ) {
1770							// Function call
1771							a[i] = a[i].replace(__reFn, '');
1772							data = data[ a[i] ]( val );
1773						}
1774		
1775						// If the nested object doesn't currently exist - since we are
1776						// trying to set the value - create it
1777						if ( data[ a[i] ] === null || data[ a[i] ] === undefined ) {
1778							data[ a[i] ] = {};
1779						}
1780						data = data[ a[i] ];
1781					}
1782		
1783					// Last item in the input - i.e, the actual set
1784					if ( aLast.match(__reFn ) ) {
1785						// Function call
1786						data = data[ aLast.replace(__reFn, '') ]( val );
1787					}
1788					else {
1789						// If array notation is used, we just want to strip it and use the property name
1790						// and assign the value. If it isn't used, then we get the result we want anyway
1791						data[ aLast.replace(__reArray, '') ] = val;
1792					}
1793				};
1794		
1795				return function (data, val) { // meta is also passed in, but not used
1796					return setData( data, val, source );
1797				};
1798			}
1799			else {
1800				// Array or flat object mapping
1801				return function (data, val) { // meta is also passed in, but not used
1802					data[source] = val;
1803				};
1804			}
1805		},
1806	
1807		/**
1808		 * Create a function that will read nested objects from arrays, based on JSON notation
1809		 * @param {*} source JSON notation string
1810		 * @returns Value read
1811		 */
1812		get: function ( source ) {
1813			if ( $.isPlainObject( source ) ) {
1814				// Build an object of get functions, and wrap them in a single call
1815				var o = {};
1816				$.each( source, function (key, val) {
1817					if ( val ) {
1818						o[key] = DataTable.util.get( val );
1819					}
1820				} );
1821		
1822				return function (data, type, row, meta) {
1823					var t = o[type] || o._;
1824					return t !== undefined ?
1825						t(data, type, row, meta) :
1826						data;
1827				};
1828			}
1829			else if ( source === null ) {
1830				// Give an empty string for rendering / sorting etc
1831				return function (data) { // type, row and meta also passed, but not used
1832					return data;
1833				};
1834			}
1835			else if ( typeof source === 'function' ) {
1836				return function (data, type, row, meta) {
1837					return source( data, type, row, meta );
1838				};
1839			}
1840			else if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||
1841					  source.indexOf('[') !== -1 || source.indexOf('(') !== -1) )
1842			{
1843				/* If there is a . in the source string then the data source is in a
1844				 * nested object so we loop over the data for each level to get the next
1845				 * level down. On each loop we test for undefined, and if found immediately
1846				 * return. This allows entire objects to be missing and sDefaultContent to
1847				 * be used if defined, rather than throwing an error
1848				 */
1849				var fetchData = function (data, type, src) {
1850					var arrayNotation, funcNotation, out, innerSrc;
1851		
1852					if ( src !== "" ) {
1853						var a = _fnSplitObjNotation( src );
1854		
1855						for ( var i=0, iLen=a.length ; i<iLen ; i++ ) {
1856							// Check if we are dealing with special notation
1857							arrayNotation = a[i].match(__reArray);
1858							funcNotation = a[i].match(__reFn);
1859		
1860							if ( arrayNotation ) {
1861								// Array notation
1862								a[i] = a[i].replace(__reArray, '');
1863		
1864								// Condition allows simply [] to be passed in
1865								if ( a[i] !== "" ) {
1866									data = data[ a[i] ];
1867								}
1868								out = [];
1869		
1870								// Get the remainder of the nested object to get
1871								a.splice( 0, i+1 );
1872								innerSrc = a.join('.');
1873		
1874								// Traverse each entry in the array getting the properties requested
1875								if ( Array.isArray( data ) ) {
1876									for ( var j=0, jLen=data.length ; j<jLen ; j++ ) {
1877										out.push( fetchData( data[j], type, innerSrc ) );
1878									}
1879								}
1880		
1881								// If a string is given in between the array notation indicators, that
1882								// is used to join the strings together, otherwise an array is returned
1883								var join = arrayNotation[0].substring(1, arrayNotation[0].length-1);
1884								data = (join==="") ? out : out.join(join);
1885		
1886								// The inner call to fetchData has already traversed through the remainder
1887								// of the source requested, so we exit from the loop
1888								break;
1889							}
1890							else if ( funcNotation ) {
1891								// Function call
1892								a[i] = a[i].replace(__reFn, '');
1893								data = data[ a[i] ]();
1894								continue;
1895							}
1896		
1897							if (data === null || data[ a[i] ] === null) {
1898								return null;
1899							}
1900							else if ( data === undefined || data[ a[i] ] === undefined ) {
1901								return undefined;
1902							}
1903	
1904							data = data[ a[i] ];
1905						}
1906					}
1907		
1908					return data;
1909				};
1910		
1911				return function (data, type) { // row and meta also passed, but not used
1912					return fetchData( data, type, source );
1913				};
1914			}
1915			else {
1916				// Array or flat object mapping
1917				return function (data, type) { // row and meta also passed, but not used
1918					return data[source];
1919				};
1920			}
1921		}
1922	};
1923	
1924	
1925	
1926	/**
1927	 * Create a mapping object that allows camel case parameters to be looked up
1928	 * for their Hungarian counterparts. The mapping is stored in a private
1929	 * parameter called `_hungarianMap` which can be accessed on the source object.
1930	 *  @param {object} o
1931	 *  @memberof DataTable#oApi
1932	 */
1933	function _fnHungarianMap ( o )
1934	{
1935		var
1936			hungarian = 'a aa ai ao as b fn i m o s ',
1937			match,
1938			newKey,
1939			map = {};
1940	
1941		$.each( o, function (key, val) {
1942			match = key.match(/^([^A-Z]+?)([A-Z])/);
1943	
1944			if ( match && hungarian.indexOf(match[1]+' ') !== -1 )
1945			{
1946				newKey = key.replace( match[0], match[2].toLowerCase() );
1947				map[ newKey ] = key;
1948	
1949				if ( match[1] === 'o' )
1950				{
1951					_fnHungarianMap( o[key] );
1952				}
1953			}
1954		} );
1955	
1956		o._hungarianMap = map;
1957	}
1958	
1959	
1960	/**
1961	 * Convert from camel case parameters to Hungarian, based on a Hungarian map
1962	 * created by _fnHungarianMap.
1963	 *  @param {object} src The model object which holds all parameters that can be
1964	 *    mapped.
1965	 *  @param {object} user The object to convert from camel case to Hungarian.
1966	 *  @param {boolean} force When set to `true`, properties which already have a
1967	 *    Hungarian value in the `user` object will be overwritten. Otherwise they
1968	 *    won't be.
1969	 *  @memberof DataTable#oApi
1970	 */
1971	function _fnCamelToHungarian ( src, user, force )
1972	{
1973		if ( ! src._hungarianMap ) {
1974			_fnHungarianMap( src );
1975		}
1976	
1977		var hungarianKey;
1978	
1979		$.each( user, function (key, val) {
1980			hungarianKey = src._hungarianMap[ key ];
1981	
1982			if ( hungarianKey !== undefined && (force || user[hungarianKey] === undefined) )
1983			{
1984				// For objects, we need to buzz down into the object to copy parameters
1985				if ( hungarianKey.charAt(0) === 'o' )
1986				{
1987					// Copy the camelCase options over to the hungarian
1988					if ( ! user[ hungarianKey ] ) {
1989						user[ hungarianKey ] = {};
1990					}
1991					$.extend( true, user[hungarianKey], user[key] );
1992	
1993					_fnCamelToHungarian( src[hungarianKey], user[hungarianKey], force );
1994				}
1995				else {
1996					user[hungarianKey] = user[ key ];
1997				}
1998			}
1999		} );
2000	}
2001	
2002	
2003	/**
2004	 * Language compatibility - when certain options are given, and others aren't, we
2005	 * need to duplicate the values over, in order to provide backwards compatibility
2006	 * with older language files.
2007	 *  @param {object} oSettings dataTables settings object
2008	 *  @memberof DataTable#oApi
2009	 */
2010	function _fnLanguageCompat( lang )
2011	{
2012		// Note the use of the Hungarian notation for the parameters in this method as
2013		// this is called after the mapping of camelCase to Hungarian
2014		var defaults = DataTable.defaults.oLanguage;
2015	
2016		// Default mapping
2017		var defaultDecimal = defaults.sDecimal;
2018		if ( defaultDecimal ) {
2019			_addNumericSort( defaultDecimal );
2020		}
2021	
2022		if ( lang ) {
2023			var zeroRecords = lang.sZeroRecords;
2024	
2025			// Backwards compatibility - if there is no sEmptyTable given, then use the same as
2026			// sZeroRecords - assuming that is given.
2027			if ( ! lang.sEmptyTable && zeroRecords &&
2028				defaults.sEmptyTable === "No data available in table" )
2029			{
2030				_fnMap( lang, lang, 'sZeroRecords', 'sEmptyTable' );
2031			}
2032	
2033			// Likewise with loading records
2034			if ( ! lang.sLoadingRecords && zeroRecords &&
2035				defaults.sLoadingRecords === "Loading..." )
2036			{
2037				_fnMap( lang, lang, 'sZeroRecords', 'sLoadingRecords' );
2038			}
2039	
2040			// Old parameter name of the thousands separator mapped onto the new
2041			if ( lang.sInfoThousands ) {
2042				lang.sThousands = lang.sInfoThousands;
2043			}
2044	
2045			var decimal = lang.sDecimal;
2046			if ( decimal && defaultDecimal !== decimal ) {
2047				_addNumericSort( decimal );
2048			}
2049		}
2050	}
2051	
2052	
2053	/**
2054	 * Map one parameter onto another
2055	 *  @param {object} o Object to map
2056	 *  @param {*} knew The new parameter name
2057	 *  @param {*} old The old parameter name
2058	 */
2059	var _fnCompatMap = function ( o, knew, old ) {
2060		if ( o[ knew ] !== undefined ) {
2061			o[ old ] = o[ knew ];
2062		}
2063	};
2064	
2065	
2066	/**
2067	 * Provide backwards compatibility for the main DT options. Note that the new
2068	 * options are mapped onto the old parameters, so this is an external interface
2069	 * change only.
2070	 *  @param {object} init Object to map
2071	 */
2072	function _fnCompatOpts ( init )
2073	{
2074		_fnCompatMap( init, 'ordering',      'bSort' );
2075		_fnCompatMap( init, 'orderMulti',    'bSortMulti' );
2076		_fnCompatMap( init, 'orderClasses',  'bSortClasses' );
2077		_fnCompatMap( init, 'orderCellsTop', 'bSortCellsTop' );
2078		_fnCompatMap( init, 'order',         'aaSorting' );
2079		_fnCompatMap( init, 'orderFixed',    'aaSortingFixed' );
2080		_fnCompatMap( init, 'paging',        'bPaginate' );
2081		_fnCompatMap( init, 'pagingType',    'sPaginationType' );
2082		_fnCompatMap( init, 'pageLength',    'iDisplayLength' );
2083		_fnCompatMap( init, 'searching',     'bFilter' );
2084	
2085		// Boolean initialisation of x-scrolling
2086		if ( typeof init.sScrollX === 'boolean' ) {
2087			init.sScrollX = init.sScrollX ? '100%' : '';
2088		}
2089		if ( typeof init.scrollX === 'boolean' ) {
2090			init.scrollX = init.scrollX ? '100%' : '';
2091		}
2092	
2093		// Column search objects are in an array, so it needs to be converted
2094		// element by element
2095		var searchCols = init.aoSearchCols;
2096	
2097		if ( searchCols ) {
2098			for ( var i=0, ien=searchCols.length ; i<ien ; i++ ) {
2099				if ( searchCols[i] ) {
2100					_fnCamelToHungarian( DataTable.models.oSearch, searchCols[i] );
2101				}
2102			}
2103		}
2104	}
2105	
2106	
2107	/**
2108	 * Provide backwards compatibility for column options. Note that the new options
2109	 * are mapped onto the old parameters, so this is an external interface change
2110	 * only.
2111	 *  @param {object} init Object to map
2112	 */
2113	function _fnCompatCols ( init )
2114	{
2115		_fnCompatMap( init, 'orderable',     'bSortable' );
2116		_fnCompatMap( init, 'orderData',     'aDataSort' );
2117		_fnCompatMap( init, 'orderSequence', 'asSorting' );
2118		_fnCompatMap( init, 'orderDataType', 'sortDataType' );
2119	
2120		// orderData can be given as an integer
2121		var dataSort = init.aDataSort;
2122		if ( typeof dataSort === 'number' && ! Array.isArray( dataSort ) ) {
2123			init.aDataSort = [ dataSort ];
2124		}
2125	}
2126	
2127	
2128	/**
2129	 * Browser feature detection for capabilities, quirks
2130	 *  @param {object} settings dataTables settings object
2131	 *  @memberof DataTable#oApi
2132	 */
2133	function _fnBrowserDetect( settings )
2134	{
2135		// We don't need to do this every time DataTables is constructed, the values
2136		// calculated are specific to the browser and OS configuration which we
2137		// don't expect to change between initialisations
2138		if ( ! DataTable.__browser ) {
2139			var browser = {};
2140			DataTable.__browser = browser;
2141	
2142			// Scrolling feature / quirks detection
2143			var n = $('<div/>')
2144				.css( {
2145					position: 'fixed',
2146					top: 0,
2147					left: $(window).scrollLeft()*-1, // allow for scrolling
2148					height: 1,
2149					width: 1,
2150					overflow: 'hidden'
2151				} )
2152				.append(
2153					$('<div/>')
2154						.css( {
2155							position: 'absolute',
2156							top: 1,
2157							left: 1,
2158							width: 100,
2159							overflow: 'scroll'
2160						} )
2161						.append(
2162							$('<div/>')
2163								.css( {
2164									width: '100%',
2165									height: 10
2166								} )
2167						)
2168				)
2169				.appendTo( 'body' );
2170	
2171			var outer = n.children();
2172			var inner = outer.children();
2173	
2174			// Numbers below, in order, are:
2175			// inner.offsetWidth, inner.clientWidth, outer.offsetWidth, outer.clientWidth
2176			//
2177			// IE6 XP:                           100 100 100  83
2178			// IE7 Vista:                        100 100 100  83
2179			// IE 8+ Windows:                     83  83 100  83
2180			// Evergreen Windows:                 83  83 100  83
2181			// Evergreen Mac with scrollbars:     85  85 100  85
2182			// Evergreen Mac without scrollbars: 100 100 100 100
2183	
2184			// Get scrollbar width
2185			browser.barWidth = outer[0].offsetWidth - outer[0].clientWidth;
2186	
2187			// IE6/7 will oversize a width 100% element inside a scrolling element, to
2188			// include the width of the scrollbar, while other browsers ensure the inner
2189			// element is contained without forcing scrolling
2190			browser.bScrollOversize = inner[0].offsetWidth === 100 && outer[0].clientWidth !== 100;
2191	
2192			// In rtl text layout, some browsers (most, but not all) will place the
2193			// scrollbar on the left, rather than the right.
2194			browser.bScrollbarLeft = Math.round( inner.offset().left ) !== 1;
2195	
2196			// IE8- don't provide height and width for getBoundingClientRect
2197			browser.bBounding = n[0].getBoundingClientRect().width ? true : false;
2198	
2199			n.remove();
2200		}
2201	
2202		$.extend( settings.oBrowser, DataTable.__browser );
2203		settings.oScroll.iBarWidth = DataTable.__browser.barWidth;
2204	}
2205	
2206	
2207	/**
2208	 * Array.prototype reduce[Right] method, used for browsers which don't support
2209	 * JS 1.6. Done this way to reduce code size, since we iterate either way
2210	 *  @param {object} settings dataTables settings object
2211	 *  @memberof DataTable#oApi
2212	 */
2213	function _fnReduce ( that, fn, init, start, end, inc )
2214	{
2215		var
2216			i = start,
2217			value,
2218			isSet = false;
2219	
2220		if ( init !== undefined ) {
2221			value = init;
2222			isSet = true;
2223		}
2224	
2225		while ( i !== end ) {
2226			if ( ! that.hasOwnProperty(i) ) {
2227				continue;
2228			}
2229	
2230			value = isSet ?
2231				fn( value, that[i], i, that ) :
2232				that[i];
2233	
2234			isSet = true;
2235			i += inc;
2236		}
2237	
2238		return value;
2239	}
2240	
2241	/**
2242	 * Add a column to the list used for the table with default values
2243	 *  @param {object} oSettings dataTables settings object
2244	 *  @param {node} nTh The th element for this column
2245	 *  @memberof DataTable#oApi
2246	 */
2247	function _fnAddColumn( oSettings, nTh )
2248	{
2249		// Add column to aoColumns array
2250		var oDefaults = DataTable.defaults.column;
2251		var iCol = oSettings.aoColumns.length;
2252		var oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {
2253			"nTh": nTh ? nTh : document.createElement('th'),
2254			"sTitle":    oDefaults.sTitle    ? oDefaults.sTitle    : nTh ? nTh.innerHTML : '',
2255			"aDataSort": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],
2256			"mData": oDefaults.mData ? oDefaults.mData : iCol,
2257			idx: iCol
2258		} );
2259		oSettings.aoColumns.push( oCol );
2260	
2261		// Add search object for column specific search. Note that the `searchCols[ iCol ]`
2262		// passed into extend can be undefined. This allows the user to give a default
2263		// with only some of the parameters defined, and also not give a default
2264		var searchCols = oSettings.aoPreSearchCols;
2265		searchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch, searchCols[ iCol ] );
2266	
2267		// Use the default column options function to initialise classes etc
2268		_fnColumnOptions( oSettings, iCol, $(nTh).data() );
2269	}
2270	
2271	
2272	/**
2273	 * Apply options for a column
2274	 *  @param {object} oSettings dataTables settings object
2275	 *  @param {int} iCol column index to consider
2276	 *  @param {object} oOptions object with sType, bVisible and bSearchable etc
2277	 *  @memberof DataTable#oApi
2278	 */
2279	function _fnColumnOptions( oSettings, iCol, oOptions )
2280	{
2281		var oCol = oSettings.aoColumns[ iCol ];
2282		var oClasses = oSettings.oClasses;
2283		var th = $(oCol.nTh);
2284	
2285		// Try to get width information from the DOM. We can't get it from CSS
2286		// as we'd need to parse the CSS stylesheet. `width` option can override
2287		if ( ! oCol.sWidthOrig ) {
2288			// Width attribute
2289			oCol.sWidthOrig = th.attr('width') || null;
2290	
2291			// Style attribute
2292			var t = (th.attr('style') || '').match(/width:\s*(\d+[pxem%]+)/);
2293			if ( t ) {
2294				oCol.sWidthOrig = t[1];
2295			}
2296		}
2297	
2298		/* User specified column options */
2299		if ( oOptions !== undefined && oOptions !== null )
2300		{
2301			// Backwards compatibility
2302			_fnCompatCols( oOptions );
2303	
2304			// Map camel case parameters to their Hungarian counterparts
2305			_fnCamelToHungarian( DataTable.defaults.column, oOptions, true );
2306	
2307			/* Backwards compatibility for mDataProp */
2308			if ( oOptions.mDataProp !== undefined && !oOptions.mData )
2309			{
2310				oOptions.mData = oOptions.mDataProp;
2311			}
2312	
2313			if ( oOptions.sType )
2314			{
2315				oCol._sManualType = oOptions.sType;
2316			}
2317	
2318			// `class` is a reserved word in Javascript, so we need to provide
2319			// the ability to use a valid name for the camel case input
2320			if ( oOptions.className && ! oOptions.sClass )
2321			{
2322				oOptions.sClass = oOptions.className;
2323			}
2324			if ( oOptions.sClass ) {
2325				th.addClass( oOptions.sClass );
2326			}
2327	
2328			var origClass = oCol.sClass;
2329	
2330			$.extend( oCol, oOptions );
2331			_fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
2332	
2333			// Merge class from previously defined classes with this one, rather than just
2334			// overwriting it in the extend above
2335			if (origClass !== oCol.sClass) {
2336				oCol.sClass = origClass + ' ' + oCol.sClass;
2337			}
2338	
2339			/* iDataSort to be applied (backwards compatibility), but aDataSort will take
2340			 * priority if defined
2341			 */
2342			if ( oOptions.iDataSort !== undefined )
2343			{
2344				oCol.aDataSort = [ oOptions.iDataSort ];
2345			}
2346			_fnMap( oCol, oOptions, "aDataSort" );
2347	

2352
2353		}
2354	
2355		/* Cache the data get and set functions for speed */
2356		var mDataSrc = oCol.mData;
2357		var mData = _fnGetObjectDataFn( mDataSrc );
2358		var mRender = oCol.mRender ? _fnGetObjectDataFn( oCol.mRender ) : null;
2359	
2360		var attrTest = function( src ) {
2361			return typeof src === 'string' && src.indexOf('@') !== -1;
2362		};
2363		oCol._bAttrSrc = $.isPlainObject( mDataSrc ) && (
2364			attrTest(mDataSrc.sort) || attrTest(mDataSrc.type) || attrTest(mDataSrc.filter)
2365		);
2366		oCol._setter = null;
2367	
2368		oCol.fnGetData = function (rowData, type, meta) {
2369			var innerData = mData( rowData, type, undefined, meta );
2370	
2371			return mRender && type ?
2372				mRender( innerData, type, rowData, meta ) :
2373				innerData;
2374		};
2375		oCol.fnSetData = function ( rowData, val, meta ) {
2376			return _fnSetObjectDataFn( mDataSrc )( rowData, val, meta );
2377		};
2378	
2379		// Indicate if DataTables should read DOM data as an object or array
2380		// Used in _fnGetRowElements
2381		if ( typeof mDataSrc !== 'number' && ! oCol._isArrayHost ) {
2382			oSettings._rowReadObject = true;
2383		}
2384	
2385		/* Feature sorting overrides column specific when off */
2386		if ( !oSettings.oFeatures.bSort )
2387		{
2388			oCol.bSortable = false;
2389			th.addClass( oClasses.sSortableNone ); // Have to add class here as order event isn't called
2390		}
2391	
2392		/* Check that the class assignment is correct for sorting */
2393		var bAsc = $.inArray('asc', oCol.asSorting) !== -1;
2394		var bDesc = $.inArray('desc', oCol.asSorting) !== -1;
2395		if ( !oCol.bSortable || (!bAsc && !bDesc) )
2396		{
2397			oCol.sSortingClass = oClasses.sSortableNone;
2398			oCol.sSortingClassJUI = "";
2399		}
2400		else if ( bAsc && !bDesc )
2401		{
2402			oCol.sSortingClass = oClasses.sSortableAsc;
2403			oCol.sSortingClassJUI = oClasses.sSortJUIAscAllowed;
2404		}
2405		else if ( !bAsc && bDesc )
2406		{
2407			oCol.sSortingClass = oClasses.sSortableDesc;
2408			oCol.sSortingClassJUI = oClasses.sSortJUIDescAllowed;
2409		}
2410		else
2411		{
2412			oCol.sSortingClass = oClasses.sSortable;
2413			oCol.sSortingClassJUI = oClasses.sSortJUI;
2414		}
2415	}
2416	
2417	
2418	/**
2419	 * Adjust the table column widths for new data. Note: you would probably want to
2420	 * do a redraw after calling this function!
2421	 *  @param {object} settings dataTables settings object
2422	 *  @memberof DataTable#oApi
2423	 */
2424	function _fnAdjustColumnSizing ( settings )
2425	{
2426		/* Not interested in doing column width calculation if auto-width is disabled */
2427		if ( settings.oFeatures.bAutoWidth !== false )
2428		{
2429			var columns = settings.aoColumns;
2430	
2431			_fnCalculateColumnWidths( settings );
2432			for ( var i=0 , iLen=columns.length ; i<iLen ; i++ )
2433			{
2434				columns[i].nTh.style.width = columns[i].sWidth;
2435			}
2436		}
2437	
2438		var scroll = settings.oScroll;
2439		if ( scroll.sY !== '' || scroll.sX !== '')
2440		{
2441			_fnScrollDraw( settings );
2442		}
2443	
2444		_fnCallbackFire( settings, null, 'column-sizing', [settings] );
2445	}
2446	
2447	
2448	/**
2449	 * Convert the index of a visible column to the index in the data array (take account
2450	 * of hidden columns)
2451	 *  @param {object} oSettings dataTables settings object
2452	 *  @param {int} iMatch Visible column index to lookup
2453	 *  @returns {int} i the data index
2454	 *  @memberof DataTable#oApi
2455	 */
2456	function _fnVisibleToColumnIndex( oSettings, iMatch )
2457	{
2458		var aiVis = _fnGetColumns( oSettings, 'bVisible' );
2459	
2460		return typeof aiVis[iMatch] === 'number' ?
2461			aiVis[iMatch] :
2462			null;
2463	}
2464	
2465	
2466	/**
2467	 * Convert the index of an index in the data array and convert it to the visible
2468	 *   column index (take account of hidden columns)
2469	 *  @param {int} iMatch Column index to lookup
2470	 *  @param {object} oSettings dataTables settings object
2471	 *  @returns {int} i the data index
2472	 *  @memberof DataTable#oApi
2473	 */
2474	function _fnColumnIndexToVisible( oSettings, iMatch )
2475	{
2476		var aiVis = _fnGetColumns( oSettings, 'bVisible' );
2477		var iPos = $.inArray( iMatch, aiVis );
2478	
2479		return iPos !== -1 ? iPos : null;
2480	}
2481	
2482	
2483	/**
2484	 * Get the number of visible columns
2485	 *  @param {object} oSettings dataTables settings object
2486	 *  @returns {int} i the number of visible columns
2487	 *  @memberof DataTable#oApi
2488	 */
2489	function _fnVisbleColumns( oSettings )
2490	{
2491		var vis = 0;
2492	
2493		// No reduce in IE8, use a loop for now
2494		$.each( oSettings.aoColumns, function ( i, col ) {
2495			if ( col.bVisible && $(col.nTh).css('display') !== 'none' ) {
2496				vis++;
2497			}
2498		} );
2499	
2500		return vis;
2501	}
2502	
2503	
2504	/**
2505	 * Get an array of column indexes that match a given property
2506	 *  @param {object} oSettings dataTables settings object
2507	 *  @param {string} sParam Parameter in aoColumns to look for - typically
2508	 *    bVisible or bSearchable
2509	 *  @returns {array} Array of indexes with matched properties
2510	 *  @memberof DataTable#oApi
2511	 */
2512	function _fnGetColumns( oSettings, sParam )
2513	{
2514		var a = [];
2515	
2516		$.map( oSettings.aoColumns, function(val, i) {
2517			if ( val[sParam] ) {
2518				a.push( i );
2519			}
2520		} );
2521	
2522		return a;
2523	}
2524	
2525	
2526	/**
2527	 * Calculate the 'type' of a column
2528	 *  @param {object} settings dataTables settings object
2529	 *  @memberof DataTable#oApi
2530	 */
2531	function _fnColumnTypes ( settings )
2532	{
2533		var columns = settings.aoColumns;
2534		var data = settings.aoData;
2535		var types = DataTable.ext.type.detect;
2536		var i, ien, j, jen, k, ken;
2537		var col, cell, detectedType, cache;
2538	
2539		// For each column, spin over the 
2540		for ( i=0, ien=columns.length ; i<ien ; i++ ) {
2541			col = columns[i];
2542			cache = [];
2543	
2544			if ( ! col.sType && col._sManualType ) {
2545				col.sType = col._sManualType;
2546			}
2547			else if ( ! col.sType ) {
2548				for ( j=0, jen=types.length ; j<jen ; j++ ) {
2549					for ( k=0, ken=data.length ; k<ken ; k++ ) {
2550						// Use a cache array so we only need to get the type data
2551						// from the formatter once (when using multiple detectors)
2552						if ( cache[k] === undefined ) {
2553							cache[k] = _fnGetCellData( settings, k, i, 'type' );
2554						}
2555	
2556						detectedType = types[j]( cache[k], settings );
2557	
2558						// If null, then this type can't apply to this column, so
2559						// rather than testing all cells, break out. There is an
2560						// exception for the last type which is `html`. We need to
2561						// scan all rows since it is possible to mix string and HTML
2562						// types
2563						if ( ! detectedType && j !== types.length-1 ) {
2564							break;
2565						}
2566	
2567						// Only a single match is needed for html type since it is
2568						// bottom of the pile and very similar to string - but it
2569						// must not be empty
2570						if ( detectedType === 'html' && ! _empty(cache[k]) ) {
2571							break;
2572						}
2573					}
2574	
2575					// Type is valid for all data points in the column - use this
2576					// type
2577					if ( detectedType ) {
2578						col.sType = detectedType;
2579						break;
2580					}
2581				}
2582	
2583				// Fall back - if no type was detected, always use string
2584				if ( ! col.sType ) {
2585					col.sType = 'string';
2586				}
2587			}
2588		}
2589	}
2590	
2591	
2592	/**
2593	 * Take the column definitions and static columns arrays and calculate how
2594	 * they relate to column indexes. The callback function will then apply the
2595	 * definition found for a column to a suitable configuration object.
2596	 *  @param {object} oSettings dataTables settings object
2597	 *  @param {array} aoColDefs The aoColumnDefs array that is to be applied
2598	 *  @param {array} aoCols The aoColumns array that defines columns individually
2599	 *  @param {function} fn Callback function - takes two parameters, the calculated
2600	 *    column index and the definition for that column.
2601	 *  @memberof DataTable#oApi
2602	 */
2603	function _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )
2604	{
2605		var i, iLen, j, jLen, k, kLen, def;
2606		var columns = oSettings.aoColumns;
2607	
2608		// Column definitions with aTargets
2609		if ( aoColDefs )
2610		{
2611			/* Loop over the definitions array - loop in reverse so first instance has priority */
2612			for ( i=aoColDefs.length-1 ; i>=0 ; i-- )
2613			{
2614				def = aoColDefs[i];
2615	
2616				/* Each definition can target multiple columns, as it is an array */
2617				var aTargets = def.target !== undefined
2618					? def.target
2619					: def.targets !== undefined
2620						? def.targets
2621						: def.aTargets;
2622	
2623				if ( ! Array.isArray( aTargets ) )
2624				{
2625					aTargets = [ aTargets ];
2626				}
2627	
2628				for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
2629				{
2630					if ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )
2631					{
2632						/* Add columns that we don't yet know about */
2633						while( columns.length <= aTargets[j] )
2634						{
2635							_fnAddColumn( oSettings );
2636						}
2637	
2638						/* Integer, basic index */
2639						fn( aTargets[j], def );
2640					}
2641					else if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )
2642					{
2643						/* Negative integer, right to left column counting */
2644						fn( columns.length+aTargets[j], def );
2645					}
2646					else if ( typeof aTargets[j] === 'string' )
2647					{
2648						/* Class name matching on TH element */
2649						for ( k=0, kLen=columns.length ; k<kLen ; k++ )
2650						{
2651							if ( aTargets[j] == "_all" ||
2652							     $(columns[k].nTh).hasClass( aTargets[j] ) )
2653							{
2654								fn( k, def );
2655							}
2656						}
2657					}
2658				}
2659			}
2660		}
2661	
2662		// Statically defined columns array
2663		if ( aoCols )
2664		{
2665			for ( i=0, iLen=aoCols.length ; i<iLen ; i++ )
2666			{
2667				fn( i, aoCols[i] );
2668			}
2669		}
2670	}
2671	
2672	/**
2673	 * Add a data array to the table, creating DOM node etc. This is the parallel to
2674	 * _fnGatherData, but for adding rows from a Javascript source, rather than a
2675	 * DOM source.
2676	 *  @param {object} oSettings dataTables settings object
2677	 *  @param {array} aData data array to be added
2678	 *  @param {node} [nTr] TR element to add to the table - optional. If not given,
2679	 *    DataTables will create a row automatically
2680	 *  @param {array} [anTds] Array of TD|TH elements for the row - must be given
2681	 *    if nTr is.
2682	 *  @returns {int} >=0 if successful (index of new aoData entry), -1 if failed
2683	 *  @memberof DataTable#oApi
2684	 */
2685	function _fnAddData ( oSettings, aDataIn, nTr, anTds )
2686	{
2687		/* Create the object for storing information about this new row */
2688		var iRow = oSettings.aoData.length;
2689		var oData = $.extend( true, {}, DataTable.models.oRow, {
2690			src: nTr ? 'dom' : 'data',
2691			idx: iRow
2692		} );
2693	
2694		oData._aData = aDataIn;
2695		oSettings.aoData.push( oData );
2696	
2697		/* Create the cells */
2698		var nTd, sThisType;
2699		var columns = oSettings.aoColumns;
2700	
2701		// Invalidate the column types as the new data needs to be revalidated
2702		for ( var i=0, iLen=columns.length ; i<iLen ; i++ )
2703		{
2704			columns[i].sType = null;
2705		}
2706	
2707		/* Add to the display array */
2708		oSettings.aiDisplayMaster.push( iRow );
2709	
2710		var id = oSettings.rowIdFn( aDataIn );
2711		if ( id !== undefined ) {
2712			oSettings.aIds[ id ] = oData;
2713		}
2714	
2715		/* Create the DOM information, or register it if already present */
2716		if ( nTr || ! oSettings.oFeatures.bDeferRender )
2717		{
2718			_fnCreateTr( oSettings, iRow, nTr, anTds );
2719		}
2720	
2721		return iRow;
2722	}
2723	
2724	
2725	/**
2726	 * Add one or more TR elements to the table. Generally we'd expect to
2727	 * use this for reading data from a DOM sourced table, but it could be
2728	 * used for an TR element. Note that if a TR is given, it is used (i.e.
2729	 * it is not cloned).
2730	 *  @param {object} settings dataTables settings object
2731	 *  @param {array|node|jQuery} trs The TR element(s) to add to the table
2732	 *  @returns {array} Array of indexes for the added rows
2733	 *  @memberof DataTable#oApi
2734	 */
2735	function _fnAddTr( settings, trs )
2736	{
2737		var row;
2738	
2739		// Allow an individual node to be passed in
2740		if ( ! (trs instanceof $) ) {
2741			trs = $(trs);
2742		}
2743	
2744		return trs.map( function (i, el) {
2745			row = _fnGetRowElements( settings, el );
2746			return _fnAddData( settings, row.data, el, row.cells );
2747		} );
2748	}
2749	
2750	
2751	/**
2752	 * Take a TR element and convert it to an index in aoData
2753	 *  @param {object} oSettings dataTables settings object
2754	 *  @param {node} n the TR element to find
2755	 *  @returns {int} index if the node is found, null if not
2756	 *  @memberof DataTable#oApi
2757	 */
2758	function _fnNodeToDataIndex( oSettings, n )
2759	{
2760		return (n._DT_RowIndex!==undefined) ? n._DT_RowIndex : null;
2761	}
2762	
2763	
2764	/**
2765	 * Take a TD element and convert it into a column data index (not the visible index)
2766	 *  @param {object} oSettings dataTables settings object
2767	 *  @param {int} iRow The row number the TD/TH can be found in
2768	 *  @param {node} n The TD/TH element to find
2769	 *  @returns {int} index if the node is found, -1 if not
2770	 *  @memberof DataTable#oApi
2771	 */
2772	function _fnNodeToColumnIndex( oSettings, iRow, n )
2773	{
2774		return $.inArray( n, oSettings.aoData[ iRow ].anCells );
2775	}
2776	
2777	
2778	/**
2779	 * Get the data for a given cell from the internal cache, taking into account data mapping
2780	 *  @param {object} settings dataTables settings object
2781	 *  @param {int} rowIdx aoData row id
2782	 *  @param {int} colIdx Column index
2783	 *  @param {string} type data get type ('display', 'type' 'filter|search' 'sort|order')
2784	 *  @returns {*} Cell data
2785	 *  @memberof DataTable#oApi
2786	 */
2787	function _fnGetCellData( settings, rowIdx, colIdx, type )
2788	{
2789		if (type === 'search') {
2790			type = 'filter';
2791		}
2792		else if (type === 'order') {
2793			type = 'sort';
2794		}
2795	
2796		var draw           = settings.iDraw;
2797		var col            = settings.aoColumns[colIdx];
2798		var rowData        = settings.aoData[rowIdx]._aData;
2799		var defaultContent = col.sDefaultContent;
2800		var cellData       = col.fnGetData( rowData, type, {
2801			settings: settings,
2802			row:      rowIdx,
2803			col:      colIdx
2804		} );
2805	
2806		if ( cellData === undefined ) {
2807			if ( settings.iDrawError != draw && defaultContent === null ) {
2808				_fnLog( settings, 0, "Requested unknown parameter "+
2809					(typeof col.mData=='function' ? '{function}' : "'"+col.mData+"'")+
2810					" for row "+rowIdx+", column "+colIdx, 4 );
2811				settings.iDrawError = draw;
2812			}
2813			return defaultContent;
2814		}
2815	
2816		// When the data source is null and a specific data type is requested (i.e.
2817		// not the original data), we can use default column data
2818		if ( (cellData === rowData || cellData === null) && defaultContent !== null && type !== undefined ) {
2819			cellData = defaultContent;
2820		}
2821		else if ( typeof cellData === 'function' ) {
2822			// If the data source is a function, then we run it and use the return,
2823			// executing in the scope of the data object (for instances)
2824			return cellData.call( rowData );
2825		}
2826	
2827		if ( cellData === null && type === 'display' ) {
2828			return '';
2829		}
2830	
2831		if ( type === 'filter' ) {
2832			var fomatters = DataTable.ext.type.search;
2833	
2834			if ( fomatters[ col.sType ] ) {
2835				cellData = fomatters[ col.sType ]( cellData );
2836			}
2837		}
2838	
2839		return cellData;
2840	}
2841	
2842	
2843	/**
2844	 * Set the value for a specific cell, into the internal data cache
2845	 *  @param {object} settings dataTables settings object
2846	 *  @param {int} rowIdx aoData row id
2847	 *  @param {int} colIdx Column index
2848	 *  @param {*} val Value to set
2849	 *  @memberof DataTable#oApi
2850	 */
2851	function _fnSetCellData( settings, rowIdx, colIdx, val )
2852	{
2853		var col     = settings.aoColumns[colIdx];
2854		var rowData = settings.aoData[rowIdx]._aData;
2855	
2856		col.fnSetData( rowData, val, {
2857			settings: settings,
2858			row:      rowIdx,
2859			col:      colIdx
2860		}  );
2861	}
2862	
2863	
2864	// Private variable that is used to match action syntax in the data property object
2865	var __reArray = /\[.*?\]$/;
2866	var __reFn = /\(\)$/;
2867	
2868	/**
2869	 * Split string on periods, taking into account escaped periods
2870	 * @param  {string} str String to split
2871	 * @return {array} Split string
2872	 */
2873	function _fnSplitObjNotation( str )
2874	{
2875		return $.map( str.match(/(\\.|[^\.])+/g) || [''], function ( s ) {
2876			return s.replace(/\\\./g, '.');
2877		} );
2878	}
2879	
2880	
2881	/**
2882	 * Return a function that can be used to get data from a source object, taking
2883	 * into account the ability to use nested objects as a source
2884	 *  @param {string|int|function} mSource The data source for the object
2885	 *  @returns {function} Data get function
2886	 *  @memberof DataTable#oApi
2887	 */
2888	var _fnGetObjectDataFn = DataTable.util.get;
2889	
2890	
2891	/**
2892	 * Return a function that can be used to set data from a source object, taking
2893	 * into account the ability to use nested objects as a source
2894	 *  @param {string|int|function} mSource The data source for the object
2895	 *  @returns {function} Data set function
2896	 *  @memberof DataTable#oApi
2897	 */
2898	var _fnSetObjectDataFn = DataTable.util.set;
2899	
2900	
2901	/**
2902	 * Return an array with the full table data
2903	 *  @param {object} oSettings dataTables settings object
2904	 *  @returns array {array} aData Master data array
2905	 *  @memberof DataTable#oApi
2906	 */
2907	function _fnGetDataMaster ( settings )
2908	{
2909		return _pluck( settings.aoData, '_aData' );
2910	}
2911	
2912	
2913	/**
2914	 * Nuke the table
2915	 *  @param {object} oSettings dataTables settings object
2916	 *  @memberof DataTable#oApi
2917	 */
2918	function _fnClearTable( settings )
2919	{
2920		settings.aoData.length = 0;
2921		settings.aiDisplayMaster.length = 0;
2922		settings.aiDisplay.length = 0;
2923		settings.aIds = {};
2924	}
2925	
2926	
2927	 /**
2928	 * Take an array of integers (index array) and remove a target integer (value - not
2929	 * the key!)
2930	 *  @param {array} a Index array to target
2931	 *  @param {int} iTarget value to find
2932	 *  @memberof DataTable#oApi
2933	 */
2934	function _fnDeleteIndex( a, iTarget, splice )
2935	{
2936		var iTargetIndex = -1;
2937	
2938		for ( var i=0, iLen=a.length ; i<iLen ; i++ )
2939		{
2940			if ( a[i] == iTarget )
2941			{
2942				iTargetIndex = i;
2943			}
2944			else if ( a[i] > iTarget )
2945			{
2946				a[i]--;
2947			}
2948		}
2949	
2950		if ( iTargetIndex != -1 && splice === undefined )
2951		{
2952			a.splice( iTargetIndex, 1 );
2953		}
2954	}
2955	
2956	
2957	/**
2958	 * Mark cached data as invalid such that a re-read of the data will occur when
2959	 * the cached data is next requested. Also update from the data source object.
2960	 *
2961	 * @param {object} settings DataTables settings object
2962	 * @param {int}    rowIdx   Row index to invalidate
2963	 * @param {string} [src]    Source to invalidate from: undefined, 'auto', 'dom'
2964	 *     or 'data'
2965	 * @param {int}    [colIdx] Column index to invalidate. If undefined the whole
2966	 *     row will be invalidated
2967	 * @memberof DataTable#oApi
2968	 *
2969	 * @todo For the modularisation of v1.11 this will need to become a callback, so
2970	 *   the sort and filter methods can subscribe to it. That will required
2971	 *   initialisation options for sorting, which is why it is not already baked in
2972	 */
2973	function _fnInvalidate( settings, rowIdx, src, colIdx )
2974	{
2975		var row = settings.aoData[ rowIdx ];
2976		var i, ien;
2977		var cellWrite = function ( cell, col ) {
2978			// This is very frustrating, but in IE if you just write directly
2979			// to innerHTML, and elements that are overwritten are GC'ed,
2980			// even if there is a reference to them elsewhere
2981			while ( cell.childNodes.length ) {
2982				cell.removeChild( cell.firstChild );
2983			}
2984	
2985			cell.innerHTML = _fnGetCellData( settings, rowIdx, col, 'display' );
2986		};
2987	
2988		// Are we reading last data from DOM or the data object?
2989		if ( src === 'dom' || ((! src || src === 'auto') && row.src === 'dom') ) {
2990			// Read the data from the DOM
2991			row._aData = _fnGetRowElements(
2992					settings, row, colIdx, colIdx === undefined ? undefined : row._aData
2993				)
2994				.data;
2995		}
2996		else {
2997			// Reading from data object, update the DOM
2998			var cells = row.anCells;
2999	
3000			if ( cells ) {
3001				if ( colIdx !== undefined ) {
3002					cellWrite( cells[colIdx], colIdx );
3003				}
3004				else {
3005					for ( i=0, ien=cells.length ; i<ien ; i++ ) {
3006						cellWrite( cells[i], i );
3007					}
3008				}
3009			}
3010		}
3011	
3012		// For both row and cell invalidation, the cached data for sorting and
3013		// filtering is nulled out
3014		row._aSortData = null;
3015		row._aFilterData = null;
3016	
3017		// Invalidate the type for a specific column (if given) or all columns since
3018		// the data might have changed
3019		var cols = settings.aoColumns;
3020		if ( colIdx !== undefined ) {
3021			cols[ colIdx ].sType = null;
3022		}
3023		else {
3024			for ( i=0, ien=cols.length ; i<ien ; i++ ) {
3025				cols[i].sType = null;
3026			}
3027	
3028			// Update DataTables special `DT_*` attributes for the row
3029			_fnRowAttributes( settings, row );
3030		}
3031	}
3032	
3033	
3034	/**
3035	 * Build a data source object from an HTML row, reading the contents of the
3036	 * cells that are in the row.
3037	 *
3038	 * @param {object} settings DataTables settings object
3039	 * @param {node|object} TR element from which to read data or existing row
3040	 *   object from which to re-read the data from the cells
3041	 * @param {int} [colIdx] Optional column index
3042	 * @param {array|object} [d] Data source object. If `colIdx` is given then this
3043	 *   parameter should also be given and will be used to write the data into.
3044	 *   Only the column in question will be written
3045	 * @returns {object} Object with two parameters: `data` the data read, in
3046	 *   document order, and `cells` and array of nodes (they can be useful to the
3047	 *   caller, so rather than needing a second traversal to get them, just return
3048	 *   them from here).
3049	 * @memberof DataTable#oApi
3050	 */
3051	function _fnGetRowElements( settings, row, colIdx, d )
3052	{
3053		var
3054			tds = [],
3055			td = row.firstChild,
3056			name, col, o, i=0, contents,
3057			columns = settings.aoColumns,
3058			objectRead = settings._rowReadObject;
3059	
3060		// Allow the data object to be passed in, or construct
3061		d = d !== undefined ?
3062			d :
3063			objectRead ?
3064				{} :
3065				[];
3066	
3067		var attr = function ( str, td  ) {
3068			if ( typeof str === 'string' ) {
3069				var idx = str.indexOf('@');
3070	
3071				if ( idx !== -1 ) {
3072					var attr = str.substring( idx+1 );
3073					var setter = _fnSetObjectDataFn( str );
3074					setter( d, td.getAttribute( attr ) );
3075				}
3076			}
3077		};
3078	
3079		// Read data from a cell and store into the data object
3080		var cellProcess = function ( cell ) {
3081			if ( colIdx === undefined || colIdx === i ) {
3082				col = columns[i];
3083				contents = (cell.innerHTML).trim();
3084	
3085				if ( col && col._bAttrSrc ) {
3086					var setter = _fnSetObjectDataFn( col.mData._ );
3087					setter( d, contents );
3088	
3089					attr( col.mData.sort, cell );
3090					attr( col.mData.type, cell );
3091					attr( col.mData.filter, cell );
3092				}
3093				else {
3094					// Depending on the `data` option for the columns the data can
3095					// be read to either an object or an array.
3096					if ( objectRead ) {
3097						if ( ! col._setter ) {
3098							// Cache the setter function
3099							col._setter = _fnSetObjectDataFn( col.mData );
3100						}
3101						col._setter( d, contents );
3102					}
3103					else {
3104						d[i] = contents;
3105					}
3106				}
3107			}
3108	
3109			i++;
3110		};
3111	
3112		if ( td ) {
3113			// `tr` element was passed in
3114			while ( td ) {
3115				name = td.nodeName.toUpperCase();
3116	
3117				if ( name == "TD" || name == "TH" ) {
3118					cellProcess( td );
3119					tds.push( td );
3120				}
3121	
3122				td = td.nextSibling;
3123			}
3124		}
3125		else {
3126			// Existing row object passed in
3127			tds = row.anCells;
3128	
3129			for ( var j=0, jen=tds.length ; j<jen ; j++ ) {
3130				cellProcess( tds[j] );
3131			}
3132		}
3133	
3134		// Read the ID from the DOM if present
3135		var rowNode = row.firstChild ? row : row.nTr;
3136	
3137		if ( rowNode ) {
3138			var id = rowNode.getAttribute( 'id' );
3139	
3140			if ( id ) {
3141				_fnSetObjectDataFn( settings.rowId )( d, id );
3142			}
3143		}
3144	
3145		return {
3146			data: d,
3147			cells: tds
3148		};
3149	}
3150	/**
3151	 * Create a new TR element (and it's TD children) for a row
3152	 *  @param {object} oSettings dataTables settings object
3153	 *  @param {int} iRow Row to consider
3154	 *  @param {node} [nTrIn] TR element to add to the table - optional. If not given,
3155	 *    DataTables will create a row automatically
3156	 *  @param {array} [anTds] Array of TD|TH elements for the row - must be given
3157	 *    if nTr is.
3158	 *  @memberof DataTable#oApi
3159	 */
3160	function _fnCreateTr ( oSettings, iRow, nTrIn, anTds )
3161	{
3162		var
3163			row = oSettings.aoData[iRow],
3164			rowData = row._aData,
3165			cells = [],
3166			nTr, nTd, oCol,
3167			i, iLen, create;
3168	
3169		if ( row.nTr === null )
3170		{
3171			nTr = nTrIn || document.createElement('tr');
3172	
3173			row.nTr = nTr;
3174			row.anCells = cells;
3175	
3176			/* Use a private property on the node to allow reserve mapping from the node
3177			 * to the aoData array for fast look up
3178			 */
3179			nTr._DT_RowIndex = iRow;
3180	
3181			/* Special parameters can be given by the data source to be used on the row */
3182			_fnRowAttributes( oSettings, row );
3183	
3184			/* Process each column */
3185			for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
3186			{
3187				oCol = oSettings.aoColumns[i];
3188				create = nTrIn ? false : true;
3189	
3190				nTd = create ? document.createElement( oCol.sCellType ) : anTds[i];
3191	
3192				if (! nTd) {
3193					_fnLog( oSettings, 0, 'Incorrect column count', 18 );
3194				}
3195	
3196				nTd._DT_CellIndex = {
3197					row: iRow,
3198					column: i
3199				};
3200				
3201				cells.push( nTd );
3202	
3203				// Need to create the HTML if new, or if a rendering function is defined
3204				if ( create || ((oCol.mRender || oCol.mData !== i) &&
3205					 (!$.isPlainObject(oCol.mData) || oCol.mData._ !== i+'.display')
3206				)) {
3207					nTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );
3208				}
3209	
3210				/* Add user defined class */
3211				if ( oCol.sClass )
3212				{
3213					nTd.className += ' '+oCol.sClass;
3214				}
3215	
3216				// Visibility - add or remove as required
3217				if ( oCol.bVisible && ! nTrIn )
3218				{
3219					nTr.appendChild( nTd );
3220				}
3221				else if ( ! oCol.bVisible && nTrIn )
3222				{
3223					nTd.parentNode.removeChild( nTd );
3224				}
3225	
3226				if ( oCol.fnCreatedCell )
3227				{
3228					oCol.fnCreatedCell.call( oSettings.oInstance,
3229						nTd, _fnGetCellData( oSettings, iRow, i ), rowData, iRow, i
3230					);
3231				}
3232			}
3233	
3234			_fnCallbackFire( oSettings, 'aoRowCreatedCallback', null, [nTr, rowData, iRow, cells] );
3235		}
3236	}
3237	
3238	
3239	/**
3240	 * Add attributes to a row based on the special `DT_*` parameters in a data
3241	 * source object.
3242	 *  @param {object} settings DataTables settings object
3243	 *  @param {object} DataTables row object for the row to be modified
3244	 *  @memberof DataTable#oApi
3245	 */
3246	function _fnRowAttributes( settings, row )
3247	{
3248		var tr = row.nTr;
3249		var data = row._aData;
3250	
3251		if ( tr ) {
3252			var id = settings.rowIdFn( data );
3253	
3254			if ( id ) {
3255				tr.id = id;
3256			}
3257	
3258			if ( data.DT_RowClass ) {
3259				// Remove any classes added by DT_RowClass before
3260				var a = data.DT_RowClass.split(' ');
3261				row.__rowc = row.__rowc ?
3262					_unique( row.__rowc.concat( a ) ) :
3263					a;
3264	
3265				$(tr)
3266					.removeClass( row.__rowc.join(' ') )
3267					.addClass( data.DT_RowClass );
3268			}
3269	
3270			if ( data.DT_RowAttr ) {
3271				$(tr).attr( data.DT_RowAttr );
3272			}
3273	
3274			if ( data.DT_RowData ) {
3275				$(tr).data( data.DT_RowData );
3276			}
3277		}
3278	}
3279	
3280	
3281	/**
3282	 * Create the HTML header for the table
3283	 *  @param {object} oSettings dataTables settings object
3284	 *  @memberof DataTable#oApi
3285	 */
3286	function _fnBuildHead( oSettings )
3287	{
3288		var i, ien, cell, row, column;
3289		var thead = oSettings.nTHead;
3290		var tfoot = oSettings.nTFoot;
3291		var createHeader = $('th, td', thead).length === 0;
3292		var classes = oSettings.oClasses;
3293		var columns = oSettings.aoColumns;
3294	
3295		if ( createHeader ) {
3296			row = $('<tr/>').appendTo( thead );
3297		}
3298	
3299		for ( i=0, ien=columns.length ; i<ien ; i++ ) {
3300			column = columns[i];
3301			cell = $( column.nTh ).addClass( column.sClass );
3302	
3303			if ( createHeader ) {
3304				cell.appendTo( row );
3305			}
3306	
3307			// 1.11 move into sorting
3308			if ( oSettings.oFeatures.bSort ) {
3309				cell.addClass( column.sSortingClass );
3310	
3311				if ( column.bSortable !== false ) {
3312					cell
3313						.attr( 'tabindex', oSettings.iTabIndex )
3314						.attr( 'aria-controls', oSettings.sTableId );
3315	
3316					_fnSortAttachListener( oSettings, column.nTh, i );
3317				}
3318			}
3319	
3320			if ( column.sTitle != cell[0].innerHTML ) {
3321				cell.html( column.sTitle );
3322			}
3323	
3324			_fnRenderer( oSettings, 'header' )(
3325				oSettings, cell, column, classes
3326			);
3327		}
3328	
3329		if ( createHeader ) {
3330			_fnDetectHeader( oSettings.aoHeader, thead );
3331		}
3332	
3333		/* Deal with the footer - add classes if required */
3334		$(thead).children('tr').children('th, td').addClass( classes.sHeaderTH );
3335		$(tfoot).children('tr').children('th, td').addClass( classes.sFooterTH );
3336	
3337		// Cache the footer cells. Note that we only take the cells from the first
3338		// row in the footer. If there is more than one row the user wants to
3339		// interact with, they need to use the table().foot() method. Note also this
3340		// allows cells to be used for multiple columns using colspan
3341		if ( tfoot !== null ) {
3342			var cells = oSettings.aoFooter[0];
3343	
3344			for ( i=0, ien=cells.length ; i<ien ; i++ ) {
3345				column = columns[i];
3346	
3347				if (column) {
3348					column.nTf = cells[i].cell;
3349		
3350					if ( column.sClass ) {
3351						$(column.nTf).addClass( column.sClass );
3352					}
3353				}
3354				else {
3355					_fnLog( oSettings, 0, 'Incorrect column count', 18 );
3356				}
3357			}
3358		}
3359	}
3360	
3361	
3362	/**
3363	 * Draw the header (or footer) element based on the column visibility states. The
3364	 * methodology here is to use the layout array from _fnDetectHeader, modified for
3365	 * the instantaneous column visibility, to construct the new layout. The grid is
3366	 * traversed over cell at a time in a rows x columns grid fashion, although each
3367	 * cell insert can cover multiple elements in the grid - which is tracks using the
3368	 * aApplied array. Cell inserts in the grid will only occur where there isn't
3369	 * already a cell in that position.
3370	 *  @param {object} oSettings dataTables settings object
3371	 *  @param array {objects} aoSource Layout array from _fnDetectHeader
3372	 *  @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,
3373	 *  @memberof DataTable#oApi
3374	 */
3375	function _fnDrawHead( oSettings, aoSource, bIncludeHidden )
3376	{
3377		var i, iLen, j, jLen, k, kLen, n, nLocalTr;
3378		var aoLocal = [];
3379		var aApplied = [];
3380		var iColumns = oSettings.aoColumns.length;
3381		var iRowspan, iColspan;
3382	
3383		if ( ! aoSource )
3384		{
3385			return;
3386		}
3387	
3388		if (  bIncludeHidden === undefined )
3389		{
3390			bIncludeHidden = false;
3391		}
3392	
3393		/* Make a copy of the master layout array, but without the visible columns in it */
3394		for ( i=0, iLen=aoSource.length ; i<iLen ; i++ )
3395		{
3396			aoLocal[i] = aoSource[i].slice();
3397			aoLocal[i].nTr = aoSource[i].nTr;
3398	
3399			/* Remove any columns which are currently hidden */
3400			for ( j=iColumns-1 ; j>=0 ; j-- )
3401			{
3402				if ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )
3403				{
3404					aoLocal[i].splice( j, 1 );
3405				}
3406			}
3407	
3408			/* Prep the applied array - it needs an element for each row */
3409			aApplied.push( [] );
3410		}
3411	
3412		for ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )
3413		{
3414			nLocalTr = aoLocal[i].nTr;
3415	
3416			/* All cells are going to be replaced, so empty out the row */
3417			if ( nLocalTr )
3418			{
3419				while( (n = nLocalTr.firstChild) )
3420				{
3421					nLocalTr.removeChild( n );
3422				}
3423			}
3424	
3425			for ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )
3426			{
3427				iRowspan = 1;
3428				iColspan = 1;
3429	
3430				/* Check to see if there is already a cell (row/colspan) covering our target
3431				 * insert point. If there is, then there is nothing to do.
3432				 */
3433				if ( aApplied[i][j] === undefined )
3434				{
3435					nLocalTr.appendChild( aoLocal[i][j].cell );
3436					aApplied[i][j] = 1;
3437	
3438					/* Expand the cell to cover as many rows as needed */
3439					while ( aoLocal[i+iRowspan] !== undefined &&
3440					        aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )
3441					{
3442						aApplied[i+iRowspan][j] = 1;
3443						iRowspan++;
3444					}
3445	
3446					/* Expand the cell to cover as many columns as needed */
3447					while ( aoLocal[i][j+iColspan] !== undefined &&
3448					        aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )
3449					{
3450						/* Must update the applied array over the rows for the columns */
3451						for ( k=0 ; k<iRowspan ; k++ )
3452						{
3453							aApplied[i+k][j+iColspan] = 1;
3454						}
3455						iColspan++;
3456					}
3457	
3458					/* Do the actual expansion in the DOM */
3459					$(aoLocal[i][j].cell)
3460						.attr('rowspan', iRowspan)
3461						.attr('colspan', iColspan);
3462				}
3463			}
3464		}
3465	}
3466	
3467	
3468	/**
3469	 * Insert the required TR nodes into the table for display
3470	 *  @param {object} oSettings dataTables settings object
3471	 *  @param ajaxComplete true after ajax call to complete rendering
3472	 *  @memberof DataTable#oApi
3473	 */
3474	function _fnDraw( oSettings, ajaxComplete )
3475	{
3476		// Allow for state saving and a custom start position
3477		_fnStart( oSettings );
3478	
3479		/* Provide a pre-callback function which can be used to cancel the draw is false is returned */
3480		var aPreDraw = _fnCallbackFire( oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings] );
3481		if ( $.inArray( false, aPreDraw ) !== -1 )
3482		{
3483			_fnProcessingDisplay( oSettings, false );
3484			return;
3485		}
3486	
3487		var anRows = [];
3488		var iRowCount = 0;
3489		var asStripeClasses = oSettings.asStripeClasses;
3490		var iStripes = asStripeClasses.length;
3491		var oLang = oSettings.oLanguage;
3492		var bServerSide = _fnDataSource( oSettings ) == 'ssp';
3493		var aiDisplay = oSettings.aiDisplay;
3494		var iDisplayStart = oSettings._iDisplayStart;
3495		var iDisplayEnd = oSettings.fnDisplayEnd();
3496	
3497		oSettings.bDrawing = true;
3498	
3499		/* Server-side processing draw intercept */
3500		if ( oSettings.bDeferLoading )
3501		{
3502			oSettings.bDeferLoading = false;
3503			oSettings.iDraw++;
3504			_fnProcessingDisplay( oSettings, false );
3505		}
3506		else if ( !bServerSide )
3507		{
3508			oSettings.iDraw++;
3509		}
3510		else if ( !oSettings.bDestroying && !ajaxComplete)
3511		{
3512			_fnAjaxUpdate( oSettings );
3513			return;
3514		}
3515	
3516		if ( aiDisplay.length !== 0 )
3517		{
3518			var iStart = bServerSide ? 0 : iDisplayStart;
3519			var iEnd = bServerSide ? oSettings.aoData.length : iDisplayEnd;
3520	
3521			for ( var j=iStart ; j<iEnd ; j++ )
3522			{
3523				var iDataIndex = aiDisplay[j];
3524				var aoData = oSettings.aoData[ iDataIndex ];
3525				if ( aoData.nTr === null )
3526				{
3527					_fnCreateTr( oSettings, iDataIndex );
3528				}
3529	
3530				var nRow = aoData.nTr;
3531	
3532				/* Remove the old striping classes and then add the new one */
3533				if ( iStripes !== 0 )
3534				{
3535					var sStripe = asStripeClasses[ iRowCount % iStripes ];
3536					if ( aoData._sRowStripe != sStripe )
3537					{
3538						$(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );
3539						aoData._sRowStripe = sStripe;
3540					}
3541				}
3542	
3543				// Row callback functions - might want to manipulate the row
3544				// iRowCount and j are not currently documented. Are they at all
3545				// useful?
3546				_fnCallbackFire( oSettings, 'aoRowCallback', null,
3547					[nRow, aoData._aData, iRowCount, j, iDataIndex] );
3548	
3549				anRows.push( nRow );
3550				iRowCount++;
3551			}
3552		}
3553		else
3554		{
3555			/* Table is empty - create a row with an empty message in it */
3556			var sZero = oLang.sZeroRecords;
3557			if ( oSettings.iDraw == 1 &&  _fnDataSource( oSettings ) == 'ajax' )
3558			{
3559				sZero = oLang.sLoadingRecords;
3560			}
3561			else if ( oLang.sEmptyTable && oSettings.fnRecordsTotal() === 0 )
3562			{
3563				sZero = oLang.sEmptyTable;
3564			}
3565	
3566			anRows[ 0 ] = $( '<tr/>', { 'class': iStripes ? asStripeClasses[0] : '' } )
3567				.append( $('<td />', {
3568					'valign':  'top',
3569					'colSpan': _fnVisbleColumns( oSettings ),
3570					'class':   oSettings.oClasses.sRowEmpty
3571				} ).html( sZero ) )[0];
3572		}
3573	
3574		/* Header and footer callbacks */
3575		_fnCallbackFire( oSettings, 'aoHeaderCallback', 'header', [ $(oSettings.nTHead).children('tr')[0],
3576			_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
3577	
3578		_fnCallbackFire( oSettings, 'aoFooterCallback', 'footer', [ $(oSettings.nTFoot).children('tr')[0],
3579			_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
3580	
3581		var body = $(oSettings.nTBody);
3582	
3583		body.children().detach();
3584		body.append( $(anRows) );
3585	
3586		/* Call all required callback functions for the end of a draw */
3587		_fnCallbackFire( oSettings, 'aoDrawCallback', 'draw', [oSettings] );
3588	
3589		/* Draw is complete, sorting and filtering must be as well */
3590		oSettings.bSorted = false;
3591		oSettings.bFiltered = false;
3592		oSettings.bDrawing = false;
3593	}
3594	
3595	
3596	/**
3597	 * Redraw the table - taking account of the various features which are enabled
3598	 *  @param {object} oSettings dataTables settings object
3599	 *  @param {boolean} [holdPosition] Keep the current paging position. By default
3600	 *    the paging is reset to the first page
3601	 *  @memberof DataTable#oApi
3602	 */
3603	function _fnReDraw( settings, holdPosition )
3604	{
3605		var
3606			features = settings.oFeatures,
3607			sort     = features.bSort,
3608			filter   = features.bFilter;
3609	
3610		if ( sort ) {
3611			_fnSort( settings );
3612		}
3613	
3614		if ( filter ) {
3615			_fnFilterComplete( settings, settings.oPreviousSearch );
3616		}
3617		else {
3618			// No filtering, so we want to just use the display master
3619			settings.aiDisplay = settings.aiDisplayMaster.slice();
3620		}
3621	
3622		if ( holdPosition !== true ) {
3623			settings._iDisplayStart = 0;
3624		}
3625	
3626		// Let any modules know about the draw hold position state (used by
3627		// scrolling internally)
3628		settings._drawHold = holdPosition;
3629	
3630		_fnDraw( settings );
3631	
3632		settings._drawHold = false;
3633	}
3634	
3635	
3636	/**
3637	 * Add the options to the page HTML for the table
3638	 *  @param {object} oSettings dataTables settings object
3639	 *  @memberof DataTable#oApi
3640	 */
3641	function _fnAddOptionsHtml ( oSettings )
3642	{
3643		var classes = oSettings.oClasses;
3644		var table = $(oSettings.nTable);
3645		var holding = $('<div/>').insertBefore( table ); // Holding element for speed
3646		var features = oSettings.oFeatures;
3647	
3648		// All DataTables are wrapped in a div
3649		var insert = $('<div/>', {
3650			id:      oSettings.sTableId+'_wrapper',
3651			'class': classes.sWrapper + (oSettings.nTFoot ? '' : ' '+classes.sNoFooter)
3652		} );
3653	
3654		oSettings.nHolding = holding[0];
3655		oSettings.nTableWrapper = insert[0];
3656		oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;
3657	
3658		/* Loop over the user set positioning and place the elements as needed */
3659		var aDom = oSettings.sDom.split('');
3660		var featureNode, cOption, nNewNode, cNext, sAttr, j;
3661		for ( var i=0 ; i<aDom.length ; i++ )
3662		{
3663			featureNode = null;
3664			cOption = aDom[i];
3665	
3666			if ( cOption == '<' )
3667			{
3668				/* New container div */
3669				nNewNode = $('<div/>')[0];
3670	
3671				/* Check to see if we should append an id and/or a class name to the container */
3672				cNext = aDom[i+1];
3673				if ( cNext == "'" || cNext == '"' )
3674				{
3675					sAttr = "";
3676					j = 2;
3677					while ( aDom[i+j] != cNext )
3678					{
3679						sAttr += aDom[i+j];
3680						j++;
3681					}
3682	
3683					/* Replace jQuery UI constants @todo depreciated */
3684					if ( sAttr == "H" )
3685					{
3686						sAttr = classes.sJUIHeader;
3687					}
3688					else if ( sAttr == "F" )
3689					{
3690						sAttr = classes.sJUIFooter;
3691					}
3692	
3693					/* The attribute can be in the format of "#id.class", "#id" or "class" This logic
3694					 * breaks the string into parts and applies them as needed
3695					 */
3696					if ( sAttr.indexOf('.') != -1 )
3697					{
3698						var aSplit = sAttr.split('.');
3699						nNewNode.id = aSplit[0].substr(1, aSplit[0].length-1);
3700						nNewNode.className = aSplit[1];
3701					}
3702					else if ( sAttr.charAt(0) == "#" )
3703					{
3704						nNewNode.id = sAttr.substr(1, sAttr.length-1);
3705					}
3706					else
3707					{
3708						nNewNode.className = sAttr;
3709					}
3710	
3711					i += j; /* Move along the position array */
3712				}
3713	
3714				insert.append( nNewNode );
3715				insert = $(nNewNode);
3716			}
3717			else if ( cOption == '>' )
3718			{
3719				/* End container div */
3720				insert = insert.parent();
3721			}
3722			// @todo Move options into their own plugins?
3723			else if ( cOption == 'l' && features.bPaginate && features.bLengthChange )
3724			{
3725				/* Length */
3726				featureNode = _fnFeatureHtmlLength( oSettings );
3727			}
3728			else if ( cOption == 'f' && features.bFilter )
3729			{
3730				/* Filter */
3731				featureNode = _fnFeatureHtmlFilter( oSettings );
3732			}
3733			else if ( cOption == 'r' && features.bProcessing )
3734			{
3735				/* pRocessing */
3736				featureNode = _fnFeatureHtmlProcessing( oSettings );
3737			}
3738			else if ( cOption == 't' )
3739			{
3740				/* Table */
3741				featureNode = _fnFeatureHtmlTable( oSettings );
3742			}
3743			else if ( cOption ==  'i' && features.bInfo )
3744			{
3745				/* Info */
3746				featureNode = _fnFeatureHtmlInfo( oSettings );
3747			}
3748			else if ( cOption == 'p' && features.bPaginate )
3749			{
3750				/* Pagination */
3751				featureNode = _fnFeatureHtmlPaginate( oSettings );
3752			}
3753			else if ( DataTable.ext.feature.length !== 0 )
3754			{
3755				/* Plug-in features */
3756				var aoFeatures = DataTable.ext.feature;
3757				for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )
3758				{
3759					if ( cOption == aoFeatures[k].cFeature )
3760					{
3761						featureNode = aoFeatures[k].fnInit( oSettings );
3762						break;
3763					}
3764				}
3765			}
3766	
3767			/* Add to the 2D features array */
3768			if ( featureNode )
3769			{
3770				var aanFeatures = oSettings.aanFeatures;
3771	
3772				if ( ! aanFeatures[cOption] )
3773				{
3774					aanFeatures[cOption] = [];
3775				}
3776	
3777				aanFeatures[cOption].push( featureNode );
3778				insert.append( featureNode );
3779			}
3780		}
3781	
3782		/* Built our DOM structure - replace the holding div with what we want */
3783		holding.replaceWith( insert );
3784		oSettings.nHolding = null;
3785	}
3786	
3787	
3788	/**
3789	 * Use the DOM source to create up an array of header cells. The idea here is to
3790	 * create a layout grid (array) of rows x columns, which contains a reference
3791	 * to the cell that that point in the grid (regardless of col/rowspan), such that
3792	 * any column / row could be removed and the new grid constructed
3793	 *  @param array {object} aLayout Array to store the calculated layout in
3794	 *  @param {node} nThead The header/footer element for the table
3795	 *  @memberof DataTable#oApi
3796	 */
3797	function _fnDetectHeader ( aLayout, nThead )
3798	{
3799		var nTrs = $(nThead).children('tr');
3800		var nTr, nCell;
3801		var i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;
3802		var bUnique;
3803		var fnShiftCol = function ( a, i, j ) {
3804			var k = a[i];
3805	                while ( k[j] ) {
3806				j++;
3807			}
3808			return j;
3809		};
3810	
3811		aLayout.splice( 0, aLayout.length );
3812	
3813		/* We know how many rows there are in the layout - so prep it */
3814		for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
3815		{
3816			aLayout.push( [] );
3817		}
3818	
3819		/* Calculate a layout array */
3820		for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
3821		{
3822			nTr = nTrs[i];
3823			iColumn = 0;
3824	
3825			/* For every cell in the row... */
3826			nCell = nTr.firstChild;
3827			while ( nCell ) {
3828				if ( nCell.nodeName.toUpperCase() == "TD" ||
3829				     nCell.nodeName.toUpperCase() == "TH" )
3830				{
3831					/* Get the col and rowspan attributes from the DOM and sanitise them */
3832					iColspan = nCell.getAttribute('colspan') * 1;
3833					iRowspan = nCell.getAttribute('rowspan') * 1;
3834					iColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;
3835					iRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;
3836	
3837					/* There might be colspan cells already in this row, so shift our target
3838					 * accordingly
3839					 */
3840					iColShifted = fnShiftCol( aLayout, i, iColumn );
3841	
3842					/* Cache calculation for unique columns */
3843					bUnique = iColspan === 1 ? true : false;
3844	
3845					/* If there is col / rowspan, copy the information into the layout grid */
3846					for ( l=0 ; l<iColspan ; l++ )
3847					{
3848						for ( k=0 ; k<iRowspan ; k++ )
3849						{
3850							aLayout[i+k][iColShifted+l] = {
3851								"cell": nCell,
3852								"unique": bUnique
3853							};
3854							aLayout[i+k].nTr = nTr;
3855						}
3856					}
3857				}
3858				nCell = nCell.nextSibling;
3859			}
3860		}
3861	}
3862	
3863	
3864	/**
3865	 * Get an array of unique th elements, one for each column
3866	 *  @param {object} oSettings dataTables settings object
3867	 *  @param {node} nHeader automatically detect the layout from this node - optional
3868	 *  @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional
3869	 *  @returns array {node} aReturn list of unique th's
3870	 *  @memberof DataTable#oApi
3871	 */
3872	function _fnGetUniqueThs ( oSettings, nHeader, aLayout )
3873	{
3874		var aReturn = [];
3875		if ( !aLayout )
3876		{
3877			aLayout = oSettings.aoHeader;
3878			if ( nHeader )
3879			{
3880				aLayout = [];
3881				_fnDetectHeader( aLayout, nHeader );
3882			}
3883		}
3884	
3885		for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )
3886		{
3887			for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )
3888			{
3889				if ( aLayout[i][j].unique &&
3890					 (!aReturn[j] || !oSettings.bSortCellsTop) )
3891				{
3892					aReturn[j] = aLayout[i][j].cell;
3893				}
3894			}
3895		}
3896	
3897		return aReturn;
3898	}
3899	
3900	/**
3901	 * Set the start position for draw
3902	 *  @param {object} oSettings dataTables settings object
3903	 */
3904	function _fnStart( oSettings )
3905	{
3906		var bServerSide = _fnDataSource( oSettings ) == 'ssp';
3907		var iInitDisplayStart = oSettings.iInitDisplayStart;
3908	
3909		// Check and see if we have an initial draw position from state saving
3910		if ( iInitDisplayStart !== undefined && iInitDisplayStart !== -1 )
3911		{
3912			oSettings._iDisplayStart = bServerSide ?
3913				iInitDisplayStart :
3914				iInitDisplayStart >= oSettings.fnRecordsDisplay() ?
3915					0 :
3916					iInitDisplayStart;
3917	
3918			oSettings.iInitDisplayStart = -1;
3919		}
3920	}
3921	
3922	/**
3923	 * Create an Ajax call based on the table's settings, taking into account that
3924	 * parameters can have multiple forms, and backwards compatibility.
3925	 *
3926	 * @param {object} oSettings dataTables settings object
3927	 * @param {array} data Data to send to the server, required by
3928	 *     DataTables - may be augmented by developer callbacks
3929	 * @param {function} fn Callback function to run when data is obtained
3930	 */
3931	function _fnBuildAjax( oSettings, data, fn )
3932	{
3933		// Compatibility with 1.9-, allow fnServerData and event to manipulate
3934		_fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [data] );
3935	
3936		// Convert to object based for 1.10+ if using the old array scheme which can
3937		// come from server-side processing or serverParams
3938		if ( data && Array.isArray(data) ) {
3939			var tmp = {};
3940			var rbracket = /(.*?)\[\]$/;
3941	
3942			$.each( data, function (key, val) {
3943				var match = val.name.match(rbracket);
3944	
3945				if ( match ) {
3946					// Support for arrays
3947					var name = match[0];
3948	
3949					if ( ! tmp[ name ] ) {
3950						tmp[ name ] = [];
3951					}
3952					tmp[ name ].push( val.value );
3953				}
3954				else {
3955					tmp[val.name] = val.value;
3956				}
3957			} );
3958			data = tmp;
3959		}
3960	
3961		var ajaxData;
3962		var ajax = oSettings.ajax;
3963		var instance = oSettings.oInstance;
3964		var callback = function ( json ) {
3965			var status = oSettings.jqXHR
3966				? oSettings.jqXHR.status
3967				: null;
3968	
3969			if ( json === null || (typeof status === 'number' && status == 204 ) ) {
3970				json = {};
3971				_fnAjaxDataSrc( oSettings, json, [] );
3972			}
3973	
3974			var error = json.error || json.sError;
3975			if ( error ) {
3976				_fnLog( oSettings, 0, error );
3977			}
3978	
3979			oSettings.json = json;
3980	
3981			_fnCallbackFire( oSettings, null, 'xhr', [oSettings, json, oSettings.jqXHR] );
3982			fn( json );
3983		};
3984	
3985		if ( $.isPlainObject( ajax ) && ajax.data )
3986		{
3987			ajaxData = ajax.data;
3988	
3989			var newData = typeof ajaxData === 'function' ?
3990				ajaxData( data, oSettings ) :  // fn can manipulate data or return
3991				ajaxData;                      // an object object or array to merge
3992	
3993			// If the function returned something, use that alone
3994			data = typeof ajaxData === 'function' && newData ?
3995				newData :
3996				$.extend( true, data, newData );
3997	
3998			// Remove the data property as we've resolved it already and don't want
3999			// jQuery to do it again (it is restored at the end of the function)
4000			delete ajax.data;
4001		}
4002	
4003		var baseAjax = {
4004			"data": data,
4005			"success": callback,
4006			"dataType": "json",
4007			"cache": false,
4008			"type": oSettings.sServerMethod,
4009			"error": function (xhr, error, thrown) {
4010				var ret = _fnCallbackFire( oSettings, null, 'xhr', [oSettings, null, oSettings.jqXHR] );
4011	
4012				if ( $.inArray( true, ret ) === -1 ) {
4013					if ( error == "parsererror" ) {
4014						_fnLog( oSettings, 0, 'Invalid JSON response', 1 );
4015					}
4016					else if ( xhr.readyState === 4 ) {
4017						_fnLog( oSettings, 0, 'Ajax error', 7 );
4018					}
4019				}
4020	
4021				_fnProcessingDisplay( oSettings, false );
4022			}
4023		};
4024	
4025		// Store the data submitted for the API
4026		oSettings.oAjaxData = data;
4027	
4028		// Allow plug-ins and external processes to modify the data
4029		_fnCallbackFire( oSettings, null, 'preXhr', [oSettings, data] );
4030	
4031		if ( oSettings.fnServerData )
4032		{
4033			// DataTables 1.9- compatibility
4034			oSettings.fnServerData.call( instance,
4035				oSettings.sAjaxSource,
4036				$.map( data, function (val, key) { // Need to convert back to 1.9 trad format
4037					return { name: key, value: val };
4038				} ),
4039				callback,
4040				oSettings
4041			);
4042		}
4043		else if ( oSettings.sAjaxSource || typeof ajax === 'string' )
4044		{
4045			// DataTables 1.9- compatibility
4046			oSettings.jqXHR = $.ajax( $.extend( baseAjax, {
4047				url: ajax || oSettings.sAjaxSource
4048			} ) );
4049		}
4050		else if ( typeof ajax === 'function' )
4051		{
4052			// Is a function - let the caller define what needs to be done
4053			oSettings.jqXHR = ajax.call( instance, data, callback, oSettings );
4054		}
4055		else
4056		{
4057			// Object to extend the base settings
4058			oSettings.jqXHR = $.ajax( $.extend( baseAjax, ajax ) );
4059	
4060			// Restore for next time around
4061			ajax.data = ajaxData;
4062		}
4063	}
4064	
4065	
4066	/**
4067	 * Update the table using an Ajax call
4068	 *  @param {object} settings dataTables settings object
4069	 *  @returns {boolean} Block the table drawing or not
4070	 *  @memberof DataTable#oApi
4071	 */
4072	function _fnAjaxUpdate( settings )
4073	{
4074		settings.iDraw++;
4075		_fnProcessingDisplay( settings, true );
4076	
4077		// Keep track of drawHold state to handle scrolling after the Ajax call
4078		var drawHold = settings._drawHold;
4079	
4080		_fnBuildAjax(
4081			settings,
4082			_fnAjaxParameters( settings ),
4083			function(json) {
4084				settings._drawHold = drawHold;
4085				_fnAjaxUpdateDraw( settings, json );
4086				settings._drawHold = false;
4087			}
4088		);
4089	}
4090	
4091	
4092	/**
4093	 * Build up the parameters in an object needed for a server-side processing
4094	 * request. Note that this is basically done twice, is different ways - a modern
4095	 * method which is used by default in DataTables 1.10 which uses objects and
4096	 * arrays, or the 1.9- method with is name / value pairs. 1.9 method is used if
4097	 * the sAjaxSource option is used in the initialisation, or the legacyAjax
4098	 * option is set.
4099	 *  @param {object} oSettings dataTables settings object
4100	 *  @returns {bool} block the table drawing or not
4101	 *  @memberof DataTable#oApi
4102	 */
4103	function _fnAjaxParameters( settings )
4104	{
4105		var
4106			columns = settings.aoColumns,
4107			columnCount = columns.length,
4108			features = settings.oFeatures,
4109			preSearch = settings.oPreviousSearch,
4110			preColSearch = settings.aoPreSearchCols,
4111			i, data = [], dataProp, column, columnSearch,
4112			sort = _fnSortFlatten( settings ),
4113			displayStart = settings._iDisplayStart,
4114			displayLength = features.bPaginate !== false ?
4115				settings._iDisplayLength :
4116				-1;
4117	
4118		var param = function ( name, value ) {
4119			data.push( { 'name': name, 'value': value } );
4120		};
4121	
4122		// DataTables 1.9- compatible method
4123		param( 'sEcho',          settings.iDraw );
4124		param( 'iColumns',       columnCount );
4125		param( 'sColumns',       _pluck( columns, 'sName' ).join(',') );
4126		param( 'iDisplayStart',  displayStart );
4127		param( 'iDisplayLength', displayLength );
4128	
4129		// DataTables 1.10+ method
4130		var d = {
4131			draw:    settings.iDraw,
4132			columns: [],
4133			order:   [],
4134			start:   displayStart,
4135			length:  displayLength,
4136			search:  {
4137				value: preSearch.sSearch,
4138				regex: preSearch.bRegex
4139			}
4140		};
4141	
4142		for ( i=0 ; i<columnCount ; i++ ) {
4143			column = columns[i];
4144			columnSearch = preColSearch[i];
4145			dataProp = typeof column.mData=="function" ? 'function' : column.mData ;
4146	
4147			d.columns.push( {
4148				data:       dataProp,
4149				name:       column.sName,
4150				searchable: column.bSearchable,
4151				orderable:  column.bSortable,
4152				search:     {
4153					value: columnSearch.sSearch,
4154					regex: columnSearch.bRegex
4155				}
4156			} );
4157	
4158			param( "mDataProp_"+i, dataProp );
4159	
4160			if ( features.bFilter ) {
4161				param( 'sSearch_'+i,     columnSearch.sSearch );
4162				param( 'bRegex_'+i,      columnSearch.bRegex );
4163				param( 'bSearchable_'+i, column.bSearchable );
4164			}
4165	
4166			if ( features.bSort ) {
4167				param( 'bSortable_'+i, column.bSortable );
4168			}
4169		}
4170	
4171		if ( features.bFilter ) {
4172			param( 'sSearch', preSearch.sSearch );
4173			param( 'bRegex', preSearch.bRegex );
4174		}
4175	
4176		if ( features.bSort ) {
4177			$.each( sort, function ( i, val ) {
4178				d.order.push( { column: val.col, dir: val.dir } );
4179	
4180				param( 'iSortCol_'+i, val.col );
4181				param( 'sSortDir_'+i, val.dir );
4182			} );
4183	
4184			param( 'iSortingCols', sort.length );
4185		}
4186	
4187		// If the legacy.ajax parameter is null, then we automatically decide which
4188		// form to use, based on sAjaxSource
4189		var legacy = DataTable.ext.legacy.ajax;
4190		if ( legacy === null ) {
4191			return settings.sAjaxSource ? data : d;
4192		}
4193	
4194		// Otherwise, if legacy has been specified then we use that to decide on the
4195		// form
4196		return legacy ? data : d;
4197	}
4198	
4199	
4200	/**
4201	 * Data the data from the server (nuking the old) and redraw the table
4202	 *  @param {object} oSettings dataTables settings object
4203	 *  @param {object} json json data return from the server.
4204	 *  @param {string} json.sEcho Tracking flag for DataTables to match requests
4205	 *  @param {int} json.iTotalRecords Number of records in the data set, not accounting for filtering
4206	 *  @param {int} json.iTotalDisplayRecords Number of records in the data set, accounting for filtering
4207	 *  @param {array} json.aaData The data to display on this page
4208	 *  @param {string} [json.sColumns] Column ordering (sName, comma separated)
4209	 *  @memberof DataTable#oApi
4210	 */
4211	function _fnAjaxUpdateDraw ( settings, json )
4212	{
4213		// v1.10 uses camelCase variables, while 1.9 uses Hungarian notation.
4214		// Support both
4215		var compat = function ( old, modern ) {
4216			return json[old] !== undefined ? json[old] : json[modern];
4217		};
4218	
4219		var data = _fnAjaxDataSrc( settings, json );
4220		var draw            = compat( 'sEcho',                'draw' );
4221		var recordsTotal    = compat( 'iTotalRecords',        'recordsTotal' );
4222		var recordsFiltered = compat( 'iTotalDisplayRecords', 'recordsFiltered' );
4223	
4224		if ( draw !== undefined ) {
4225			// Protect against out of sequence returns
4226			if ( draw*1 < settings.iDraw ) {
4227				return;
4228			}
4229			settings.iDraw = draw * 1;
4230		}
4231	
4232		// No data in returned object, so rather than an array, we show an empty table
4233		if ( ! data ) {
4234			data = [];
4235		}
4236	
4237		_fnClearTable( settings );
4238		settings._iRecordsTotal   = parseInt(recordsTotal, 10);
4239		settings._iRecordsDisplay = parseInt(recordsFiltered, 10);
4240	
4241		for ( var i=0, ien=data.length ; i<ien ; i++ ) {
4242			_fnAddData( settings, data[i] );
4243		}
4244		settings.aiDisplay = settings.aiDisplayMaster.slice();
4245	
4246		_fnDraw( settings, true );
4247	
4248		if ( ! settings._bInitComplete ) {
4249			_fnInitComplete( settings, json );
4250		}
4251	
4252		_fnProcessingDisplay( settings, false );
4253	}
4254	
4255	
4256	/**
4257	 * Get the data from the JSON data source to use for drawing a table. Using
4258	 * `_fnGetObjectDataFn` allows the data to be sourced from a property of the
4259	 * source object, or from a processing function.
4260	 *  @param {object} oSettings dataTables settings object
4261	 *  @param  {object} json Data source object / array from the server
4262	 *  @return {array} Array of data to use
4263	 */
4264	 function _fnAjaxDataSrc ( oSettings, json, write )
4265	 {
4266		var dataSrc = $.isPlainObject( oSettings.ajax ) && oSettings.ajax.dataSrc !== undefined ?
4267			oSettings.ajax.dataSrc :
4268			oSettings.sAjaxDataProp; // Compatibility with 1.9-.
4269	
4270		if ( ! write ) {
4271			if ( dataSrc === 'data' ) {
4272				// If the default, then we still want to support the old style, and safely ignore
4273				// it if possible
4274				return json.aaData || json[dataSrc];
4275			}
4276	
4277			return dataSrc !== "" ?
4278				_fnGetObjectDataFn( dataSrc )( json ) :
4279				json;
4280		}
4281	
4282		// set
4283		_fnSetObjectDataFn( dataSrc )( json, write );
4284	}
4285	
4286	/**
4287	 * Generate the node required for filtering text
4288	 *  @returns {node} Filter control element
4289	 *  @param {object} oSettings dataTables settings object
4290	 *  @memberof DataTable#oApi
4291	 */
4292	function _fnFeatureHtmlFilter ( settings )
4293	{
4294		var classes = settings.oClasses;
4295		var tableId = settings.sTableId;
4296		var language = settings.oLanguage;
4297		var previousSearch = settings.oPreviousSearch;
4298		var features = settings.aanFeatures;
4299		var input = '<input type="search" class="'+classes.sFilterInput+'"/>';
4300	
4301		var str = language.sSearch;
4302		str = str.match(/_INPUT_/) ?
4303			str.replace('_INPUT_', input) :
4304			str+input;
4305	
4306		var filter = $('<div/>', {
4307				'id': ! features.f ? tableId+'_filter' : null,
4308				'class': classes.sFilter
4309			} )
4310			.append( $('<label/>' ).append( str ) );
4311	
4312		var searchFn = function(event) {
4313			/* Update all other filter input elements for the new display */
4314			var n = features.f;
4315			var val = !this.value ? "" : this.value; // mental IE8 fix :-(
4316			if(previousSearch