https://noltrix.com/lib/dataTables/datatables.js?v=ycNxJOP5J1px6nQ4yu9iWNo8X50CNLorNUpzt_EAgIA

1/*
2 * This combined file was created by the DataTables downloader builder:
3 *   https://datatables.net/download
4 *
5 * To rebuild or modify this file with the latest versions of the included
6 * software please visit:
7 *   https://datatables.net/download/#dt/dt-1.13.4/af-2.5.3/b-2.3.6/b-colvis-2.3.6/b-html5-2.3.6/b-print-2.3.6/cr-1.6.2/fc-4.2.2/fh-3.3.2/kt-2.9.0/r-2.4.1/rg-1.3.1/rr-1.3.3/sc-2.1.1/sb-1.4.2/sp-2.1.2/sl-1.6.2/sr-1.2.2
8 *
9 * Included libraries:
10 *   DataTables 1.13.4, AutoFill 2.5.3, Buttons 2.3.6, Column visibility 2.3.6, HTML5 export 2.3.6, Print view 2.3.6, ColReorder 1.6.2, FixedColumns 4.2.2, FixedHeader 3.3.2, KeyTable 2.9.0, Responsive 2.4.1, RowGroup 1.3.1, RowReorder 1.3.3, Scroller 2.1.1, SearchBuilder 1.4.2, SearchPanes 2.1.2, Select 1.6.2, StateRestore 1.2.2
11 */
12
13/*! DataTables 1.13.4
14 * ©2008-2023 SpryMedia Ltd - datatables.net/license
15 */
16
17/**
18 * @summary     DataTables
19 * @description Paginate, search and order HTML tables
20 * @version     1.13.4
21 * @author      SpryMedia Ltd
22 * @contact     www.datatables.net
23 * @copyright   SpryMedia Ltd.
24 *
25 * This source file is free software, available under the following license:
26 *   MIT license - http://datatables.net/license
27 *
28 * This source file is distributed in the hope that it will be useful, but
29 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
30 * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
31 *
32 * For details please refer to: http://www.datatables.net
33 */
34
35/*jslint evil: true, undef: true, browser: true */
36/*globals $,require,jQuery,define,_selector_run,_selector_opts,_selector_first,_selector_row_indexes,_ext,_Api,_api_register,_api_registerPlural,_re_new_lines,_re_html,_re_formatted_numeric,_re_escape_regex,_empty,_intVal,_numToDecimal,_isNumber,_isHtml,_htmlNumeric,_pluck,_pluck_order,_range,_stripHtml,_unique,_fnBuildAjax,_fnAjaxUpdate,_fnAjaxParameters,_fnAjaxUpdateDraw,_fnAjaxDataSrc,_fnAddColumn,_fnColumnOptions,_fnAdjustColumnSizing,_fnVisibleToColumnIndex,_fnColumnIndexToVisible,_fnVisbleColumns,_fnGetColumns,_fnColumnTypes,_fnApplyColumnDefs,_fnHungarianMap,_fnCamelToHungarian,_fnLanguageCompat,_fnBrowserDetect,_fnAddData,_fnAddTr,_fnNodeToDataIndex,_fnNodeToColumnIndex,_fnGetCellData,_fnSetCellData,_fnSplitObjNotation,_fnGetObjectDataFn,_fnSetObjectDataFn,_fnGetDataMaster,_fnClearTable,_fnDeleteIndex,_fnInvalidate,_fnGetRowElements,_fnCreateTr,_fnBuildHead,_fnDrawHead,_fnDraw,_fnReDraw,_fnAddOptionsHtml,_fnDetectHeader,_fnGetUniqueThs,_fnFeatureHtmlFilter,_fnFilterComplete,_fnFilterCustom,_fnFilterColumn,_fnFilter,_fnFilterCreateSearch,_fnEscapeRegex,_fnFilterData,_fnFeatureHtmlInfo,_fnUpdateInfo,_fnInfoMacros,_fnInitialise,_fnInitComplete,_fnLengthChange,_fnFeatureHtmlLength,_fnFeatureHtmlPaginate,_fnPageChange,_fnFeatureHtmlProcessing,_fnProcessingDisplay,_fnFeatureHtmlTable,_fnScrollDraw,_fnApplyToChildren,_fnCalculateColumnWidths,_fnThrottle,_fnConvertToWidth,_fnGetWidestNode,_fnGetMaxLenString,_fnStringToCss,_fnSortFlatten,_fnSort,_fnSortAria,_fnSortListener,_fnSortAttachListener,_fnSortingClasses,_fnSortData,_fnSaveState,_fnLoadState,_fnSettingsFromNode,_fnLog,_fnMap,_fnBindAction,_fnCallbackReg,_fnCallbackFire,_fnLengthOverflow,_fnRenderer,_fnDataSource,_fnRowAttributes*/
37
38(function( factory ) {
39	"use strict";
40
41	if ( typeof define === 'function' && define.amd ) {
42		// AMD
43		define( ['jquery'], function ( $ ) {
44			return factory( $, window, document );
45		} );
46	}
47	else if ( typeof exports === 'object' ) {
48		// CommonJS
49		// jQuery's factory checks for a global window - if it isn't present then it
50		// returns a factory function that expects the window object
51		var jq = require('jquery');
52
53		if (typeof window !== 'undefined') {
54			module.exports = function (root, $) {
55				if ( ! root ) {
56					// CommonJS environments without a window global must pass a
57					// root. This will give an error otherwise
58					root = window;
59				}
60
61				if ( ! $ ) {
62					$ = jq( root );
63				}
64
65				return factory( $, root, root.document );
66			};
67		}
68		else {
69			return factory( jq, window, window.document );
70		}
71	}
72	else {
73		// Browser
74		window.DataTable = factory( jQuery, window, document );
75	}
76}
77(function( $, window, document, undefined ) {
78	"use strict";
79
80	
81	var DataTable = function ( selector, options )
82	{
83		// Check if called with a window or jQuery object for DOM less applications
84		// This is for backwards compatibility
85		if (DataTable.factory(selector, options)) {
86			return DataTable;
87		}
88	
89		// When creating with `new`, create a new DataTable, returning the API instance
90		if (this instanceof DataTable) {
91			return $(selector).DataTable(options);
92		}
93		else {
94			// Argument switching
95			options = selector;
96		}
97	
98		/**
99		 * Perform a jQuery selector action on the table's TR elements (from the tbody) and
100		 * return the resulting jQuery object.
101		 *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on
102		 *  @param {object} [oOpts] Optional parameters for modifying the rows to be included
103		 *  @param {string} [oOpts.filter=none] Select TR elements that meet the current filter
104		 *    criterion ("applied") or all TR elements (i.e. no filter).
105		 *  @param {string} [oOpts.order=current] Order of the TR elements in the processed array.
106		 *    Can be either 'current', whereby the current sorting of the table is used, or
107		 *    'original' whereby the original order the data was read into the table is used.
108		 *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page
109		 *    ("current") or not ("all"). If 'current' is given, then order is assumed to be
110		 *    'current' and filter is 'applied', regardless of what they might be given as.
111		 *  @returns {object} jQuery object, filtered by the given selector.
112		 *  @dtopt API
113		 *  @deprecated Since v1.10
114		 *
115		 *  @example
116		 *    $(document).ready(function() {
117		 *      var oTable = $('#example').dataTable();
118		 *
119		 *      // Highlight every second row
120		 *      oTable.$('tr:odd').css('backgroundColor', 'blue');
121		 *    } );
122		 *
123		 *  @example
124		 *    $(document).ready(function() {
125		 *      var oTable = $('#example').dataTable();
126		 *
127		 *      // Filter to rows with 'Webkit' in them, add a background colour and then
128		 *      // remove the filter, thus highlighting the 'Webkit' rows only.
129		 *      oTable.fnFilter('Webkit');
130		 *      oTable.$('tr', {"search": "applied"}).css('backgroundColor', 'blue');
131		 *      oTable.fnFilter('');
132		 *    } );
133		 */
134		this.$ = function ( sSelector, oOpts )
135		{
136			return this.api(true).$( sSelector, oOpts );
137		};
138		
139		
140		/**
141		 * Almost identical to $ in operation, but in this case returns the data for the matched

272		 * parent element changes (for example a window resize).
273		 *  @param {boolean} [bRedraw=true] Redraw the table or not, you will typically want to
274		 *  @dtopt API
275		 *  @deprecated Since v1.10
276		 *
277		 *  @example
278		 *    $(document).ready(function() {
279		 *      var oTable = $('#example').dataTable( {
280		 *        "sScrollY": "200px",
281		 *        "bPaginate": false
282		 *      } );
283		 *
284		 *      $(window).on('resize', function () {
285		 *        oTable.fnAdjustColumnSizing();
286		 *      } );
287		 *    } );
288		 */
289		this.fnAdjustColumnSizing = function ( bRedraw )
290		{
291			var api = this.api( true ).columns.adjust();
292			var settings = api.settings()[0];
293			var scroll = settings.oScroll;
294		
295			if ( bRedraw === undefined || bRedraw ) {
296				api.draw( false );
297			}
298			else if ( scroll.sX !== "" || scroll.sY !== "" ) {
299				/* If not redrawing, but scrolling, we want to apply the new column sizes anyway */
300				_fnScrollDraw( settings );
301			}
302		};
303		
304		
305		/**
306		 * Quickly and simply clear a table
307		 *  @param {bool} [bRedraw=true] redraw the table or not
308		 *  @dtopt API
309		 *  @deprecated Since v1.10
310		 *
311		 *  @example
312		 *    $(document).ready(function() {
313		 *      var oTable = $('#example').dataTable();
314		 *
315		 *      // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...)
316		 *      oTable.fnClearTable();
317		 *    } );
318		 */
319		this.fnClearTable = function( bRedraw )
320		{
321			var api = this.api( true ).clear();
322		
323			if ( bRedraw === undefined || bRedraw ) {
324				api.draw();
325			}
326		};
327		
328		
329		/**
330		 * The exact opposite of 'opening' a row, this function will close any rows which
331		 * are currently 'open'.
332		 *  @param {node} nTr the table row to 'close'
333		 *  @returns {int} 0 on success, or 1 if failed (can't find the row)
334		 *  @dtopt API
335		 *  @deprecated Since v1.10
336		 *
337		 *  @example
338		 *    $(document).ready(function() {
339		 *      var oTable;
340		 *
341		 *      // 'open' an information row when a row is clicked on
342		 *      $('#example tbody tr').click( function () {
343		 *        if ( oTable.fnIsOpen(this) ) {
344		 *          oTable.fnClose( this );
345		 *        } else {
346		 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );
347		 *        }
348		 *      } );
349		 *
350		 *      oTable = $('#example').dataTable();
351		 *    } );
352		 */
353		this.fnClose = function( nTr )
354		{
355			this.api( true ).row( nTr ).child.hide();
356		};
357		
358		
359		/**
360		 * Remove a row for the table
361		 *  @param {mixed} target The index of the row from aoData to be deleted, or
362		 *    the TR element you want to delete
363		 *  @param {function|null} [callBack] Callback function
364		 *  @param {bool} [redraw=true] Redraw the table or not
365		 *  @returns {array} The row that was deleted
366		 *  @dtopt API
367		 *  @deprecated Since v1.10
368		 *
369		 *  @example
370		 *    $(document).ready(function() {
371		 *      var oTable = $('#example').dataTable();
372		 *
373		 *      // Immediately remove the first row
374		 *      oTable.fnDeleteRow( 0 );
375		 *    } );
376		 */
377		this.fnDeleteRow = function( target, callback, redraw )
378		{
379			var api = this.api( true );
380			var rows = api.rows( target );
381			var settings = rows.settings()[0];
382			var data = settings.aoData[ rows[0][0] ];
383		
384			rows.remove();
385		
386			if ( callback ) {
387				callback.call( this, settings, data );
388			}
389		
390			if ( redraw === undefined || redraw ) {
391				api.draw();
392			}
393		
394			return data;
395		};
396		
397		
398		/**
399		 * Restore the table to it's original state in the DOM by removing all of DataTables
400		 * enhancements, alterations to the DOM structure of the table and event listeners.
401		 *  @param {boolean} [remove=false] Completely remove the table from the DOM
402		 *  @dtopt API
403		 *  @deprecated Since v1.10
404		 *
405		 *  @example
406		 *    $(document).ready(function() {
407		 *      // This example is fairly pointless in reality, but shows how fnDestroy can be used
408		 *      var oTable = $('#example').dataTable();
409		 *      oTable.fnDestroy();
410		 *    } );
411		 */
412		this.fnDestroy = function ( remove )
413		{
414			this.api( true ).destroy( remove );
415		};
416		
417		
418		/**
419		 * Redraw the table
420		 *  @param {bool} [complete=true] Re-filter and resort (if enabled) the table before the draw.
421		 *  @dtopt API
422		 *  @deprecated Since v1.10
423		 *
424		 *  @example
425		 *    $(document).ready(function() {
426		 *      var oTable = $('#example').dataTable();
427		 *
428		 *      // Re-draw the table - you wouldn't want to do it here, but it's an example :-)
429		 *      oTable.fnDraw();
430		 *    } );
431		 */
432		this.fnDraw = function( complete )
433		{
434			// Note that this isn't an exact match to the old call to _fnDraw - it takes
435			// into account the new data, but can hold position.
436			this.api( true ).draw( complete );
437		};
438		
439		
440		/**
441		 * Filter the input based on data
442		 *  @param {string} sInput String to filter the table on
443		 *  @param {int|null} [iColumn] Column to limit filtering to
444		 *  @param {bool} [bRegex=false] Treat as regular expression or not
445		 *  @param {bool} [bSmart=true] Perform smart filtering or not
446		 *  @param {bool} [bShowGlobal=true] Show the input global filter in it's input box(es)
447		 *  @param {bool} [bCaseInsensitive=true] Do case-insensitive matching (true) or not (false)
448		 *  @dtopt API
449		 *  @deprecated Since v1.10
450		 *
451		 *  @example
452		 *    $(document).ready(function() {
453		 *      var oTable = $('#example').dataTable();
454		 *
455		 *      // Sometime later - filter...
456		 *      oTable.fnFilter( 'test string' );
457		 *    } );
458		 */
459		this.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive )
460		{
461			var api = this.api( true );
462		
463			if ( iColumn === null || iColumn === undefined ) {
464				api.search( sInput, bRegex, bSmart, bCaseInsensitive );
465			}
466			else {
467				api.column( iColumn ).search( sInput, bRegex, bSmart, bCaseInsensitive );
468			}
469		
470			api.draw();
471		};
472		
473		
474		/**
475		 * Get the data for the whole table, an individual row or an individual cell based on the
476		 * provided parameters.
477		 *  @param {int|node} [src] A TR row node, TD/TH cell node or an integer. If given as
478		 *    a TR node then the data source for the whole row will be returned. If given as a
479		 *    TD/TH cell node then iCol will be automatically calculated and the data for the
480		 *    cell returned. If given as an integer, then this is treated as the aoData internal
481		 *    data index for the row (see fnGetPosition) and the data for that row used.
482		 *  @param {int} [col] Optional column index that you want the data of.
483		 *  @returns {array|object|string} If mRow is undefined, then the data for all rows is
484		 *    returned. If mRow is defined, just data for that row, and is iCol is
485		 *    defined, only data for the designated cell is returned.
486		 *  @dtopt API
487		 *  @deprecated Since v1.10
488		 *
489		 *  @example
490		 *    // Row data
491		 *    $(document).ready(function() {
492		 *      oTable = $('#example').dataTable();
493		 *
494		 *      oTable.$('tr').click( function () {
495		 *        var data = oTable.fnGetData( this );
496		 *        // ... do something with the array / object of data for the row
497		 *      } );
498		 *    } );
499		 *
500		 *  @example
501		 *    // Individual cell data
502		 *    $(document).ready(function() {
503		 *      oTable = $('#example').dataTable();
504		 *
505		 *      oTable.$('td').click( function () {
506		 *        var sData = oTable.fnGetData( this );
507		 *        alert( 'The cell clicked on had the value of '+sData );
508		 *      } );
509		 *    } );
510		 */
511		this.fnGetData = function( src, col )
512		{
513			var api = this.api( true );
514		
515			if ( src !== undefined ) {
516				var type = src.nodeName ? src.nodeName.toLowerCase() : '';
517		
518				return col !== undefined || type == 'td' || type == 'th' ?
519					api.cell( src, col ).data() :
520					api.row( src ).data() || null;
521			}
522		
523			return api.data().toArray();
524		};
525		
526		
527		/**
528		 * Get an array of the TR nodes that are used in the table's body. Note that you will
529		 * typically want to use the '$' API method in preference to this as it is more
530		 * flexible.
531		 *  @param {int} [iRow] Optional row index for the TR element you want
532		 *  @returns {array|node} If iRow is undefined, returns an array of all TR elements
533		 *    in the table's body, or iRow is defined, just the TR element requested.
534		 *  @dtopt API
535		 *  @deprecated Since v1.10
536		 *
537		 *  @example
538		 *    $(document).ready(function() {
539		 *      var oTable = $('#example').dataTable();
540		 *
541		 *      // Get the nodes from the table
542		 *      var nNodes = oTable.fnGetNodes( );
543		 *    } );
544		 */
545		this.fnGetNodes = function( iRow )
546		{
547			var api = this.api( true );
548		
549			return iRow !== undefined ?
550				api.row( iRow ).node() :
551				api.rows().nodes().flatten().toArray();
552		};
553		
554		
555		/**
556		 * Get the array indexes of a particular cell from it's DOM element
557		 * and column index including hidden columns
558		 *  @param {node} node this can either be a TR, TD or TH in the table's body
559		 *  @returns {int} If nNode is given as a TR, then a single index is returned, or
560		 *    if given as a cell, an array of [row index, column index (visible),
561		 *    column index (all)] is given.
562		 *  @dtopt API
563		 *  @deprecated Since v1.10
564		 *
565		 *  @example
566		 *    $(document).ready(function() {
567		 *      $('#example tbody td').click( function () {
568		 *        // Get the position of the current data from the node
569		 *        var aPos = oTable.fnGetPosition( this );
570		 *
571		 *        // Get the data array for this row
572		 *        var aData = oTable.fnGetData( aPos[0] );
573		 *
574		 *        // Update the data array and return the value
575		 *        aData[ aPos[1] ] = 'clicked';
576		 *        this.innerHTML = 'clicked';
577		 *      } );
578		 *
579		 *      // Init DataTables
580		 *      oTable = $('#example').dataTable();
581		 *    } );
582		 */
583		this.fnGetPosition = function( node )
584		{
585			var api = this.api( true );
586			var nodeName = node.nodeName.toUpperCase();
587		
588			if ( nodeName == 'TR' ) {
589				return api.row( node ).index();
590			}
591			else if ( nodeName == 'TD' || nodeName == 'TH' ) {
592				var cell = api.cell( node ).index();
593		
594				return [
595					cell.row,
596					cell.columnVisible,
597					cell.column
598				];
599			}
600			return null;
601		};
602		
603		
604		/**
605		 * Check to see if a row is 'open' or not.
606		 *  @param {node} nTr the table row to check
607		 *  @returns {boolean} true if the row is currently open, false otherwise
608		 *  @dtopt API
609		 *  @deprecated Since v1.10
610		 *
611		 *  @example
612		 *    $(document).ready(function() {
613		 *      var oTable;
614		 *
615		 *      // 'open' an information row when a row is clicked on
616		 *      $('#example tbody tr').click( function () {
617		 *        if ( oTable.fnIsOpen(this) ) {
618		 *          oTable.fnClose( this );
619		 *        } else {
620		 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );
621		 *        }
622		 *      } );
623		 *
624		 *      oTable = $('#example').dataTable();
625		 *    } );
626		 */
627		this.fnIsOpen = function( nTr )
628		{
629			return this.api( true ).row( nTr ).child.isShown();
630		};
631		
632		
633		/**
634		 * This function will place a new row directly after a row which is currently
635		 * on display on the page, with the HTML contents that is passed into the
636		 * function. This can be used, for example, to ask for confirmation that a
637		 * particular record should be deleted.
638		 *  @param {node} nTr The table row to 'open'
639		 *  @param {string|node|jQuery} mHtml The HTML to put into the row
640		 *  @param {string} sClass Class to give the new TD cell
641		 *  @returns {node} The row opened. Note that if the table row passed in as the
642		 *    first parameter, is not found in the table, this method will silently
643		 *    return.
644		 *  @dtopt API
645		 *  @deprecated Since v1.10
646		 *
647		 *  @example
648		 *    $(document).ready(function() {
649		 *      var oTable;
650		 *
651		 *      // 'open' an information row when a row is clicked on
652		 *      $('#example tbody tr').click( function () {
653		 *        if ( oTable.fnIsOpen(this) ) {
654		 *          oTable.fnClose( this );
655		 *        } else {
656		 *          oTable.fnOpen( this, "Temporary row opened", "info_row" );
657		 *        }
658		 *      } );
659		 *
660		 *      oTable = $('#example').dataTable();
661		 *    } );
662		 */
663		this.fnOpen = function( nTr, mHtml, sClass )
664		{
665			return this.api( true )
666				.row( nTr )
667				.child( mHtml, sClass )
668				.show()
669				.child()[0];
670		};
671		
672		
673		/**
674		 * Change the pagination - provides the internal logic for pagination in a simple API
675		 * function. With this function you can have a DataTables table go to the next,
676		 * previous, first or last pages.
677		 *  @param {string|int} mAction Paging action to take: "first", "previous", "next" or "last"
678		 *    or page number to jump to (integer), note that page 0 is the first page.
679		 *  @param {bool} [bRedraw=true] Redraw the table or not
680		 *  @dtopt API
681		 *  @deprecated Since v1.10
682		 *
683		 *  @example
684		 *    $(document).ready(function() {
685		 *      var oTable = $('#example').dataTable();
686		 *      oTable.fnPageChange( 'next' );
687		 *    } );
688		 */
689		this.fnPageChange = function ( mAction, bRedraw )
690		{
691			var api = this.api( true ).page( mAction );
692		
693			if ( bRedraw === undefined || bRedraw ) {
694				api.draw(false);
695			}
696		};
697		
698		
699		/**
700		 * Show a particular column
701		 *  @param {int} iCol The column whose display should be changed
702		 *  @param {bool} bShow Show (true) or hide (false) the column
703		 *  @param {bool} [bRedraw=true] Redraw the table or not
704		 *  @dtopt API
705		 *  @deprecated Since v1.10
706		 *
707		 *  @example
708		 *    $(document).ready(function() {
709		 *      var oTable = $('#example').dataTable();
710		 *
711		 *      // Hide the second column after initialisation
712		 *      oTable.fnSetColumnVis( 1, false );
713		 *    } );
714		 */
715		this.fnSetColumnVis = function ( iCol, bShow, bRedraw )
716		{
717			var api = this.api( true ).column( iCol ).visible( bShow );
718		
719			if ( bRedraw === undefined || bRedraw ) {
720				api.columns.adjust().draw();
721			}
722		};
723		
724		
725		/**
726		 * Get the settings for a particular table for external manipulation
727		 *  @returns {object} DataTables settings object. See
728		 *    {@link DataTable.models.oSettings}
729		 *  @dtopt API
730		 *  @deprecated Since v1.10
731		 *
732		 *  @example
733		 *    $(document).ready(function() {
734		 *      var oTable = $('#example').dataTable();
735		 *      var oSettings = oTable.fnSettings();
736		 *
737		 *      // Show an example parameter from the settings
738		 *      alert( oSettings._iDisplayStart );
739		 *    } );
740		 */
741		this.fnSettings = function()
742		{
743			return _fnSettingsFromNode( this[_ext.iApiIndex] );
744		};
745		
746		
747		/**
748		 * Sort the table by a particular column
749		 *  @param {int} iCol the data index to sort on. Note that this will not match the
750		 *    'display index' if you have hidden data entries
751		 *  @dtopt API
752		 *  @deprecated Since v1.10
753		 *
754		 *  @example
755		 *    $(document).ready(function() {
756		 *      var oTable = $('#example').dataTable();
757		 *
758		 *      // Sort immediately with columns 0 and 1
759		 *      oTable.fnSort( [ [0,'asc'], [1,'asc'] ] );
760		 *    } );
761		 */
762		this.fnSort = function( aaSort )
763		{
764			this.api( true ).order( aaSort ).draw();
765		};
766		
767		
768		/**
769		 * Attach a sort listener to an element for a given column
770		 *  @param {node} nNode the element to attach the sort listener to
771		 *  @param {int} iColumn the column that a click on this node will sort on
772		 *  @param {function} [fnCallback] callback function when sort is run
773		 *  @dtopt API
774		 *  @deprecated Since v1.10
775		 *
776		 *  @example
777		 *    $(document).ready(function() {
778		 *      var oTable = $('#example').dataTable();
779		 *
780		 *      // Sort on column 1, when 'sorter' is clicked on
781		 *      oTable.fnSortListener( document.getElementById('sorter'), 1 );
782		 *    } );
783		 */
784		this.fnSortListener = function( nNode, iColumn, fnCallback )
785		{
786			this.api( true ).order.listener( nNode, iColumn, fnCallback );
787		};
788		
789		
790		/**
791		 * Update a table cell or row - this method will accept either a single value to
792		 * update the cell with, an array of values with one element for each column or
793		 * an object in the same format as the original data source. The function is
794		 * self-referencing in order to make the multi column updates easier.
795		 *  @param {object|array|string} mData Data to update the cell/row with
796		 *  @param {node|int} mRow TR element you want to update or the aoData index
797		 *  @param {int} [iColumn] The column to update, give as null or undefined to
798		 *    update a whole row.
799		 *  @param {bool} [bRedraw=true] Redraw the table or not
800		 *  @param {bool} [bAction=true] Perform pre-draw actions or not
801		 *  @returns {int} 0 on success, 1 on error
802		 *  @dtopt API
803		 *  @deprecated Since v1.10
804		 *
805		 *  @example
806		 *    $(document).ready(function() {
807		 *      var oTable = $('#example').dataTable();
808		 *      oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell
809		 *      oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], $('tbody tr')[0] ); // Row
810		 *    } );
811		 */
812		this.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )
813		{
814			var api = this.api( true );
815		
816			if ( iColumn === undefined || iColumn === null ) {
817				api.row( mRow ).data( mData );
818			}
819			else {
820				api.cell( mRow, iColumn ).data( mData );
821			}
822		
823			if ( bAction === undefined || bAction ) {
824				api.columns.adjust();
825			}
826		
827			if ( bRedraw === undefined || bRedraw ) {
828				api.draw();
829			}
830			return 0;
831		};
832		
833		
834		/**
835		 * Provide a common method for plug-ins to check the version of DataTables being used, in order
836		 * to ensure compatibility.
837		 *  @param {string} sVersion Version string to check for, in the format "X.Y.Z". Note that the
838		 *    formats "X" and "X.Y" are also acceptable.
839		 *  @returns {boolean} true if this version of DataTables is greater or equal to the required
840		 *    version, or false if this version of DataTales is not suitable
841		 *  @method
842		 *  @dtopt API
843		 *  @deprecated Since v1.10
844		 *
845		 *  @example
846		 *    $(document).ready(function() {
847		 *      var oTable = $('#example').dataTable();
848		 *      alert( oTable.fnVersionCheck( '1.9.0' ) );
849		 *    } );
850		 */
851		this.fnVersionCheck = _ext.fnVersionCheck;
852		
853	
854		var _that = this;
855		var emptyInit = options === undefined;
856		var len = this.length;
857	
858		if ( emptyInit ) {
859			options = {};
860		}
861	
862		this.oApi = this.internal = _ext.internal;
863	
864		// Extend with old style plug-in API methods
865		for ( var fn in DataTable.ext.internal ) {
866			if ( fn ) {
867				this[fn] = _fnExternApiFunc(fn);
868			}
869		}
870	
871		this.each(function() {
872			// For each initialisation we want to give it a clean initialisation
873			// object that can be bashed around
874			var o = {};
875			var oInit = len > 1 ? // optimisation for single table case
876				_fnExtend( o, options, true ) :
877				options;
878	
879			/*global oInit,_that,emptyInit*/
880			var i=0, iLen, j, jLen, k, kLen;
881			var sId = this.getAttribute( 'id' );
882			var bInitHandedOff = false;
883			var defaults = DataTable.defaults;
884			var $this = $(this);
885			
886			
887			/* Sanity check */
888			if ( this.nodeName.toLowerCase() != 'table' )
889			{
890				_fnLog( null, 0, 'Non-table node initialisation ('+this.nodeName+')', 2 );
891				return;
892			}
893			
894			/* Backwards compatibility for the defaults */
895			_fnCompatOpts( defaults );
896			_fnCompatCols( defaults.column );
897			
898			/* Convert the camel-case defaults to Hungarian */
899			_fnCamelToHungarian( defaults, defaults, true );
900			_fnCamelToHungarian( defaults.column, defaults.column, true );
901			
902			/* Setting up the initialisation object */
903			_fnCamelToHungarian( defaults, $.extend( oInit, $this.data() ), true );
904			
905			
906			
907			/* Check to see if we are re-initialising a table */
908			var allSettings = DataTable.settings;
909			for ( i=0, iLen=allSettings.length ; i<iLen ; i++ )
910			{
911				var s = allSettings[i];
912			
913				/* Base check on table node */
914				if (
915					s.nTable == this ||
916					(s.nTHead && s.nTHead.parentNode == this) ||
917					(s.nTFoot && s.nTFoot.parentNode == this)
918				) {
919					var bRetrieve = oInit.bRetrieve !== undefined ? oInit.bRetrieve : defaults.bRetrieve;
920					var bDestroy = oInit.bDestroy !== undefined ? oInit.bDestroy : defaults.bDestroy;
921			
922					if ( emptyInit || bRetrieve )
923					{
924						return s.oInstance;
925					}
926					else if ( bDestroy )
927					{
928						s.oInstance.fnDestroy();
929						break;
930					}
931					else
932					{
933						_fnLog( s, 0, 'Cannot reinitialise DataTable', 3 );
934						return;
935					}
936				}
937			
938				/* If the element we are initialising has the same ID as a table which was previously
939				 * initialised, but the table nodes don't match (from before) then we destroy the old
940				 * instance by simply deleting it. This is under the assumption that the table has been
941				 * destroyed by other methods. Anyone using non-id selectors will need to do this manually
942				 */
943				if ( s.sTableId == this.id )
944				{
945					allSettings.splice( i, 1 );
946					break;
947				}
948			}
949			
950			/* Ensure the table has an ID - required for accessibility */
951			if ( sId === null || sId === "" )
952			{
953				sId = "DataTables_Table_"+(DataTable.ext._unique++);
954				this.id = sId;
955			}
956			
957			/* Create the settings object for this table and set some of the default parameters */
958			var oSettings = $.extend( true, {}, DataTable.models.oSettings, {
959				"sDestroyWidth": $this[0].style.width,
960				"sInstance":     sId,
961				"sTableId":      sId
962			} );
963			oSettings.nTable = this;
964			oSettings.oApi   = _that.internal;
965			oSettings.oInit  = oInit;
966			
967			allSettings.push( oSettings );
968			
969			// Need to add the instance after the instance after the settings object has been added
970			// to the settings array, so we can self reference the table instance if more than one
971			oSettings.oInstance = (_that.length===1) ? _that : $this.dataTable();
972			
973			// Backwards compatibility, before we apply all the defaults
974			_fnCompatOpts( oInit );
975			_fnLanguageCompat( oInit.oLanguage );
976			
977			// If the length menu is given, but the init display length is not, use the length menu
978			if ( oInit.aLengthMenu && ! oInit.iDisplayLength )
979			{
980				oInit.iDisplayLength = Array.isArray( oInit.aLengthMenu[0] ) ?
981					oInit.aLengthMenu[0][0] : oInit.aLengthMenu[0];
982			}
983			
984			// Apply the defaults and init options to make a single init object will all
985			// options defined from defaults and instance options.
986			oInit = _fnExtend( $.extend( true, {}, defaults ), oInit );
987			
988			
989			// Map the initialisation options onto the settings object
990			_fnMap( oSettings.oFeatures, oInit, [
991				"bPaginate",
992				"bLengthChange",
993				"bFilter",
994				"bSort",
995				"bSortMulti",
996				"bInfo",
997				"bProcessing",
998				"bAutoWidth",
999				"bSortClasses",
1000				"bServerSide",
1001				"bDeferRender"
1002			] );
1003			_fnMap( oSettings, oInit, [
1004				"asStripeClasses",
1005				"ajax",
1006				"fnServerData",
1007				"fnFormatNumber",
1008				"sServerMethod",
1009				"aaSorting",
1010				"aaSortingFixed",
1011				"aLengthMenu",
1012				"sPaginationType",
1013				"sAjaxSource",
1014				"sAjaxDataProp",
1015				"iStateDuration",
1016				"sDom",
1017				"bSortCellsTop",
1018				"iTabIndex",
1019				"fnStateLoadCallback",
1020				"fnStateSaveCallback",
1021				"renderer",
1022				"searchDelay",
1023				"rowId",
1024				[ "iCookieDuration", "iStateDuration" ], // backwards compat
1025				[ "oSearch", "oPreviousSearch" ],
1026				[ "aoSearchCols", "aoPreSearchCols" ],
1027				[ "iDisplayLength", "_iDisplayLength" ]
1028			] );
1029			_fnMap( oSettings.oScroll, oInit, [
1030				[ "sScrollX", "sX" ],
1031				[ "sScrollXInner", "sXInner" ],
1032				[ "sScrollY", "sY" ],
1033				[ "bScrollCollapse", "bCollapse" ]
1034			] );
1035			_fnMap( oSettings.oLanguage, oInit, "fnInfoCallback" );
1036			
1037			/* Callback functions which are array driven */
1038			_fnCallbackReg( oSettings, 'aoDrawCallback',       oInit.fnDrawCallback,      'user' );
1039			_fnCallbackReg( oSettings, 'aoServerParams',       oInit.fnServerParams,      'user' );
1040			_fnCallbackReg( oSettings, 'aoStateSaveParams',    oInit.fnStateSaveParams,   'user' );
1041			_fnCallbackReg( oSettings, 'aoStateLoadParams',    oInit.fnStateLoadParams,   'user' );
1042			_fnCallbackReg( oSettings, 'aoStateLoaded',        oInit.fnStateLoaded,       'user' );
1043			_fnCallbackReg( oSettings, 'aoRowCallback',        oInit.fnRowCallback,       'user' );
1044			_fnCallbackReg( oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow,        'user' );
1045			_fnCallbackReg( oSettings, 'aoHeaderCallback',     oInit.fnHeaderCallback,    'user' );
1046			_fnCallbackReg( oSettings, 'aoFooterCallback',     oInit.fnFooterCallback,    'user' );
1047			_fnCallbackReg( oSettings, 'aoInitComplete',       oInit.fnInitComplete,      'user' );
1048			_fnCallbackReg( oSettings, 'aoPreDrawCallback',    oInit.fnPreDrawCallback,   'user' );
1049			
1050			oSettings.rowIdFn = _fnGetObjectDataFn( oInit.rowId );
1051			
1052			/* Browser support detection */
1053			_fnBrowserDetect( oSettings );
1054			
1055			var oClasses = oSettings.oClasses;
1056			
1057			$.extend( oClasses, DataTable.ext.classes, oInit.oClasses );
1058			$this.addClass( oClasses.sTable );
1059			
1060			
1061			if ( oSettings.iInitDisplayStart === undefined )
1062			{
1063				/* Display start point, taking into account the save saving */
1064				oSettings.iInitDisplayStart = oInit.iDisplayStart;
1065				oSettings._iDisplayStart = oInit.iDisplayStart;
1066			}
1067			
1068			if ( oInit.iDeferLoading !== null )
1069			{
1070				oSettings.bDeferLoading = true;
1071				var tmp = Array.isArray( oInit.iDeferLoading );
1072				oSettings._iRecordsDisplay = tmp ? oInit.iDeferLoading[0] : oInit.iDeferLoading;
1073				oSettings._iRecordsTotal = tmp ? oInit.iDeferLoading[1] : oInit.iDeferLoading;
1074			}
1075			
1076			/* Language definitions */
1077			var oLanguage = oSettings.oLanguage;
1078			$.extend( true, oLanguage, oInit.oLanguage );
1079			
1080			if ( oLanguage.sUrl )
1081			{
1082				/* Get the language definitions from a file - because this Ajax call makes the language
1083				 * get async to the remainder of this function we use bInitHandedOff to indicate that
1084				 * _fnInitialise will be fired by the returned Ajax handler, rather than the constructor
1085				 */
1086				$.ajax( {
1087					dataType: 'json',
1088					url: oLanguage.sUrl,
1089					success: function ( json ) {
1090						_fnCamelToHungarian( defaults.oLanguage, json );
1091						_fnLanguageCompat( json );
1092						$.extend( true, oLanguage, json, oSettings.oInit.oLanguage );
1093			
1094						_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);
1095						_fnInitialise( oSettings );
1096					},
1097					error: function () {
1098						// Error occurred loading language file, continue on as best we can
1099						_fnInitialise( oSettings );
1100					}
1101				} );
1102				bInitHandedOff = true;
1103			}
1104			else {
1105				_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);
1106			}
1107			
1108			/*
1109			 * Stripes
1110			 */
1111			if ( oInit.asStripeClasses === null )
1112			{
1113				oSettings.asStripeClasses =[
1114					oClasses.sStripeOdd,
1115					oClasses.sStripeEven
1116				];
1117			}
1118			
1119			/* Remove row stripe classes if they are already on the table row */
1120			var stripeClasses = oSettings.asStripeClasses;
1121			var rowOne = $this.children('tbody').find('tr').eq(0);
1122			if ( $.inArray( true, $.map( stripeClasses, function(el, i) {
1123				return rowOne.hasClass(el);
1124			} ) ) !== -1 ) {
1125				$('tbody tr', this).removeClass( stripeClasses.join(' ') );
1126				oSettings.asDestroyStripes = stripeClasses.slice();
1127			}
1128			
1129			/*
1130			 * Columns
1131			 * See if we should load columns automatically or use defined ones
1132			 */
1133			var anThs = [];
1134			var aoColumnsInit;
1135			var nThead = this.getElementsByTagName('thead');
1136			if ( nThead.length !== 0 )
1137			{
1138				_fnDetectHeader( oSettings.aoHeader, nThead[0] );
1139				anThs = _fnGetUniqueThs( oSettings );
1140			}
1141			
1142			/* If not given a column array, generate one with nulls */
1143			if ( oInit.aoColumns === null )
1144			{
1145				aoColumnsInit = [];
1146				for ( i=0, iLen=anThs.length ; i<iLen ; i++ )
1147				{
1148					aoColumnsInit.push( null );
1149				}
1150			}
1151			else
1152			{
1153				aoColumnsInit = oInit.aoColumns;
1154			}
1155			
1156			/* Add the columns */
1157			for ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )
1158			{
1159				_fnAddColumn( oSettings, anThs ? anThs[i] : null );
1160			}
1161			
1162			/* Apply the column definitions */
1163			_fnApplyColumnDefs( oSettings, oInit.aoColumnDefs, aoColumnsInit, function (iCol, oDef) {
1164				_fnColumnOptions( oSettings, iCol, oDef );
1165			} );
1166			
1167			/* HTML5 attribute detection - build an mData object automatically if the
1168			 * attributes are found
1169			 */
1170			if ( rowOne.length ) {
1171				var a = function ( cell, name ) {
1172					return cell.getAttribute( 'data-'+name ) !== null ? name : null;
1173				};
1174			
1175				$( rowOne[0] ).children('th, td').each( function (i, cell) {
1176					var col = oSettings.aoColumns[i];
1177			
1178					if (! col) {
1179						_fnLog( oSettings, 0, 'Incorrect column count', 18 );
1180					}
1181			
1182					if ( col.mData === i ) {
1183						var sort = a( cell, 'sort' ) || a( cell, 'order' );
1184						var filter = a( cell, 'filter' ) || a( cell, 'search' );
1185			
1186						if ( sort !== null || filter !== null ) {
1187							col.mData = {
1188								_:      i+'.display',
1189								sort:   sort !== null   ? i+'.@data-'+sort   : undefined,
1190								type:   sort !== null   ? i+'.@data-'+sort   : undefined,
1191								filter: filter !== null ? i+'.@data-'+filter : undefined
1192							};
1193							col._isArrayHost = true;
1194			
1195							_fnColumnOptions( oSettings, i );
1196						}
1197					}
1198				} );
1199			}
1200			
1201			var features = oSettings.oFeatures;
1202			var loadedInit = function () {
1203				/*
1204				 * Sorting
1205				 * @todo For modularisation (1.11) this needs to do into a sort start up handler
1206				 */
1207			
1208				// If aaSorting is not defined, then we use the first indicator in asSorting
1209				// in case that has been altered, so the default sort reflects that option
1210				if ( oInit.aaSorting === undefined ) {
1211					var sorting = oSettings.aaSorting;
1212					for ( i=0, iLen=sorting.length ; i<iLen ; i++ ) {
1213						sorting[i][1] = oSettings.aoColumns[ i ].asSorting[0];
1214					}
1215				}
1216			
1217				/* Do a first pass on the sorting classes (allows any size changes to be taken into
1218				 * account, and also will apply sorting disabled classes if disabled
1219				 */
1220				_fnSortingClasses( oSettings );
1221			
1222				if ( features.bSort ) {
1223					_fnCallbackReg( oSettings, 'aoDrawCallback', function () {
1224						if ( oSettings.bSorted ) {
1225							var aSort = _fnSortFlatten( oSettings );
1226							var sortedColumns = {};
1227			
1228							$.each( aSort, function (i, val) {
1229								sortedColumns[ val.src ] = val.dir;
1230							} );
1231			
1232							_fnCallbackFire( oSettings, null, 'order', [oSettings, aSort, sortedColumns] );
1233							_fnSortAria( oSettings );
1234						}
1235					} );
1236				}
1237			
1238				_fnCallbackReg( oSettings, 'aoDrawCallback', function () {
1239					if ( oSettings.bSorted || _fnDataSource( oSettings ) === 'ssp' || features.bDeferRender ) {
1240						_fnSortingClasses( oSettings );
1241					}
1242				}, 'sc' );
1243			
1244			
1245				/*
1246				 * Final init
1247				 * Cache the header, body and footer as required, creating them if needed
1248				 */
1249			
1250				// Work around for Webkit bug 83867 - store the caption-side before removing from doc
1251				var captions = $this.children('caption').each( function () {
1252					this._captionSide = $(this).css('caption-side');
1253				} );
1254			
1255				var thead = $this.children('thead');
1256				if ( thead.length === 0 ) {
1257					thead = $('<thead/>').appendTo($this);
1258				}
1259				oSettings.nTHead = thead[0];
1260			
1261				var tbody = $this.children('tbody');
1262				if ( tbody.length === 0 ) {
1263					tbody = $('<tbody/>').insertAfter(thead);
1264				}
1265				oSettings.nTBody = tbody[0];
1266			
1267				var tfoot = $this.children('tfoot');
1268				if ( tfoot.length === 0 && captions.length > 0 && (oSettings.oScroll.sX !== "" || oSettings.oScroll.sY !== "") ) {
1269					// If we are a scrolling table, and no footer has been given, then we need to create
1270					// a tfoot element for the caption element to be appended to
1271					tfoot = $('<tfoot/>').appendTo($this);
1272				}
1273			
1274				if ( tfoot.length === 0 || tfoot.children().length === 0 ) {
1275					$this.addClass( oClasses.sNoFooter );
1276				}
1277				else if ( tfoot.length > 0 ) {
1278					oSettings.nTFoot = tfoot[0];
1279					_fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot );
1280				}
1281			
1282				/* Check if there is data passing into the constructor */
1283				if ( oInit.aaData ) {
1284					for ( i=0 ; i<oInit.aaData.length ; i++ ) {
1285						_fnAddData( oSettings, oInit.aaData[ i ] );
1286					}
1287				}
1288				else if ( oSettings.bDeferLoading || _fnDataSource( oSettings ) == 'dom' ) {
1289					/* Grab the data from the page - only do this when deferred loading or no Ajax
1290					 * source since there is no point in reading the DOM data if we are then going
1291					 * to replace it with Ajax data
1292					 */
1293					_fnAddTr( oSettings, $(oSettings.nTBody).children('tr') );
1294				}
1295			
1296				/* Copy the data index array */
1297				oSettings.aiDisplay = oSettings.aiDisplayMaster.slice();
1298			
1299				/* Initialisation complete - table can be drawn */
1300				oSettings.bInitialised = true;
1301			
1302				/* Check if we need to initialise the table (it might not have been handed off to the
1303				 * language processor)
1304				 */
1305				if ( bInitHandedOff === false ) {
1306					_fnInitialise( oSettings );
1307				}
1308			};
1309			
1310			/* Must be done after everything which can be overridden by the state saving! */
1311			_fnCallbackReg( oSettings, 'aoDrawCallback', _fnSaveState, 'state_save' );
1312			
1313			if ( oInit.bStateSave )
1314			{
1315				features.bStateSave = true;
1316				_fnLoadState( oSettings, oInit, loadedInit );
1317			}
1318			else {
1319				loadedInit();
1320			}
1321			
1322		} );
1323		_that = null;
1324		return this;
1325	};
1326	
1327	
1328	/*
1329	 * It is useful to have variables which are scoped locally so only the
1330	 * DataTables functions can access them and they don't leak into global space.
1331	 * At the same time these functions are often useful over multiple files in the
1332	 * core and API, so we list, or at least document, all variables which are used
1333	 * by DataTables as private variables here. This also ensures that there is no
1334	 * clashing of variable names and that they can easily referenced for reuse.
1335	 */
1336	
1337	
1338	// Defined else where
1339	//  _selector_run
1340	//  _selector_opts
1341	//  _selector_first
1342	//  _selector_row_indexes
1343	
1344	var _ext; // DataTable.ext
1345	var _Api; // DataTable.Api
1346	var _api_register; // DataTable.Api.register
1347	var _api_registerPlural; // DataTable.Api.registerPlural
1348	
1349	var _re_dic = {};
1350	var _re_new_lines = /[\r\n\u2028]/g;
1351	var _re_html = /<.*?>/g;
1352	
1353	// This is not strict ISO8601 - Date.parse() is quite lax, although
1354	// implementations differ between browsers.
1355	var _re_date = /^\d{2,4}[\.\/\-]\d{1,2}[\.\/\-]\d{1,2}([T ]{1}\d{1,2}[:\.]\d{2}([\.:]\d{2})?)?$/;
1356	
1357	// Escape regular expression special characters
1358	var _re_escape_regex = new RegExp( '(\\' + [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\', '$', '^', '-' ].join('|\\') + ')', 'g' );
1359	
1360	// http://en.wikipedia.org/wiki/Foreign_exchange_market
1361	// - \u20BD - Russian ruble.
1362	// - \u20a9 - South Korean Won
1363	// - \u20BA - Turkish Lira
1364	// - \u20B9 - Indian Rupee
1365	// - R - Brazil (R$) and South Africa
1366	// - fr - Swiss Franc
1367	// - kr - Swedish krona, Norwegian krone and Danish krone
1368	// - \u2009 is thin space and \u202F is narrow no-break space, both used in many
1369	// - Ƀ - Bitcoin
1370	// - Ξ - Ethereum
1371	//   standards as thousands separators.
1372	var _re_formatted_numeric = /['\u00A0,$£€¥%\u2009\u202F\u20BD\u20a9\u20BArfkɃΞ]/gi;
1373	
1374	
1375	var _empty = function ( d ) {
1376		return !d || d === true || d === '-' ? true : false;
1377	};
1378	
1379	
1380	var _intVal = function ( s ) {
1381		var integer = parseInt( s, 10 );
1382		return !isNaN(integer) && isFinite(s) ? integer : null;
1383	};
1384	
1385	// Convert from a formatted number with characters other than `.` as the
1386	// decimal place, to a Javascript number
1387	var _numToDecimal = function ( num, decimalPoint ) {
1388		// Cache created regular expressions for speed as this function is called often
1389		if ( ! _re_dic[ decimalPoint ] ) {
1390			_re_dic[ decimalPoint ] = new RegExp( _fnEscapeRegex( decimalPoint ), 'g' );
1391		}
1392		return typeof num === 'string' && decimalPoint !== '.' ?
1393			num.replace( /\./g, '' ).replace( _re_dic[ decimalPoint ], '.' ) :
1394			num;
1395	};
1396	
1397	
1398	var _isNumber = function ( d, decimalPoint, formatted ) {
1399		let type = typeof d;
1400		var strType = type === 'string';
1401	
1402		if ( type === 'number' || type === 'bigint') {
1403			return true;
1404		}
1405	
1406		// If empty return immediately so there must be a number if it is a
1407		// formatted string (this stops the string "k", or "kr", etc being detected
1408		// as a formatted number for currency
1409		if ( _empty( d ) ) {
1410			return true;
1411		}
1412	
1413		if ( decimalPoint && strType ) {
1414			d = _numToDecimal( d, decimalPoint );
1415		}
1416	
1417		if ( formatted && strType ) {
1418			d = d.replace( _re_formatted_numeric, '' );
1419		}
1420	
1421		return !isNaN( parseFloat(d) ) && isFinite( d );
1422	};
1423	
1424	
1425	// A string without HTML in it can be considered to be HTML still
1426	var _isHtml = function ( d ) {
1427		return _empty( d ) || typeof d === 'string';
1428	};
1429	
1430	
1431	var _htmlNumeric = function ( d, decimalPoint, formatted ) {
1432		if ( _empty( d ) ) {
1433			return true;
1434		}
1435	
1436		var html = _isHtml( d );
1437		return ! html ?
1438			null :
1439			_isNumber( _stripHtml( d ), decimalPoint, formatted ) ?
1440				true :
1441				null;
1442	};
1443	
1444	
1445	var _pluck = function ( a, prop, prop2 ) {
1446		var out = [];
1447		var i=0, ien=a.length;
1448	
1449		// Could have the test in the loop for slightly smaller code, but speed
1450		// is essential here
1451		if ( prop2 !== undefined ) {
1452			for ( ; i<ien ; i++ ) {
1453				if ( a[i] && a[i][ prop ] ) {
1454					out.push( a[i][ prop ][ prop2 ] );
1455				}
1456			}
1457		}
1458		else {
1459			for ( ; i<ien ; i++ ) {
1460				if ( a[i] ) {
1461					out.push( a[i][ prop ] );
1462				}
1463			}
1464		}
1465	
1466		return out;
1467	};
1468	
1469	
1470	// Basically the same as _pluck, but rather than looping over `a` we use `order`
1471	// as the indexes to pick from `a`
1472	var _pluck_order = function ( a, order, prop, prop2 )
1473	{
1474		var out = [];
1475		var i=0, ien=order.length;
1476	
1477		// Could have the test in the loop for slightly smaller code, but speed
1478		// is essential here
1479		if ( prop2 !== undefined ) {
1480			for ( ; i<ien ; i++ ) {
1481				if ( a[ order[i] ][ prop ] ) {
1482					out.push( a[ order[i] ][ prop ][ prop2 ] );
1483				}
1484			}
1485		}
1486		else {
1487			for ( ; i<ien ; i++ ) {
1488				out.push( a[ order[i] ][ prop ] );
1489			}
1490		}
1491	
1492		return out;
1493	};
1494	
1495	
1496	var _range = function ( len, start )
1497	{
1498		var out = [];
1499		var end;
1500	
1501		if ( start === undefined ) {
1502			start = 0;
1503			end = len;
1504		}
1505		else {
1506			end = start;
1507			start = len;
1508		}
1509	
1510		for ( var i=start ; i<end ; i++ ) {
1511			out.push( i );
1512		}
1513	
1514		return out;
1515	};
1516	
1517	
1518	var _removeEmpty = function ( a )
1519	{
1520		var out = [];
1521	
1522		for ( var i=0, ien=a.length ; i<ien ; i++ ) {
1523			if ( a[i] ) { // careful - will remove all falsy values!
1524				out.push( a[i] );
1525			}
1526		}
1527	
1528		return out;
1529	};
1530	
1531	
1532	var _stripHtml = function ( d ) {
1533		return d.replace( _re_html, '' );
1534	};
1535	
1536	
1537	/**
1538	 * Determine if all values in the array are unique. This means we can short
1539	 * cut the _unique method at the cost of a single loop. A sorted array is used
1540	 * to easily check the values.
1541	 *
1542	 * @param  {array} src Source array
1543	 * @return {boolean} true if all unique, false otherwise
1544	 * @ignore
1545	 */
1546	var _areAllUnique = function ( src ) {
1547		if ( src.length < 2 ) {
1548			return true;
1549		}
1550	
1551		var sorted = src.slice().sort();
1552		var last = sorted[0];
1553	
1554		for ( var i=1, ien=sorted.length ; i<ien ; i++ ) {
1555			if ( sorted[i] === last ) {
1556				return false;
1557			}
1558	
1559			last = sorted[i];
1560		}
1561	
1562		return true;
1563	};
1564	
1565	
1566	/**
1567	 * Find the unique elements in a source array.
1568	 *
1569	 * @param  {array} src Source array
1570	 * @return {array} Array of unique items
1571	 * @ignore
1572	 */
1573	var _unique = function ( src )
1574	{
1575		if ( _areAllUnique( src ) ) {
1576			return src.slice();
1577		}
1578	
1579		// A faster unique method is to use object keys to identify used values,
1580		// but this doesn't work with arrays or objects, which we must also
1581		// consider. See jsperf.com/compare-array-unique-versions/4 for more
1582		// information.
1583		var
1584			out = [],
1585			val,
1586			i, ien=src.length,
1587			j, k=0;
1588	
1589		again: for ( i=0 ; i<ien ; i++ ) {
1590			val = src[i];
1591	
1592			for ( j=0 ; j<k ; j++ ) {
1593				if ( out[j] === val ) {
1594					continue again;
1595				}
1596			}
1597	
1598			out.push( val );
1599			k++;
1600		}
1601	
1602		return out;
1603	};
1604	
1605	// Surprisingly this is faster than [].concat.apply
1606	// https://jsperf.com/flatten-an-array-loop-vs-reduce/2
1607	var _flatten = function (out, val) {
1608		if (Array.isArray(val)) {
1609			for (var i=0 ; i<val.length ; i++) {
1610				_flatten(out, val[i]);
1611			}
1612		}
1613		else {
1614			out.push(val);
1615		}
1616	  
1617		return out;
1618	}
1619	
1620	var _includes = function (search, start) {
1621		if (start === undefined) {
1622			start = 0;
1623		}
1624	
1625		return this.indexOf(search, start) !== -1;	
1626	};
1627	
1628	// Array.isArray polyfill.
1629	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
1630	if (! Array.isArray) {
1631	    Array.isArray = function(arg) {
1632	        return Object.prototype.toString.call(arg) === '[object Array]';
1633	    };
1634	}
1635	
1636	if (! Array.prototype.includes) {
1637		Array.prototype.includes = _includes;
1638	}
1639	
1640	// .trim() polyfill
1641	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim
1642	if (!String.prototype.trim) {
1643	  String.prototype.trim = function () {
1644	    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
1645	  };
1646	}
1647	
1648	if (! String.prototype.includes) {
1649		String.prototype.includes = _includes;
1650	}
1651	
1652	/**
1653	 * DataTables utility methods
1654	 * 
1655	 * This namespace provides helper methods that DataTables uses internally to
1656	 * create a DataTable, but which are not exclusively used only for DataTables.
1657	 * These methods can be used by extension authors to save the duplication of
1658	 * code.
1659	 *
1660	 *  @namespace
1661	 */
1662	DataTable.util = {
1663		/**
1664		 * Throttle the calls to a function. Arguments and context are maintained
1665		 * for the throttled function.
1666		 *
1667		 * @param {function} fn Function to be called
1668		 * @param {integer} freq Call frequency in mS
1669		 * @return {function} Wrapped function
1670		 */
1671		throttle: function ( fn, freq ) {
1672			var
1673				frequency = freq !== undefined ? freq : 200,
1674				last,
1675				timer;
1676	
1677			return function () {
1678				var
1679					that = this,
1680					now  = +new Date(),
1681					args = arguments;
1682	
1683				if ( last && now < last + frequency ) {
1684					clearTimeout( timer );
1685	
1686					timer = setTimeout( function () {
1687						last = undefined;
1688						fn.apply( that, args );
1689					}, frequency );
1690				}
1691				else {
1692					last = now;
1693					fn.apply( that, args );
1694				}
1695			};
1696		},
1697	
1698	
1699		/**
1700		 * Escape a string such that it can be used in a regular expression
1701		 *
1702		 *  @param {string} val string to escape
1703		 *  @returns {string} escaped string
1704		 */
1705		escapeRegex: function ( val ) {
1706			return val.replace( _re_escape_regex, '\\$1' );
1707		},
1708	
1709		/**
1710		 * Create a function that will write to a nested object or array
1711		 * @param {*} source JSON notation string
1712		 * @returns Write function
1713		 */
1714		set: function ( source ) {
1715			if ( $.isPlainObject( source ) ) {
1716				/* Unlike get, only the underscore (global) option is used for for
1717				 * setting data since we don't know the type here. This is why an object
1718				 * option is not documented for `mData` (which is read/write), but it is
1719				 * for `mRender` which is read only.
1720				 */
1721				return DataTable.util.set( source._ );
1722			}
1723			else if ( source === null ) {
1724				// Nothing to do when the data source is null
1725				return function () {};
1726			}
1727			else if ( typeof source === 'function' ) {
1728				return function (data, val, meta) {
1729					source( data, 'set', val, meta );
1730				};
1731			}
1732			else if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||
1733					  source.indexOf('[') !== -1 || source.indexOf('(') !== -1) )
1734			{
1735				// Like the get, we need to get data from a nested object
1736				var setData = function (data, val, src) {
1737					var a = _fnSplitObjNotation( src ), b;
1738					var aLast = a[a.length-1];
1739					var arrayNotation, funcNotation, o, innerSrc;
1740		
1741					for ( var i=0, iLen=a.length-1 ; i<iLen ; i++ ) {
1742						// Protect against prototype pollution
1743						if (a[i] === '__proto__' || a[i] === 'constructor') {
1744							throw new Error('Cannot set prototype values');
1745						}
1746		
1747						// Check if we are dealing with an array notation request
1748						arrayNotation = a[i].match(__reArray);
1749						funcNotation = a[i].match(__reFn);
1750		
1751						if ( arrayNotation ) {
1752							a[i] = a[i].replace(__reArray, '');
1753							data[ a[i] ] = [];
1754		
1755							// Get the remainder of the nested object to set so we can recurse
1756							b = a.slice();
1757							b.splice( 0, i+1 );
1758							innerSrc = b.join('.');
1759		
1760							// Traverse each entry in the array setting the properties requested
1761							if ( Array.isArray( val ) ) {
1762								for ( var j=0, jLen=val.length ; j<jLen ; j++ ) {
1763									o = {};
1764									setData( o, val[j], innerSrc );
1765									data[ a[i] ].push( o );
1766								}
1767							}
1768							else {
1769								// We've been asked to save data to an array, but it
1770								// isn't array data to be saved. Best that can be done
1771								// is to just save the value.
1772								data[ a[i] ] = val;
1773							}
1774		
1775							// The inner call to setData has already traversed through the remainder
1776							// of the source and has set the data, thus we can exit here
1777							return;
1778						}
1779						else if ( funcNotation ) {
1780							// Function call
1781							a[i] = a[i].replace(__reFn, '');
1782							data = data[ a[i] ]( val );
1783						}
1784		
1785						// If the nested object doesn't currently exist - since we are
1786						// trying to set the value - create it
1787						if ( data[ a[i] ] === null || data[ a[i] ] === undefined ) {
1788							data[ a[i] ] = {};
1789						}
1790						data = data[ a[i] ];
1791					}
1792		
1793					// Last item in the input - i.e, the actual set
1794					if ( aLast.match(__reFn ) ) {
1795						// Function call
1796						data = data[ aLast.replace(__reFn, '') ]( val );
1797					}
1798					else {
1799						// If array notation is used, we just want to strip it and use the property name
1800						// and assign the value. If it isn't used, then we get the result we want anyway
1801						data[ aLast.replace(__reArray, '') ] = val;
1802					}
1803				};
1804		
1805				return function (data, val) { // meta is also passed in, but not used
1806					return setData( data, val, source );
1807				};
1808			}
1809			else {
1810				// Array or flat object mapping
1811				return function (data, val) { // meta is also passed in, but not used
1812					data[source] = val;
1813				};
1814			}
1815		},
1816	
1817		/**
1818		 * Create a function that will read nested objects from arrays, based on JSON notation
1819		 * @param {*} source JSON notation string
1820		 * @returns Value read
1821		 */
1822		get: function ( source ) {
1823			if ( $.isPlainObject( source ) ) {
1824				// Build an object of get functions, and wrap them in a single call
1825				var o = {};
1826				$.each( source, function (key, val) {
1827					if ( val ) {
1828						o[key] = DataTable.util.get( val );
1829					}
1830				} );
1831		
1832				return function (data, type, row, meta) {
1833					var t = o[type] || o._;
1834					return t !== undefined ?
1835						t(data, type, row, meta) :
1836						data;
1837				};
1838			}
1839			else if ( source === null ) {
1840				// Give an empty string for rendering / sorting etc
1841				return function (data) { // type, row and meta also passed, but not used
1842					return data;
1843				};
1844			}
1845			else if ( typeof source === 'function' ) {
1846				return function (data, type, row, meta) {
1847					return source( data, type, row, meta );
1848				};
1849			}
1850			else if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||
1851					  source.indexOf('[') !== -1 || source.indexOf('(') !== -1) )
1852			{
1853				/* If there is a . in the source string then the data source is in a
1854				 * nested object so we loop over the data for each level to get the next
1855				 * level down. On each loop we test for undefined, and if found immediately
1856				 * return. This allows entire objects to be missing and sDefaultContent to
1857				 * be used if defined, rather than throwing an error
1858				 */
1859				var fetchData = function (data, type, src) {
1860					var arrayNotation, funcNotation, out, innerSrc;
1861		
1862					if ( src !== "" ) {
1863						var a = _fnSplitObjNotation( src );
1864		
1865						for ( var i=0, iLen=a.length ; i<iLen ; i++ ) {
1866							// Check if we are dealing with special notation
1867							arrayNotation = a[i].match(__reArray);
1868							funcNotation = a[i].match(__reFn);
1869		
1870							if ( arrayNotation ) {
1871								// Array notation
1872								a[i] = a[i].replace(__reArray, '');
1873		
1874								// Condition allows simply [] to be passed in
1875								if ( a[i] !== "" ) {
1876									data = data[ a[i] ];
1877								}
1878								out = [];
1879		
1880								// Get the remainder of the nested object to get
1881								a.splice( 0, i+1 );
1882								innerSrc = a.join('.');
1883		
1884								// Traverse each entry in the array getting the properties requested
1885								if ( Array.isArray( data ) ) {
1886									for ( var j=0, jLen=data.length ; j<jLen ; j++ ) {
1887										out.push( fetchData( data[j], type, innerSrc ) );
1888									}
1889								}
1890		
1891								// If a string is given in between the array notation indicators, that
1892								// is used to join the strings together, otherwise an array is returned
1893								var join = arrayNotation[0].substring(1, arrayNotation[0].length-1);
1894								data = (join==="") ? out : out.join(join);
1895		
1896								// The inner call to fetchData has already traversed through the remainder
1897								// of the source requested, so we exit from the loop
1898								break;
1899							}
1900							else if ( funcNotation ) {
1901								// Function call
1902								a[i] = a[i].replace(__reFn, '');
1903								data = data[ a[i] ]();
1904								continue;
1905							}
1906		
1907							if ( data === null || data[ a[i] ] === undefined ) {
1908								return undefined;
1909							}
1910	
1911							data = data[ a[i] ];
1912						}
1913					}
1914		
1915					return data;
1916				};
1917		
1918				return function (data, type) { // row and meta also passed, but not used
1919					return fetchData( data, type, source );
1920				};
1921			}
1922			else {
1923				// Array or flat object mapping
1924				return function (data, type) { // row and meta also passed, but not used
1925					return data[source];
1926				};
1927			}
1928		}
1929	};
1930	
1931	
1932	
1933	/**
1934	 * Create a mapping object that allows camel case parameters to be looked up
1935	 * for their Hungarian counterparts. The mapping is stored in a private
1936	 * parameter called `_hungarianMap` which can be accessed on the source object.
1937	 *  @param {object} o
1938	 *  @memberof DataTable#oApi
1939	 */
1940	function _fnHungarianMap ( o )
1941	{
1942		var
1943			hungarian = 'a aa ai ao as b fn i m o s ',
1944			match,
1945			newKey,
1946			map = {};
1947	
1948		$.each( o, function (key, val) {
1949			match = key.match(/^([^A-Z]+?)([A-Z])/);
1950	
1951			if ( match && hungarian.indexOf(match[1]+' ') !== -1 )
1952			{
1953				newKey = key.replace( match[0], match[2].toLowerCase() );
1954				map[ newKey ] = key;
1955	
1956				if ( match[1] === 'o' )
1957				{
1958					_fnHungarianMap( o[key] );
1959				}
1960			}
1961		} );
1962	
1963		o._hungarianMap = map;
1964	}
1965	
1966	
1967	/**
1968	 * Convert from camel case parameters to Hungarian, based on a Hungarian map
1969	 * created by _fnHungarianMap.
1970	 *  @param {object} src The model object which holds all parameters that can be
1971	 *    mapped.
1972	 *  @param {object} user The object to convert from camel case to Hungarian.
1973	 *  @param {boolean} force When set to `true`, properties which already have a
1974	 *    Hungarian value in the `user` object will be overwritten. Otherwise they
1975	 *    won't be.
1976	 *  @memberof DataTable#oApi
1977	 */
1978	function _fnCamelToHungarian ( src, user, force )
1979	{
1980		if ( ! src._hungarianMap ) {
1981			_fnHungarianMap( src );
1982		}
1983	
1984		var hungarianKey;
1985	
1986		$.each( user, function (key, val) {
1987			hungarianKey = src._hungarianMap[ key ];
1988	
1989			if ( hungarianKey !== undefined && (force || user[hungarianKey] === undefined) )
1990			{
1991				// For objects, we need to buzz down into the object to copy parameters
1992				if ( hungarianKey.charAt(0) === 'o' )
1993				{
1994					// Copy the camelCase options over to the hungarian
1995					if ( ! user[ hungarianKey ] ) {
1996						user[ hungarianKey ] = {};
1997					}
1998					$.extend( true, user[hungarianKey], user[key] );
1999	
2000					_fnCamelToHungarian( src[hungarianKey], user[hungarianKey], force );
2001				}
2002				else {
2003					user[hungarianKey] = user[ key ];
2004				}
2005			}
2006		} );
2007	}
2008	
2009	
2010	/**
2011	 * Language compatibility - when certain options are given, and others aren't, we
2012	 * need to duplicate the values over, in order to provide backwards compatibility
2013	 * with older language files.
2014	 *  @param {object} oSettings dataTables settings object
2015	 *  @memberof DataTable#oApi
2016	 */
2017	function _fnLanguageCompat( lang )
2018	{
2019		// Note the use of the Hungarian notation for the parameters in this method as
2020		// this is called after the mapping of camelCase to Hungarian
2021		var defaults = DataTable.defaults.oLanguage;
2022	
2023		// Default mapping
2024		var defaultDecimal = defaults.sDecimal;
2025		if ( defaultDecimal ) {
2026			_addNumericSort( defaultDecimal );
2027		}
2028	
2029		if ( lang ) {
2030			var zeroRecords = lang.sZeroRecords;
2031	
2032			// Backwards compatibility - if there is no sEmptyTable given, then use the same as
2033			// sZeroRecords - assuming that is given.
2034			if ( ! lang.sEmptyTable && zeroRecords &&
2035				defaults.sEmptyTable === "No data available in table" )
2036			{
2037				_fnMap( lang, lang, 'sZeroRecords', 'sEmptyTable' );
2038			}
2039	
2040			// Likewise with loading records
2041			if ( ! lang.sLoadingRecords && zeroRecords &&
2042				defaults.sLoadingRecords === "Loading..." )
2043			{
2044				_fnMap( lang, lang, 'sZeroRecords', 'sLoadingRecords' );
2045			}
2046	
2047			// Old parameter name of the thousands separator mapped onto the new
2048			if ( lang.sInfoThousands ) {
2049				lang.sThousands = lang.sInfoThousands;
2050			}
2051	
2052			var decimal = lang.sDecimal;
2053			if ( decimal && defaultDecimal !== decimal ) {
2054				_addNumericSort( decimal );
2055			}
2056		}
2057	}
2058	
2059	
2060	/**
2061	 * Map one parameter onto another
2062	 *  @param {object} o Object to map
2063	 *  @param {*} knew The new parameter name
2064	 *  @param {*} old The old parameter name
2065	 */
2066	var _fnCompatMap = function ( o, knew, old ) {
2067		if ( o[ knew ] !== undefined ) {
2068			o[ old ] = o[ knew ];
2069		}
2070	};
2071	
2072	
2073	/**
2074	 * Provide backwards compatibility for the main DT options. Note that the new
2075	 * options are mapped onto the old parameters, so this is an external interface
2076	 * change only.
2077	 *  @param {object} init Object to map
2078	 */
2079	function _fnCompatOpts ( init )
2080	{
2081		_fnCompatMap( init, 'ordering',      'bSort' );
2082		_fnCompatMap( init, 'orderMulti',    'bSortMulti' );
2083		_fnCompatMap( init, 'orderClasses',  'bSortClasses' );
2084		_fnCompatMap( init, 'orderCellsTop', 'bSortCellsTop' );
2085		_fnCompatMap( init, 'order',         'aaSorting' );
2086		_fnCompatMap( init, 'orderFixed',    'aaSortingFixed' );
2087		_fnCompatMap( init, 'paging',        'bPaginate' );
2088		_fnCompatMap( init, 'pagingType',    'sPaginationType' );
2089		_fnCompatMap( init, 'pageLength',    'iDisplayLength' );
2090		_fnCompatMap( init, 'searching',     'bFilter' );
2091	
2092		// Boolean initialisation of x-scrolling
2093		if ( typeof init.sScrollX === 'boolean' ) {
2094			init.sScrollX = init.sScrollX ? '100%' : '';
2095		}
2096		if ( typeof init.scrollX === 'boolean' ) {
2097			init.scrollX = init.scrollX ? '100%' : '';
2098		}
2099	
2100		// Column search objects are in an array, so it needs to be converted
2101		// element by element
2102		var searchCols = init.aoSearchCols;
2103	
2104		if ( searchCols ) {
2105			for ( var i=0, ien=searchCols.length ; i<ien ; i++ ) {
2106				if ( searchCols[i] ) {
2107					_fnCamelToHungarian( DataTable.models.oSearch, searchCols[i] );
2108				}
2109			}
2110		}
2111	}
2112	
2113	
2114	/**
2115	 * Provide backwards compatibility for column options. Note that the new options
2116	 * are mapped onto the old parameters, so this is an external interface change
2117	 * only.
2118	 *  @param {object} init Object to map
2119	 */
2120	function _fnCompatCols ( init )
2121	{
2122		_fnCompatMap( init, 'orderable',     'bSortable' );
2123		_fnCompatMap( init, 'orderData',     'aDataSort' );
2124		_fnCompatMap( init, 'orderSequence', 'asSorting' );
2125		_fnCompatMap( init, 'orderDataType', 'sortDataType' );
2126	
2127		// orderData can be given as an integer
2128		var dataSort = init.aDataSort;
2129		if ( typeof dataSort === 'number' && ! Array.isArray( dataSort ) ) {
2130			init.aDataSort = [ dataSort ];
2131		}
2132	}
2133	
2134	
2135	/**
2136	 * Browser feature detection for capabilities, quirks
2137	 *  @param {object} settings dataTables settings object
2138	 *  @memberof DataTable#oApi
2139	 */
2140	function _fnBrowserDetect( settings )
2141	{
2142		// We don't need to do this every time DataTables is constructed, the values
2143		// calculated are specific to the browser and OS configuration which we
2144		// don't expect to change between initialisations
2145		if ( ! DataTable.__browser ) {
2146			var browser = {};
2147			DataTable.__browser = browser;
2148	
2149			// Scrolling feature / quirks detection
2150			var n = $('<div/>')
2151				.css( {
2152					position: 'fixed',
2153					top: 0,
2154					left: $(window).scrollLeft()*-1, // allow for scrolling
2155					height: 1,
2156					width: 1,
2157					overflow: 'hidden'
2158				} )
2159				.append(
2160					$('<div/>')
2161						.css( {
2162							position: 'absolute',
2163							top: 1,
2164							left: 1,
2165							width: 100,
2166							overflow: 'scroll'
2167						} )
2168						.append(
2169							$('<div/>')
2170								.css( {
2171									width: '100%',
2172									height: 10
2173								} )
2174						)
2175				)
2176				.appendTo( 'body' );
2177	
2178			var outer = n.children();
2179			var inner = outer.children();
2180	
2181			// Numbers below, in order, are:
2182			// inner.offsetWidth, inner.clientWidth, outer.offsetWidth, outer.clientWidth
2183			//
2184			// IE6 XP:                           100 100 100  83
2185			// IE7 Vista:                        100 100 100  83
2186			// IE 8+ Windows:                     83  83 100  83
2187			// Evergreen Windows:                 83  83 100  83
2188			// Evergreen Mac with scrollbars:     85  85 100  85
2189			// Evergreen Mac without scrollbars: 100 100 100 100
2190	
2191			// Get scrollbar width
2192			browser.barWidth = outer[0].offsetWidth - outer[0].clientWidth;
2193	
2194			// IE6/7 will oversize a width 100% element inside a scrolling element, to
2195			// include the width of the scrollbar, while other browsers ensure the inner
2196			// element is contained without forcing scrolling
2197			browser.bScrollOversize = inner[0].offsetWidth === 100 && outer[0].clientWidth !== 100;
2198	
2199			// In rtl text layout, some browsers (most, but not all) will place the
2200			// scrollbar on the left, rather than the right.
2201			browser.bScrollbarLeft = Math.round( inner.offset().left ) !== 1;
2202	
2203			// IE8- don't provide height and width for getBoundingClientRect
2204			browser.bBounding = n[0].getBoundingClientRect().width ? true : false;
2205	
2206			n.remove();
2207		}
2208	
2209		$.extend( settings.oBrowser, DataTable.__browser );
2210		settings.oScroll.iBarWidth = DataTable.__browser.barWidth;
2211	}
2212	
2213	
2214	/**
2215	 * Array.prototype reduce[Right] method, used for browsers which don't support
2216	 * JS 1.6. Done this way to reduce code size, since we iterate either way
2217	 *  @param {object} settings dataTables settings object
2218	 *  @memberof DataTable#oApi
2219	 */
2220	function _fnReduce ( that, fn, init, start, end, inc )
2221	{
2222		var
2223			i = start,
2224			value,
2225			isSet = false;
2226	
2227		if ( init !== undefined ) {
2228			value = init;
2229			isSet = true;
2230		}
2231	
2232		while ( i !== end ) {
2233			if ( ! that.hasOwnProperty(i) ) {
2234				continue;
2235			}
2236	
2237			value = isSet ?
2238				fn( value, that[i], i, that ) :
2239				that[i];
2240	
2241			isSet = true;
2242			i += inc;
2243		}
2244	
2245		return value;
2246	}
2247	
2248	/**
2249	 * Add a column to the list used for the table with default values
2250	 *  @param {object} oSettings dataTables settings object
2251	 *  @param {node} nTh The th element for this column
2252	 *  @memberof DataTable#oApi
2253	 */
2254	function _fnAddColumn( oSettings, nTh )
2255	{
2256		// Add column to aoColumns array
2257		var oDefaults = DataTable.defaults.column;
2258		var iCol = oSettings.aoColumns.length;
2259		var oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {
2260			"nTh": nTh ? nTh : document.createElement('th'),
2261			"sTitle":    oDefaults.sTitle    ? oDefaults.sTitle    : nTh ? nTh.innerHTML : '',
2262			"aDataSort": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],
2263			"mData": oDefaults.mData ? oDefaults.mData : iCol,
2264			idx: iCol
2265		} );
2266		oSettings.aoColumns.push( oCol );
2267	
2268		// Add search object for column specific search. Note that the `searchCols[ iCol ]`
2269		// passed into extend can be undefined. This allows the user to give a default
2270		// with only some of the parameters defined, and also not give a default
2271		var searchCols = oSettings.aoPreSearchCols;
2272		searchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch, searchCols[ iCol ] );
2273	
2274		// Use the default column options function to initialise classes etc
2275		_fnColumnOptions( oSettings, iCol, $(nTh).data() );
2276	}
2277	
2278	
2279	/**
2280	 * Apply options for a column
2281	 *  @param {object} oSettings dataTables settings object
2282	 *  @param {int} iCol column index to consider
2283	 *  @param {object} oOptions object with sType, bVisible and bSearchable etc
2284	 *  @memberof DataTable#oApi
2285	 */
2286	function _fnColumnOptions( oSettings, iCol, oOptions )
2287	{
2288		var oCol = oSettings.aoColumns[ iCol ];
2289		var oClasses = oSettings.oClasses;
2290		var th = $(oCol.nTh);
2291	
2292		// Try to get width information from the DOM. We can't get it from CSS
2293		// as we'd need to parse the CSS stylesheet. `width` option can override
2294		if ( ! oCol.sWidthOrig ) {
2295			// Width attribute
2296			oCol.sWidthOrig = th.attr('width') || null;
2297	
2298			// Style attribute
2299			var t = (th.attr('style') || '').match(/width:\s*(\d+[pxem%]+)/);
2300			if ( t ) {
2301				oCol.sWidthOrig = t[1];
2302			}
2303		}
2304	
2305		/* User specified column options */
2306		if ( oOptions !== undefined && oOptions !== null )
2307		{
2308			// Backwards compatibility
2309			_fnCompatCols( oOptions );
2310	
2311			// Map camel case parameters to their Hungarian counterparts
2312			_fnCamelToHungarian( DataTable.defaults.column, oOptions, true );
2313	
2314			/* Backwards compatibility for mDataProp */
2315			if ( oOptions.mDataProp !== undefined && !oOptions.mData )
2316			{
2317				oOptions.mData = oOptions.mDataProp;
2318			}
2319	
2320			if ( oOptions.sType )
2321			{
2322				oCol._sManualType = oOptions.sType;
2323			}
2324	
2325			// `class` is a reserved word in Javascript, so we need to provide
2326			// the ability to use a valid name for the camel case input
2327			if ( oOptions.className && ! oOptions.sClass )
2328			{
2329				oOptions.sClass = oOptions.className;
2330			}
2331			if ( oOptions.sClass ) {
2332				th.addClass( oOptions.sClass );
2333			}
2334	
2335			var origClass = oCol.sClass;
2336	
2337			$.extend( oCol, oOptions );
2338			_fnMap( oCol, oOptions, "sWidth", "sWidthOrig" );
2339	
2340			// Merge class from previously defined classes with this one, rather than just
2341			// overwriting it in the extend above
2342			if (origClass !== oCol.sClass) {
2343				oCol.sClass = origClass + ' ' + oCol.sClass;
2344			}
2345	
2346			/* iDataSort to be applied (backwards compatibility), but aDataSort will take
2347			 * priority if defined
2348			 */
2349			if ( oOptions.iDataSort !== undefined )
2350			{
2351				oCol.aDataSort = [ oOptions.iDataSort ];
2352			}
2353			_fnMap( oCol, oOptions, "aDataSort" );
2354		}
2355	
2356		/* Cache the data get and set functions for speed */
2357		var mDataSrc = oCol.mData;
2358		var mData = _fnGetObjectDataFn( mDataSrc );
2359		var mRender = oCol.mRender ? _fnGetObjectDataFn( oCol.mRender ) : null;
2360	
2361		var attrTest = function( src ) {
2362			return typeof src === 'string' && src.indexOf('@') !== -1;
2363		};
2364		oCol._bAttrSrc = $.isPlainObject( mDataSrc ) && (
2365			attrTest(mDataSrc.sort) || attrTest(mDataSrc.type) || attrTest(mDataSrc.filter)
2366		);
2367		oCol._setter = null;
2368	
2369		oCol.fnGetData = function (rowData, type, meta) {
2370			var innerData = mData( rowData, type, undefined, meta );
2371	
2372			return mRender && type ?
2373				mRender( innerData, type, rowData, meta ) :
2374				innerData;
2375		};
2376		oCol.fnSetData = function ( rowData, val, meta ) {
2377			return _fnSetObjectDataFn( mDataSrc )( rowData, val, meta );
2378		};
2379	
2380		// Indicate if DataTables should read DOM data as an object or array
2381		// Used in _fnGetRowElements
2382		if ( typeof mDataSrc !== 'number' && ! oCol._isArrayHost ) {
2383			oSettings._rowReadObject = true;
2384		}
2385	
2386		/* Feature sorting overrides column specific when off */
2387		if ( !oSettings.oFeatures.bSort )
2388		{
2389			oCol.bSortable = false;
2390			th.addClass( oClasses.sSortableNone ); // Have to add class here as order event isn't called
2391		}
2392	
2393		/* Check that the class assignment is correct for sorting */
2394		var bAsc = $.inArray('asc', oCol.asSorting) !== -1;
2395		var bDesc = $.inArray('desc', oCol.asSorting) !== -1;
2396		if ( !oCol.bSortable || (!bAsc && !bDesc) )
2397		{
2398			oCol.sSortingClass = oClasses.sSortableNone;
2399			oCol.sSortingClassJUI = "";
2400		}
2401		else if ( bAsc && !bDesc )
2402		{
2403			oCol.sSortingClass = oClasses.sSortableAsc;
2404			oCol.sSortingClassJUI = oClasses.sSortJUIAscAllowed;
2405		}
2406		else if ( !bAsc && bDesc )
2407		{
2408			oCol.sSortingClass = oClasses.sSortableDesc;
2409			oCol.sSortingClassJUI = oClasses.sSortJUIDescAllowed;
2410		}
2411		else
2412		{
2413			oCol.sSortingClass = oClasses.sSortable;
2414			oCol.sSortingClassJUI = oClasses.sSortJUI;
2415		}
2416	}
2417	
2418	
2419	/**
2420	 * Adjust the table column widths for new data. Note: you would probably want to
2421	 * do a redraw after calling this function!
2422	 *  @param {object} settings dataTables settings object
2423	 *  @memberof DataTable#oApi
2424	 */
2425	function _fnAdjustColumnSizing ( settings )
2426	{
2427		/* Not interested in doing column width calculation if auto-width is disabled */
2428		if ( settings.oFeatures.bAutoWidth !== false )
2429		{
2430			var columns = settings.aoColumns;
2431	
2432			_fnCalculateColumnWidths( settings );
2433			for ( var i=0 , iLen=columns.length ; i<iLen ; i++ )
2434			{
2435				columns[i].nTh.style.width = columns[i].sWidth;
2436			}
2437		}
2438	
2439		var scroll = settings.oScroll;
2440		if ( scroll.sY !== '' || scroll.sX !== '')
2441		{
2442			_fnScrollDraw( settings );
2443		}
2444	
2445		_fnCallbackFire( settings, null, 'column-sizing', [settings] );
2446	}
2447	
2448	
2449	/**
2450	 * Convert the index of a visible column to the index in the data array (take account
2451	 * of hidden columns)
2452	 *  @param {object} oSettings dataTables settings object
2453	 *  @param {int} iMatch Visible column index to lookup
2454	 *  @returns {int} i the data index
2455	 *  @memberof DataTable#oApi
2456	 */
2457	function _fnVisibleToColumnIndex( oSettings, iMatch )
2458	{
2459		var aiVis = _fnGetColumns( oSettings, 'bVisible' );
2460	
2461		return typeof aiVis[iMatch] === 'number' ?
2462			aiVis[iMatch] :
2463			null;
2464	}
2465	
2466	
2467	/**
2468	 * Convert the index of an index in the data array and convert it to the visible
2469	 *   column index (take account of hidden columns)
2470	 *  @param {int} iMatch Column index to lookup
2471	 *  @param {object} oSettings dataTables settings object
2472	 *  @returns {int} i the data index
2473	 *  @memberof DataTable#oApi
2474	 */
2475	function _fnColumnIndexToVisible( oSettings, iMatch )
2476	{
2477		var aiVis = _fnGetColumns( oSettings, 'bVisible' );
2478		var iPos = $.inArray( iMatch, aiVis );
2479	
2480		return iPos !== -1 ? iPos : null;
2481	}
2482	
2483	
2484	/**
2485	 * Get the number of visible columns
2486	 *  @param {object} oSettings dataTables settings object
2487	 *  @returns {int} i the number of visible columns
2488	 *  @memberof DataTable#oApi
2489	 */
2490	function _fnVisbleColumns( oSettings )
2491	{
2492		var vis = 0;
2493	
2494		// No reduce in IE8, use a loop for now
2495		$.each( oSettings.aoColumns, function ( i, col ) {
2496			if ( col.bVisible && $(col.nTh).css('display') !== 'none' ) {
2497				vis++;
2498			}
2499		} );
2500	
2501		return vis;
2502	}
2503	
2504	
2505	/**
2506	 * Get an array of column indexes that match a given property
2507	 *  @param {object} oSettings dataTables settings object
2508	 *  @param {string} sParam Parameter in aoColumns to look for - typically
2509	 *    bVisible or bSearchable
2510	 *  @returns {array} Array of indexes with matched properties
2511	 *  @memberof DataTable#oApi
2512	 */
2513	function _fnGetColumns( oSettings, sParam )
2514	{
2515		var a = [];
2516	
2517		$.map( oSettings.aoColumns, function(val, i) {
2518			if ( val[sParam] ) {
2519				a.push( i );
2520			}
2521		} );
2522	
2523		return a;
2524	}
2525	
2526	
2527	/**
2528	 * Calculate the 'type' of a column
2529	 *  @param {object} settings dataTables settings object
2530	 *  @memberof DataTable#oApi
2531	 */
2532	function _fnColumnTypes ( settings )
2533	{
2534		var columns = settings.aoColumns;
2535		var data = settings.aoData;
2536		var types = DataTable.ext.type.detect;
2537		var i, ien, j, jen, k, ken;
2538		var col, cell, detectedType, cache;
2539	
2540		// For each column, spin over the 
2541		for ( i=0, ien=columns.length ; i<ien ; i++ ) {
2542			col = columns[i];
2543			cache = [];
2544	
2545			if ( ! col.sType && col._sManualType ) {
2546				col.sType = col._sManualType;
2547			}
2548			else if ( ! col.sType ) {
2549				for ( j=0, jen=types.length ; j<jen ; j++ ) {
2550					for ( k=0, ken=data.length ; k<ken ; k++ ) {
2551						// Use a cache array so we only need to get the type data
2552						// from the formatter once (when using multiple detectors)
2553						if ( cache[k] === undefined ) {
2554							cache[k] = _fnGetCellData( settings, k, i, 'type' );
2555						}
2556	
2557						detectedType = types[j]( cache[k], settings );
2558	
2559						// If null, then this type can't apply to this column, so
2560						// rather than testing all cells, break out. There is an
2561						// exception for the last type which is `html`. We need to
2562						// scan all rows since it is possible to mix string and HTML
2563						// types
2564						if ( ! detectedType && j !== types.length-1 ) {
2565							break;
2566						}
2567	
2568						// Only a single match is needed for html type since it is
2569						// bottom of the pile and very similar to string - but it
2570						// must not be empty
2571						if ( detectedType === 'html' && ! _empty(cache[k]) ) {
2572							break;
2573						}
2574					}
2575	
2576					// Type is valid for all data points in the column - use this
2577					// type
2578					if ( detectedType ) {
2579						col.sType = detectedType;
2580						break;
2581					}
2582				}
2583	
2584				// Fall back - if no type was detected, always use string
2585				if ( ! col.sType ) {
2586					col.sType = 'string';
2587				}
2588			}
2589		}
2590	}
2591	
2592	
2593	/**
2594	 * Take the column definitions and static columns arrays and calculate how
2595	 * they relate to column indexes. The callback function will then apply the
2596	 * definition found for a column to a suitable configuration object.
2597	 *  @param {object} oSettings dataTables settings object
2598	 *  @param {array} aoColDefs The aoColumnDefs array that is to be applied
2599	 *  @param {array} aoCols The aoColumns array that defines columns individually
2600	 *  @param {function} fn Callback function - takes two parameters, the calculated
2601	 *    column index and the definition for that column.
2602	 *  @memberof DataTable#oApi
2603	 */
2604	function _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )
2605	{
2606		var i, iLen, j, jLen, k, kLen, def;
2607		var columns = oSettings.aoColumns;
2608	
2609		// Column definitions with aTargets
2610		if ( aoColDefs )
2611		{
2612			/* Loop over the definitions array - loop in reverse so first instance has priority */
2613			for ( i=aoColDefs.length-1 ; i>=0 ; i-- )
2614			{
2615				def = aoColDefs[i];
2616	
2617				/* Each definition can target multiple columns, as it is an array */
2618				var aTargets = def.target !== undefined
2619					? def.target
2620					: def.targets !== undefined
2621						? def.targets
2622						: def.aTargets;
2623	
2624				if ( ! Array.isArray( aTargets ) )
2625				{
2626					aTargets = [ aTargets ];
2627				}
2628	
2629				for ( j=0, jLen=aTargets.length ; j<jLen ; j++ )
2630				{
2631					if ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )
2632					{
2633						/* Add columns that we don't yet know about */
2634						while( columns.length <= aTargets[j] )
2635						{
2636							_fnAddColumn( oSettings );
2637						}
2638	
2639						/* Integer, basic index */
2640						fn( aTargets[j], def );
2641					}
2642					else if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )
2643					{
2644						/* Negative integer, right to left column counting */
2645						fn( columns.length+aTargets[j], def );
2646					}
2647					else if ( typeof aTargets[j] === 'string' )
2648					{
2649						/* Class name matching on TH element */
2650						for ( k=0, kLen=columns.length ; k<kLen ; k++ )
2651						{
2652							if ( aTargets[j] == "_all" ||
2653							     $(columns[k].nTh).hasClass( aTargets[j] ) )
2654							{
2655								fn( k, def );
2656							}
2657						}
2658					}
2659				}
2660			}
2661		}
2662	
2663		// Statically defined columns array
2664		if ( aoCols )
2665		{
2666			for ( i=0, iLen=aoCols.length ; i<iLen ; i++ )
2667			{
2668				fn( i, aoCols[i] );
2669			}
2670		}
2671	}
2672	
2673	/**
2674	 * Add a data array to the table, creating DOM node etc. This is the parallel to
2675	 * _fnGatherData, but for adding rows from a Javascript source, rather than a
2676	 * DOM source.
2677	 *  @param {object} oSettings dataTables settings object
2678	 *  @param {array} aData data array to be added
2679	 *  @param {node} [nTr] TR element to add to the table - optional. If not given,
2680	 *    DataTables will create a row automatically
2681	 *  @param {array} [anTds] Array of TD|TH elements for the row - must be given
2682	 *    if nTr is.
2683	 *  @returns {int} >=0 if successful (index of new aoData entry), -1 if failed
2684	 *  @memberof DataTable#oApi
2685	 */
2686	function _fnAddData ( oSettings, aDataIn, nTr, anTds )
2687	{
2688		/* Create the object for storing information about this new row */
2689		var iRow = oSettings.aoData.length;
2690		var oData = $.extend( true, {}, DataTable.models.oRow, {
2691			src: nTr ? 'dom' : 'data',
2692			idx: iRow
2693		} );
2694	
2695		oData._aData = aDataIn;
2696		oSettings.aoData.push( oData );
2697	
2698		/* Create the cells */
2699		var nTd, sThisType;
2700		var columns = oSettings.aoColumns;
2701	
2702		// Invalidate the column types as the new data needs to be revalidated
2703		for ( var i=0, iLen=columns.length ; i<iLen ; i++ )
2704		{
2705			columns[i].sType = null;
2706		}
2707	
2708		/* Add to the display array */
2709		oSettings.aiDisplayMaster.push( iRow );
2710	
2711		var id = oSettings.rowIdFn( aDataIn );
2712		if ( id !== undefined ) {
2713			oSettings.aIds[ id ] = oData;
2714		}
2715	
2716		/* Create the DOM information, or register it if already present */
2717		if ( nTr || ! oSettings.oFeatures.bDeferRender )
2718		{
2719			_fnCreateTr( oSettings, iRow, nTr, anTds );
2720		}
2721	
2722		return iRow;
2723	}
2724	
2725	
2726	/**
2727	 * Add one or more TR elements to the table. Generally we'd expect to
2728	 * use this for reading data from a DOM sourced table, but it could be
2729	 * used for an TR element. Note that if a TR is given, it is used (i.e.
2730	 * it is not cloned).
2731	 *  @param {object} settings dataTables settings object
2732	 *  @param {array|node|jQuery} trs The TR element(s) to add to the table
2733	 *  @returns {array} Array of indexes for the added rows
2734	 *  @memberof DataTable#oApi
2735	 */
2736	function _fnAddTr( settings, trs )
2737	{
2738		var row;
2739	
2740		// Allow an individual node to be passed in
2741		if ( ! (trs instanceof $) ) {
2742			trs = $(trs);
2743		}
2744	
2745		return trs.map( function (i, el) {
2746			row = _fnGetRowElements( settings, el );
2747			return _fnAddData( settings, row.data, el, row.cells );
2748		} );
2749	}
2750	
2751	
2752	/**
2753	 * Take a TR element and convert it to an index in aoData
2754	 *  @param {object} oSettings dataTables settings object
2755	 *  @param {node} n the TR element to find
2756	 *  @returns {int} index if the node is found, null if not
2757	 *  @memberof DataTable#oApi
2758	 */
2759	function _fnNodeToDataIndex( oSettings, n )
2760	{
2761		return (n._DT_RowIndex!==undefined) ? n._DT_RowIndex : null;
2762	}
2763	
2764	
2765	/**
2766	 * Take a TD element and convert it into a column data index (not the visible index)
2767	 *  @param {object} oSettings dataTables settings object
2768	 *  @param {int} iRow The row number the TD/TH can be found in
2769	 *  @param {node} n The TD/TH element to find
2770	 *  @returns {int} index if the node is found, -1 if not
2771	 *  @memberof DataTable#oApi
2772	 */
2773	function _fnNodeToColumnIndex( oSettings, iRow, n )
2774	{
2775		return $.inArray( n, oSettings.aoData[ iRow ].anCells );
2776	}
2777	
2778	
2779	/**
2780	 * Get the data for a given cell from the internal cache, taking into account data mapping
2781	 *  @param {object} settings dataTables settings object
2782	 *  @param {int} rowIdx aoData row id
2783	 *  @param {int} colIdx Column index
2784	 *  @param {string} type data get type ('display', 'type' 'filter|search' 'sort|order')
2785	 *  @returns {*} Cell data
2786	 *  @memberof DataTable#oApi
2787	 */
2788	function _fnGetCellData( settings, rowIdx, colIdx, type )
2789	{
2790		if (type === 'search') {
2791			type = 'filter';
2792		}
2793		else if (type === 'order') {
2794			type = 'sort';
2795		}
2796	
2797		var draw           = settings.iDraw;
2798		var col            = settings.aoColumns[colIdx];
2799		var rowData        = settings.aoData[rowIdx]._aData;
2800		var defaultContent = col.sDefaultContent;
2801		var cellData       = col.fnGetData( rowData, type, {
2802			settings: settings,
2803			row:      rowIdx,
2804			col:      colIdx
2805		} );
2806	
2807		if ( cellData === undefined ) {
2808			if ( settings.iDrawError != draw && defaultContent === null ) {
2809				_fnLog( settings, 0, "Requested unknown parameter "+
2810					(typeof col.mData=='function' ? '{function}' : "'"+col.mData+"'")+
2811					" for row "+rowIdx+", column "+colIdx, 4 );
2812				settings.iDrawError = draw;
2813			}
2814			return defaultContent;
2815		}
2816	
2817		// When the data source is null and a specific data type is requested (i.e.
2818		// not the original data), we can use default column data
2819		if ( (cellData === rowData || cellData === null) && defaultContent !== null && type !== undefined ) {
2820			cellData = defaultContent;
2821		}
2822		else if ( typeof cellData === 'function' ) {
2823			// If the data source is a function, then we run it and use the return,
2824			// executing in the scope of the data object (for instances)
2825			return cellData.call( rowData );
2826		}
2827	
2828		if ( cellData === null && type === 'display' ) {
2829			return '';
2830		}
2831	
2832		if ( type === 'filter' ) {
2833			var fomatters = DataTable.ext.type.search;
2834	
2835			if ( fomatters[ col.sType ] ) {
2836				cellData = fomatters[ col.sType ]( cellData );
2837			}
2838		}
2839	
2840		return cellData;
2841	}
2842	
2843	
2844	/**
2845	 * Set the value for a specific cell, into the internal data cache
2846	 *  @param {object} settings dataTables settings object
2847	 *  @param {int} rowIdx aoData row id
2848	 *  @param {int} colIdx Column index
2849	 *  @param {*} val Value to set
2850	 *  @memberof DataTable#oApi
2851	 */
2852	function _fnSetCellData( settings, rowIdx, colIdx, val )
2853	{
2854		var col     = settings.aoColumns[colIdx];
2855		var rowData = settings.aoData[rowIdx]._aData;
2856	
2857		col.fnSetData( rowData, val, {
2858			settings: settings,
2859			row:      rowIdx,
2860			col:      colIdx
2861		}  );
2862	}
2863	
2864	
2865	// Private variable that is used to match action syntax in the data property object
2866	var __reArray = /\[.*?\]$/;
2867	var __reFn = /\(\)$/;
2868	
2869	/**
2870	 * Split string on periods, taking into account escaped periods
2871	 * @param  {string} str String to split
2872	 * @return {array} Split string
2873	 */
2874	function _fnSplitObjNotation( str )
2875	{
2876		return $.map( str.match(/(\\.|[^\.])+/g) || [''], function ( s ) {
2877			return s.replace(/\\\./g, '.');
2878		} );
2879	}
2880	
2881	
2882	/**
2883	 * Return a function that can be used to get data from a source object, taking
2884	 * into account the ability to use nested objects as a source
2885	 *  @param {string|int|function} mSource The data source for the object
2886	 *  @returns {function} Data get function
2887	 *  @memberof DataTable#oApi
2888	 */
2889	var _fnGetObjectDataFn = DataTable.util.get;
2890	
2891	
2892	/**
2893	 * Return a function that can be used to set data from a source object, taking
2894	 * into account the ability to use nested objects as a source
2895	 *  @param {string|int|function} mSource The data source for the object
2896	 *  @returns {function} Data set function
2897	 *  @memberof DataTable#oApi
2898	 */
2899	var _fnSetObjectDataFn = DataTable.util.set;
2900	
2901	
2902	/**
2903	 * Return an array with the full table data
2904	 *  @param {object} oSettings dataTables settings object
2905	 *  @returns array {array} aData Master data array
2906	 *  @memberof DataTable#oApi
2907	 */
2908	function _fnGetDataMaster ( settings )
2909	{
2910		return _pluck( settings.aoData, '_aData' );
2911	}
2912	
2913	
2914	/**
2915	 * Nuke the table
2916	 *  @param {object} oSettings dataTables settings object
2917	 *  @memberof DataTable#oApi
2918	 */
2919	function _fnClearTable( settings )
2920	{
2921		settings.aoData.length = 0;
2922		settings.aiDisplayMaster.length = 0;
2923		settings.aiDisplay.length = 0;
2924		settings.aIds = {};
2925	}
2926	
2927	
2928	 /**
2929	 * Take an array of integers (index array) and remove a target integer (value - not
2930	 * the key!)
2931	 *  @param {array} a Index array to target
2932	 *  @param {int} iTarget value to find
2933	 *  @memberof DataTable#oApi
2934	 */
2935	function _fnDeleteIndex( a, iTarget, splice )
2936	{
2937		var iTargetIndex = -1;
2938	
2939		for ( var i=0, iLen=a.length ; i<iLen ; i++ )
2940		{
2941			if ( a[i] == iTarget )
2942			{
2943				iTargetIndex = i;
2944			}
2945			else if ( a[i] > iTarget )
2946			{
2947				a[i]--;
2948			}
2949		}
2950	
2951		if ( iTargetIndex != -1 && splice === undefined )
2952		{
2953			a.splice( iTargetIndex, 1 );
2954		}
2955	}
2956	
2957	
2958	/**
2959	 * Mark cached data as invalid such that a re-read of the data will occur when
2960	 * the cached data is next requested. Also update from the data source object.
2961	 *
2962	 * @param {object} settings DataTables settings object
2963	 * @param {int}    rowIdx   Row index to invalidate
2964	 * @param {string} [src]    Source to invalidate from: undefined, 'auto', 'dom'
2965	 *     or 'data'
2966	 * @param {int}    [colIdx] Column index to invalidate. If undefined the whole
2967	 *     row will be invalidated
2968	 * @memberof DataTable#oApi
2969	 *
2970	 * @todo For the modularisation of v1.11 this will need to become a callback, so
2971	 *   the sort and filter methods can subscribe to it. That will required
2972	 *   initialisation options for sorting, which is why it is not already baked in
2973	 */
2974	function _fnInvalidate( settings, rowIdx, src, colIdx )
2975	{
2976		var row = settings.aoData[ rowIdx ];
2977		var i, ien;
2978		var cellWrite = function ( cell, col ) {
2979			// This is very frustrating, but in IE if you just write directly
2980			// to innerHTML, and elements that are overwritten are GC'ed,
2981			// even if there is a reference to them elsewhere
2982			while ( cell.childNodes.length ) {
2983				cell.removeChild( cell.firstChild );
2984			}
2985	
2986			cell.innerHTML = _fnGetCellData( settings, rowIdx, col, 'display' );
2987		};
2988	
2989		// Are we reading last data from DOM or the data object?
2990		if ( src === 'dom' || ((! src || src === 'auto') && row.src === 'dom') ) {
2991			// Read the data from the DOM
2992			row._aData = _fnGetRowElements(
2993					settings, row, colIdx, colIdx === undefined ? undefined : row._aData
2994				)
2995				.data;
2996		}
2997		else {
2998			// Reading from data object, update the DOM
2999			var cells = row.anCells;
3000	
3001			if ( cells ) {
3002				if ( colIdx !== undefined ) {
3003					cellWrite( cells[colIdx], colIdx );
3004				}
3005				else {
3006					for ( i=0, ien=cells.length ; i<ien ; i++ ) {
3007						cellWrite( cells[i], i );
3008					}
3009				}
3010			}
3011		}
3012	
3013		// For both row and cell invalidation, the cached data for sorting and
3014		// filtering is nulled out
3015		row._aSortData = null;
3016		row._aFilterData = null;
3017	
3018		// Invalidate the type for a specific column (if given) or all columns since
3019		// the data might have changed
3020		var cols = settings.aoColumns;
3021		if ( colIdx !== undefined ) {
3022			cols[ colIdx ].sType = null;
3023		}
3024		else {
3025			for ( i=0, ien=cols.length ; i<ien ; i++ ) {
3026				cols[i].sType = null;
3027			}
3028	
3029			// Update DataTables special `DT_*` attributes for the row
3030			_fnRowAttributes( settings, row );
3031		}
3032	}
3033	
3034	
3035	/**
3036	 * Build a data source object from an HTML row, reading the contents of the
3037	 * cells that are in the row.
3038	 *
3039	 * @param {object} settings DataTables settings object
3040	 * @param {node|object} TR element from which to read data or existing row
3041	 *   object from which to re-read the data from the cells
3042	 * @param {int} [colIdx] Optional column index
3043	 * @param {array|object} [d] Data source object. If `colIdx` is given then this
3044	 *   parameter should also be given and will be used to write the data into.
3045	 *   Only the column in question will be written
3046	 * @returns {object} Object with two parameters: `data` the data read, in
3047	 *   document order, and `cells` and array of nodes (they can be useful to the
3048	 *   caller, so rather than needing a second traversal to get them, just return
3049	 *   them from here).
3050	 * @memberof DataTable#oApi
3051	 */
3052	function _fnGetRowElements( settings, row, colIdx, d )
3053	{
3054		var
3055			tds = [],
3056			td = row.firstChild,
3057			name, col, o, i=0, contents,
3058			columns = settings.aoColumns,
3059			objectRead = settings._rowReadObject;
3060	
3061		// Allow the data object to be passed in, or construct
3062		d = d !== undefined ?
3063			d :
3064			objectRead ?
3065				{} :
3066				[];
3067	
3068		var attr = function ( str, td  ) {
3069			if ( typeof str === 'string' ) {
3070				var idx = str.indexOf('@');
3071	
3072				if ( idx !== -1 ) {
3073					var attr = str.substring( idx+1 );
3074					var setter = _fnSetObjectDataFn( str );
3075					setter( d, td.getAttribute( attr ) );
3076				}
3077			}
3078		};
3079	
3080		// Read data from a cell and store into the data object
3081		var cellProcess = function ( cell ) {
3082			if ( colIdx === undefined || colIdx === i ) {
3083				col = columns[i];
3084				contents = (cell.innerHTML).trim();
3085	
3086				if ( col && col._bAttrSrc ) {
3087					var setter = _fnSetObjectDataFn( col.mData._ );
3088					setter( d, contents );
3089	
3090					attr( col.mData.sort, cell );
3091					attr( col.mData.type, cell );
3092					attr( col.mData.filter, cell );
3093				}
3094				else {
3095					// Depending on the `data` option for the columns the data can
3096					// be read to either an object or an array.
3097					if ( objectRead ) {
3098						if ( ! col._setter ) {
3099							// Cache the setter function
3100							col._setter = _fnSetObjectDataFn( col.mData );
3101						}
3102						col._setter( d, contents );
3103					}
3104					else {
3105						d[i] = contents;
3106					}
3107				}
3108			}
3109	
3110			i++;
3111		};
3112	
3113		if ( td ) {
3114			// `tr` element was passed in
3115			while ( td ) {
3116				name = td.nodeName.toUpperCase();
3117	
3118				if ( name == "TD" || name == "TH" ) {
3119					cellProcess( td );
3120					tds.push( td );
3121				}
3122	
3123				td = td.nextSibling;
3124			}
3125		}
3126		else {
3127			// Existing row object passed in
3128			tds = row.anCells;
3129	
3130			for ( var j=0, jen=tds.length ; j<jen ; j++ ) {
3131				cellProcess( tds[j] );
3132			}
3133		}
3134	
3135		// Read the ID from the DOM if present
3136		var rowNode = row.firstChild ? row : row.nTr;
3137	
3138		if ( rowNode ) {
3139			var id = rowNode.getAttribute( 'id' );
3140	
3141			if ( id ) {
3142				_fnSetObjectDataFn( settings.rowId )( d, id );
3143			}
3144		}
3145	
3146		return {
3147			data: d,
3148			cells: tds
3149		};
3150	}
3151	/**
3152	 * Create a new TR element (and it's TD children) for a row
3153	 *  @param {object} oSettings dataTables settings object
3154	 *  @param {int} iRow Row to consider
3155	 *  @param {node} [nTrIn] TR element to add to the table - optional. If not given,
3156	 *    DataTables will create a row automatically
3157	 *  @param {array} [anTds] Array of TD|TH elements for the row - must be given
3158	 *    if nTr is.
3159	 *  @memberof DataTable#oApi
3160	 */
3161	function _fnCreateTr ( oSettings, iRow, nTrIn, anTds )
3162	{
3163		var
3164			row = oSettings.aoData[iRow],
3165			rowData = row._aData,
3166			cells = [],
3167			nTr, nTd, oCol,
3168			i, iLen, create;
3169	
3170		if ( row.nTr === null )
3171		{
3172			nTr = nTrIn || document.createElement('tr');
3173	
3174			row.nTr = nTr;
3175			row.anCells = cells;
3176	
3177			/* Use a private property on the node to allow reserve mapping from the node
3178			 * to the aoData array for fast look up
3179			 */
3180			nTr._DT_RowIndex = iRow;
3181	
3182			/* Special parameters can be given by the data source to be used on the row */
3183			_fnRowAttributes( oSettings, row );
3184	
3185			/* Process each column */
3186			for ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )
3187			{
3188				oCol = oSettings.aoColumns[i];
3189				create = nTrIn ? false : true;
3190	
3191				nTd = create ? document.createElement( oCol.sCellType ) : anTds[i];
3192	
3193				if (! nTd) {
3194					_fnLog( oSettings, 0, 'Incorrect column count', 18 );
3195				}
3196	
3197				nTd._DT_CellIndex = {
3198					row: iRow,
3199					column: i
3200				};
3201				
3202				cells.push( nTd );
3203	
3204				// Need to create the HTML if new, or if a rendering function is defined
3205				if ( create || ((oCol.mRender || oCol.mData !== i) &&
3206					 (!$.isPlainObject(oCol.mData) || oCol.mData._ !== i+'.display')
3207				)) {
3208					nTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );
3209				}
3210	
3211				/* Add user defined class */
3212				if ( oCol.sClass )
3213				{
3214					nTd.className += ' '+oCol.sClass;
3215				}
3216	
3217				// Visibility - add or remove as required
3218				if ( oCol.bVisible && ! nTrIn )
3219				{
3220					nTr.appendChild( nTd );
3221				}
3222				else if ( ! oCol.bVisible && nTrIn )
3223				{
3224					nTd.parentNode.removeChild( nTd );
3225				}
3226	
3227				if ( oCol.fnCreatedCell )
3228				{
3229					oCol.fnCreatedCell.call( oSettings.oInstance,
3230						nTd, _fnGetCellData( oSettings, iRow, i ), rowData, iRow, i
3231					);
3232				}
3233			}
3234	
3235			_fnCallbackFire( oSettings, 'aoRowCreatedCallback', null, [nTr, rowData, iRow, cells] );
3236		}
3237	}
3238	
3239	
3240	/**
3241	 * Add attributes to a row based on the special `DT_*` parameters in a data
3242	 * source object.
3243	 *  @param {object} settings DataTables settings object
3244	 *  @param {object} DataTables row object for the row to be modified
3245	 *  @memberof DataTable#oApi
3246	 */
3247	function _fnRowAttributes( settings, row )
3248	{
3249		var tr = row.nTr;
3250		var data = row._aData;
3251	
3252		if ( tr ) {
3253			var id = settings.rowIdFn( data );
3254	
3255			if ( id ) {
3256				tr.id = id;
3257			}
3258	
3259			if ( data.DT_RowClass ) {
3260				// Remove any classes added by DT_RowClass before
3261				var a = data.DT_RowClass.split(' ');
3262				row.__rowc = row.__rowc ?
3263					_unique( row.__rowc.concat( a ) ) :
3264					a;
3265	
3266				$(tr)
3267					.removeClass( row.__rowc.join(' ') )
3268					.addClass( data.DT_RowClass );
3269			}
3270	
3271			if ( data.DT_RowAttr ) {
3272				$(tr).attr( data.DT_RowAttr );
3273			}
3274	
3275			if ( data.DT_RowData ) {
3276				$(tr).data( data.DT_RowData );
3277			}
3278		}
3279	}
3280	
3281	
3282	/**
3283	 * Create the HTML header for the table
3284	 *  @param {object} oSettings dataTables settings object
3285	 *  @memberof DataTable#oApi
3286	 */
3287	function _fnBuildHead( oSettings )
3288	{
3289		var i, ien, cell, row, column;
3290		var thead = oSettings.nTHead;
3291		var tfoot = oSettings.nTFoot;
3292		var createHeader = $('th, td', thead).length === 0;
3293		var classes = oSettings.oClasses;
3294		var columns = oSettings.aoColumns;
3295	
3296		if ( createHeader ) {
3297			row = $('<tr/>').appendTo( thead );
3298		}
3299	
3300		for ( i=0, ien=columns.length ; i<ien ; i++ ) {
3301			column = columns[i];
3302			cell = $( column.nTh ).addClass( column.sClass );
3303	
3304			if ( createHeader ) {
3305				cell.appendTo( row );
3306			}
3307	
3308			// 1.11 move into sorting
3309			if ( oSettings.oFeatures.bSort ) {
3310				cell.addClass( column.sSortingClass );
3311	
3312				if ( column.bSortable !== false ) {
3313					cell
3314						.attr( 'tabindex', oSettings.iTabIndex )
3315						.attr( 'aria-controls', oSettings.sTableId );
3316	
3317					_fnSortAttachListener( oSettings, column.nTh, i );
3318				}
3319			}
3320	
3321			if ( column.sTitle != cell[0].innerHTML ) {
3322				cell.html( column.sTitle );
3323			}
3324	
3325			_fnRenderer( oSettings, 'header' )(
3326				oSettings, cell, column, classes
3327			);
3328		}
3329	
3330		if ( createHeader ) {
3331			_fnDetectHeader( oSettings.aoHeader, thead );
3332		}
3333	
3334		/* Deal with the footer - add classes if required */
3335		$(thead).children('tr').children('th, td').addClass( classes.sHeaderTH );
3336		$(tfoot).children('tr').children('th, td').addClass( classes.sFooterTH );
3337	
3338		// Cache the footer cells. Note that we only take the cells from the first
3339		// row in the footer. If there is more than one row the user wants to
3340		// interact with, they need to use the table().foot() method. Note also this
3341		// allows cells to be used for multiple columns using colspan
3342		if ( tfoot !== null ) {
3343			var cells = oSettings.aoFooter[0];
3344	
3345			for ( i=0, ien=cells.length ; i<ien ; i++ ) {
3346				column = columns[i];
3347	
3348				if (column) {
3349					column.nTf = cells[i].cell;
3350		
3351					if ( column.sClass ) {
3352						$(column.nTf).addClass( column.sClass );
3353					}
3354				}
3355				else {
3356					_fnLog( oSettings, 0, 'Incorrect column count', 18 );
3357				}
3358			}
3359		}
3360	}
3361	
3362	
3363	/**
3364	 * Draw the header (or footer) element based on the column visibility states. The
3365	 * methodology here is to use the layout array from _fnDetectHeader, modified for
3366	 * the instantaneous column visibility, to construct the new layout. The grid is
3367	 * traversed over cell at a time in a rows x columns grid fashion, although each
3368	 * cell insert can cover multiple elements in the grid - which is tracks using the
3369	 * aApplied array. Cell inserts in the grid will only occur where there isn't
3370	 * already a cell in that position.
3371	 *  @param {object} oSettings dataTables settings object
3372	 *  @param array {objects} aoSource Layout array from _fnDetectHeader
3373	 *  @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,
3374	 *  @memberof DataTable#oApi
3375	 */
3376	function _fnDrawHead( oSettings, aoSource, bIncludeHidden )
3377	{
3378		var i, iLen, j, jLen, k, kLen, n, nLocalTr;
3379		var aoLocal = [];
3380		var aApplied = [];
3381		var iColumns = oSettings.aoColumns.length;
3382		var iRowspan, iColspan;
3383	
3384		if ( ! aoSource )
3385		{
3386			return;
3387		}
3388	
3389		if (  bIncludeHidden === undefined )
3390		{
3391			bIncludeHidden = false;
3392		}
3393	
3394		/* Make a copy of the master layout array, but without the visible columns in it */
3395		for ( i=0, iLen=aoSource.length ; i<iLen ; i++ )
3396		{
3397			aoLocal[i] = aoSource[i].slice();
3398			aoLocal[i].nTr = aoSource[i].nTr;
3399	
3400			/* Remove any columns which are currently hidden */
3401			for ( j=iColumns-1 ; j>=0 ; j-- )
3402			{
3403				if ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )
3404				{
3405					aoLocal[i].splice( j, 1 );
3406				}
3407			}
3408	
3409			/* Prep the applied array - it needs an element for each row */
3410			aApplied.push( [] );
3411		}
3412	
3413		for ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )
3414		{
3415			nLocalTr = aoLocal[i].nTr;
3416	
3417			/* All cells are going to be replaced, so empty out the row */
3418			if ( nLocalTr )
3419			{
3420				while( (n = nLocalTr.firstChild) )
3421				{
3422					nLocalTr.removeChild( n );
3423				}
3424			}
3425	
3426			for ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )
3427			{
3428				iRowspan = 1;
3429				iColspan = 1;
3430	
3431				/* Check to see if there is already a cell (row/colspan) covering our target
3432				 * insert point. If there is, then there is nothing to do.
3433				 */
3434				if ( aApplied[i][j] === undefined )
3435				{
3436					nLocalTr.appendChild( aoLocal[i][j].cell );
3437					aApplied[i][j] = 1;
3438	
3439					/* Expand the cell to cover as many rows as needed */
3440					while ( aoLocal[i+iRowspan] !== undefined &&
3441					        aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )
3442					{
3443						aApplied[i+iRowspan][j] = 1;
3444						iRowspan++;
3445					}
3446	
3447					/* Expand the cell to cover as many columns as needed */
3448					while ( aoLocal[i][j+iColspan] !== undefined &&
3449					        aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )
3450					{
3451						/* Must update the applied array over the rows for the columns */
3452						for ( k=0 ; k<iRowspan ; k++ )
3453						{
3454							aApplied[i+k][j+iColspan] = 1;
3455						}
3456						iColspan++;
3457					}
3458	
3459					/* Do the actual expansion in the DOM */
3460					$(aoLocal[i][j].cell)
3461						.attr('rowspan', iRowspan)
3462						.attr('colspan', iColspan);
3463				}
3464			}
3465		}
3466	}
3467	
3468	
3469	/**
3470	 * Insert the required TR nodes into the table for display
3471	 *  @param {object} oSettings dataTables settings object
3472	 *  @param ajaxComplete true after ajax call to complete rendering
3473	 *  @memberof DataTable#oApi
3474	 */
3475	function _fnDraw( oSettings, ajaxComplete )
3476	{
3477		// Allow for state saving and a custom start position
3478		_fnStart( oSettings );
3479	
3480		/* Provide a pre-callback function which can be used to cancel the draw is false is returned */
3481		var aPreDraw = _fnCallbackFire( oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings] );
3482		if ( $.inArray( false, aPreDraw ) !== -1 )
3483		{
3484			_fnProcessingDisplay( oSettings, false );
3485			return;
3486		}
3487	
3488		var anRows = [];
3489		var iRowCount = 0;
3490		var asStripeClasses = oSettings.asStripeClasses;
3491		var iStripes = asStripeClasses.length;
3492		var oLang = oSettings.oLanguage;
3493		var bServerSide = _fnDataSource( oSettings ) == 'ssp';
3494		var aiDisplay = oSettings.aiDisplay;
3495		var iDisplayStart = oSettings._iDisplayStart;
3496		var iDisplayEnd = oSettings.fnDisplayEnd();
3497	
3498		oSettings.bDrawing = true;
3499	
3500		/* Server-side processing draw intercept */
3501		if ( oSettings.bDeferLoading )
3502		{
3503			oSettings.bDeferLoading = false;
3504			oSettings.iDraw++;
3505			_fnProcessingDisplay( oSettings, false );
3506		}
3507		else if ( !bServerSide )
3508		{
3509			oSettings.iDraw++;
3510		}
3511		else if ( !oSettings.bDestroying && !ajaxComplete)
3512		{
3513			_fnAjaxUpdate( oSettings );
3514			return;
3515		}
3516	
3517		if ( aiDisplay.length !== 0 )
3518		{
3519			var iStart = bServerSide ? 0 : iDisplayStart;
3520			var iEnd = bServerSide ? oSettings.aoData.length : iDisplayEnd;
3521	
3522			for ( var j=iStart ; j<iEnd ; j++ )
3523			{
3524				var iDataIndex = aiDisplay[j];
3525				var aoData = oSettings.aoData[ iDataIndex ];
3526				if ( aoData.nTr === null )
3527				{
3528					_fnCreateTr( oSettings, iDataIndex );
3529				}
3530	
3531				var nRow = aoData.nTr;
3532	
3533				/* Remove the old striping classes and then add the new one */
3534				if ( iStripes !== 0 )
3535				{
3536					var sStripe = asStripeClasses[ iRowCount % iStripes ];
3537					if ( aoData._sRowStripe != sStripe )
3538					{
3539						$(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );
3540						aoData._sRowStripe = sStripe;
3541					}
3542				}
3543	
3544				// Row callback functions - might want to manipulate the row
3545				// iRowCount and j are not currently documented. Are they at all
3546				// useful?
3547				_fnCallbackFire( oSettings, 'aoRowCallback', null,
3548					[nRow, aoData._aData, iRowCount, j, iDataIndex] );
3549	
3550				anRows.push( nRow );
3551				iRowCount++;
3552			}
3553		}
3554		else
3555		{
3556			/* Table is empty - create a row with an empty message in it */
3557			var sZero = oLang.sZeroRecords;
3558			if ( oSettings.iDraw == 1 &&  _fnDataSource( oSettings ) == 'ajax' )
3559			{
3560				sZero = oLang.sLoadingRecords;
3561			}
3562			else if ( oLang.sEmptyTable && oSettings.fnRecordsTotal() === 0 )
3563			{
3564				sZero = oLang.sEmptyTable;
3565			}
3566	
3567			anRows[ 0 ] = $( '<tr/>', { 'class': iStripes ? asStripeClasses[0] : '' } )
3568				.append( $('<td />', {
3569					'valign':  'top',
3570					'colSpan': _fnVisbleColumns( oSettings ),
3571					'class':   oSettings.oClasses.sRowEmpty
3572				} ).html( sZero ) )[0];
3573		}
3574	
3575		/* Header and footer callbacks */
3576		_fnCallbackFire( oSettings, 'aoHeaderCallback', 'header', [ $(oSettings.nTHead).children('tr')[0],
3577			_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
3578	
3579		_fnCallbackFire( oSettings, 'aoFooterCallback', 'footer', [ $(oSettings.nTFoot).children('tr')[0],
3580			_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );
3581	
3582		var body = $(oSettings.nTBody);
3583	
3584		body.children().detach();
3585		body.append( $(anRows) );
3586	
3587		/* Call all required callback functions for the end of a draw */
3588		_fnCallbackFire( oSettings, 'aoDrawCallback', 'draw', [oSettings] );
3589	
3590		/* Draw is complete, sorting and filtering must be as well */
3591		oSettings.bSorted = false;
3592		oSettings.bFiltered = false;
3593		oSettings.bDrawing = false;
3594	}
3595	
3596	
3597	/**
3598	 * Redraw the table - taking account of the various features which are enabled
3599	 *  @param {object} oSettings dataTables settings object
3600	 *  @param {boolean} [holdPosition] Keep the current paging position. By default
3601	 *    the paging is reset to the first page
3602	 *  @memberof DataTable#oApi
3603	 */
3604	function _fnReDraw( settings, holdPosition )
3605	{
3606		var
3607			features = settings.oFeatures,
3608			sort     = features.bSort,
3609			filter   = features.bFilter;
3610	
3611		if ( sort ) {
3612			_fnSort( settings );
3613		}
3614	
3615		if ( filter ) {
3616			_fnFilterComplete( settings, settings.oPreviousSearch );
3617		}
3618		else {
3619			// No filtering, so we want to just use the display master
3620			settings.aiDisplay = settings.aiDisplayMaster.slice();
3621		}
3622	
3623		if ( holdPosition !== true ) {
3624			settings._iDisplayStart = 0;
3625		}
3626	
3627		// Let any modules know about the draw hold position state (used by
3628		// scrolling internally)
3629		settings._drawHold = holdPosition;
3630	
3631		_fnDraw( settings );
3632	
3633		settings._drawHold = false;
3634	}
3635	
3636	
3637	/**
3638	 * Add the options to the page HTML for the table
3639	 *  @param {object} oSettings dataTables settings object
3640	 *  @memberof DataTable#oApi
3641	 */
3642	function _fnAddOptionsHtml ( oSettings )
3643	{
3644		var classes = oSettings.oClasses;
3645		var table = $(oSettings.nTable);
3646		var holding = $('<div/>').insertBefore( table ); // Holding element for speed
3647		var features = oSettings.oFeatures;
3648	
3649		// All DataTables are wrapped in a div
3650		var insert = $('<div/>', {
3651			id:      oSettings.sTableId+'_wrapper',
3652			'class': classes.sWrapper + (oSettings.nTFoot ? '' : ' '+classes.sNoFooter)
3653		} );
3654	
3655		oSettings.nHolding = holding[0];
3656		oSettings.nTableWrapper = insert[0];
3657		oSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;
3658	
3659		/* Loop over the user set positioning and place the elements as needed */
3660		var aDom = oSettings.sDom.split('');
3661		var featureNode, cOption, nNewNode, cNext, sAttr, j;
3662		for ( var i=0 ; i<aDom.length ; i++ )
3663		{
3664			featureNode = null;
3665			cOption = aDom[i];
3666	
3667			if ( cOption == '<' )
3668			{
3669				/* New container div */
3670				nNewNode = $('<div/>')[0];
3671	
3672				/* Check to see if we should append an id and/or a class name to the container */
3673				cNext = aDom[i+1];
3674				if ( cNext == "'" || cNext == '"' )
3675				{
3676					sAttr = "";
3677					j = 2;
3678					while ( aDom[i+j] != cNext )
3679					{
3680						sAttr += aDom[i+j];
3681						j++;
3682					}
3683	
3684					/* Replace jQuery UI constants @todo depreciated */
3685					if ( sAttr == "H" )
3686					{
3687						sAttr = classes.sJUIHeader;
3688					}
3689					else if ( sAttr == "F" )
3690					{
3691						sAttr = classes.sJUIFooter;
3692					}
3693	
3694					/* The attribute can be in the format of "#id.class", "#id" or "class" This logic
3695					 * breaks the string into parts and applies them as needed
3696					 */
3697					if ( sAttr.indexOf('.') != -1 )
3698					{
3699						var aSplit = sAttr.split('.');
3700						nNewNode.id = aSplit[0].substr(1, aSplit[0].length-1);
3701						nNewNode.className = aSplit[1];
3702					}
3703					else if ( sAttr.charAt(0) == "#" )
3704					{
3705						nNewNode.id = sAttr.substr(1, sAttr.length-1);
3706					}
3707					else
3708					{
3709						nNewNode.className = sAttr;
3710					}
3711	
3712					i += j; /* Move along the position array */
3713				}
3714	
3715				insert.append( nNewNode );
3716				insert = $(nNewNode);
3717			}
3718			else if ( cOption == '>' )
3719			{
3720				/* End container div */
3721				insert = insert.parent();
3722			}
3723			// @todo Move options into their own plugins?
3724			else if ( cOption == 'l' && features.bPaginate && features.bLengthChange )
3725			{
3726				/* Length */
3727				featureNode = _fnFeatureHtmlLength( oSettings );
3728			}
3729			else if ( cOption == 'f' && features.bFilter )
3730			{
3731				/* Filter */
3732				featureNode = _fnFeatureHtmlFilter( oSettings );
3733			}
3734			else if ( cOption == 'r' && features.bProcessing )
3735			{
3736				/* pRocessing */
3737				featureNode = _fnFeatureHtmlProcessing( oSettings );
3738			}
3739			else if ( cOption == 't' )
3740			{
3741				/* Table */
3742				featureNode = _fnFeatureHtmlTable( oSettings );
3743			}
3744			else if ( cOption ==  'i' && features.bInfo )
3745			{
3746				/* Info */
3747				featureNode = _fnFeatureHtmlInfo( oSettings );
3748			}
3749			else if ( cOption == 'p' && features.bPaginate )
3750			{
3751				/* Pagination */
3752				featureNode = _fnFeatureHtmlPaginate( oSettings );
3753			}
3754			else if ( DataTable.ext.feature.length !== 0 )
3755			{
3756				/* Plug-in features */
3757				var aoFeatures = DataTable.ext.feature;
3758				for ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )
3759				{
3760					if ( cOption == aoFeatures[k].cFeature )
3761					{
3762						featureNode = aoFeatures[k].fnInit( oSettings );
3763						break;
3764					}
3765				}
3766			}
3767	
3768			/* Add to the 2D features array */
3769			if ( featureNode )
3770			{
3771				var aanFeatures = oSettings.aanFeatures;
3772	
3773				if ( ! aanFeatures[cOption] )
3774				{
3775					aanFeatures[cOption] = [];
3776				}
3777	
3778				aanFeatures[cOption].push( featureNode );
3779				insert.append( featureNode );
3780			}
3781		}
3782	
3783		/* Built our DOM structure - replace the holding div with what we want */
3784		holding.replaceWith( insert );
3785		oSettings.nHolding = null;
3786	}
3787	
3788	
3789	/**
3790	 * Use the DOM source to create up an array of header cells. The idea here is to
3791	 * create a layout grid (array) of rows x columns, which contains a reference
3792	 * to the cell that that point in the grid (regardless of col/rowspan), such that
3793	 * any column / row could be removed and the new grid constructed
3794	 *  @param array {object} aLayout Array to store the calculated layout in
3795	 *  @param {node} nThead The header/footer element for the table
3796	 *  @memberof DataTable#oApi
3797	 */
3798	function _fnDetectHeader ( aLayout, nThead )
3799	{
3800		var nTrs = $(nThead).children('tr');
3801		var nTr, nCell;
3802		var i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;
3803		var bUnique;
3804		var fnShiftCol = function ( a, i, j ) {
3805			var k = a[i];
3806	                while ( k[j] ) {
3807				j++;
3808			}
3809			return j;
3810		};
3811	
3812		aLayout.splice( 0, aLayout.length );
3813	
3814		/* We know how many rows there are in the layout - so prep it */
3815		for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
3816		{
3817			aLayout.push( [] );
3818		}
3819	
3820		/* Calculate a layout array */
3821		for ( i=0, iLen=nTrs.length ; i<iLen ; i++ )
3822		{
3823			nTr = nTrs[i];
3824			iColumn = 0;
3825	
3826			/* For every cell in the row... */
3827			nCell = nTr.firstChild;
3828			while ( nCell ) {
3829				if ( nCell.nodeName.toUpperCase() == "TD" ||
3830				     nCell.nodeName.toUpperCase() == "TH" )
3831				{
3832					/* Get the col and rowspan attributes from the DOM and sanitise them */
3833					iColspan = nCell.getAttribute('colspan') * 1;
3834					iRowspan = nCell.getAttribute('rowspan') * 1;
3835					iColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;
3836					iRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;
3837	
3838					/* There might be colspan cells already in this row, so shift our target
3839					 * accordingly
3840					 */
3841					iColShifted = fnShiftCol( aLayout, i, iColumn );
3842	
3843					/* Cache calculation for unique columns */
3844					bUnique = iColspan === 1 ? true : false;
3845	
3846					/* If there is col / rowspan, copy the information into the layout grid */
3847					for ( l=0 ; l<iColspan ; l++ )
3848					{
3849						for ( k=0 ; k<iRowspan ; k++ )
3850						{
3851							aLayout[i+k][iColShifted+l] = {
3852								"cell": nCell,
3853								"unique": bUnique
3854							};
3855							aLayout[i+k].nTr = nTr;
3856						}
3857					}
3858				}
3859				nCell = nCell.nextSibling;
3860			}
3861		}
3862	}
3863	
3864	
3865	/**
3866	 * Get an array of unique th elements, one for each column
3867	 *  @param {object} oSettings dataTables settings object
3868	 *  @param {node} nHeader automatically detect the layout from this node - optional
3869	 *  @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional
3870	 *  @returns array {node} aReturn list of unique th's
3871	 *  @memberof DataTable#oApi
3872	 */
3873	function _fnGetUniqueThs ( oSettings, nHeader, aLayout )
3874	{
3875		var aReturn = [];
3876		if ( !aLayout )
3877		{
3878			aLayout = oSettings.aoHeader;
3879			if ( nHeader )
3880			{
3881				aLayout = [];
3882				_fnDetectHeader( aLayout, nHeader );
3883			}
3884		}
3885	
3886		for ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )
3887		{
3888			for ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )
3889			{
3890				if ( aLayout[i][j].unique &&
3891					 (!aReturn[j] || !oSettings.bSortCellsTop) )
3892				{
3893					aReturn[j] = aLayout[i][j].cell;
3894				}
3895			}
3896		}
3897	
3898		return aReturn;
3899	}
3900	
3901	/**
3902	 * Set the start position for draw
3903	 *  @param {object} oSettings dataTables settings object
3904	 */
3905	function _fnStart( oSettings )
3906	{
3907		var bServerSide = _fnDataSource( oSettings ) == 'ssp';
3908		var iInitDisplayStart = oSettings.iInitDisplayStart;
3909	
3910		// Check and see if we have an initial draw position from state saving
3911		if ( iInitDisplayStart !== undefined && iInitDisplayStart !== -1 )
3912		{
3913			oSettings._iDisplayStart = bServerSide ?
3914				iInitDisplayStart :
3915				iInitDisplayStart >= oSettings.fnRecordsDisplay() ?
3916					0 :
3917					iInitDisplayStart;
3918	
3919			oSettings.iInitDisplayStart = -1;
3920		}
3921	}
3922	
3923	/**
3924	 * Create an Ajax call based on the table's settings, taking into account that
3925	 * parameters can have multiple forms, and backwards compatibility.
3926	 *
3927	 * @param {object} oSettings dataTables settings object
3928	 * @param {array} data Data to send to the server, required by
3929	 *     DataTables - may be augmented by developer callbacks
3930	 * @param {function} fn Callback function to run when data is obtained
3931	 */
3932	function _fnBuildAjax( oSettings, data, fn )
3933	{
3934		// Compatibility with 1.9-, allow fnServerData and event to manipulate
3935		_fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [data] );
3936	
3937		// Convert to object based for 1.10+ if using the old array scheme which can
3938		// come from server-side processing or serverParams
3939		if ( data && Array.isArray(data) ) {
3940			var tmp = {};
3941			var rbracket = /(.*?)\[\]$/;
3942	
3943			$.each( data, function (key, val) {
3944				var match = val.name.match(rbracket);
3945	
3946				if ( match ) {
3947					// Support for arrays
3948					var name = match[0];
3949	
3950					if ( ! tmp[ name ] ) {
3951						tmp[ name ] = [];
3952					}
3953					tmp[ name ].push( val.value );
3954				}
3955				else {
3956					tmp[val.name] = val.value;
3957				}
3958			} );
3959			data = tmp;
3960		}
3961	
3962		var ajaxData;
3963		var ajax = oSettings.ajax;
3964		var instance = oSettings.oInstance;
3965		var callback = function ( json ) {
3966			var status = oSettings.jqXHR
3967				? oSettings.jqXHR.status
3968				: null;
3969	
3970			if ( json === null || (typeof status === 'number' && status == 204 ) ) {
3971				json = {};
3972				_fnAjaxDataSrc( oSettings, json, [] );
3973			}
3974	
3975			var error = json.error || json.sError;
3976			if ( error ) {
3977				_fnLog( oSettings, 0, error );
3978			}
3979	
3980			oSettings.json = json;
3981	
3982			_fnCallbackFire( oSettings, null, 'xhr', [oSettings, json, oSettings.jqXHR] );
3983			fn( json );
3984		};
3985	
3986		if ( $.isPlainObject( ajax ) && ajax.data )
3987		{
3988			ajaxData = ajax.data;
3989	
3990			var newData = typeof ajaxData === 'function' ?
3991				ajaxData( data, oSettings ) :  // fn can manipulate data or return
3992				ajaxData;                      // an object object or array to merge
3993	
3994			// If the function returned something, use that alone
3995			data = typeof ajaxData === 'function' && newData ?
3996				newData :
3997				$.extend( true, data, newData );
3998	
3999			// Remove the data property as we've resolved it already and don't want
4000			// jQuery to do it again (it is restored at the end of the function)
4001			delete ajax.data;
4002		}
4003	
4004		var baseAjax = {
4005			"data": data,
4006			"success": callback,
4007			"dataType": "json",
4008			"cache": false,
4009			"type": oSettings.sServerMethod,
4010			"error": function (xhr, error, thrown) {
4011				var ret = _fnCallbackFire( oSettings, null, 'xhr', [oSettings, null, oSettings.jqXHR] );
4012	
4013				if ( $.inArray( true, ret ) === -1 ) {
4014					if ( error == "parsererror" ) {
4015						_fnLog( oSettings, 0, 'Invalid JSON response', 1 );
4016					}
4017					else if ( xhr.readyState === 4 ) {
4018						_fnLog( oSettings, 0, 'Ajax error', 7 );
4019					}
4020				}
4021	
4022				_fnProcessingDisplay( oSettings, false );
4023			}
4024		};
4025	
4026		// Store the data submitted for the API
4027		oSettings.oAjaxData = data;
4028	
4029		// Allow plug-ins and external processes to modify the data
4030		_fnCallbackFire( oSettings, null, 'preXhr', [oSettings, data] );
4031	
4032		if ( oSettings.fnServerData )
4033		{
4034			// DataTables 1.9- compatibility
4035			oSettings.fnServerData.call( instance,
4036				oSettings.sAjaxSource,
4037				$.map( data, function (val, key) { // Need to convert back to 1.9 trad format
4038					return { name: key, value: val };
4039				} ),
4040				callback,
4041				oSettings
4042			);
4043		}
4044		else if ( oSettings.sAjaxSource || typeof ajax === 'string' )
4045		{
4046			// DataTables 1.9- compatibility
4047			oSettings.jqXHR = $.ajax( $.extend( baseAjax, {
4048				url: ajax || oSettings.sAjaxSource
4049			} ) );
4050		}
4051		else if ( typeof ajax === 'function' )
4052		{
4053			// Is a function - let the caller define what needs to be done
4054			oSettings.jqXHR = ajax.call( instance, data, callback, oSettings );
4055		}
4056		else
4057		{
4058			// Object to extend the base settings
4059			oSettings.jqXHR = $.ajax( $.extend( baseAjax, ajax ) );
4060	
4061			// Restore for next time around
4062			ajax.data = ajaxData;
4063		}
4064	}
4065	
4066	
4067	/**
4068	 * Update the table using an Ajax call
4069	 *  @param {object} settings dataTables settings object
4070	 *  @returns {boolean} Block the table drawing or not
4071	 *  @memberof DataTable#oApi
4072	 */
4073	function _fnAjaxUpdate( settings )
4074	{
4075		settings.iDraw++;
4076		_fnProcessingDisplay( settings, true );
4077	
4078		_fnBuildAjax(
4079			settings,
4080			_fnAjaxParameters( settings ),
4081			function(json) {
4082				_fnAjaxUpdateDraw( settings, json );
4083			}
4084		);
4085	}
4086	
4087	
4088	/**
4089	 * Build up the parameters in an object needed for a server-side processing
4090	 * request. Note that this is basically done twice, is different ways - a modern
4091	 * method which is used by default in DataTables 1.10 which uses objects and
4092	 * arrays, or the 1.9- method with is name / value pairs. 1.9 method is used if
4093	 * the sAjaxSource option is used in the initialisation, or the legacyAjax
4094	 * option is set.
4095	 *  @param {object} oSettings dataTables settings object
4096	 *  @returns {bool} block the table drawing or not
4097	 *  @memberof DataTable#oApi
4098	 */
4099	function _fnAjaxParameters( settings )
4100	{
4101		var
4102			columns = settings.aoColumns,
4103			columnCount = columns.length,
4104			features = settings.oFeatures,
4105			preSearch = settings.oPreviousSearch,
4106			preColSearch = settings.aoPreSearchCols,
4107			i, data = [], dataProp, column, columnSearch,
4108			sort = _fnSortFlatten( settings ),
4109			displayStart = settings._iDisplayStart,
4110			displayLength = features.bPaginate !== false ?
4111				settings._iDisplayLength :
4112				-1;
4113	
4114		var param = function ( name, value ) {
4115			data.push( { 'name': name, 'value': value } );
4116		};
4117	
4118		// DataTables 1.9- compatible method
4119		param( 'sEcho',          settings.iDraw );
4120		param( 'iColumns',       columnCount );
4121		param( 'sColumns',       _pluck( columns, 'sName' ).join(',') );
4122		param( 'iDisplayStart',  displayStart );
4123		param( 'iDisplayLength', displayLength );
4124	
4125		// DataTables 1.10+ method
4126		var d = {
4127			draw:    settings.iDraw,
4128			columns: [],
4129			order:   [],
4130			start:   displayStart,
4131			length:  displayLength,
4132			search:  {
4133				value: preSearch.sSearch,
4134				regex: preSearch.bRegex
4135			}
4136		};
4137	
4138		for ( i=0 ; i<columnCount ; i++ ) {
4139			column = columns[i];
4140			columnSearch = preColSearch[i];
4141			dataProp = typeof column.mData=="function" ? 'function' : column.mData ;
4142	
4143			d.columns.push( {
4144				data:       dataProp,
4145				name:       column.sName,
4146				searchable: column.bSearchable,
4147				orderable:  column.bSortable,
4148				search:     {
4149					value: columnSearch.sSearch,
4150					regex: columnSearch.bRegex
4151				}
4152			} );
4153	
4154			param( "mDataProp_"+i, dataProp );
4155	
4156			if ( features.bFilter ) {
4157				param( 'sSearch_'+i,     columnSearch.sSearch );
4158				param( 'bRegex_'+i,      columnSearch.bRegex );
4159				param( 'bSearchable_'+i, column.bSearchable );
4160			}
4161	
4162			if ( features.bSort ) {
4163				param( 'bSortable_'+i, column.bSortable );
4164			}
4165		}
4166	
4167		if ( features.bFilter ) {
4168			param( 'sSearch', preSearch.sSearch );
4169			param( 'bRegex', preSearch.bRegex );
4170		}
4171	
4172		if ( features.bSort ) {
4173			$.each( sort, function ( i, val ) {
4174				d.order.push( { column: val.col, dir: val.dir } );
4175	
4176				param( 'iSortCol_'+i, val.col );
4177				param( 'sSortDir_'+i, val.dir );
4178			} );
4179	
4180			param( 'iSortingCols', sort.length );
4181		}
4182	
4183		// If the legacy.ajax parameter is null, then we automatically decide which
4184		// form to use, based on sAjaxSource
4185		var legacy = DataTable.ext.legacy.ajax;
4186		if ( legacy === null ) {
4187			return settings.sAjaxSource ? data : d;
4188		}
4189	
4190		// Otherwise, if legacy has been specified then we use that to decide on the
4191		// form
4192		return legacy ? data : d;
4193	}
4194	
4195	
4196	/**
4197	 * Data the data from the server (nuking the old) and redraw the table
4198	 *  @param {object} oSettings dataTables settings object
4199	 *  @param {object} json json data return from the server.
4200	 *  @param {string} json.sEcho Tracking flag for DataTables to match requests
4201	 *  @param {int} json.iTotalRecords Number of records in the data set, not accounting for filtering
4202	 *  @param {int} json.iTotalDisplayRecords Number of records in the data set, accounting for filtering
4203	 *  @param {array} json.aaData The data to display on this page
4204	 *  @param {string} [json.sColumns] Column ordering (sName, comma separated)
4205	 *  @memberof DataTable#oApi
4206	 */
4207	function _fnAjaxUpdateDraw ( settings, json )
4208	{
4209		// v1.10 uses camelCase variables, while 1.9 uses Hungarian notation.
4210		// Support both
4211		var compat = function ( old, modern ) {
4212			return json[old] !== undefined ? json[old] : json[modern];
4213		};
4214	
4215		var data = _fnAjaxDataSrc( settings, json );
4216		var draw            = compat( 'sEcho',                'draw' );
4217		var recordsTotal    = compat( 'iTotalRecords',        'recordsTotal' );
4218		var recordsFiltered = compat( 'iTotalDisplayRecords', 'recordsFiltered' );
4219	
4220		if ( draw !== undefined ) {
4221			// Protect against out of sequence returns
4222			if ( draw*1 < settings.iDraw ) {
4223				return;
4224			}
4225			settings.iDraw = draw * 1;
4226		}
4227	
4228		// No data in returned object, so rather than an array, we show an empty table
4229		if ( ! data ) {
4230			data = [];
4231		}
4232	
4233		_fnClearTable( settings );
4234		settings._iRecordsTotal   = parseInt(recordsTotal, 10);
4235		settings._iRecordsDisplay = parseInt(recordsFiltered, 10);
4236	
4237		for ( var i=0, ien=data.length ; i<ien ; i++ ) {
4238			_fnAddData( settings, data[i] );
4239		}
4240		settings.aiDisplay = settings.aiDisplayMaster.slice();
4241	
4242		_fnDraw( settings, true );
4243	
4244		if ( ! settings._bInitComplete ) {
4245			_fnInitComplete( settings, json );
4246		}
4247	
4248		_fnProcessingDisplay( settings, false );
4249	}
4250	
4251	
4252	/**
4253	 * Get the data from the JSON data source to use for drawing a table. Using
4254	 * `_fnGetObjectDataFn` allows the data to be sourced from a property of the
4255	 * source object, or from a processing function.
4256	 *  @param {object} oSettings dataTables settings object
4257	 *  @param  {object} json Data source object / array from the server
4258	 *  @return {array} Array of data to use
4259	 */
4260	 function _fnAjaxDataSrc ( oSettings, json, write )
4261	 {
4262		var dataSrc = $.isPlainObject( oSettings.ajax ) && oSettings.ajax.dataSrc !== undefined ?
4263			oSettings.ajax.dataSrc :
4264			oSettings.sAjaxDataProp; // Compatibility with 1.9-.
4265	
4266		if ( ! write ) {
4267			if ( dataSrc === 'data' ) {
4268				// If the default, then we still want to support the old style, and safely ignore
4269				// it if possible
4270				return json.aaData || json[dataSrc];
4271			}
4272	
4273			return dataSrc !== "" ?
4274				_fnGetObjectDataFn( dataSrc )( json ) :
4275				json;
4276		}
4277	
4278		// set
4279		_fnSetObjectDataFn( dataSrc )( json, write );
4280	}
4281	
4282	/**
4283	 * Generate the node required for filtering text
4284	 *  @returns {node} Filter control element
4285	 *  @param {object} oSettings dataTables settings object
4286	 *  @memberof DataTable#oApi
4287	 */
4288	function _fnFeatureHtmlFilter ( settings )
4289	{
4290		var classes = settings.oClasses;
4291		var tableId = settings.sTableId;
4292		var language = settings.oLanguage;
4293		var previousSearch = settings.oPreviousSearch;
4294		var features = settings.aanFeatures;
4295		var input = '<input type="search" class="'+classes.sFilterInput+'"/>';
4296	
4297		var str = language.sSearch;
4298		str = str.match(/_INPUT_/) ?
4299			str.replace('_INPUT_', input) :
4300			str+input;
4301	
4302		var filter = $('<div/>', {
4303				'id': ! features.f ? tableId+'_filter' : null,
4304				'class': classes.sFilter
4305			} )
4306			.append( $('<label/>' ).append( str ) );
4307	
4308		var searchFn = function(event) {
4309			/* Update all other filter input elements for the new display */
4310			var n = features.f;
4311			var val = !this.value ? "" : this.value; // mental IE8 fix :-(
4312			if(previousSearch.return && event.key !== "Enter") {
4313				return;
4314			}
4315			/* Now do the filter */
4316			if ( val != previousSearch.sSearch ) {
4317				_fnFilterComplete( settings, {
4318					"sSearch": val,
4319					"bRegex": previousSearch.bRegex,
4320					"bSmart": previousSearch.bSmart ,
4321					"bCaseInsensitive": previousSearch.bCaseInsensitive,
4322					"return": previousSearch.return
4323				} );
4324	
4325				// Need to redraw, without resorting
4326				settings._iDisplayStart = 0;
4327				_fnDraw( settings );
4328			}
4329		};
4330	
4331		var searchDelay = settings.searchDelay !== null ?
4332			settings.searchDelay :
4333			_fnDataSource( settings ) === 'ssp' ?
4334				400 :
4335				0;
4336	
4337		var jqFilter = $('input', filter)
4338			.val( previousSearch.sSearch )
4339			.attr( 'placeholder', language.sSearchPlaceholder )
4340			.on(
4341				'keyup.DT search.DT input.DT paste.DT cut.DT',
4342				searchDelay ?
4343					_fnThrottle( searchFn, searchDelay ) :
4344					searchFn
4345			)
4346			.on( 'mouseup', function(e) {
4347				// Edge fix! Edge 17 does not trigger anything other than mouse events when clicking
4348				// on the clear icon (Edge bug 17584515). This is safe in other browsers as `searchFn`
4349				// checks the value to see if it has changed. In other browsers it won't have.
4350				setTimeout( function () {
4351					searchFn.call(jqFilter[0], e);
4352				}, 10);
4353			} )
4354			.on( 'keypress.DT', function(e) {
4355				/* Prevent form submission */
4356				if ( e.keyCode == 13 ) {
4357					return false;
4358				}
4359			} )
4360			.attr('aria-controls', tableId);
4361	
4362		// Update the input elements whenever the table is filtered
4363		$(settings.nTable).on( 'search.dt.DT', function ( ev, s ) {
4364			if ( settings === s ) {
4365				// IE9 throws an 'unknown error' if document.activeElement is used
4366				// inside an iframe or frame...
4367				try {
4368					if ( jqFilter[0] !== document.activeElement ) {
4369						jqFilter.val( previousSearch.sSearch );
4370					}
4371				}
4372				catch ( e ) {}
4373			}
4374		} );
4375	
4376		return filter[0];
4377	}
4378	
4379	
4380	/**
4381	 * Filter the table using both the global filter and column based filtering
4382	 *  @param {object} oSettings dataTables settings object
4383	 *  @param {object} oSearch search information
4384	 *  @param {int} [iForce] force a research of the master array (1) or not (undefined or 0)
4385	 *  @memberof DataTable#oApi
4386	 */
4387	function _fnFilterComplete ( oSettings, oInput, iForce )
4388	{
4389		var oPrevSearch = oSettings.oPreviousSearch;
4390		var aoPrevSearch = oSettings.aoPreSearchCols;
4391		var fnSaveFilter = function ( oFilter ) {
4392			/* Save the filtering values */
4393			oPrevSearch.sSearch = oFilter.sSearch;
4394			oPrevSearch.bRegex = oFilter.bRegex;
4395			oPrevSearch.bSmart = oFilter.bSmart;
4396			oPrevSearch.bCaseInsensitive = oFilter.bCaseInsensitive;
4397			oPrevSearch.return = oFilter.return;
4398		};
4399		var fnRegex = function ( o ) {
4400			// Backwards compatibility with the bEscapeRegex option
4401			return o.bEscapeRegex !== undefined ? !o.bEscapeRegex : o.bRegex;
4402		};
4403	
4404		// Resolve any column types that are unknown due to addition or invalidation
4405		// @todo As per sort - can this be moved into an event handler?
4406		_fnColumnTypes( oSettings );
4407	
4408		/* In server-side processing all filtering is done by the server, so no point hanging around here */
4409		if ( _fnDataSource( oSettings ) != 'ssp' )
4410		{
4411			/* Global filter */
4412			_fnFilter( oSettings, oInput.sSearch, iForce, fnRegex(oInput), oInput.bSmart, oInput.bCaseInsensitive, oInput.return );
4413			fnSaveFilter( oInput );
4414	
4415			/* Now do the individual column filter */
4416			for ( var i=0 ; i<aoPrevSearch.length ; i++ )
4417			{
4418				_fnFilterColumn( oSettings, aoPrevSearch[i].sSearch, i, fnRegex(aoPrevSearch[i]),
4419					aoPrevSearch[i].bSmart, aoPrevSearch[i].bCaseInsensitive );
4420			}
4421	
4422			/* Custom filtering */
4423			_fnFilterCustom( oSettings );
4424		}
4425		else
4426		{
4427			fnSaveFilter( oInput );
4428		}
4429	
4430		/* Tell the draw function we have been filtering */
4431		oSettings.bFiltered = true;
4432		_fnCallbackFire( oSettings, null, 'search', [oSettings] );
4433	}
4434	
4435	
4436	/**
4437	 * Apply custom filtering functions
4438	 *  @param {object} oSettings dataTables settings object
4439	 *  @memberof DataTable#oApi
4440	 */
4441	function _fnFilterCustom( settings )
4442	{
4443		var filters = DataTable.ext.search;
4444		var displayRows = settings.aiDisplay;
4445		var row, rowIdx;
4446	
4447		for ( var i=0, ien=filters.length ; i<ien ; i++ ) {
4448			var rows = [];
4449	
4450			// Loop over each row and see if it should be included
4451			for ( var j=0, jen=displayRows.length ; j<jen ; j++ ) {
4452				rowIdx = displayRows[ j ];
4453				row = settings.aoData[ rowIdx ];
4454	
4455				if ( filters[i]( settings, row._aFilterData, rowIdx, row._aData, j ) ) {
4456					rows.push( rowIdx );
4457				}
4458			}
4459	
4460			// So the array reference doesn't break set the results into the
4461			// existing array
4462			displayRows.length = 0;
4463			$.merge( displayRows, rows );
4464		}
4465	}
4466	
4467	
4468	/**
4469	 * Filter the table on a per-column basis
4470	 *  @param {object} oSettings dataTables settings object
4471	 *  @param {string} sInput string to filter on
4472	 *  @param {int} iColumn column to filter
4473	 *  @param {bool} bRegex treat search string as a regular expression or not
4474	 *  @param {bool} bSmart use smart filtering or not
4475	 *  @param {bool} bCaseInsensitive Do case insensitive matching or not
4476	 *  @memberof DataTable#oApi
4477	 */
4478	function _fnFilterColumn ( settings, searchStr, colIdx, regex, smart, caseInsensitive )
4479	{
4480		if ( searchStr === '' ) {
4481			return;
4482		}
4483	
4484		var data;
4485		var out = [];
4486		var display = settings.aiDisplay;
4487		var rpSearch = _fnFilterCreateSearch( searchStr, regex, smart, caseInsensitive );
4488	
4489		for ( var i=0 ; i<display.length ; i++ ) {
4490			data = settings.aoData[ display[i] ]._aFilterData[ colIdx ];
4491	
4492			if ( rpSearch.test( data ) ) {
4493				out.push( display[i] );
4494			}
4495		}
4496	
4497		settings.aiDisplay = out;
4498	}
4499	
4500	
4501	/**
4502	 * Filter the data table based on user input and draw the table
4503	 *  @param {object} settings dataTables settings object
4504	 *  @param {string} input string to filter on
4505	 *  @param {int} force optional - force a research of the master array (1) or not (undefined or 0)
4506	 *  @param {bool} regex treat as a regular expression or not
4507	 *  @param {bool} smart perform smart filtering or not
4508	 *  @param {bool} caseInsensitive Do case insensitive matching or not
4509	 *  @memberof DataTable#oApi
4510	 */
4511	function _fnFilter( settings, input, force, regex, smart, caseInsensitive )
4512	{
4513		var rpSearch = _fnFilterCreateSearch( input, regex, smart, caseInsensitive );
4514		var prevSearch = settings.oPreviousSearch.sSearch;
4515		var displayMaster = settings.aiDisplayMaster;
4516		var display, invalidated, i;
4517		var filtered = [];
4518	
4519		// Need to take account of custom filtering functions - always filter
4520		if ( DataTable.ext.search.length !== 0 ) {
4521			force = true;
4522		}
4523	
4524		// Check if any of the rows were invalidated
4525		invalidated = _fnFilterData( settings );
4526	
4527		// If the input is blank - we just want the full data set
4528		if ( input.length <= 0 ) {
4529			settings.aiDisplay = displayMaster.slice();
4530		}
4531		else {
4532			// New search - start from the master array
4533			if ( invalidated ||
4534				 force ||
4535				 regex ||
4536				 prevSearch.length > input.length ||
4537				 input.indexOf(prevSearch) !== 0 ||
4538				 settings.bSorted // On resort, the display master needs to be
4539				                  // re-filtered since indexes will have changed
4540			) {
4541				settings.aiDisplay = displayMaster.slice();
4542			}
4543	
4544			// Search the display array
4545			display = settings.aiDisplay;
4546	
4547			for ( i=0 ; i<display.length ; i++ ) {
4548				if ( rpSearch.test( settings.aoData[ display[i] ]._sFilterRow ) ) {
4549					filtered.push( display[i] );
4550				}
4551			}
4552	
4553			settings.aiDisplay = filtered;
4554		}
4555	}
4556	
4557	
4558	/**
4559	 * Build a regular expression object suitable for searching a table
4560	 *  @param {string} sSearch string to search for
4561	 *  @param {bool} bRegex treat as a regular expression or not
4562	 *  @param {bool} bSmart perform smart filtering or not
4563	 *  @param {bool} bCaseInsensitive Do case insensitive matching or not
4564	 *  @returns {RegExp} constructed object
4565	 *  @memberof DataTable#oApi
4566	 */
4567	function _fnFilterCreateSearch( search, regex, smart, caseInsensitive )
4568	{
4569		search = regex ?
4570			search :
4571			_fnEscapeRegex( search );
4572		
4573		if ( smart ) {
4574			/* For smart filtering we want to allow the search to work regardless of
4575			 * word order. We also want double quoted text to be preserved, so word
4576			 * order is important - a la google. So this is what we want to
4577			 * generate:
4578			 * 
4579			 * ^(?=.*?\bone\b)(?=.*?\btwo three\b)(?=.*?\bfour\b).*$
4580			 */
4581			var a = $.map( search.match( /"[^"]+"|[^ ]+/g ) || [''], function ( word ) {
4582				if ( word.charAt(0) === '"' ) {
4583					var m = word.match( /^"(.*)"$/ );
4584					word = m ? m[1] : word;
4585				}
4586	
4587				return word.replace('"', '');
4588			} );
4589	
4590			search = '^(?=.*?'+a.join( ')(?=.*?' )+').*$';
4591		}
4592	
4593		return new RegExp( search, caseInsensitive ? 'i' : '' );
4594	}
4595	
4596	
4597	/**
4598	 * Escape a string such that it can be used in a regular expression
4599	 *  @param {string} sVal string to escape
4600	 *  @returns {string} escaped string
4601	 *  @memberof DataTable#oApi
4602	 */
4603	var _fnEscapeRegex = DataTable.util.escapeRegex;
4604	
4605	var __filter_div = $('<div>')[0];
4606	var __filter_div_textContent = __filter_div.textContent !== undefined;
4607	
4608	// Update the filtering data for each row if needed (by invalidation or first run)
4609	function _fnFilterData ( settings )
4610	{
4611		var columns = settings.aoColumns;
4612		var column;
4613		var i, j, ien, jen, filterData, cellData, row;
4614		var wasInvalidated = false;
4615	
4616		for ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
4617			row = settings.aoData[i];
4618	
4619			if ( ! row._aFilterData ) {
4620				filterData = [];
4621	
4622				for ( j=0, jen=columns.length ; j<jen ; j++ ) {
4623					column = columns[j];
4624	
4625					if ( column.bSearchable ) {
4626						cellData = _fnGetCellData( settings, i, j, 'filter' );
4627	
4628						// Search in DataTables 1.10 is string based. In 1.11 this
4629						// should be altered to also allow strict type checking.
4630						if ( cellData === null ) {
4631							cellData = '';
4632						}
4633	
4634						if ( typeof cellData !== 'string' && cellData.toString ) {
4635							cellData = cellData.toString();
4636						}
4637					}
4638					else {
4639						cellData = '';
4640					}
4641	
4642					// If it looks like there is an HTML entity in the string,
4643					// attempt to decode it so sorting works as expected. Note that
4644					// we could use a single line of jQuery to do this, but the DOM
4645					// method used here is much faster http://jsperf.com/html-decode
4646					if ( cellData.indexOf && cellData.indexOf('&') !== -1 ) {
4647						__filter_div.innerHTML = cellData;
4648						cellData = __filter_div_textContent ?
4649							__filter_div.textContent :
4650							__filter_div.innerText;
4651					}
4652	
4653					if ( cellData.replace ) {
4654						cellData = cellData.replace(/[\r\n\u2028]/g, '');
4655					}
4656	
4657					filterData.push( cellData );
4658				}
4659	
4660				row._aFilterData = filterData;
4661				row._sFilterRow = filterData.join('  ');
4662				wasInvalidated = true;
4663			}
4664		}
4665	
4666		return wasInvalidated;
4667	}
4668	
4669	
4670	/**
4671	 * Convert from the internal Hungarian notation to camelCase for external
4672	 * interaction
4673	 *  @param {object} obj Object to convert
4674	 *  @returns {object} Inverted object
4675	 *  @memberof DataTable#oApi
4676	 */
4677	function _fnSearchToCamel ( obj )
4678	{
4679		return {
4680			search:          obj.sSearch,
4681			smart:           obj.bSmart,
4682			regex:           obj.bRegex,
4683			caseInsensitive: obj.bCaseInsensitive
4684		};
4685	}
4686	
4687	
4688	
4689	/**
4690	 * Convert from camelCase notation to the internal Hungarian. We could use the
4691	 * Hungarian convert function here, but this is cleaner
4692	 *  @param {object} obj Object to convert
4693	 *  @returns {object} Inverted object
4694	 *  @memberof DataTable#oApi
4695	 */
4696	function _fnSearchToHung ( obj )
4697	{
4698		return {
4699			sSearch:          obj.search,
4700			bSmart:           obj.smart,
4701			bRegex:           obj.regex,
4702			bCaseInsensitive: obj.caseInsensitive
4703		};
4704	}
4705	
4706	/**
4707	 * Generate the node required for the info display
4708	 *  @param {object} oSettings dataTables settings object
4709	 *  @returns {node} Information element
4710	 *  @memberof DataTable#oApi
4711	 */
4712	function _fnFeatureHtmlInfo ( settings )
4713	{
4714		var
4715			tid = settings.sTableId,
4716			nodes = settings.aanFeatures.i,
4717			n = $('<div/>', {
4718				'class': settings.oClasses.sInfo,
4719				'id': ! nodes ? tid+'_info' : null
4720			} );
4721	
4722		if ( ! nodes ) {
4723			// Update display on each draw
4724			settings.aoDrawCallback.push( {
4725				"fn": _fnUpdateInfo,
4726				"sName": "information"
4727			} );
4728	
4729			n
4730				.attr( 'role', 'status' )
4731				.attr( 'aria-live', 'polite' );
4732	
4733			// Table is described by our info div
4734			$(settings.nTable).attr( 'aria-describedby', tid+'_info' );
4735		}
4736	
4737		return n[0];
4738	}
4739	
4740	
4741	/**
4742	 * Update the information elements in the display
4743	 *  @param {object} settings dataTables settings object
4744	 *  @memberof DataTable#oApi
4745	 */
4746	function _fnUpdateInfo ( settings )
4747	{
4748		/* Show information about the table */
4749		var nodes = settings.aanFeatures.i;
4750		if ( nodes.length === 0 ) {
4751			return;
4752		}
4753	
4754		var
4755			lang  = settings.oLanguage,
4756			start = settings._iDisplayStart+1,
4757			end   = settings.fnDisplayEnd(),
4758			max   = settings.fnRecordsTotal(),
4759			total = settings.fnRecordsDisplay(),
4760			out   = total ?
4761				lang.sInfo :
4762				lang.sInfoEmpty;
4763	
4764		if ( total !== max ) {
4765			/* Record set after filtering */
4766			out += ' ' + lang.sInfoFiltered;
4767		}
4768	
4769		// Convert the macros
4770		out += lang.sInfoPostFix;
4771		out = _fnInfoMacros( settings, out );
4772	
4773		var callback = lang.fnInfoCallback;
4774		if ( callback !== null ) {
4775			out = callback.call( settings.oInstance,
4776				settings, start, end, max, total, out
4777			);
4778		}
4779	
4780		$(nodes).html( out );
4781	}
4782	
4783	
4784	function _fnInfoMacros ( settings, str )
4785	{
4786		// When infinite scrolling, we are always starting at 1. _iDisplayStart is used only
4787		// internally
4788		var
4789			formatter  = settings.fnFormatNumber,
4790			start      = settings._iDisplayStart+1,
4791			len        = settings._iDisplayLength,
4792			vis        = settings.fnRecordsDisplay(),
4793			all        = len === -1;
4794	
4795		return str.
4796			replace(/_START_/g, formatter.call( settings, start ) ).
4797			replace(/_END_/g,   formatter.call( settings, settings.fnDisplayEnd() ) ).
4798			replace(/_MAX_/g,   formatter.call( settings, settings.fnRecordsTotal() ) ).
4799			replace(/_TOTAL_/g, formatter.call( settings, vis ) ).
4800			replace(/_PAGE_/g,  formatter.call( settings, all ? 1 : Math.ceil( start / len ) ) ).
4801			replace(/_PAGES_/g, formatter.call( settings, all ? 1 : Math.ceil( vis / len ) ) );
4802	}
4803	
4804	
4805	
4806	/**
4807	 * Draw the table for the first time, adding all required features
4808	 *  @param {object} settings dataTables settings object
4809	 *  @memberof DataTable#oApi
4810	 */
4811	function _fnInitialise ( settings )
4812	{
4813		var i, iLen, iAjaxStart=settings.iInitDisplayStart;
4814		var columns = settings.aoColumns, column;
4815		var features = settings.oFeatures;
4816		var deferLoading = settings.bDeferLoading; // value modified by the draw
4817	
4818		/* Ensure that the table data is fully initialised */
4819		if ( ! settings.bInitialised ) {
4820			setTimeout( function(){ _fnInitialise( settings ); }, 200 );
4821			return;
4822		}
4823	
4824		/* Show the display HTML options */
4825		_fnAddOptionsHtml( settings );
4826	
4827		/* Build and draw the header / footer for the table */
4828		_fnBuildHead( settings );
4829		_fnDrawHead( settings, settings.aoHeader );
4830		_fnDrawHead( settings, settings.aoFooter );
4831	
4832		/* Okay to show that something is going on now */
4833		_fnProcessingDisplay( settings, true );
4834	
4835		/* Calculate sizes for columns */
4836		if ( features.bAutoWidth ) {
4837			_fnCalculateColumnWidths( settings );
4838		}
4839	
4840		for ( i=0, iLen=columns.length ; i<iLen ; i++ ) {
4841			column = columns[i];
4842	
4843			if ( column.sWidth ) {
4844				column.nTh.style.width = _fnStringToCss( column.sWidth );
4845			}
4846		}
4847	
4848		_fnCallbackFire( settings, null, 'preInit', [settings] );
4849	
4850		// If there is default sorting required - let's do it. The sort function
4851		// will do the drawing for us. Otherwise we draw the table regardless of the
4852		// Ajax source - this allows the table to look initialised for Ajax sourcing
4853		// data (show 'loading' message possibly)
4854		_fnReDraw( settings );
4855	
4856		// Server-side processing init complete is done by _fnAjaxUpdateDraw
4857		var dataSrc = _fnDataSource( settings );
4858		if ( dataSrc != 'ssp' || deferLoading ) {
4859			// if there is an ajax source load the data
4860			if ( dataSrc == 'ajax' ) {
4861				_fnBuildAjax( settings, [], function(json) {
4862					var aData = _fnAjaxDataSrc( settings, json );
4863	
4864					// Got the data - add it to the table
4865					for ( i=0 ; i<aData.length ; i++ ) {
4866						_fnAddData( settings, aData[i] );
4867					}
4868	
4869					// Reset the init display for cookie saving. We've already done
4870					// a filter, and therefore cleared it before. So we need to make
4871					// it appear 'fresh'
4872					settings.iInitDisplayStart = iAjaxStart;
4873	
4874					_fnReDraw( settings );
4875	
4876					_fnProcessingDisplay( settings, false );
4877					_fnInitComplete( settings, json );
4878				}, settings );
4879			}
4880			else {
4881				_fnProcessingDisplay( settings, false );
4882				_fnInitComplete( settings );
4883			}
4884		}
4885	}
4886	
4887	
4888	/**
4889	 * Draw the table for the first time, adding all required features
4890	 *  @param {object} oSettings dataTables settings object
4891	 *  @param {object} [json] JSON from the server that completed the table, if using Ajax source
4892	 *    with client-side processing (optional)
4893	 *  @memberof DataTable#oApi
4894	 */
4895	function _fnInitComplete ( settings, json )
4896	{
4897		settings._bInitComplete = true;
4898	
4899		// When data was added after the initialisation (data or Ajax) we need to
4900		// calculate the column sizing
4901		if ( json || settings.oInit.aaData ) {
4902			_fnAdjustColumnSizing( settings );
4903		}
4904	
4905		_fnCallbackFire( settings, null, 'plugin-init', [settings, json] );
4906		_fnCallbackFire( settings, 'aoInitComplete', 'init', [settings, json] );
4907	}
4908	
4909	
4910	function _fnLengthChange ( settings, val )
4911	{
4912		var len = parseInt( val, 10 );
4913		settings._iDisplayLength = len;
4914	
4915		_fnLengthOverflow( settings );
4916	
4917		// Fire length change event
4918		_fnCallbackFire( settings, null, 'length', [settings, len] );
4919	}
4920	
4921	
4922	/**
4923	 * Generate the node required for user display length changing
4924	 *  @param {object} settings dataTables settings object
4925	 *  @returns {node} Display length feature node
4926	 *  @memberof DataTable#oApi
4927	 */
4928	function _fnFeatureHtmlLength ( settings )
4929	{
4930		var
4931			classes  = settings.oClasses,
4932			tableId  = settings.sTableId,
4933			menu     = settings.aLengthMenu,
4934			d2       = Array.isArray( menu[0] ),
4935			lengths  = d2 ? menu[0] : menu,
4936			language = d2 ? menu[1] : menu;
4937	
4938		var select = $('<select/>', {
4939			'name':          tableId+'_length',
4940			'aria-controls': tableId,
4941			'class':         classes.sLengthSelect
4942		} );
4943	
4944		for ( var i=0, ien=lengths.length ; i<ien ; i++ ) {
4945			select[0][ i ] = new Option(
4946				typeof language[i] === 'number' ?
4947					settings.fnFormatNumber( language[i] ) :
4948					language[i],
4949				lengths[i]
4950			);
4951		}
4952	
4953		var div = $('<div><label/></div>').addClass( classes.sLength );
4954		if ( ! settings.aanFeatures.l ) {
4955			div[0].id = tableId+'_length';
4956		}
4957	
4958		div.children().append(
4959			settings.oLanguage.sLengthMenu.replace( '_MENU_', select[0].outerHTML )
4960		);
4961	
4962		// Can't use `select` variable as user might provide their own and the
4963		// reference is broken by the use of outerHTML
4964		$('select', div)
4965			.val( settings._iDisplayLength )
4966			.on( 'change.DT', function(e) {
4967				_fnLengthChange( settings, $(this).val() );
4968				_fnDraw( settings );
4969			} );
4970	
4971		// Update node value whenever anything changes the table's length
4972		$(settings.nTable).on( 'length.dt.DT', function (e, s, len) {
4973			if ( settings === s ) {
4974				$('select', div).val( len );
4975			}
4976		} );
4977	
4978		return div[0];
4979	}
4980	
4981	
4982	
4983	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
4984	 * Note that most of the paging logic is done in
4985	 * DataTable.ext.pager
4986	 */
4987	
4988	/**
4989	 * Generate the node required for default pagination
4990	 *  @param {object} oSettings dataTables settings object
4991	 *  @returns {node} Pagination feature node
4992	 *  @memberof DataTable#oApi
4993	 */
4994	function _fnFeatureHtmlPaginate ( settings )
4995	{
4996		var
4997			type   = settings.sPaginationType,
4998			plugin = DataTable.ext.pager[ type ],
4999			modern = typeof plugin === 'function',
5000			redraw = function( settings ) {
5001				_fnDraw( settings );
5002			},
5003			node = $('<div/>').addClass( settings.oClasses.sPaging + type )[0],
5004			features = settings.aanFeatures;
5005	
5006		if ( ! modern ) {
5007			plugin.fnInit( settings, node, redraw );
5008		}
5009	
5010		/* Add a draw callback for the pagination on first instance, to update the paging display */
5011		if ( ! features.p )
5012		{
5013			node.id = settings.sTableId+'_paginate';
5014	
5015			settings.aoDrawCallback.push( {
5016				"fn": function( settings ) {
5017					if ( modern ) {
5018						var
5019							start      = settings._iDisplayStart,
5020							len        = settings._iDisplayLength,
5021							visRecords = settings.fnRecordsDisplay(),
5022							all        = len === -1,
5023							page = all ? 0 : Math.ceil( start / len ),
5024							pages = all ? 1 : Math.ceil( visRecords / len ),
5025							buttons = plugin(page, pages),
5026							i, ien;
5027	
5028						for ( i=0, ien=features.p.length ; i<ien ; i++ ) {
5029							_fnRenderer( settings, 'pageButton' )(
5030								settings, features.p[i], i, buttons, page, pages
5031							);
5032						}
5033					}
5034					else {
5035						plugin.fnUpdate( settings, redraw );
5036					}
5037				},
5038				"sName": "pagination"
5039			} );
5040		}
5041	
5042		return node;
5043	}
5044	
5045	
5046	/**
5047	 * Alter the display settings to change the page
5048	 *  @param {object} settings DataTables settings object
5049	 *  @param {string|int} action Paging action to take: "first", "previous",
5050	 *    "next" or "last" or page number to jump to (integer)
5051	 *  @param [bool] redraw Automatically draw the update or not
5052	 *  @returns {bool} true page has changed, false - no change
5053	 *  @memberof DataTable#oApi
5054	 */
5055	function _fnPageChange ( settings, action, redraw )
5056	{
5057		var
5058			start     = settings._iDisplayStart,
5059			len       = settings._iDisplayLength,
5060			records   = settings.fnRecordsDisplay();
5061	
5062		if ( records === 0 || len === -1 )
5063		{
5064			start = 0;
5065		}
5066		else if ( typeof action === "number" )
5067		{
5068			start = action * len;
5069	
5070			if ( start > records )
5071			{
5072				start = 0;
5073			}
5074		}
5075		else if ( action == "first" )
5076		{
5077			start = 0;
5078		}
5079		else if ( action == "previous" )
5080		{
5081			start = len >= 0 ?
5082				start - len :
5083				0;
5084	
5085			if ( start < 0 )
5086			{
5087			  start = 0;
5088			}
5089		}
5090		else if ( action == "next" )
5091		{
5092			if ( start + len < records )
5093			{
5094				start += len;
5095			}
5096		}
5097		else if ( action == "last" )
5098		{
5099			start = Math.floor( (records-1) / len) * len;
5100		}
5101		else
5102		{
5103			_fnLog( settings, 0, "Unknown paging action: "+action, 5 );
5104		}
5105	
5106		var changed = settings._iDisplayStart !== start;
5107		settings._iDisplayStart = start;
5108	
5109		if ( changed ) {
5110			_fnCallbackFire( settings, null, 'page', [settings] );
5111	
5112			if ( redraw ) {
5113				_fnDraw( settings );
5114			}
5115		}
5116		else {
5117			// No change event - paging was called, but no change
5118			_fnCallbackFire( settings, null, 'page-nc', [settings] );
5119		}
5120	
5121		return changed;
5122	}
5123	
5124	
5125	
5126	/**
5127	 * Generate the node required for the processing node
5128	 *  @param {object} settings dataTables settings object
5129	 *  @returns {node} Processing element
5130	 *  @memberof DataTable#oApi
5131	 */
5132	function _fnFeatureHtmlProcessing ( settings )
5133	{
5134		return $('<div/>', {
5135				'id': ! settings.aanFeatures.r ? settings.sTableId+'_processing' : null,
5136				'class': settings.oClasses.sProcessing,
5137				'role': 'status'
5138			} )
5139			.html( settings.oLanguage.sProcessing )
5140			.append('<div><div></div><div></div><div></div><div></div></div>')
5141			.insertBefore( settings.nTable )[0];
5142	}
5143	
5144	
5145	/**
5146	 * Display or hide the processing indicator
5147	 *  @param {object} settings dataTables settings object
5148	 *  @param {bool} show Show the processing indicator (true) or not (false)
5149	 *  @memberof DataTable#oApi
5150	 */
5151	function _fnProcessingDisplay ( settings, show )
5152	{
5153		if ( settings.oFeatures.bProcessing ) {
5154			$(settings.aanFeatures.r).css( 'display', show ? 'block' : 'none' );
5155		}
5156	
5157		_fnCallbackFire( settings, null, 'processing', [settings, show] );
5158	}
5159	
5160	/**
5161	 * Add any control elements for the table - specifically scrolling
5162	 *  @param {object} settings dataTables settings object
5163	 *  @returns {node} Node to add to the DOM
5164	 *  @memberof DataTable#oApi
5165	 */
5166	function _fnFeatureHtmlTable ( settings )
5167	{
5168		var table = $(settings.nTable);
5169	
5170		// Scrolling from here on in
5171		var scroll = settings.oScroll;
5172	
5173		if ( scroll.sX === '' && scroll.sY === '' ) {
5174			return settings.nTable;
5175		}
5176	
5177		var scrollX = scroll.sX;
5178		var scrollY = scroll.sY;
5179		var classes = settings.oClasses;
5180		var caption = table.children('caption');
5181		var captionSide = caption.length ? caption[0]._captionSide : null;
5182		var headerClone = $( table[0].cloneNode(false) );
5183		var footerClone = $( table[0].cloneNode(false) );
5184		var footer = table.children('tfoot');
5185		var _div = '<div/>';
5186		var size = function ( s ) {
5187			return !s ? null : _fnStringToCss( s );
5188		};
5189	
5190		if ( ! footer.length ) {
5191			footer = null;
5192		}
5193	
5194		/*
5195		 * The HTML structure that we want to generate in this function is:
5196		 *  div - scroller
5197		 *    div - scroll head
5198		 *      div - scroll head inner
5199		 *        table - scroll head table
5200		 *          thead - thead
5201		 *    div - scroll body
5202		 *      table - table (master table)
5203		 *        thead - thead clone for sizing
5204		 *        tbody - tbody
5205		 *    div - scroll foot
5206		 *      div - scroll foot inner
5207		 *        table - scroll foot table
5208		 *          tfoot - tfoot
5209		 */
5210		var scroller = $( _div, { 'class': classes.sScrollWrapper } )
5211			.append(
5212				$(_div, { 'class': classes.sScrollHead } )
5213					.css( {
5214						overflow: 'hidden',
5215						position: 'relative',
5216						border: 0,
5217						width: scrollX ? size(scrollX) : '100%'
5218					} )
5219					.append(
5220						$(_div, { 'class': classes.sScrollHeadInner } )
5221							.css( {
5222								'box-sizing': 'content-box',
5223								width: scroll.sXInner || '100%'
5224							} )
5225							.append(
5226								headerClone
5227									.removeAttr('id')
5228									.css( 'margin-left', 0 )
5229									.append( captionSide === 'top' ? caption : null )
5230									.append(
5231										table.children('thead')
5232									)
5233							)
5234					)
5235			)
5236			.append(
5237				$(_div, { 'class': classes.sScrollBody } )
5238					.css( {
5239						position: 'relative',
5240						overflow: 'auto',
5241						width: size( scrollX )
5242					} )
5243					.append( table )
5244			);
5245	
5246		if ( footer ) {
5247			scroller.append(
5248				$(_div, { 'class': classes.sScrollFoot } )
5249					.css( {
5250						overflow: 'hidden',
5251						border: 0,
5252						width: scrollX ? size(scrollX) : '100%'
5253					} )
5254					.append(
5255						$(_div, { 'class': classes.sScrollFootInner } )
5256							.append(
5257								footerClone
5258									.removeAttr('id')
5259									.css( 'margin-left', 0 )
5260									.append( captionSide === 'bottom' ? caption : null )
5261									.append(
5262										table.children('tfoot')
5263									)
5264							)
5265					)
5266			);
5267		}
5268	
5269		var children = scroller.children();
5270		var scrollHead = children[0];
5271		var scrollBody = children[1];
5272		var scrollFoot = footer ? children[2] : null;
5273	
5274		// When the body is scrolled, then we also want to scroll the headers
5275		if ( scrollX ) {
5276			$(scrollBody).on( 'scroll.DT', function (e) {
5277				var scrollLeft = this.scrollLeft;
5278	
5279				scrollHead.scrollLeft = scrollLeft;
5280	
5281				if ( footer ) {
5282					scrollFoot.scrollLeft = scrollLeft;
5283				}
5284			} );
5285		}
5286	
5287		$(scrollBody).css('max-height', scrollY);
5288		if (! scroll.bCollapse) {
5289			$(scrollBody).css('height', scrollY);
5290		}
5291	
5292		settings.nScrollHead = scrollHead;
5293		settings.nScrollBody = scrollBody;
5294		settings.nScrollFoot = scrollFoot;
5295	
5296		// On redraw - align columns
5297		settings.aoDrawCallback.push( {
5298			"fn": _fnScrollDraw,
5299			"sName": "scrolling"
5300		} );
5301	
5302		return scroller[0];
5303	}
5304	
5305	
5306	
5307	/**
5308	 * Update the header, footer and body tables for resizing - i.e. column
5309	 * alignment.
5310	 *
5311	 * Welcome to the most horrible function DataTables. The process that this
5312	 * function follows is basically:
5313	 *   1. Re-create the table inside the scrolling div
5314	 *   2. Take live measurements from the DOM
5315	 *   3. Apply the measurements to align the columns
5316	 *   4. Clean up
5317	 *
5318	 *  @param {object} settings dataTables settings object
5319	 *  @memberof DataTable#oApi
5320	 */
5321	function _fnScrollDraw ( settings )
5322	{
5323		// Given that this is such a monster function, a lot of variables are use
5324		// to try and keep the minimised size as small as possible
5325		var
5326			scroll         = settings.oScroll,
5327			scrollX        = scroll.sX,
5328			scrollXInner   = scroll.sXInner,
5329			scrollY        = scroll.sY,
5330			barWidth       = scroll.iBarWidth,
5331			divHeader      = $(settings.nScrollHead),
5332			divHeaderStyle = divHeader[0].style,
5333			divHeaderInner = divHeader.children('div'),
5334			divHeaderInnerStyle = divHeaderInner[0].style,
5335			divHeaderTable = divHeaderInner.children('table'),
5336			divBodyEl      = settings.nScrollBody,
5337			divBody        = $(divBodyEl),
5338			divBodyStyle   = divBodyEl.style,
5339			divFooter      = $(settings.nScrollFoot),
5340			divFooterInner = divFooter.children('div'),
5341			divFooterTable = divFooterInner.children('table'),
5342			header         = $(settings.nTHead),
5343			table          = $(settings.nTable),
5344			tableEl        = table[0],
5345			tableStyle     = tableEl.style,
5346			footer         = settings.nTFoot ? $(settings.nTFoot) : null,
5347			browser        = settings.oBrowser,
5348			ie67           = browser.bScrollOversize,
5349			dtHeaderCells  = _pluck( settings.aoColumns, 'nTh' ),
5350			headerTrgEls, footerTrgEls,
5351			headerSrcEls, footerSrcEls,
5352			headerCopy, footerCopy,
5353			headerWidths=[], footerWidths=[],
5354			headerContent=[], footerContent=[],
5355			idx, correction, sanityWidth,
5356			zeroOut = function(nSizer) {
5357				var style = nSizer.style;
5358				style.paddingTop = "0";
5359				style.paddingBottom = "0";
5360				style.borderTopWidth = "0";
5361				style.borderBottomWidth = "0";
5362				style.height = 0;
5363			};
5364	
5365		// If the scrollbar visibility has changed from the last draw, we need to
5366		// adjust the column sizes as the table width will have changed to account
5367		// for the scrollbar
5368		var scrollBarVis = divBodyEl.scrollHeight > divBodyEl.clientHeight;
5369		
5370		if ( settings.scrollBarVis !== scrollBarVis && settings.scrollBarVis !== undefined ) {
5371			settings.scrollBarVis = scrollBarVis;
5372			_fnAdjustColumnSizing( settings );
5373			return; // adjust column sizing will call this function again
5374		}
5375		else {
5376			settings.scrollBarVis = scrollBarVis;
5377		}
5378	
5379		/*
5380		 * 1. Re-create the table inside the scrolling div
5381		 */
5382	
5383		// Remove the old minimised thead and tfoot elements in the inner table
5384		table.children('thead, tfoot').remove();
5385	
5386		if ( footer ) {
5387			footerCopy = footer.clone().prependTo( table );
5388			footerTrgEls = footer.find('tr'); // the original tfoot is in its own table and must be sized
5389			footerSrcEls = footerCopy.find('tr');
5390			footerCopy.find('[id]').removeAttr('id');
5391		}
5392	
5393		// Clone the current header and footer elements and then place it into the inner table
5394		headerCopy = header.clone().prependTo( table );
5395		headerTrgEls = header.find('tr'); // original header is in its own table
5396		headerSrcEls = headerCopy.find('tr');
5397		headerCopy.find('th, td').removeAttr('tabindex');
5398		headerCopy.find('[id]').removeAttr('id');
5399	
5400	
5401		/*
5402		 * 2. Take live measurements from the DOM - do not alter the DOM itself!
5403		 */
5404	
5405		// Remove old sizing and apply the calculated column widths
5406		// Get the unique column headers in the newly created (cloned) header. We want to apply the
5407		// calculated sizes to this header
5408		if ( ! scrollX )
5409		{
5410			divBodyStyle.width = '100%';
5411			divHeader[0].style.width = '100%';
5412		}
5413	
5414		$.each( _fnGetUniqueThs( settings, headerCopy ), function ( i, el ) {
5415			idx = _fnVisibleToColumnIndex( settings, i );
5416			el.style.width = settings.aoColumns[idx].sWidth;
5417		} );
5418	
5419		if ( footer ) {
5420			_fnApplyToChildren( function(n) {
5421				n.style.width = "";
5422			}, footerSrcEls );
5423		}
5424	
5425		// Size the table as a whole
5426		sanityWidth = table.outerWidth();
5427		if ( scrollX === "" ) {
5428			// No x scrolling
5429			tableStyle.width = "100%";
5430	
5431			// IE7 will make the width of the table when 100% include the scrollbar
5432			// - which is shouldn't. When there is a scrollbar we need to take this
5433			// into account.
5434			if ( ie67 && (table.find('tbody').height() > divBodyEl.offsetHeight ||
5435				divBody.css('overflow-y') == "scroll")
5436			) {
5437				tableStyle.width = _fnStringToCss( table.outerWidth() - barWidth);
5438			}
5439	
5440			// Recalculate the sanity width
5441			sanityWidth = table.outerWidth();
5442		}
5443		else if ( scrollXInner !== "" ) {
5444			// legacy x scroll inner has been given - use it
5445			tableStyle.width = _fnStringToCss(scrollXInner);
5446	
5447			// Recalculate the sanity width
5448			sanityWidth = table.outerWidth();
5449		}
5450	
5451		// Hidden header should have zero height, so remove padding and borders. Then
5452		// set the width based on the real headers
5453	
5454		// Apply all styles in one pass
5455		_fnApplyToChildren( zeroOut, headerSrcEls );
5456	
5457		// Read all widths in next pass
5458		_fnApplyToChildren( function(nSizer) {
5459			var style = window.getComputedStyle ?
5460				window.getComputedStyle(nSizer).width :
5461				_fnStringToCss( $(nSizer).width() );
5462	
5463			headerContent.push( nSizer.innerHTML );
5464			headerWidths.push( style );
5465		}, headerSrcEls );
5466	
5467		// Apply all widths in final pass
5468		_fnApplyToChildren( function(nToSize, i) {
5469			nToSize.style.width = headerWidths[i];
5470		}, headerTrgEls );
5471	
5472		$(headerSrcEls).css('height', 0);
5473	
5474		/* Same again with the footer if we have one */
5475		if ( footer )
5476		{
5477			_fnApplyToChildren( zeroOut, footerSrcEls );
5478	
5479			_fnApplyToChildren( function(nSizer) {
5480				footerContent.push( nSizer.innerHTML );
5481				footerWidths.push( _fnStringToCss( $(nSizer).css('width') ) );
5482			}, footerSrcEls );
5483	
5484			_fnApplyToChildren( function(nToSize, i) {
5485				nToSize.style.width = footerWidths[i];
5486			}, footerTrgEls );
5487	
5488			$(footerSrcEls).height(0);
5489		}
5490	
5491	
5492		/*
5493		 * 3. Apply the measurements
5494		 */
5495	
5496		// "Hide" the header and footer that we used for the sizing. We need to keep
5497		// the content of the cell so that the width applied to the header and body
5498		// both match, but we want to hide it completely. We want to also fix their
5499		// width to what they currently are
5500		_fnApplyToChildren( function(nSizer, i) {
5501			nSizer.innerHTML = '<div class="dataTables_sizing">'+headerContent[i]+'</div>';
5502			nSizer.childNodes[0].style.height = "0";
5503			nSizer.childNodes[0].style.overflow = "hidden";
5504			nSizer.style.width = headerWidths[i];
5505		}, headerSrcEls );
5506	
5507		if ( footer )
5508		{
5509			_fnApplyToChildren( function(nSizer, i) {
5510				nSizer.innerHTML = '<div class="dataTables_sizing">'+footerContent[i]+'</div>';
5511				nSizer.childNodes[0].style.height = "0";
5512				nSizer.childNodes[0].style.overflow = "hidden";
5513				nSizer.style.width = footerWidths[i];
5514			}, footerSrcEls );
5515		}
5516	
5517		// Sanity check that the table is of a sensible width. If not then we are going to get
5518		// misalignment - try to prevent this by not allowing the table to shrink below its min width
5519		if ( Math.round(table.outerWidth()) < Math.round(sanityWidth) )
5520		{
5521			// The min width depends upon if we have a vertical scrollbar visible or not */
5522			correction = ((divBodyEl.scrollHeight > divBodyEl.offsetHeight ||
5523				divBody.css('overflow-y') == "scroll")) ?
5524					sanityWidth+barWidth :
5525					sanityWidth;
5526	
5527			// IE6/7 are a law unto themselves...
5528			if ( ie67 && (divBodyEl.scrollHeight >
5529				divBodyEl.offsetHeight || divBody.css('overflow-y') == "scroll")
5530			) {
5531				tableStyle.width = _fnStringToCss( correction-barWidth );
5532			}
5533	
5534			// And give the user a warning that we've stopped the table getting too small
5535			if ( scrollX === "" || scrollXInner !== "" ) {
5536				_fnLog( settings, 1, 'Possible column misalignment', 6 );
5537			}
5538		}
5539		else
5540		{
5541			correction = '100%';
5542		}
5543	
5544		// Apply to the container elements
5545		divBodyStyle.width = _fnStringToCss( correction );
5546		divHeaderStyle.width = _fnStringToCss( correction );
5547	
5548		if ( footer ) {
5549			settings.nScrollFoot.style.width = _fnStringToCss( correction );
5550		}
5551	
5552	
5553		/*
5554		 * 4. Clean up
5555		 */
5556		if ( ! scrollY ) {
5557			/* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting
5558			 * the scrollbar height from the visible display, rather than adding it on. We need to
5559			 * set the height in order to sort this. Don't want to do it in any other browsers.
5560			 */
5561			if ( ie67 ) {
5562				divBodyStyle.height = _fnStringToCss( tableEl.offsetHeight+barWidth );
5563			}
5564		}
5565	
5566		/* Finally set the width's of the header and footer tables */
5567		var iOuterWidth = table.outerWidth();
5568		divHeaderTable[0].style.width = _fnStringToCss( iOuterWidth );
5569		divHeaderInnerStyle.width = _fnStringToCss( iOuterWidth );
5570	
5571		// Figure out if there are scrollbar present - if so then we need a the header and footer to
5572		// provide a bit more space to allow "overflow" scrolling (i.e. past the scrollbar)
5573		var bScrolling = table.height() > divBodyEl.clientHeight || divBody.css('overflow-y') == "scroll";
5574		var padding = 'padding' + (browser.bScrollbarLeft ? 'Left' : 'Right' );
5575		divHeaderInnerStyle[ padding ] = bScrolling ? barWidth+"px" : "0px";
5576	
5577		if ( footer ) {
5578			divFooterTable[0].style.width = _fnStringToCss( iOuterWidth );
5579			divFooterInner[0].style.width = _fnStringToCss( iOuterWidth );
5580			divFooterInner[0].style[padding] = bScrolling ? barWidth+"px" : "0px";
5581		}
5582	
5583		// Correct DOM ordering for colgroup - comes before the thead
5584		table.children('colgroup').insertBefore( table.children('thead') );
5585	
5586		/* Adjust the position of the header in case we loose the y-scrollbar */
5587		divBody.trigger('scroll');
5588	
5589		// If sorting or filtering has occurred, jump the scrolling back to the top
5590		// only if we aren't holding the position
5591		if ( (settings.bSorted || settings.bFiltered) && ! settings._drawHold ) {
5592			divBodyEl.scrollTop = 0;
5593		}
5594	}
5595	
5596	
5597	
5598	/**
5599	 * Apply a given function to the display child nodes of an element array (typically
5600	 * TD children of TR rows
5601	 *  @param {function} fn Method to apply to the objects
5602	 *  @param array {nodes} an1 List of elements to look through for display children
5603	 *  @param array {nodes} an2 Another list (identical structure to the first) - optional
5604	 *  @memberof DataTable#oApi
5605	 */
5606	function _fnApplyToChildren( fn, an1, an2 )
5607	{
5608		var index=0, i=0, iLen=an1.length;
5609		var nNode1, nNode2;
5610	
5611		while ( i < iLen ) {
5612			nNode1 = an1[i].firstChild;
5613			nNode2 = an2 ? an2[i].firstChild : null;
5614	
5615			while ( nNode1 ) {
5616				if ( nNode1.nodeType === 1 ) {
5617					if ( an2 ) {
5618						fn( nNode1, nNode2, index );
5619					}
5620					else {
5621						fn( nNode1, index );
5622					}
5623	
5624					index++;
5625				}
5626	
5627				nNode1 = nNode1.nextSibling;
5628				nNode2 = an2 ? nNode2.nextSibling : null;
5629			}
5630	
5631			i++;
5632		}
5633	}
5634	
5635	
5636	
5637	var __re_html_remove = /<.*?>/g;
5638	
5639	
5640	/**
5641	 * Calculate the width of columns for the table
5642	 *  @param {object} oSettings dataTables settings object
5643	 *  @memberof DataTable#oApi
5644	 */
5645	function _fnCalculateColumnWidths ( oSettings )
5646	{
5647		var
5648			table = oSettings.nTable,
5649			columns = oSettings.aoColumns,
5650			scroll = oSettings.oScroll,
5651			scrollY = scroll.sY,
5652			scrollX = scroll.sX,
5653			scrollXInner = scroll.sXInner,
5654			columnCount = columns.length,
5655			visibleColumns = _fnGetColumns( oSettings, 'bVisible' ),
5656			headerCells = $('th', oSettings.nTHead),
5657			tableWidthAttr = table.getAttribute('width'), // from DOM element
5658			tableContainer = table.parentNode,
5659			userInputs = false,
5660			i, column, columnIdx, width, outerWidth,
5661			browser = oSettings.oBrowser,
5662			ie67 = browser.bScrollOversize;
5663	
5664		var styleWidth = table.style.width;
5665		if ( styleWidth && styleWidth.indexOf('%') !== -1 ) {
5666			tableWidthAttr = styleWidth;
5667		}
5668	
5669		/* Convert any user input sizes into pixel sizes */
5670		for ( i=0 ; i<visibleColumns.length ; i++ ) {
5671			column = columns[ visibleColumns[i] ];
5672	
5673			if ( column.sWidth !== null ) {
5674				column.sWidth = _fnConvertToWidth( column.sWidthOrig, tableContainer );
5675	
5676				userInputs = true;
5677			}
5678		}
5679	
5680		/* If the number of columns in the DOM equals the number that we have to
5681		 * process in DataTables, then we can use the offsets that are created by
5682		 * the web- browser. No custom sizes can be set in order for this to happen,
5683		 * nor scrolling used
5684		 */
5685		if ( ie67 || ! userInputs && ! scrollX && ! scrollY &&
5686		     columnCount == _fnVisbleColumns( oSettings ) &&
5687		     columnCount == headerCells.length
5688		) {
5689			for ( i=0 ; i<columnCount ; i++ ) {
5690				var colIdx = _fnVisibleToColumnIndex( oSettings, i );
5691	
5692				if ( colIdx !== null ) {
5693					columns[ colIdx ].sWidth = _fnStringToCss( headerCells.eq(i).width() );
5694				}
5695			}
5696		}
5697		else
5698		{
5699			// Otherwise construct a single row, worst case, table with the widest
5700			// node in the data, assign any user defined widths, then insert it into
5701			// the DOM and allow the browser to do all the hard work of calculating
5702			// table widths
5703			var tmpTable = $(table).clone() // don't use cloneNode - IE8 will remove events on the main table
5704				.css( 'visibility', 'hidden' )
5705				.removeAttr( 'id' );
5706	
5707			// Clean up the table body
5708			tmpTable.find('tbody tr').remove();
5709			var tr = $('<tr/>').appendTo( tmpTable.find('tbody') );
5710	
5711			// Clone the table header and footer - we can't use the header / footer
5712			// from the cloned table, since if scrolling is active, the table's
5713			// real header and footer are contained in different table tags
5714			tmpTable.find('thead, tfoot').remove();
5715			tmpTable
5716				.append( $(oSettings.nTHead).clone() )
5717				.append( $(oSettings.nTFoot).clone() );
5718	
5719			// Remove any assigned widths from the footer (from scrolling)
5720			tmpTable.find('tfoot th, tfoot td').css('width', '');
5721	
5722			// Apply custom sizing to the cloned header
5723			headerCells = _fnGetUniqueThs( oSettings, tmpTable.find('thead')[0] );
5724	
5725			for ( i=0 ; i<visibleColumns.length ; i++ ) {
5726				column = columns[ visibleColumns[i] ];
5727	
5728				headerCells[i].style.width = column.sWidthOrig !== null && column.sWidthOrig !== '' ?
5729					_fnStringToCss( column.sWidthOrig ) :
5730					'';
5731	
5732				// For scrollX we need to force the column width otherwise the
5733				// browser will collapse it. If this width is smaller than the
5734				// width the column requires, then it will have no effect
5735				if ( column.sWidthOrig && scrollX ) {
5736					$( headerCells[i] ).append( $('<div/>').css( {
5737						width: column.sWidthOrig,
5738						margin: 0,
5739						padding: 0,
5740						border: 0,
5741						height: 1
5742					} ) );
5743				}
5744			}
5745	
5746			// Find the widest cell for each column and put it into the table
5747			if ( oSettings.aoData.length ) {
5748				for ( i=0 ; i<visibleColumns.length ; i++ ) {
5749					columnIdx = visibleColumns[i];
5750					column = columns[ columnIdx ];
5751	
5752					$( _fnGetWidestNode( oSettings, columnIdx ) )
5753						.clone( false )
5754						.append( column.sContentPadding )
5755						.appendTo( tr );
5756				}
5757			}
5758	
5759			// Tidy the temporary table - remove name attributes so there aren't
5760			// duplicated in the dom (radio elements for example)
5761			$('[name]', tmpTable).removeAttr('name');
5762	
5763			// Table has been built, attach to the document so we can work with it.
5764			// A holding element is used, positioned at the top of the container
5765			// with minimal height, so it has no effect on if the container scrolls
5766			// or not. Otherwise it might trigger scrolling when it actually isn't
5767			// needed
5768			var holder = $('<div/>').css( scrollX || scrollY ?
5769					{
5770						position: 'absolute',
5771						top: 0,
5772						left: 0,
5773						height: 1,
5774						right: 0,
5775						overflow: 'hidden'
5776					} :
5777					{}
5778				)
5779				.append( tmpTable )
5780				.appendTo( tableContainer );
5781	
5782			// When scrolling (X or Y) we want to set the width of the table as 
5783			// appropriate. However, when not scrolling leave the table width as it
5784			// is. This results in slightly different, but I think correct behaviour
5785			if ( scrollX && scrollXInner ) {
5786				tmpTable.width( scrollXInner );
5787			}
5788			else if ( scrollX ) {
5789				tmpTable.css( 'width', 'auto' );
5790				tmpTable.removeAttr('width');
5791	
5792				// If there is no width attribute or style, then allow the table to
5793				// collapse
5794				if ( tmpTable.width() < tableContainer.clientWidth && tableWidthAttr ) {
5795					tmpTable.width( tableContainer.clientWidth );
5796				}
5797			}
5798			else if ( scrollY ) {
5799				tmpTable.width( tableContainer.clientWidth );
5800			}
5801			else if ( tableWidthAttr ) {
5802				tmpTable.width( tableWidthAttr );
5803			}
5804	
5805			// Get the width of each column in the constructed table - we need to
5806			// know the inner width (so it can be assigned to the other table's
5807			// cells) and the outer width so we can calculate the full width of the
5808			// table. This is safe since DataTables requires a unique cell for each
5809			// column, but if ever a header can span multiple columns, this will
5810			// need to be modified.
5811			var total = 0;
5812			for ( i=0 ; i<visibleColumns.length ; i++ ) {
5813				var cell = $(headerCells[i]);
5814				var border = cell.outerWidth() - cell.width();
5815	
5816				// Use getBounding... where possible (not IE8-) because it can give
5817				// sub-pixel accuracy, which we then want to round up!
5818				var bounding = browser.bBounding ?
5819					Math.ceil( headerCells[i].getBoundingClientRect().width ) :
5820					cell.outerWidth();
5821	
5822				// Total is tracked to remove any sub-pixel errors as the outerWidth
5823				// of the table might not equal the total given here (IE!).
5824				total += bounding;
5825	
5826				// Width for each column to use
5827				columns[ visibleColumns[i] ].sWidth = _fnStringToCss( bounding - border );
5828			}
5829	
5830			table.style.width = _fnStringToCss( total );
5831	
5832			// Finished with the table - ditch it
5833			holder.remove();
5834		}
5835	
5836		// If there is a width attr, we want to attach an event listener which
5837		// allows the table sizing to automatically adjust when the window is
5838		// resized. Use the width attr rather than CSS, since we can't know if the
5839		// CSS is a relative value or absolute - DOM read is always px.
5840		if ( tableWidthAttr ) {
5841			table.style.width = _fnStringToCss( tableWidthAttr );
5842		}
5843	
5844		if ( (tableWidthAttr || scrollX) && ! oSettings._reszEvt ) {
5845			var bindResize = function () {
5846				$(window).on('resize.DT-'+oSettings.sInstance, _fnThrottle( function () {
5847					_fnAdjustColumnSizing( oSettings );
5848				} ) );
5849			};
5850	
5851			// IE6/7 will crash if we bind a resize event handler on page load.
5852			// To be removed in 1.11 which drops IE6/7 support
5853			if ( ie67 ) {
5854				setTimeout( bindResize, 1000 );
5855			}
5856			else {
5857				bindResize();
5858			}
5859	
5860			oSettings._reszEvt = true;
5861		}
5862	}
5863	
5864	
5865	/**
5866	 * Throttle the calls to a function. Arguments and context are maintained for
5867	 * the throttled function
5868	 *  @param {function} fn Function to be called
5869	 *  @param {int} [freq=200] call frequency in mS
5870	 *  @returns {function} wrapped function
5871	 *  @memberof DataTable#oApi
5872	 */
5873	var _fnThrottle = DataTable.util.throttle;
5874	
5875	
5876	/**
5877	 * Convert a CSS unit width to pixels (e.g. 2em)
5878	 *  @param {string} width width to be converted
5879	 *  @param {node} parent parent to get the with for (required for relative widths) - optional
5880	 *  @returns {int} width in pixels
5881	 *  @memberof DataTable#oApi
5882	 */
5883	function _fnConvertToWidth ( width, parent )
5884	{
5885		if ( ! width ) {
5886			return 0;
5887		}
5888	
5889		var n = $('<div/>')
5890			.css( 'width', _fnStringToCss( width ) )
5891			.appendTo( parent || document.body );
5892	
5893		var val = n[0].offsetWidth;
5894		n.remove();
5895	
5896		return val;
5897	}
5898	
5899	
5900	/**
5901	 * Get the widest node
5902	 *  @param {object} settings dataTables settings object
5903	 *  @param {int} colIdx column of interest
5904	 *  @returns {node} widest table node
5905	 *  @memberof DataTable#oApi
5906	 */
5907	function _fnGetWidestNode( settings, colIdx )
5908	{
5909		var idx = _fnGetMaxLenString( settings, colIdx );
5910		if ( idx < 0 ) {
5911			return null;
5912		}
5913	
5914		var data = settings.aoData[ idx ];
5915		return ! data.nTr ? // Might not have been created when deferred rendering
5916			$('<td/>').html( _fnGetCellData( settings, idx, colIdx, 'display' ) )[0] :
5917			data.anCells[ colIdx ];
5918	}
5919	
5920	
5921	/**
5922	 * Get the maximum strlen for each data column
5923	 *  @param {object} settings dataTables settings object
5924	 *  @param {int} colIdx column of interest
5925	 *  @returns {string} max string length for each column
5926	 *  @memberof DataTable#oApi
5927	 */
5928	function _fnGetMaxLenString( settings, colIdx )
5929	{
5930		var s, max=-1, maxIdx = -1;
5931	
5932		for ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
5933			s = _fnGetCellData( settings, i, colIdx, 'display' )+'';
5934			s = s.replace( __re_html_remove, '' );
5935			s = s.replace( /&nbsp;/g, ' ' );
5936	
5937			if ( s.length > max ) {
5938				max = s.length;
5939				maxIdx = i;
5940			}
5941		}
5942	
5943		return maxIdx;
5944	}
5945	
5946	
5947	/**
5948	 * Append a CSS unit (only if required) to a string
5949	 *  @param {string} value to css-ify
5950	 *  @returns {string} value with css unit
5951	 *  @memberof DataTable#oApi
5952	 */
5953	function _fnStringToCss( s )
5954	{
5955		if ( s === null ) {
5956			return '0px';
5957		}
5958	
5959		if ( typeof s == 'number' ) {
5960			return s < 0 ?
5961				'0px' :
5962				s+'px';
5963		}
5964	
5965		// Check it has a unit character already
5966		return s.match(/\d$/) ?
5967			s+'px' :
5968			s;
5969	}
5970	
5971	
5972	
5973	function _fnSortFlatten ( settings )
5974	{
5975		var
5976			i, iLen, k, kLen,
5977			aSort = [],
5978			aiOrig = [],
5979			aoColumns = settings.aoColumns,
5980			aDataSort, iCol, sType, srcCol,
5981			fixed = settings.aaSortingFixed,
5982			fixedObj = $.isPlainObject( fixed ),
5983			nestedSort = [],
5984			add = function ( a ) {
5985				if ( a.length && ! Array.isArray( a[0] ) ) {
5986					// 1D array
5987					nestedSort.push( a );
5988				}
5989				else {
5990					// 2D array
5991					$.merge( nestedSort, a );
5992				}
5993			};
5994	
5995		// Build the sort array, with pre-fix and post-fix options if they have been
5996		// specified
5997		if ( Array.isArray( fixed ) ) {
5998			add( fixed );
5999		}
6000	
6001		if ( fixedObj && fixed.pre ) {
6002			add( fixed.pre );
6003		}
6004	
6005		add( settings.aaSorting );
6006	
6007		if (fixedObj && fixed.post ) {
6008			add( fixed.post );
6009		}
6010	
6011		for ( i=0 ; i<nestedSort.length ; i++ )
6012		{
6013			srcCol = nestedSort[i][0];
6014			aDataSort = aoColumns[ srcCol ].aDataSort;
6015	
6016			for ( k=0, kLen=aDataSort.length ; k<kLen ; k++ )
6017			{
6018				iCol = aDataSort[k];
6019				sType = aoColumns[ iCol ].sType || 'string';
6020	
6021				if ( nestedSort[i]._idx === undefined ) {
6022					nestedSort[i]._idx = $.inArray( nestedSort[i][1], aoColumns[iCol].asSorting );
6023				}
6024	
6025				aSort.push( {
6026					src:       srcCol,
6027					col:       iCol,
6028					dir:       nestedSort[i][1],
6029					index:     nestedSort[i]._idx,
6030					type:      sType,
6031					formatter: DataTable.ext.type.order[ sType+"-pre" ]
6032				} );
6033			}
6034		}
6035	
6036		return aSort;
6037	}
6038	
6039	/**
6040	 * Change the order of the table
6041	 *  @param {object} oSettings dataTables settings object
6042	 *  @memberof DataTable#oApi
6043	 *  @todo This really needs split up!
6044	 */
6045	function _fnSort ( oSettings )
6046	{
6047		var
6048			i, ien, iLen, j, jLen, k, kLen,
6049			sDataType, nTh,
6050			aiOrig = [],
6051			oExtSort = DataTable.ext.type.order,
6052			aoData = oSettings.aoData,
6053			aoColumns = oSettings.aoColumns,
6054			aDataSort, data, iCol, sType, oSort,
6055			formatters = 0,
6056			sortCol,
6057			displayMaster = oSettings.aiDisplayMaster,
6058			aSort;
6059	
6060		// Resolve any column types that are unknown due to addition or invalidation
6061		// @todo Can this be moved into a 'data-ready' handler which is called when
6062		//   data is going to be used in the table?
6063		_fnColumnTypes( oSettings );
6064	
6065		aSort = _fnSortFlatten( oSettings );
6066	
6067		for ( i=0, ien=aSort.length ; i<ien ; i++ ) {
6068			sortCol = aSort[i];
6069	
6070			// Track if we can use the fast sort algorithm
6071			if ( sortCol.formatter ) {
6072				formatters++;
6073			}
6074	
6075			// Load the data needed for the sort, for each cell
6076			_fnSortData( oSettings, sortCol.col );
6077		}
6078	
6079		/* No sorting required if server-side or no sorting array */
6080		if ( _fnDataSource( oSettings ) != 'ssp' && aSort.length !== 0 )
6081		{
6082			// Create a value - key array of the current row positions such that we can use their
6083			// current position during the sort, if values match, in order to perform stable sorting
6084			for ( i=0, iLen=displayMaster.length ; i<iLen ; i++ ) {
6085				aiOrig[ displayMaster[i] ] = i;
6086			}
6087	
6088			/* Do the sort - here we want multi-column sorting based on a given data source (column)
6089			 * and sorting function (from oSort) in a certain direction. It's reasonably complex to
6090			 * follow on it's own, but this is what we want (example two column sorting):
6091			 *  fnLocalSorting = function(a,b){
6092			 *    var iTest;
6093			 *    iTest = oSort['string-asc']('data11', 'data12');
6094			 *      if (iTest !== 0)
6095			 *        return iTest;
6096			 *    iTest = oSort['numeric-desc']('data21', 'data22');
6097			 *    if (iTest !== 0)
6098			 *      return iTest;
6099			 *    return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );
6100			 *  }
6101			 * Basically we have a test for each sorting column, if the data in that column is equal,
6102			 * test the next column. If all columns match, then we use a numeric sort on the row
6103			 * positions in the original data array to provide a stable sort.
6104			 *
6105			 * Note - I know it seems excessive to have two sorting methods, but the first is around
6106			 * 15% faster, so the second is only maintained for backwards compatibility with sorting
6107			 * methods which do not have a pre-sort formatting function.
6108			 */
6109			if ( formatters === aSort.length ) {
6110				// All sort types have formatting functions
6111				displayMaster.sort( function ( a, b ) {
6112					var
6113						x, y, k, test, sort,
6114						len=aSort.length,
6115						dataA = aoData[a]._aSortData,
6116						dataB = aoData[b]._aSortData;
6117	
6118					for ( k=0 ; k<len ; k++ ) {
6119						sort = aSort[k];
6120	
6121						x = dataA[ sort.col ];
6122						y = dataB[ sort.col ];
6123	
6124						test = x<y ? -1 : x>y ? 1 : 0;
6125						if ( test !== 0 ) {
6126							return sort.dir === 'asc' ? test : -test;
6127						}
6128					}
6129	
6130					x = aiOrig[a];
6131					y = aiOrig[b];
6132					return x<y ? -1 : x>y ? 1 : 0;
6133				} );
6134			}
6135			else {
6136				// Depreciated - remove in 1.11 (providing a plug-in option)
6137				// Not all sort types have formatting methods, so we have to call their sorting
6138				// methods.
6139				displayMaster.sort( function ( a, b ) {
6140					var
6141						x, y, k, l, test, sort, fn,
6142						len=aSort.length,
6143						dataA = aoData[a]._aSortData,
6144						dataB = aoData[b]._aSortData;
6145	
6146					for ( k=0 ; k<len ; k++ ) {
6147						sort = aSort[k];
6148	
6149						x = dataA[ sort.col ];
6150						y = dataB[ sort.col ];
6151	
6152						fn = oExtSort[ sort.type+"-"+sort.dir ] || oExtSort[ "string-"+sort.dir ];
6153						test = fn( x, y );
6154						if ( test !== 0 ) {
6155							return test;
6156						}
6157					}
6158	
6159					x = aiOrig[a];
6160					y = aiOrig[b];
6161					return x<y ? -1 : x>y ? 1 : 0;
6162				} );
6163			}
6164		}
6165	
6166		/* Tell the draw function that we have sorted the data */
6167		oSettings.bSorted = true;
6168	}
6169	
6170	
6171	function _fnSortAria ( settings )
6172	{
6173		var label;
6174		var nextSort;
6175		var columns = settings.aoColumns;
6176		var aSort = _fnSortFlatten( settings );
6177		var oAria = settings.oLanguage.oAria;
6178	
6179		// ARIA attributes - need to loop all columns, to update all (removing old
6180		// attributes as needed)
6181		for ( var i=0, iLen=columns.length ; i<iLen ; i++ )
6182		{
6183			var col = columns[i];
6184			var asSorting = col.asSorting;
6185			var sTitle = col.ariaTitle || col.sTitle.replace( /<.*?>/g, "" );
6186			var th = col.nTh;
6187	
6188			// IE7 is throwing an error when setting these properties with jQuery's
6189			// attr() and removeAttr() methods...
6190			th.removeAttribute('aria-sort');
6191	
6192			/* In ARIA only the first sorting column can be marked as sorting - no multi-sort option */
6193			if ( col.bSortable ) {
6194				if ( aSort.length > 0 && aSort[0].col == i ) {
6195					th.setAttribute('aria-sort', aSort[0].dir=="asc" ? "ascending" : "descending" );
6196					nextSort = asSorting[ aSort[0].index+1 ] || asSorting[0];
6197				}
6198				else {
6199					nextSort = asSorting[0];
6200				}
6201	
6202				label = sTitle + ( nextSort === "asc" ?
6203					oAria.sSortAscending :
6204					oAria.sSortDescending
6205				);
6206			}
6207			else {
6208				label = sTitle;
6209			}
6210	
6211			th.setAttribute('aria-label', label);
6212		}
6213	}
6214	
6215	
6216	/**
6217	 * Function to run on user sort request
6218	 *  @param {object} settings dataTables settings object
6219	 *  @param {node} attachTo node to attach the handler to
6220	 *  @param {int} colIdx column sorting index
6221	 *  @param {boolean} [append=false] Append the requested sort to the existing
6222	 *    sort if true (i.e. multi-column sort)
6223	 *  @param {function} [callback] callback function
6224	 *  @memberof DataTable#oApi
6225	 */
6226	function _fnSortListener ( settings, colIdx, append, callback )
6227	{
6228		var col = settings.aoColumns[ colIdx ];
6229		var sorting = settings.aaSorting;
6230		var asSorting = col.asSorting;
6231		var nextSortIdx;
6232		var next = function ( a, overflow ) {
6233			var idx = a._idx;
6234			if ( idx === undefined ) {
6235				idx = $.inArray( a[1], asSorting );
6236			}
6237	
6238			return idx+1 < asSorting.length ?
6239				idx+1 :
6240				overflow ?
6241					null :
6242					0;
6243		};
6244	
6245		// Convert to 2D array if needed
6246		if ( typeof sorting[0] === 'number' ) {
6247			sorting = settings.aaSorting = [ sorting ];
6248		}
6249	
6250		// If appending the sort then we are multi-column sorting
6251		if ( append && settings.oFeatures.bSortMulti ) {
6252			// Are we already doing some kind of sort on this column?
6253			var sortIdx = $.inArray( colIdx, _pluck(sorting, '0') );
6254	
6255			if ( sortIdx !== -1 ) {
6256				// Yes, modify the sort
6257				nextSortIdx = next( sorting[sortIdx], true );
6258	
6259				if ( nextSortIdx === null && sorting.length === 1 ) {
6260					nextSortIdx = 0; // can't remove sorting completely
6261				}
6262	
6263				if ( nextSortIdx === null ) {
6264					sorting.splice( sortIdx, 1 );
6265				}
6266				else {
6267					sorting[sortIdx][1] = asSorting[ nextSortIdx ];
6268					sorting[sortIdx]._idx = nextSortIdx;
6269				}
6270			}
6271			else {
6272				// No sort on this column yet
6273				sorting.push( [ colIdx, asSorting[0], 0 ] );
6274				sorting[sorting.length-1]._idx = 0;
6275			}
6276		}
6277		else if ( sorting.length && sorting[0][0] == colIdx ) {
6278			// Single column - already sorting on this column, modify the sort
6279			nextSortIdx = next( sorting[0] );
6280	
6281			sorting.length = 1;
6282			sorting[0][1] = asSorting[ nextSortIdx ];
6283			sorting[0]._idx = nextSortIdx;
6284		}
6285		else {
6286			// Single column - sort only on this column
6287			sorting.length = 0;
6288			sorting.push( [ colIdx, asSorting[0] ] );
6289			sorting[0]._idx = 0;
6290		}
6291	
6292		// Run the sort by calling a full redraw
6293		_fnReDraw( settings );
6294	
6295		// callback used for async user interaction
6296		if ( typeof callback == 'function' ) {
6297			callback( settings );
6298		}
6299	}
6300	
6301	
6302	/**
6303	 * Attach a sort handler (click) to a node
6304	 *  @param {object} settings dataTables settings object
6305	 *  @param {node} attachTo node to attach the handler to
6306	 *  @param {int} colIdx column sorting index
6307	 *  @param {function} [callback] callback function
6308	 *  @memberof DataTable#oApi
6309	 */
6310	function _fnSortAttachListener ( settings, attachTo, colIdx, callback )
6311	{
6312		var col = settings.aoColumns[ colIdx ];
6313	
6314		_fnBindAction( attachTo, {}, function (e) {
6315			/* If the column is not sortable - don't to anything */
6316			if ( col.bSortable === false ) {
6317				return;
6318			}
6319	
6320			// If processing is enabled use a timeout to allow the processing
6321			// display to be shown - otherwise to it synchronously
6322			if ( settings.oFeatures.bProcessing ) {
6323				_fnProcessingDisplay( settings, true );
6324	
6325				setTimeout( function() {
6326					_fnSortListener( settings, colIdx, e.shiftKey, callback );
6327	
6328					// In server-side processing, the draw callback will remove the
6329					// processing display
6330					if ( _fnDataSource( settings ) !== 'ssp' ) {
6331						_fnProcessingDisplay( settings, false );
6332					}
6333				}, 0 );
6334			}
6335			else {
6336				_fnSortListener( settings, colIdx, e.shiftKey, callback );
6337			}
6338		} );
6339	}
6340	
6341	
6342	/**
6343	 * Set the sorting classes on table's body, Note: it is safe to call this function
6344	 * when bSort and bSortClasses are false
6345	 *  @param {object} oSettings dataTables settings object
6346	 *  @memberof DataTable#oApi
6347	 */
6348	function _fnSortingClasses( settings )
6349	{
6350		var oldSort = settings.aLastSort;
6351		var sortClass = settings.oClasses.sSortColumn;
6352		var sort = _fnSortFlatten( settings );
6353		var features = settings.oFeatures;
6354		var i, ien, colIdx;
6355	
6356		if ( features.bSort && features.bSortClasses ) {
6357			// Remove old sorting classes
6358			for ( i=0, ien=oldSort.length ; i<ien ; i++ ) {
6359				colIdx = oldSort[i].src;
6360	
6361				// Remove column sorting
6362				$( _pluck( settings.aoData, 'anCells', colIdx ) )
6363					.removeClass( sortClass + (i<2 ? i+1 : 3) );
6364			}
6365	
6366			// Add new column sorting
6367			for ( i=0, ien=sort.length ; i<ien ; i++ ) {
6368				colIdx = sort[i].src;
6369	
6370				$( _pluck( settings.aoData, 'anCells', colIdx ) )
6371					.addClass( sortClass + (i<2 ? i+1 : 3) );
6372			}
6373		}
6374	
6375		settings.aLastSort = sort;
6376	}
6377	
6378	
6379	// Get the data to sort a column, be it from cache, fresh (populating the
6380	// cache), or from a sort formatter
6381	function _fnSortData( settings, idx )
6382	{
6383		// Custom sorting function - provided by the sort data type
6384		var column = settings.aoColumns[ idx ];
6385		var customSort = DataTable.ext.order[ column.sSortDataType ];
6386		var customData;
6387	
6388		if ( customSort ) {
6389			customData = customSort.call( settings.oInstance, settings, idx,
6390				_fnColumnIndexToVisible( settings, idx )
6391			);
6392		}
6393	
6394		// Use / populate cache
6395		var row, cellData;
6396		var formatter = DataTable.ext.type.order[ column.sType+"-pre" ];
6397	
6398		for ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {
6399			row = settings.aoData[i];
6400	
6401			if ( ! row._aSortData ) {
6402				row._aSortData = [];
6403			}
6404	
6405			if ( ! row._aSortData[idx] || customSort ) {
6406				cellData = customSort ?
6407					customData[i] : // If there was a custom sort function, use data from there
6408					_fnGetCellData( settings, i, idx, 'sort' );
6409	
6410				row._aSortData[ idx ] = formatter ?
6411					formatter( cellData ) :
6412					cellData;
6413			}
6414		}
6415	}
6416	
6417	
6418	
6419	/**
6420	 * Save the state of a table
6421	 *  @param {object} oSettings dataTables settings object
6422	 *  @memberof DataTable#oApi
6423	 */
6424	function _fnSaveState ( settings )
6425	{
6426		if (settings._bLoadingState) {
6427			return;
6428		}
6429	
6430		/* Store the interesting variables */
6431		var state = {
6432			time:    +new Date(),
6433			start:   settings._iDisplayStart,
6434			length:  settings._iDisplayLength,
6435			order:   $.extend( true, [], settings.aaSorting ),
6436			search:  _fnSearchToCamel( settings.oPreviousSearch ),
6437			columns: $.map( settings.aoColumns, function ( col, i ) {
6438				return {
6439					visible: col.bVisible,
6440					search: _fnSearchToCamel( settings.aoPreSearchCols[i] )
6441				};
6442			} )
6443		};
6444	
6445		settings.oSavedState = state;
6446		_fnCallbackFire( settings, "aoStateSaveParams", 'stateSaveParams', [settings, state] );
6447		
6448		if ( settings.oFeatures.bStateSave && !settings.bDestroying )
6449		{
6450			settings.fnStateSaveCallback.call( settings.oInstance, settings, state );
6451		}	
6452	}
6453	
6454	
6455	/**
6456	 * Attempt to load a saved table state
6457	 *  @param {object} oSettings dataTables settings object
6458	 *  @param {object} oInit DataTables init object so we can override settings
6459	 *  @param {function} callback Callback to execute when the state has been loaded
6460	 *  @memberof DataTable#oApi
6461	 */
6462	function _fnLoadState ( settings, oInit, callback )
6463	{
6464		if ( ! settings.oFeatures.bStateSave ) {
6465			callback();
6466			return;
6467		}
6468	
6469		var loaded = function(state) {
6470			_fnImplementState(settings, state, callback);
6471		}
6472	
6473		var state = settings.fnStateLoadCallback.call( settings.oInstance, settings, loaded );
6474	
6475		if ( state !== undefined ) {
6476			_fnImplementState( settings, state, callback );
6477		}
6478		// otherwise, wait for the loaded callback to be executed
6479	
6480		return true;
6481	}
6482	
6483	function _fnImplementState ( settings, s, callback) {
6484		var i, ien;
6485		var columns = settings.aoColumns;
6486		settings._bLoadingState = true;
6487	
6488		// When StateRestore was introduced the state could now be implemented at any time
6489		// Not just initialisation. To do this an api instance is required in some places
6490		var api = settings._bInitComplete ? new DataTable.Api(settings) : null;
6491	
6492		if ( ! s || ! s.time ) {
6493			settings._bLoadingState = false;
6494			callback();
6495			return;
6496		}
6497	
6498		// Allow custom and plug-in manipulation functions to alter the saved data set and
6499		// cancelling of loading by returning false
6500		var abStateLoad = _fnCallbackFire( settings, 'aoStateLoadParams', 'stateLoadParams', [settings, s] );
6501		if ( $.inArray( false, abStateLoad ) !== -1 ) {
6502			settings._bLoadingState = false;
6503			callback();
6504			return;
6505		}
6506	
6507		// Reject old data
6508		var duration = settings.iStateDuration;
6509		if ( duration > 0 && s.time < +new Date() - (duration*1000) ) {
6510			settings._bLoadingState = false;
6511			callback();
6512			return;
6513		}
6514	
6515		// Number of columns have changed - all bets are off, no restore of settings
6516		if ( s.columns && columns.length !== s.columns.length ) {
6517			settings._bLoadingState = false;
6518			callback();
6519			return;
6520		}
6521	
6522		// Store the saved state so it might be accessed at any time
6523		settings.oLoadedState = $.extend( true, {}, s );
6524	
6525		// Page Length
6526		if ( s.length !== undefined ) {
6527			// If already initialised just set the value directly so that the select element is also updated
6528			if (api) {
6529				api.page.len(s.length)
6530			}
6531			else {
6532				settings._iDisplayLength   = s.length;
6533			}
6534		}
6535	
6536		// Restore key features - todo - for 1.11 this needs to be done by
6537		// subscribed events
6538		if ( s.start !== undefined ) {
6539			if(api === null) {
6540				settings._iDisplayStart    = s.start;
6541				settings.iInitDisplayStart = s.start;
6542			}
6543			else {
6544				_fnPageChange(settings, s.start/settings._iDisplayLength);
6545			}
6546		}
6547	
6548		// Order
6549		if ( s.order !== undefined ) {
6550			settings.aaSorting = [];
6551			$.each( s.order, function ( i, col ) {
6552				settings.aaSorting.push( col[0] >= columns.length ?
6553					[ 0, col[1] ] :
6554					col
6555				);
6556			} );
6557		}
6558	
6559		// Search
6560		if ( s.search !== undefined ) {
6561			$.extend( settings.oPreviousSearch, _fnSearchToHung( s.search ) );
6562		}
6563	
6564		// Columns
6565		if ( s.columns ) {
6566			for ( i=0, ien=s.columns.length ; i<ien ; i++ ) {
6567				var col = s.columns[i];
6568	
6569				// Visibility
6570				if ( col.visible !== undefined ) {
6571					// If the api is defined, the table has been initialised so we need to use it rather than internal settings
6572					if (api) {
6573						// Don't redraw the columns on every iteration of this loop, we will do this at the end instead
6574						api.column(i).visible(col.visible, false);
6575					}
6576					else {
6577						columns[i].bVisible = col.visible;
6578					}
6579				}
6580	
6581				// Search
6582				if ( col.search !== undefined ) {
6583					$.extend( settings.aoPreSearchCols[i], _fnSearchToHung( col.search ) );
6584				}
6585			}
6586			
6587			// If the api is defined then we need to adjust the columns once the visibility has been changed
6588			if (api) {
6589				api.columns.adjust();
6590			}
6591		}
6592	
6593		settings._bLoadingState = false;
6594		_fnCallbackFire( settings, 'aoStateLoaded', 'stateLoaded', [settings, s] );
6595		callback();
6596	};
6597	
6598	
6599	/**
6600	 * Return the settings object for a particular table
6601	 *  @param {node} table table we are using as a dataTable
6602	 *  @returns {object} Settings object - or null if not found
6603	 *  @memberof DataTable#oApi
6604	 */
6605	function _fnSettingsFromNode ( table )
6606	{
6607		var settings = DataTable.settings;
6608		var idx = $.inArray( table, _pluck( settings, 'nTable' ) );
6609	
6610		return idx !== -1 ?
6611			settings[ idx ] :
6612			null;
6613	}
6614	
6615	
6616	/**
6617	 * Log an error message
6618	 *  @param {object} settings dataTables settings object
6619	 *  @param {int} level log error messages, or display them to the user
6620	 *  @param {string} msg error message
6621	 *  @param {int} tn Technical note id to get more information about the error.
6622	 *  @memberof DataTable#oApi
6623	 */
6624	function _fnLog( settings, level, msg, tn )
6625	{
6626		msg = 'DataTables warning: '+
6627			(settings ? 'table id='+settings.sTableId+' - ' : '')+msg;
6628	
6629		if ( tn ) {
6630			msg += '. For more information about this error, please see '+
6631			'http://datatables.net/tn/'+tn;
6632		}
6633	
6634		if ( ! level  ) {
6635			// Backwards compatibility pre 1.10
6636			var ext = DataTable.ext;
6637			var type = ext.sErrMode || ext.errMode;
6638	
6639			if ( settings ) {
6640				_fnCallbackFire( settings, null, 'error', [ settings, tn, msg ] );
6641			}
6642	
6643			if ( type == 'alert' ) {
6644				alert( msg );
6645			}
6646			else if ( type == 'throw' ) {
6647				throw new Error(msg);
6648			}
6649			else if ( typeof type == 'function' ) {
6650				type( settings, tn, msg );
6651			}
6652		}
6653		else if ( window.console && console.log ) {
6654			console.log( msg );
6655		}
6656	}
6657	
6658	
6659	/**
6660	 * See if a property is defined on one object, if so assign it to the other object
6661	 *  @param {object} ret target object
6662	 *  @param {object} src source object
6663	 *  @param {string} name property
6664	 *  @param {string} [mappedName] name to map too - optional, name used if not given
6665	 *  @memberof DataTable#oApi
6666	 */
6667	function _fnMap( ret, src, name, mappedName )
6668	{
6669		if ( Array.isArray( name ) ) {
6670			$.each( name, function (i, val) {
6671				if ( Array.isArray( val ) ) {
6672					_fnMap( ret, src, val[0], val[1] );
6673				}
6674				else {
6675					_fnMap( ret, src, val );
6676				}
6677			} );
6678	
6679			return;
6680		}
6681	
6682		if ( mappedName === undefined ) {
6683			mappedName = name;
6684		}
6685	
6686		if ( src[name] !== undefined ) {
6687			ret[mappedName] = src[name];
6688		}
6689	}
6690	
6691	
6692	/**
6693	 * Extend objects - very similar to jQuery.extend, but deep copy objects, and
6694	 * shallow copy arrays. The reason we need to do this, is that we don't want to
6695	 * deep copy array init values (such as aaSorting) since the dev wouldn't be
6696	 * able to override them, but we do want to deep copy arrays.
6697	 *  @param {object} out Object to extend
6698	 *  @param {object} extender Object from which the properties will be applied to
6699	 *      out
6700	 *  @param {boolean} breakRefs If true, then arrays will be sliced to take an
6701	 *      independent copy with the exception of the `data` or `aaData` parameters
6702	 *      if they are present. This is so you can pass in a collection to
6703	 *      DataTables and have that used as your data source without breaking the
6704	 *      references
6705	 *  @returns {object} out Reference, just for convenience - out === the return.
6706	 *  @memberof DataTable#oApi
6707	 *  @todo This doesn't take account of arrays inside the deep copied objects.
6708	 */
6709	function _fnExtend( out, extender, breakRefs )
6710	{
6711		var val;
6712	
6713		for ( var prop in extender ) {
6714			if ( extender.hasOwnProperty(prop) ) {
6715				val = extender[prop];
6716	
6717				if ( $.isPlainObject( val ) ) {
6718					if ( ! $.isPlainObject( out[prop] ) ) {
6719						out[prop] = {};
6720					}
6721					$.extend( true, out[prop], val );
6722				}
6723				else if ( breakRefs && prop !== 'data' && prop !== 'aaData' && Array.isArray(val) ) {
6724					out[prop] = val.slice();
6725				}
6726				else {
6727					out[prop] = val;
6728				}
6729			}
6730		}
6731	
6732		return out;
6733	}
6734	
6735	
6736	/**
6737	 * Bind an event handers to allow a click or return key to activate the callback.
6738	 * This is good for accessibility since a return on the keyboard will have the
6739	 * same effect as a click, if the element has focus.
6740	 *  @param {element} n Element to bind the action to
6741	 *  @param {object} oData Data object to pass to the triggered function
6742	 *  @param {function} fn Callback function for when the event is triggered
6743	 *  @memberof DataTable#oApi
6744	 */
6745	function _fnBindAction( n, oData, fn )
6746	{
6747		$(n)
6748			.on( 'click.DT', oData, function (e) {
6749					$(n).trigger('blur'); // Remove focus outline for mouse users
6750					fn(e);
6751				} )
6752			.on( 'keypress.DT', oData, function (e){
6753					if ( e.which === 13 ) {
6754						e.preventDefault();
6755						fn(e);
6756					}
6757				} )
6758			.on( 'selectstart.DT', function () {
6759					/* Take the brutal approach to cancelling text selection */
6760					return false;
6761				} );
6762	}
6763	
6764	
6765	/**
6766	 * Register a callback function. Easily allows a callback function to be added to
6767	 * an array store of callback functions that can then all be called together.
6768	 *  @param {object} oSettings dataTables settings object
6769	 *  @param {string} sStore Name of the array storage for the callbacks in oSettings
6770	 *  @param {function} fn Function to be called back
6771	 *  @param {string} sName Identifying name for the callback (i.e. a label)
6772	 *  @memberof DataTable#oApi
6773	 */
6774	function _fnCallbackReg( oSettings, sStore, fn, sName )
6775	{
6776		if ( fn )
6777		{
6778			oSettings[sStore].push( {
6779				"fn": fn,
6780				"sName": sName
6781			} );
6782		}
6783	}
6784	
6785	
6786	/**
6787	 * Fire callback functions and trigger events. Note that the loop over the
6788	 * callback array store is done backwards! Further note that you do not want to
6789	 * fire off triggers in time sensitive applications (for example cell creation)
6790	 * as its slow.
6791	 *  @param {object} settings dataTables settings object
6792	 *  @param {string} callbackArr Name of the array storage for the callbacks in
6793	 *      oSettings
6794	 *  @param {string} eventName Name of the jQuery custom event to trigger. If
6795	 *      null no trigger is fired
6796	 *  @param {array} args Array of arguments to pass to the callback function /
6797	 *      trigger
6798	 *  @memberof DataTable#oApi
6799	 */
6800	function _fnCallbackFire( settings, callbackArr, eventName, args )
6801	{
6802		var ret = [];
6803	
6804		if ( callbackArr ) {
6805			ret = $.map( settings[callbackArr].slice().reverse(), function (val, i) {
6806				return val.fn.apply( settings.oInstance, args );
6807			} );
6808		}
6809	
6810		if ( eventName !== null ) {
6811			var e = $.Event( eventName+'.dt' );
6812			var table = $(settings.nTable);
6813	
6814			table.trigger( e, args );
6815	
6816			// If not yet attached to the document, trigger the event
6817			// on the body directly to sort of simulate the bubble
6818			if (table.parents('body').length === 0) {
6819				$('body').trigger( e, args );
6820			}
6821	
6822			ret.push( e.result );
6823		}
6824	
6825		return ret;
6826	}
6827	
6828	
6829	function _fnLengthOverflow ( settings )
6830	{
6831		var
6832			start = settings._iDisplayStart,
6833			end = settings.fnDisplayEnd(),
6834			len = settings._iDisplayLength;
6835	
6836		/* If we have space to show extra rows (backing up from the end point - then do so */
6837		if ( start >= end )
6838		{
6839			start = end - len;
6840		}
6841	
6842		// Keep the start record on the current page
6843		start -= (start % len);
6844	
6845		if ( len === -1 || start < 0 )
6846		{
6847			start = 0;
6848		}
6849	
6850		settings._iDisplayStart = start;
6851	}
6852	
6853	
6854	function _fnRenderer( settings, type )
6855	{
6856		var renderer = settings.renderer;
6857		var host = DataTable.ext.renderer[type];
6858	
6859		if ( $.isPlainObject( renderer ) && renderer[type] ) {
6860			// Specific renderer for this type. If available use it, otherwise use
6861			// the default.
6862			return host[renderer[type]] || host._;
6863		}
6864		else if ( typeof renderer === 'string' ) {
6865			// Common renderer - if there is one available for this type use it,
6866			// otherwise use the default
6867			return host[renderer] || host._;
6868		}
6869	
6870		// Use the default
6871		return host._;
6872	}
6873	
6874	
6875	/**
6876	 * Detect the data source being used for the table. Used to simplify the code
6877	 * a little (ajax) and to make it compress a little smaller.
6878	 *
6879	 *  @param {object} settings dataTables settings object
6880	 *  @returns {string} Data source
6881	 *  @memberof DataTable#oApi
6882	 */
6883	function _fnDataSource ( settings )
6884	{
6885		if ( settings.oFeatures.bServerSide ) {
6886			return 'ssp';
6887		}
6888		else if ( settings.ajax || settings.sAjaxSource ) {
6889			return 'ajax';
6890		}
6891		return 'dom';
6892	}
6893	
6894	
6895	
6896	
6897	/**
6898	 * Computed structure of the DataTables API, defined by the options passed to
6899	 * `DataTable.Api.register()` when building the API.
6900	 *
6901	 * The structure is built in order to speed creation and extension of the Api
6902	 * objects since the extensions are effectively pre-parsed.
6903	 *
6904	 * The array is an array of objects with the following structure, where this
6905	 * base array represents the Api prototype base:
6906	 *
6907	 *     [
6908	 *       {
6909	 *         name:      'data'                -- string   - Property name
6910	 *         val:       function () {},       -- function - Api method (or undefined if just an object
6911	 *         methodExt: [ ... ],              -- array    - Array of Api object definitions to extend the method result
6912	 *         propExt:   [ ... ]               -- array    - Array of Api object definitions to extend the property
6913	 *       },
6914	 *       {
6915	 *         name:     'row'
6916	 *         val:       {},
6917	 *         methodExt: [ ... ],
6918	 *         propExt:   [
6919	 *           {
6920	 *             name:      'data'
6921	 *             val:       function () {},
6922	 *             methodExt: [ ... ],
6923	 *             propExt:   [ ... ]
6924	 *           },
6925	 *           ...
6926	 *         ]
6927	 *       }
6928	 *     ]
6929	 *
6930	 * @type {Array}
6931	 * @ignore
6932	 */
6933	var __apiStruct = [];
6934	
6935	
6936	/**
6937	 * `Array.prototype` reference.
6938	 *
6939	 * @type object
6940	 * @ignore
6941	 */
6942	var __arrayProto = Array.prototype;
6943	
6944	
6945	/**
6946	 * Abstraction for `context` parameter of the `Api` constructor to allow it to
6947	 * take several different forms for ease of use.
6948	 *
6949	 * Each of the input parameter types will be converted to a DataTables settings
6950	 * object where possible.
6951	 *
6952	 * @param  {string|node|jQuery|object} mixed DataTable identifier. Can be one
6953	 *   of:
6954	 *
6955	 *   * `string` - jQuery selector. Any DataTables' matching the given selector
6956	 *     with be found and used.
6957	 *   * `node` - `TABLE` node which has already been formed into a DataTable.
6958	 *   * `jQuery` - A jQuery object of `TABLE` nodes.
6959	 *   * `object` - DataTables settings object
6960	 *   * `DataTables.Api` - API instance
6961	 * @return {array|null} Matching DataTables settings objects. `null` or
6962	 *   `undefined` is returned if no matching DataTable is found.
6963	 * @ignore
6964	 */
6965	var _toSettings = function ( mixed )
6966	{
6967		var idx, jq;
6968		var settings = DataTable.settings;
6969		var tables = $.map( settings, function (el, i) {
6970			return el.nTable;
6971		} );
6972	
6973		if ( ! mixed ) {
6974			return [];
6975		}
6976		else if ( mixed.nTable && mixed.oApi ) {
6977			// DataTables settings object
6978			return [ mixed ];
6979		}
6980		else if ( mixed.nodeName && mixed.nodeName.toLowerCase() === 'table' ) {
6981			// Table node
6982			idx = $.inArray( mixed, tables );
6983			return idx !== -1 ? [ settings[idx] ] : null;
6984		}
6985		else if ( mixed && typeof mixed.settings === 'function' ) {
6986			return mixed.settings().toArray();
6987		}
6988		else if ( typeof mixed === 'string' ) {
6989			// jQuery selector
6990			jq = $(mixed);
6991		}
6992		else if ( mixed instanceof $ ) {
6993			// jQuery object (also DataTables instance)
6994			jq = mixed;
6995		}
6996	
6997		if ( jq ) {
6998			return jq.map( function(i) {
6999				idx = $.inArray( this, tables );
7000				return idx !== -1 ? settings[idx] : null;
7001			} ).toArray();
7002		}
7003	};
7004	
7005	
7006	/**
7007	 * DataTables API class - used to control and interface with  one or more
7008	 * DataTables enhanced tables.
7009	 *
7010	 * The API class is heavily based on jQuery, presenting a chainable interface
7011	 * that you can use to interact with tables. Each instance of the API class has
7012	 * a "context" - i.e. the tables that it will operate on. This could be a single
7013	 * table, all tables on a page or a sub-set thereof.
7014	 *
7015	 * Additionally the API is designed to allow you to easily work with the data in
7016	 * the tables, retrieving and manipulating it as required. This is done by
7017	 * presenting the API class as an array like interface. The contents of the
7018	 * array depend upon the actions requested by each method (for example
7019	 * `rows().nodes()` will return an array of nodes, while `rows().data()` will