{"version":3,"file":"shared/chunks/1920.9297476e8aaf96bbfada.js","mappings":"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","sources":["webpack://dsposal.web/./node_modules/datatables.net/js/jquery.dataTables.js"],"sourcesContent":["/*! DataTables 1.12.1\n * ©2008-2022 SpryMedia Ltd - datatables.net/license\n */\n\n/**\n * @summary     DataTables\n * @description Paginate, search and order HTML tables\n * @version     1.12.1\n * @author      SpryMedia Ltd\n * @contact     www.datatables.net\n * @copyright   SpryMedia Ltd.\n *\n * This source file is free software, available under the following license:\n *   MIT license - http://datatables.net/license\n *\n * This source file is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.\n *\n * For details please refer to: http://www.datatables.net\n */\n\n/*jslint evil: true, undef: true, browser: true */\n/*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*/\n\n(function( factory ) {\n\t\"use strict\";\n\n\tif ( typeof define === 'function' && define.amd ) {\n\t\t// AMD\n\t\tdefine( ['jquery'], function ( $ ) {\n\t\t\treturn factory( $, window, document );\n\t\t} );\n\t}\n\telse if ( typeof exports === 'object' ) {\n\t\t// CommonJS\n\t\tmodule.exports = function (root, $) {\n\t\t\tif ( ! root ) {\n\t\t\t\t// CommonJS environments without a window global must pass a\n\t\t\t\t// root. This will give an error otherwise\n\t\t\t\troot = window;\n\t\t\t}\n\n\t\t\tif ( ! $ ) {\n\t\t\t\t$ = typeof window !== 'undefined' ? // jQuery's factory checks for a global window\n\t\t\t\t\trequire('jquery') :\n\t\t\t\t\trequire('jquery')( root );\n\t\t\t}\n\n\t\t\treturn factory( $, root, root.document );\n\t\t};\n\t}\n\telse {\n\t\t// Browser\n\t\twindow.DataTable = factory( jQuery, window, document );\n\t}\n}\n(function( $, window, document, undefined ) {\n\t\"use strict\";\n\n\t\n\tvar DataTable = function ( selector, options )\n\t{\n\t\t// When creating with `new`, create a new DataTable, returning the API instance\n\t\tif (this instanceof DataTable) {\n\t\t\treturn $(selector).DataTable(options);\n\t\t}\n\t\telse {\n\t\t\t// Argument switching\n\t\t\toptions = selector;\n\t\t}\n\t\n\t\t/**\n\t\t * Perform a jQuery selector action on the table's TR elements (from the tbody) and\n\t\t * return the resulting jQuery object.\n\t\t *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on\n\t\t *  @param {object} [oOpts] Optional parameters for modifying the rows to be included\n\t\t *  @param {string} [oOpts.filter=none] Select TR elements that meet the current filter\n\t\t *    criterion (\"applied\") or all TR elements (i.e. no filter).\n\t\t *  @param {string} [oOpts.order=current] Order of the TR elements in the processed array.\n\t\t *    Can be either 'current', whereby the current sorting of the table is used, or\n\t\t *    'original' whereby the original order the data was read into the table is used.\n\t\t *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page\n\t\t *    (\"current\") or not (\"all\"). If 'current' is given, then order is assumed to be\n\t\t *    'current' and filter is 'applied', regardless of what they might be given as.\n\t\t *  @returns {object} jQuery object, filtered by the given selector.\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Highlight every second row\n\t\t *      oTable.$('tr:odd').css('backgroundColor', 'blue');\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Filter to rows with 'Webkit' in them, add a background colour and then\n\t\t *      // remove the filter, thus highlighting the 'Webkit' rows only.\n\t\t *      oTable.fnFilter('Webkit');\n\t\t *      oTable.$('tr', {\"search\": \"applied\"}).css('backgroundColor', 'blue');\n\t\t *      oTable.fnFilter('');\n\t\t *    } );\n\t\t */\n\t\tthis.$ = function ( sSelector, oOpts )\n\t\t{\n\t\t\treturn this.api(true).$( sSelector, oOpts );\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Almost identical to $ in operation, but in this case returns the data for the matched\n\t\t * rows - as such, the jQuery selector used should match TR row nodes or TD/TH cell nodes\n\t\t * rather than any descendants, so the data can be obtained for the row/cell. If matching\n\t\t * rows are found, the data returned is the original data array/object that was used to\n\t\t * create the row (or a generated array if from a DOM source).\n\t\t *\n\t\t * This method is often useful in-combination with $ where both functions are given the\n\t\t * same parameters and the array indexes will match identically.\n\t\t *  @param {string|node|jQuery} sSelector jQuery selector or node collection to act on\n\t\t *  @param {object} [oOpts] Optional parameters for modifying the rows to be included\n\t\t *  @param {string} [oOpts.filter=none] Select elements that meet the current filter\n\t\t *    criterion (\"applied\") or all elements (i.e. no filter).\n\t\t *  @param {string} [oOpts.order=current] Order of the data in the processed array.\n\t\t *    Can be either 'current', whereby the current sorting of the table is used, or\n\t\t *    'original' whereby the original order the data was read into the table is used.\n\t\t *  @param {string} [oOpts.page=all] Limit the selection to the currently displayed page\n\t\t *    (\"current\") or not (\"all\"). If 'current' is given, then order is assumed to be\n\t\t *    'current' and filter is 'applied', regardless of what they might be given as.\n\t\t *  @returns {array} Data for the matched elements. If any elements, as a result of the\n\t\t *    selector, were not TR, TD or TH elements in the DataTable, they will have a null\n\t\t *    entry in the array.\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Get the data from the first row in the table\n\t\t *      var data = oTable._('tr:first');\n\t\t *\n\t\t *      // Do something useful with the data\n\t\t *      alert( \"First cell is: \"+data[0] );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Filter to 'Webkit' and get all data for\n\t\t *      oTable.fnFilter('Webkit');\n\t\t *      var data = oTable._('tr', {\"search\": \"applied\"});\n\t\t *\n\t\t *      // Do something with the data\n\t\t *      alert( data.length+\" rows matched the search\" );\n\t\t *    } );\n\t\t */\n\t\tthis._ = function ( sSelector, oOpts )\n\t\t{\n\t\t\treturn this.api(true).rows( sSelector, oOpts ).data();\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Create a DataTables Api instance, with the currently selected tables for\n\t\t * the Api's context.\n\t\t * @param {boolean} [traditional=false] Set the API instance's context to be\n\t\t *   only the table referred to by the `DataTable.ext.iApiIndex` option, as was\n\t\t *   used in the API presented by DataTables 1.9- (i.e. the traditional mode),\n\t\t *   or if all tables captured in the jQuery object should be used.\n\t\t * @return {DataTables.Api}\n\t\t */\n\t\tthis.api = function ( traditional )\n\t\t{\n\t\t\treturn traditional ?\n\t\t\t\tnew _Api(\n\t\t\t\t\t_fnSettingsFromNode( this[ _ext.iApiIndex ] )\n\t\t\t\t) :\n\t\t\t\tnew _Api( this );\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Add a single new row or multiple rows of data to the table. Please note\n\t\t * that this is suitable for client-side processing only - if you are using\n\t\t * server-side processing (i.e. \"bServerSide\": true), then to add data, you\n\t\t * must add it to the data source, i.e. the server-side, through an Ajax call.\n\t\t *  @param {array|object} data The data to be added to the table. This can be:\n\t\t *    <ul>\n\t\t *      <li>1D array of data - add a single row with the data provided</li>\n\t\t *      <li>2D array of arrays - add multiple rows in a single call</li>\n\t\t *      <li>object - data object when using <i>mData</i></li>\n\t\t *      <li>array of objects - multiple data objects when using <i>mData</i></li>\n\t\t *    </ul>\n\t\t *  @param {bool} [redraw=true] redraw the table or not\n\t\t *  @returns {array} An array of integers, representing the list of indexes in\n\t\t *    <i>aoData</i> ({@link DataTable.models.oSettings}) that have been added to\n\t\t *    the table.\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    // Global var for counter\n\t\t *    var giCount = 2;\n\t\t *\n\t\t *    $(document).ready(function() {\n\t\t *      $('#example').dataTable();\n\t\t *    } );\n\t\t *\n\t\t *    function fnClickAddRow() {\n\t\t *      $('#example').dataTable().fnAddData( [\n\t\t *        giCount+\".1\",\n\t\t *        giCount+\".2\",\n\t\t *        giCount+\".3\",\n\t\t *        giCount+\".4\" ]\n\t\t *      );\n\t\t *\n\t\t *      giCount++;\n\t\t *    }\n\t\t */\n\t\tthis.fnAddData = function( data, redraw )\n\t\t{\n\t\t\tvar api = this.api( true );\n\t\t\n\t\t\t/* Check if we want to add multiple rows or not */\n\t\t\tvar rows = Array.isArray(data) && ( Array.isArray(data[0]) || $.isPlainObject(data[0]) ) ?\n\t\t\t\tapi.rows.add( data ) :\n\t\t\t\tapi.row.add( data );\n\t\t\n\t\t\tif ( redraw === undefined || redraw ) {\n\t\t\t\tapi.draw();\n\t\t\t}\n\t\t\n\t\t\treturn rows.flatten().toArray();\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * This function will make DataTables recalculate the column sizes, based on the data\n\t\t * contained in the table and the sizes applied to the columns (in the DOM, CSS or\n\t\t * through the sWidth parameter). This can be useful when the width of the table's\n\t\t * parent element changes (for example a window resize).\n\t\t *  @param {boolean} [bRedraw=true] Redraw the table or not, you will typically want to\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable( {\n\t\t *        \"sScrollY\": \"200px\",\n\t\t *        \"bPaginate\": false\n\t\t *      } );\n\t\t *\n\t\t *      $(window).on('resize', function () {\n\t\t *        oTable.fnAdjustColumnSizing();\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\tthis.fnAdjustColumnSizing = function ( bRedraw )\n\t\t{\n\t\t\tvar api = this.api( true ).columns.adjust();\n\t\t\tvar settings = api.settings()[0];\n\t\t\tvar scroll = settings.oScroll;\n\t\t\n\t\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\t\tapi.draw( false );\n\t\t\t}\n\t\t\telse if ( scroll.sX !== \"\" || scroll.sY !== \"\" ) {\n\t\t\t\t/* If not redrawing, but scrolling, we want to apply the new column sizes anyway */\n\t\t\t\t_fnScrollDraw( settings );\n\t\t\t}\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Quickly and simply clear a table\n\t\t *  @param {bool} [bRedraw=true] redraw the table or not\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Immediately 'nuke' the current rows (perhaps waiting for an Ajax callback...)\n\t\t *      oTable.fnClearTable();\n\t\t *    } );\n\t\t */\n\t\tthis.fnClearTable = function( bRedraw )\n\t\t{\n\t\t\tvar api = this.api( true ).clear();\n\t\t\n\t\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\t\tapi.draw();\n\t\t\t}\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * The exact opposite of 'opening' a row, this function will close any rows which\n\t\t * are currently 'open'.\n\t\t *  @param {node} nTr the table row to 'close'\n\t\t *  @returns {int} 0 on success, or 1 if failed (can't find the row)\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable;\n\t\t *\n\t\t *      // 'open' an information row when a row is clicked on\n\t\t *      $('#example tbody tr').click( function () {\n\t\t *        if ( oTable.fnIsOpen(this) ) {\n\t\t *          oTable.fnClose( this );\n\t\t *        } else {\n\t\t *          oTable.fnOpen( this, \"Temporary row opened\", \"info_row\" );\n\t\t *        }\n\t\t *      } );\n\t\t *\n\t\t *      oTable = $('#example').dataTable();\n\t\t *    } );\n\t\t */\n\t\tthis.fnClose = function( nTr )\n\t\t{\n\t\t\tthis.api( true ).row( nTr ).child.hide();\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Remove a row for the table\n\t\t *  @param {mixed} target The index of the row from aoData to be deleted, or\n\t\t *    the TR element you want to delete\n\t\t *  @param {function|null} [callBack] Callback function\n\t\t *  @param {bool} [redraw=true] Redraw the table or not\n\t\t *  @returns {array} The row that was deleted\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Immediately remove the first row\n\t\t *      oTable.fnDeleteRow( 0 );\n\t\t *    } );\n\t\t */\n\t\tthis.fnDeleteRow = function( target, callback, redraw )\n\t\t{\n\t\t\tvar api = this.api( true );\n\t\t\tvar rows = api.rows( target );\n\t\t\tvar settings = rows.settings()[0];\n\t\t\tvar data = settings.aoData[ rows[0][0] ];\n\t\t\n\t\t\trows.remove();\n\t\t\n\t\t\tif ( callback ) {\n\t\t\t\tcallback.call( this, settings, data );\n\t\t\t}\n\t\t\n\t\t\tif ( redraw === undefined || redraw ) {\n\t\t\t\tapi.draw();\n\t\t\t}\n\t\t\n\t\t\treturn data;\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Restore the table to it's original state in the DOM by removing all of DataTables\n\t\t * enhancements, alterations to the DOM structure of the table and event listeners.\n\t\t *  @param {boolean} [remove=false] Completely remove the table from the DOM\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      // This example is fairly pointless in reality, but shows how fnDestroy can be used\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *      oTable.fnDestroy();\n\t\t *    } );\n\t\t */\n\t\tthis.fnDestroy = function ( remove )\n\t\t{\n\t\t\tthis.api( true ).destroy( remove );\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Redraw the table\n\t\t *  @param {bool} [complete=true] Re-filter and resort (if enabled) the table before the draw.\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Re-draw the table - you wouldn't want to do it here, but it's an example :-)\n\t\t *      oTable.fnDraw();\n\t\t *    } );\n\t\t */\n\t\tthis.fnDraw = function( complete )\n\t\t{\n\t\t\t// Note that this isn't an exact match to the old call to _fnDraw - it takes\n\t\t\t// into account the new data, but can hold position.\n\t\t\tthis.api( true ).draw( complete );\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Filter the input based on data\n\t\t *  @param {string} sInput String to filter the table on\n\t\t *  @param {int|null} [iColumn] Column to limit filtering to\n\t\t *  @param {bool} [bRegex=false] Treat as regular expression or not\n\t\t *  @param {bool} [bSmart=true] Perform smart filtering or not\n\t\t *  @param {bool} [bShowGlobal=true] Show the input global filter in it's input box(es)\n\t\t *  @param {bool} [bCaseInsensitive=true] Do case-insensitive matching (true) or not (false)\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Sometime later - filter...\n\t\t *      oTable.fnFilter( 'test string' );\n\t\t *    } );\n\t\t */\n\t\tthis.fnFilter = function( sInput, iColumn, bRegex, bSmart, bShowGlobal, bCaseInsensitive )\n\t\t{\n\t\t\tvar api = this.api( true );\n\t\t\n\t\t\tif ( iColumn === null || iColumn === undefined ) {\n\t\t\t\tapi.search( sInput, bRegex, bSmart, bCaseInsensitive );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tapi.column( iColumn ).search( sInput, bRegex, bSmart, bCaseInsensitive );\n\t\t\t}\n\t\t\n\t\t\tapi.draw();\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Get the data for the whole table, an individual row or an individual cell based on the\n\t\t * provided parameters.\n\t\t *  @param {int|node} [src] A TR row node, TD/TH cell node or an integer. If given as\n\t\t *    a TR node then the data source for the whole row will be returned. If given as a\n\t\t *    TD/TH cell node then iCol will be automatically calculated and the data for the\n\t\t *    cell returned. If given as an integer, then this is treated as the aoData internal\n\t\t *    data index for the row (see fnGetPosition) and the data for that row used.\n\t\t *  @param {int} [col] Optional column index that you want the data of.\n\t\t *  @returns {array|object|string} If mRow is undefined, then the data for all rows is\n\t\t *    returned. If mRow is defined, just data for that row, and is iCol is\n\t\t *    defined, only data for the designated cell is returned.\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    // Row data\n\t\t *    $(document).ready(function() {\n\t\t *      oTable = $('#example').dataTable();\n\t\t *\n\t\t *      oTable.$('tr').click( function () {\n\t\t *        var data = oTable.fnGetData( this );\n\t\t *        // ... do something with the array / object of data for the row\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Individual cell data\n\t\t *    $(document).ready(function() {\n\t\t *      oTable = $('#example').dataTable();\n\t\t *\n\t\t *      oTable.$('td').click( function () {\n\t\t *        var sData = oTable.fnGetData( this );\n\t\t *        alert( 'The cell clicked on had the value of '+sData );\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\tthis.fnGetData = function( src, col )\n\t\t{\n\t\t\tvar api = this.api( true );\n\t\t\n\t\t\tif ( src !== undefined ) {\n\t\t\t\tvar type = src.nodeName ? src.nodeName.toLowerCase() : '';\n\t\t\n\t\t\t\treturn col !== undefined || type == 'td' || type == 'th' ?\n\t\t\t\t\tapi.cell( src, col ).data() :\n\t\t\t\t\tapi.row( src ).data() || null;\n\t\t\t}\n\t\t\n\t\t\treturn api.data().toArray();\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Get an array of the TR nodes that are used in the table's body. Note that you will\n\t\t * typically want to use the '$' API method in preference to this as it is more\n\t\t * flexible.\n\t\t *  @param {int} [iRow] Optional row index for the TR element you want\n\t\t *  @returns {array|node} If iRow is undefined, returns an array of all TR elements\n\t\t *    in the table's body, or iRow is defined, just the TR element requested.\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Get the nodes from the table\n\t\t *      var nNodes = oTable.fnGetNodes( );\n\t\t *    } );\n\t\t */\n\t\tthis.fnGetNodes = function( iRow )\n\t\t{\n\t\t\tvar api = this.api( true );\n\t\t\n\t\t\treturn iRow !== undefined ?\n\t\t\t\tapi.row( iRow ).node() :\n\t\t\t\tapi.rows().nodes().flatten().toArray();\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Get the array indexes of a particular cell from it's DOM element\n\t\t * and column index including hidden columns\n\t\t *  @param {node} node this can either be a TR, TD or TH in the table's body\n\t\t *  @returns {int} If nNode is given as a TR, then a single index is returned, or\n\t\t *    if given as a cell, an array of [row index, column index (visible),\n\t\t *    column index (all)] is given.\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      $('#example tbody td').click( function () {\n\t\t *        // Get the position of the current data from the node\n\t\t *        var aPos = oTable.fnGetPosition( this );\n\t\t *\n\t\t *        // Get the data array for this row\n\t\t *        var aData = oTable.fnGetData( aPos[0] );\n\t\t *\n\t\t *        // Update the data array and return the value\n\t\t *        aData[ aPos[1] ] = 'clicked';\n\t\t *        this.innerHTML = 'clicked';\n\t\t *      } );\n\t\t *\n\t\t *      // Init DataTables\n\t\t *      oTable = $('#example').dataTable();\n\t\t *    } );\n\t\t */\n\t\tthis.fnGetPosition = function( node )\n\t\t{\n\t\t\tvar api = this.api( true );\n\t\t\tvar nodeName = node.nodeName.toUpperCase();\n\t\t\n\t\t\tif ( nodeName == 'TR' ) {\n\t\t\t\treturn api.row( node ).index();\n\t\t\t}\n\t\t\telse if ( nodeName == 'TD' || nodeName == 'TH' ) {\n\t\t\t\tvar cell = api.cell( node ).index();\n\t\t\n\t\t\t\treturn [\n\t\t\t\t\tcell.row,\n\t\t\t\t\tcell.columnVisible,\n\t\t\t\t\tcell.column\n\t\t\t\t];\n\t\t\t}\n\t\t\treturn null;\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Check to see if a row is 'open' or not.\n\t\t *  @param {node} nTr the table row to check\n\t\t *  @returns {boolean} true if the row is currently open, false otherwise\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable;\n\t\t *\n\t\t *      // 'open' an information row when a row is clicked on\n\t\t *      $('#example tbody tr').click( function () {\n\t\t *        if ( oTable.fnIsOpen(this) ) {\n\t\t *          oTable.fnClose( this );\n\t\t *        } else {\n\t\t *          oTable.fnOpen( this, \"Temporary row opened\", \"info_row\" );\n\t\t *        }\n\t\t *      } );\n\t\t *\n\t\t *      oTable = $('#example').dataTable();\n\t\t *    } );\n\t\t */\n\t\tthis.fnIsOpen = function( nTr )\n\t\t{\n\t\t\treturn this.api( true ).row( nTr ).child.isShown();\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * This function will place a new row directly after a row which is currently\n\t\t * on display on the page, with the HTML contents that is passed into the\n\t\t * function. This can be used, for example, to ask for confirmation that a\n\t\t * particular record should be deleted.\n\t\t *  @param {node} nTr The table row to 'open'\n\t\t *  @param {string|node|jQuery} mHtml The HTML to put into the row\n\t\t *  @param {string} sClass Class to give the new TD cell\n\t\t *  @returns {node} The row opened. Note that if the table row passed in as the\n\t\t *    first parameter, is not found in the table, this method will silently\n\t\t *    return.\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable;\n\t\t *\n\t\t *      // 'open' an information row when a row is clicked on\n\t\t *      $('#example tbody tr').click( function () {\n\t\t *        if ( oTable.fnIsOpen(this) ) {\n\t\t *          oTable.fnClose( this );\n\t\t *        } else {\n\t\t *          oTable.fnOpen( this, \"Temporary row opened\", \"info_row\" );\n\t\t *        }\n\t\t *      } );\n\t\t *\n\t\t *      oTable = $('#example').dataTable();\n\t\t *    } );\n\t\t */\n\t\tthis.fnOpen = function( nTr, mHtml, sClass )\n\t\t{\n\t\t\treturn this.api( true )\n\t\t\t\t.row( nTr )\n\t\t\t\t.child( mHtml, sClass )\n\t\t\t\t.show()\n\t\t\t\t.child()[0];\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Change the pagination - provides the internal logic for pagination in a simple API\n\t\t * function. With this function you can have a DataTables table go to the next,\n\t\t * previous, first or last pages.\n\t\t *  @param {string|int} mAction Paging action to take: \"first\", \"previous\", \"next\" or \"last\"\n\t\t *    or page number to jump to (integer), note that page 0 is the first page.\n\t\t *  @param {bool} [bRedraw=true] Redraw the table or not\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *      oTable.fnPageChange( 'next' );\n\t\t *    } );\n\t\t */\n\t\tthis.fnPageChange = function ( mAction, bRedraw )\n\t\t{\n\t\t\tvar api = this.api( true ).page( mAction );\n\t\t\n\t\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\t\tapi.draw(false);\n\t\t\t}\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Show a particular column\n\t\t *  @param {int} iCol The column whose display should be changed\n\t\t *  @param {bool} bShow Show (true) or hide (false) the column\n\t\t *  @param {bool} [bRedraw=true] Redraw the table or not\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Hide the second column after initialisation\n\t\t *      oTable.fnSetColumnVis( 1, false );\n\t\t *    } );\n\t\t */\n\t\tthis.fnSetColumnVis = function ( iCol, bShow, bRedraw )\n\t\t{\n\t\t\tvar api = this.api( true ).column( iCol ).visible( bShow );\n\t\t\n\t\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\t\tapi.columns.adjust().draw();\n\t\t\t}\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Get the settings for a particular table for external manipulation\n\t\t *  @returns {object} DataTables settings object. See\n\t\t *    {@link DataTable.models.oSettings}\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *      var oSettings = oTable.fnSettings();\n\t\t *\n\t\t *      // Show an example parameter from the settings\n\t\t *      alert( oSettings._iDisplayStart );\n\t\t *    } );\n\t\t */\n\t\tthis.fnSettings = function()\n\t\t{\n\t\t\treturn _fnSettingsFromNode( this[_ext.iApiIndex] );\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Sort the table by a particular column\n\t\t *  @param {int} iCol the data index to sort on. Note that this will not match the\n\t\t *    'display index' if you have hidden data entries\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Sort immediately with columns 0 and 1\n\t\t *      oTable.fnSort( [ [0,'asc'], [1,'asc'] ] );\n\t\t *    } );\n\t\t */\n\t\tthis.fnSort = function( aaSort )\n\t\t{\n\t\t\tthis.api( true ).order( aaSort ).draw();\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Attach a sort listener to an element for a given column\n\t\t *  @param {node} nNode the element to attach the sort listener to\n\t\t *  @param {int} iColumn the column that a click on this node will sort on\n\t\t *  @param {function} [fnCallback] callback function when sort is run\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *\n\t\t *      // Sort on column 1, when 'sorter' is clicked on\n\t\t *      oTable.fnSortListener( document.getElementById('sorter'), 1 );\n\t\t *    } );\n\t\t */\n\t\tthis.fnSortListener = function( nNode, iColumn, fnCallback )\n\t\t{\n\t\t\tthis.api( true ).order.listener( nNode, iColumn, fnCallback );\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Update a table cell or row - this method will accept either a single value to\n\t\t * update the cell with, an array of values with one element for each column or\n\t\t * an object in the same format as the original data source. The function is\n\t\t * self-referencing in order to make the multi column updates easier.\n\t\t *  @param {object|array|string} mData Data to update the cell/row with\n\t\t *  @param {node|int} mRow TR element you want to update or the aoData index\n\t\t *  @param {int} [iColumn] The column to update, give as null or undefined to\n\t\t *    update a whole row.\n\t\t *  @param {bool} [bRedraw=true] Redraw the table or not\n\t\t *  @param {bool} [bAction=true] Perform pre-draw actions or not\n\t\t *  @returns {int} 0 on success, 1 on error\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *      oTable.fnUpdate( 'Example update', 0, 0 ); // Single cell\n\t\t *      oTable.fnUpdate( ['a', 'b', 'c', 'd', 'e'], $('tbody tr')[0] ); // Row\n\t\t *    } );\n\t\t */\n\t\tthis.fnUpdate = function( mData, mRow, iColumn, bRedraw, bAction )\n\t\t{\n\t\t\tvar api = this.api( true );\n\t\t\n\t\t\tif ( iColumn === undefined || iColumn === null ) {\n\t\t\t\tapi.row( mRow ).data( mData );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tapi.cell( mRow, iColumn ).data( mData );\n\t\t\t}\n\t\t\n\t\t\tif ( bAction === undefined || bAction ) {\n\t\t\t\tapi.columns.adjust();\n\t\t\t}\n\t\t\n\t\t\tif ( bRedraw === undefined || bRedraw ) {\n\t\t\t\tapi.draw();\n\t\t\t}\n\t\t\treturn 0;\n\t\t};\n\t\t\n\t\t\n\t\t/**\n\t\t * Provide a common method for plug-ins to check the version of DataTables being used, in order\n\t\t * to ensure compatibility.\n\t\t *  @param {string} sVersion Version string to check for, in the format \"X.Y.Z\". Note that the\n\t\t *    formats \"X\" and \"X.Y\" are also acceptable.\n\t\t *  @returns {boolean} true if this version of DataTables is greater or equal to the required\n\t\t *    version, or false if this version of DataTales is not suitable\n\t\t *  @method\n\t\t *  @dtopt API\n\t\t *  @deprecated Since v1.10\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready(function() {\n\t\t *      var oTable = $('#example').dataTable();\n\t\t *      alert( oTable.fnVersionCheck( '1.9.0' ) );\n\t\t *    } );\n\t\t */\n\t\tthis.fnVersionCheck = _ext.fnVersionCheck;\n\t\t\n\t\n\t\tvar _that = this;\n\t\tvar emptyInit = options === undefined;\n\t\tvar len = this.length;\n\t\n\t\tif ( emptyInit ) {\n\t\t\toptions = {};\n\t\t}\n\t\n\t\tthis.oApi = this.internal = _ext.internal;\n\t\n\t\t// Extend with old style plug-in API methods\n\t\tfor ( var fn in DataTable.ext.internal ) {\n\t\t\tif ( fn ) {\n\t\t\t\tthis[fn] = _fnExternApiFunc(fn);\n\t\t\t}\n\t\t}\n\t\n\t\tthis.each(function() {\n\t\t\t// For each initialisation we want to give it a clean initialisation\n\t\t\t// object that can be bashed around\n\t\t\tvar o = {};\n\t\t\tvar oInit = len > 1 ? // optimisation for single table case\n\t\t\t\t_fnExtend( o, options, true ) :\n\t\t\t\toptions;\n\t\n\t\t\t/*global oInit,_that,emptyInit*/\n\t\t\tvar i=0, iLen, j, jLen, k, kLen;\n\t\t\tvar sId = this.getAttribute( 'id' );\n\t\t\tvar bInitHandedOff = false;\n\t\t\tvar defaults = DataTable.defaults;\n\t\t\tvar $this = $(this);\n\t\t\t\n\t\t\t\n\t\t\t/* Sanity check */\n\t\t\tif ( this.nodeName.toLowerCase() != 'table' )\n\t\t\t{\n\t\t\t\t_fnLog( null, 0, 'Non-table node initialisation ('+this.nodeName+')', 2 );\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t\n\t\t\t/* Backwards compatibility for the defaults */\n\t\t\t_fnCompatOpts( defaults );\n\t\t\t_fnCompatCols( defaults.column );\n\t\t\t\n\t\t\t/* Convert the camel-case defaults to Hungarian */\n\t\t\t_fnCamelToHungarian( defaults, defaults, true );\n\t\t\t_fnCamelToHungarian( defaults.column, defaults.column, true );\n\t\t\t\n\t\t\t/* Setting up the initialisation object */\n\t\t\t_fnCamelToHungarian( defaults, $.extend( oInit, $this.data() ), true );\n\t\t\t\n\t\t\t\n\t\t\t\n\t\t\t/* Check to see if we are re-initialising a table */\n\t\t\tvar allSettings = DataTable.settings;\n\t\t\tfor ( i=0, iLen=allSettings.length ; i<iLen ; i++ )\n\t\t\t{\n\t\t\t\tvar s = allSettings[i];\n\t\t\t\n\t\t\t\t/* Base check on table node */\n\t\t\t\tif (\n\t\t\t\t\ts.nTable == this ||\n\t\t\t\t\t(s.nTHead && s.nTHead.parentNode == this) ||\n\t\t\t\t\t(s.nTFoot && s.nTFoot.parentNode == this)\n\t\t\t\t) {\n\t\t\t\t\tvar bRetrieve = oInit.bRetrieve !== undefined ? oInit.bRetrieve : defaults.bRetrieve;\n\t\t\t\t\tvar bDestroy = oInit.bDestroy !== undefined ? oInit.bDestroy : defaults.bDestroy;\n\t\t\t\n\t\t\t\t\tif ( emptyInit || bRetrieve )\n\t\t\t\t\t{\n\t\t\t\t\t\treturn s.oInstance;\n\t\t\t\t\t}\n\t\t\t\t\telse if ( bDestroy )\n\t\t\t\t\t{\n\t\t\t\t\t\ts.oInstance.fnDestroy();\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\t_fnLog( s, 0, 'Cannot reinitialise DataTable', 3 );\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\n\t\t\t\t/* If the element we are initialising has the same ID as a table which was previously\n\t\t\t\t * initialised, but the table nodes don't match (from before) then we destroy the old\n\t\t\t\t * instance by simply deleting it. This is under the assumption that the table has been\n\t\t\t\t * destroyed by other methods. Anyone using non-id selectors will need to do this manually\n\t\t\t\t */\n\t\t\t\tif ( s.sTableId == this.id )\n\t\t\t\t{\n\t\t\t\t\tallSettings.splice( i, 1 );\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t/* Ensure the table has an ID - required for accessibility */\n\t\t\tif ( sId === null || sId === \"\" )\n\t\t\t{\n\t\t\t\tsId = \"DataTables_Table_\"+(DataTable.ext._unique++);\n\t\t\t\tthis.id = sId;\n\t\t\t}\n\t\t\t\n\t\t\t/* Create the settings object for this table and set some of the default parameters */\n\t\t\tvar oSettings = $.extend( true, {}, DataTable.models.oSettings, {\n\t\t\t\t\"sDestroyWidth\": $this[0].style.width,\n\t\t\t\t\"sInstance\":     sId,\n\t\t\t\t\"sTableId\":      sId\n\t\t\t} );\n\t\t\toSettings.nTable = this;\n\t\t\toSettings.oApi   = _that.internal;\n\t\t\toSettings.oInit  = oInit;\n\t\t\t\n\t\t\tallSettings.push( oSettings );\n\t\t\t\n\t\t\t// Need to add the instance after the instance after the settings object has been added\n\t\t\t// to the settings array, so we can self reference the table instance if more than one\n\t\t\toSettings.oInstance = (_that.length===1) ? _that : $this.dataTable();\n\t\t\t\n\t\t\t// Backwards compatibility, before we apply all the defaults\n\t\t\t_fnCompatOpts( oInit );\n\t\t\t_fnLanguageCompat( oInit.oLanguage );\n\t\t\t\n\t\t\t// If the length menu is given, but the init display length is not, use the length menu\n\t\t\tif ( oInit.aLengthMenu && ! oInit.iDisplayLength )\n\t\t\t{\n\t\t\t\toInit.iDisplayLength = Array.isArray( oInit.aLengthMenu[0] ) ?\n\t\t\t\t\toInit.aLengthMenu[0][0] : oInit.aLengthMenu[0];\n\t\t\t}\n\t\t\t\n\t\t\t// Apply the defaults and init options to make a single init object will all\n\t\t\t// options defined from defaults and instance options.\n\t\t\toInit = _fnExtend( $.extend( true, {}, defaults ), oInit );\n\t\t\t\n\t\t\t\n\t\t\t// Map the initialisation options onto the settings object\n\t\t\t_fnMap( oSettings.oFeatures, oInit, [\n\t\t\t\t\"bPaginate\",\n\t\t\t\t\"bLengthChange\",\n\t\t\t\t\"bFilter\",\n\t\t\t\t\"bSort\",\n\t\t\t\t\"bSortMulti\",\n\t\t\t\t\"bInfo\",\n\t\t\t\t\"bProcessing\",\n\t\t\t\t\"bAutoWidth\",\n\t\t\t\t\"bSortClasses\",\n\t\t\t\t\"bServerSide\",\n\t\t\t\t\"bDeferRender\"\n\t\t\t] );\n\t\t\t_fnMap( oSettings, oInit, [\n\t\t\t\t\"asStripeClasses\",\n\t\t\t\t\"ajax\",\n\t\t\t\t\"fnServerData\",\n\t\t\t\t\"fnFormatNumber\",\n\t\t\t\t\"sServerMethod\",\n\t\t\t\t\"aaSorting\",\n\t\t\t\t\"aaSortingFixed\",\n\t\t\t\t\"aLengthMenu\",\n\t\t\t\t\"sPaginationType\",\n\t\t\t\t\"sAjaxSource\",\n\t\t\t\t\"sAjaxDataProp\",\n\t\t\t\t\"iStateDuration\",\n\t\t\t\t\"sDom\",\n\t\t\t\t\"bSortCellsTop\",\n\t\t\t\t\"iTabIndex\",\n\t\t\t\t\"fnStateLoadCallback\",\n\t\t\t\t\"fnStateSaveCallback\",\n\t\t\t\t\"renderer\",\n\t\t\t\t\"searchDelay\",\n\t\t\t\t\"rowId\",\n\t\t\t\t[ \"iCookieDuration\", \"iStateDuration\" ], // backwards compat\n\t\t\t\t[ \"oSearch\", \"oPreviousSearch\" ],\n\t\t\t\t[ \"aoSearchCols\", \"aoPreSearchCols\" ],\n\t\t\t\t[ \"iDisplayLength\", \"_iDisplayLength\" ]\n\t\t\t] );\n\t\t\t_fnMap( oSettings.oScroll, oInit, [\n\t\t\t\t[ \"sScrollX\", \"sX\" ],\n\t\t\t\t[ \"sScrollXInner\", \"sXInner\" ],\n\t\t\t\t[ \"sScrollY\", \"sY\" ],\n\t\t\t\t[ \"bScrollCollapse\", \"bCollapse\" ]\n\t\t\t] );\n\t\t\t_fnMap( oSettings.oLanguage, oInit, \"fnInfoCallback\" );\n\t\t\t\n\t\t\t/* Callback functions which are array driven */\n\t\t\t_fnCallbackReg( oSettings, 'aoDrawCallback',       oInit.fnDrawCallback,      'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoServerParams',       oInit.fnServerParams,      'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoStateSaveParams',    oInit.fnStateSaveParams,   'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoStateLoadParams',    oInit.fnStateLoadParams,   'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoStateLoaded',        oInit.fnStateLoaded,       'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoRowCallback',        oInit.fnRowCallback,       'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoRowCreatedCallback', oInit.fnCreatedRow,        'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoHeaderCallback',     oInit.fnHeaderCallback,    'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoFooterCallback',     oInit.fnFooterCallback,    'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoInitComplete',       oInit.fnInitComplete,      'user' );\n\t\t\t_fnCallbackReg( oSettings, 'aoPreDrawCallback',    oInit.fnPreDrawCallback,   'user' );\n\t\t\t\n\t\t\toSettings.rowIdFn = _fnGetObjectDataFn( oInit.rowId );\n\t\t\t\n\t\t\t/* Browser support detection */\n\t\t\t_fnBrowserDetect( oSettings );\n\t\t\t\n\t\t\tvar oClasses = oSettings.oClasses;\n\t\t\t\n\t\t\t$.extend( oClasses, DataTable.ext.classes, oInit.oClasses );\n\t\t\t$this.addClass( oClasses.sTable );\n\t\t\t\n\t\t\t\n\t\t\tif ( oSettings.iInitDisplayStart === undefined )\n\t\t\t{\n\t\t\t\t/* Display start point, taking into account the save saving */\n\t\t\t\toSettings.iInitDisplayStart = oInit.iDisplayStart;\n\t\t\t\toSettings._iDisplayStart = oInit.iDisplayStart;\n\t\t\t}\n\t\t\t\n\t\t\tif ( oInit.iDeferLoading !== null )\n\t\t\t{\n\t\t\t\toSettings.bDeferLoading = true;\n\t\t\t\tvar tmp = Array.isArray( oInit.iDeferLoading );\n\t\t\t\toSettings._iRecordsDisplay = tmp ? oInit.iDeferLoading[0] : oInit.iDeferLoading;\n\t\t\t\toSettings._iRecordsTotal = tmp ? oInit.iDeferLoading[1] : oInit.iDeferLoading;\n\t\t\t}\n\t\t\t\n\t\t\t/* Language definitions */\n\t\t\tvar oLanguage = oSettings.oLanguage;\n\t\t\t$.extend( true, oLanguage, oInit.oLanguage );\n\t\t\t\n\t\t\tif ( oLanguage.sUrl )\n\t\t\t{\n\t\t\t\t/* Get the language definitions from a file - because this Ajax call makes the language\n\t\t\t\t * get async to the remainder of this function we use bInitHandedOff to indicate that\n\t\t\t\t * _fnInitialise will be fired by the returned Ajax handler, rather than the constructor\n\t\t\t\t */\n\t\t\t\t$.ajax( {\n\t\t\t\t\tdataType: 'json',\n\t\t\t\t\turl: oLanguage.sUrl,\n\t\t\t\t\tsuccess: function ( json ) {\n\t\t\t\t\t\t_fnCamelToHungarian( defaults.oLanguage, json );\n\t\t\t\t\t\t_fnLanguageCompat( json );\n\t\t\t\t\t\t$.extend( true, oLanguage, json, oSettings.oInit.oLanguage );\n\t\t\t\n\t\t\t\t\t\t_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);\n\t\t\t\t\t\t_fnInitialise( oSettings );\n\t\t\t\t\t},\n\t\t\t\t\terror: function () {\n\t\t\t\t\t\t// Error occurred loading language file, continue on as best we can\n\t\t\t\t\t\t_fnInitialise( oSettings );\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\tbInitHandedOff = true;\n\t\t\t}\n\t\t\telse {\n\t\t\t\t_fnCallbackFire( oSettings, null, 'i18n', [oSettings]);\n\t\t\t}\n\t\t\t\n\t\t\t/*\n\t\t\t * Stripes\n\t\t\t */\n\t\t\tif ( oInit.asStripeClasses === null )\n\t\t\t{\n\t\t\t\toSettings.asStripeClasses =[\n\t\t\t\t\toClasses.sStripeOdd,\n\t\t\t\t\toClasses.sStripeEven\n\t\t\t\t];\n\t\t\t}\n\t\t\t\n\t\t\t/* Remove row stripe classes if they are already on the table row */\n\t\t\tvar stripeClasses = oSettings.asStripeClasses;\n\t\t\tvar rowOne = $this.children('tbody').find('tr').eq(0);\n\t\t\tif ( $.inArray( true, $.map( stripeClasses, function(el, i) {\n\t\t\t\treturn rowOne.hasClass(el);\n\t\t\t} ) ) !== -1 ) {\n\t\t\t\t$('tbody tr', this).removeClass( stripeClasses.join(' ') );\n\t\t\t\toSettings.asDestroyStripes = stripeClasses.slice();\n\t\t\t}\n\t\t\t\n\t\t\t/*\n\t\t\t * Columns\n\t\t\t * See if we should load columns automatically or use defined ones\n\t\t\t */\n\t\t\tvar anThs = [];\n\t\t\tvar aoColumnsInit;\n\t\t\tvar nThead = this.getElementsByTagName('thead');\n\t\t\tif ( nThead.length !== 0 )\n\t\t\t{\n\t\t\t\t_fnDetectHeader( oSettings.aoHeader, nThead[0] );\n\t\t\t\tanThs = _fnGetUniqueThs( oSettings );\n\t\t\t}\n\t\t\t\n\t\t\t/* If not given a column array, generate one with nulls */\n\t\t\tif ( oInit.aoColumns === null )\n\t\t\t{\n\t\t\t\taoColumnsInit = [];\n\t\t\t\tfor ( i=0, iLen=anThs.length ; i<iLen ; i++ )\n\t\t\t\t{\n\t\t\t\t\taoColumnsInit.push( null );\n\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\taoColumnsInit = oInit.aoColumns;\n\t\t\t}\n\t\t\t\n\t\t\t/* Add the columns */\n\t\t\tfor ( i=0, iLen=aoColumnsInit.length ; i<iLen ; i++ )\n\t\t\t{\n\t\t\t\t_fnAddColumn( oSettings, anThs ? anThs[i] : null );\n\t\t\t}\n\t\t\t\n\t\t\t/* Apply the column definitions */\n\t\t\t_fnApplyColumnDefs( oSettings, oInit.aoColumnDefs, aoColumnsInit, function (iCol, oDef) {\n\t\t\t\t_fnColumnOptions( oSettings, iCol, oDef );\n\t\t\t} );\n\t\t\t\n\t\t\t/* HTML5 attribute detection - build an mData object automatically if the\n\t\t\t * attributes are found\n\t\t\t */\n\t\t\tif ( rowOne.length ) {\n\t\t\t\tvar a = function ( cell, name ) {\n\t\t\t\t\treturn cell.getAttribute( 'data-'+name ) !== null ? name : null;\n\t\t\t\t};\n\t\t\t\n\t\t\t\t$( rowOne[0] ).children('th, td').each( function (i, cell) {\n\t\t\t\t\tvar col = oSettings.aoColumns[i];\n\t\t\t\n\t\t\t\t\tif ( col.mData === i ) {\n\t\t\t\t\t\tvar sort = a( cell, 'sort' ) || a( cell, 'order' );\n\t\t\t\t\t\tvar filter = a( cell, 'filter' ) || a( cell, 'search' );\n\t\t\t\n\t\t\t\t\t\tif ( sort !== null || filter !== null ) {\n\t\t\t\t\t\t\tcol.mData = {\n\t\t\t\t\t\t\t\t_:      i+'.display',\n\t\t\t\t\t\t\t\tsort:   sort !== null   ? i+'.@data-'+sort   : undefined,\n\t\t\t\t\t\t\t\ttype:   sort !== null   ? i+'.@data-'+sort   : undefined,\n\t\t\t\t\t\t\t\tfilter: filter !== null ? i+'.@data-'+filter : undefined\n\t\t\t\t\t\t\t};\n\t\t\t\n\t\t\t\t\t\t\t_fnColumnOptions( oSettings, i );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t}\n\t\t\t\n\t\t\tvar features = oSettings.oFeatures;\n\t\t\tvar loadedInit = function () {\n\t\t\t\t/*\n\t\t\t\t * Sorting\n\t\t\t\t * @todo For modularisation (1.11) this needs to do into a sort start up handler\n\t\t\t\t */\n\t\t\t\n\t\t\t\t// If aaSorting is not defined, then we use the first indicator in asSorting\n\t\t\t\t// in case that has been altered, so the default sort reflects that option\n\t\t\t\tif ( oInit.aaSorting === undefined ) {\n\t\t\t\t\tvar sorting = oSettings.aaSorting;\n\t\t\t\t\tfor ( i=0, iLen=sorting.length ; i<iLen ; i++ ) {\n\t\t\t\t\t\tsorting[i][1] = oSettings.aoColumns[ i ].asSorting[0];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\n\t\t\t\t/* Do a first pass on the sorting classes (allows any size changes to be taken into\n\t\t\t\t * account, and also will apply sorting disabled classes if disabled\n\t\t\t\t */\n\t\t\t\t_fnSortingClasses( oSettings );\n\t\t\t\n\t\t\t\tif ( features.bSort ) {\n\t\t\t\t\t_fnCallbackReg( oSettings, 'aoDrawCallback', function () {\n\t\t\t\t\t\tif ( oSettings.bSorted ) {\n\t\t\t\t\t\t\tvar aSort = _fnSortFlatten( oSettings );\n\t\t\t\t\t\t\tvar sortedColumns = {};\n\t\t\t\n\t\t\t\t\t\t\t$.each( aSort, function (i, val) {\n\t\t\t\t\t\t\t\tsortedColumns[ val.src ] = val.dir;\n\t\t\t\t\t\t\t} );\n\t\t\t\n\t\t\t\t\t\t\t_fnCallbackFire( oSettings, null, 'order', [oSettings, aSort, sortedColumns] );\n\t\t\t\t\t\t\t_fnSortAria( oSettings );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t\n\t\t\t\t_fnCallbackReg( oSettings, 'aoDrawCallback', function () {\n\t\t\t\t\tif ( oSettings.bSorted || _fnDataSource( oSettings ) === 'ssp' || features.bDeferRender ) {\n\t\t\t\t\t\t_fnSortingClasses( oSettings );\n\t\t\t\t\t}\n\t\t\t\t}, 'sc' );\n\t\t\t\n\t\t\t\n\t\t\t\t/*\n\t\t\t\t * Final init\n\t\t\t\t * Cache the header, body and footer as required, creating them if needed\n\t\t\t\t */\n\t\t\t\n\t\t\t\t// Work around for Webkit bug 83867 - store the caption-side before removing from doc\n\t\t\t\tvar captions = $this.children('caption').each( function () {\n\t\t\t\t\tthis._captionSide = $(this).css('caption-side');\n\t\t\t\t} );\n\t\t\t\n\t\t\t\tvar thead = $this.children('thead');\n\t\t\t\tif ( thead.length === 0 ) {\n\t\t\t\t\tthead = $('<thead/>').appendTo($this);\n\t\t\t\t}\n\t\t\t\toSettings.nTHead = thead[0];\n\t\t\t\n\t\t\t\tvar tbody = $this.children('tbody');\n\t\t\t\tif ( tbody.length === 0 ) {\n\t\t\t\t\ttbody = $('<tbody/>').insertAfter(thead);\n\t\t\t\t}\n\t\t\t\toSettings.nTBody = tbody[0];\n\t\t\t\n\t\t\t\tvar tfoot = $this.children('tfoot');\n\t\t\t\tif ( tfoot.length === 0 && captions.length > 0 && (oSettings.oScroll.sX !== \"\" || oSettings.oScroll.sY !== \"\") ) {\n\t\t\t\t\t// If we are a scrolling table, and no footer has been given, then we need to create\n\t\t\t\t\t// a tfoot element for the caption element to be appended to\n\t\t\t\t\ttfoot = $('<tfoot/>').appendTo($this);\n\t\t\t\t}\n\t\t\t\n\t\t\t\tif ( tfoot.length === 0 || tfoot.children().length === 0 ) {\n\t\t\t\t\t$this.addClass( oClasses.sNoFooter );\n\t\t\t\t}\n\t\t\t\telse if ( tfoot.length > 0 ) {\n\t\t\t\t\toSettings.nTFoot = tfoot[0];\n\t\t\t\t\t_fnDetectHeader( oSettings.aoFooter, oSettings.nTFoot );\n\t\t\t\t}\n\t\t\t\n\t\t\t\t/* Check if there is data passing into the constructor */\n\t\t\t\tif ( oInit.aaData ) {\n\t\t\t\t\tfor ( i=0 ; i<oInit.aaData.length ; i++ ) {\n\t\t\t\t\t\t_fnAddData( oSettings, oInit.aaData[ i ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if ( oSettings.bDeferLoading || _fnDataSource( oSettings ) == 'dom' ) {\n\t\t\t\t\t/* Grab the data from the page - only do this when deferred loading or no Ajax\n\t\t\t\t\t * source since there is no point in reading the DOM data if we are then going\n\t\t\t\t\t * to replace it with Ajax data\n\t\t\t\t\t */\n\t\t\t\t\t_fnAddTr( oSettings, $(oSettings.nTBody).children('tr') );\n\t\t\t\t}\n\t\t\t\n\t\t\t\t/* Copy the data index array */\n\t\t\t\toSettings.aiDisplay = oSettings.aiDisplayMaster.slice();\n\t\t\t\n\t\t\t\t/* Initialisation complete - table can be drawn */\n\t\t\t\toSettings.bInitialised = true;\n\t\t\t\n\t\t\t\t/* Check if we need to initialise the table (it might not have been handed off to the\n\t\t\t\t * language processor)\n\t\t\t\t */\n\t\t\t\tif ( bInitHandedOff === false ) {\n\t\t\t\t\t_fnInitialise( oSettings );\n\t\t\t\t}\n\t\t\t};\n\t\t\t\n\t\t\t/* Must be done after everything which can be overridden by the state saving! */\n\t\t\t_fnCallbackReg( oSettings, 'aoDrawCallback', _fnSaveState, 'state_save' );\n\t\t\t\n\t\t\tif ( oInit.bStateSave )\n\t\t\t{\n\t\t\t\tfeatures.bStateSave = true;\n\t\t\t\t_fnLoadState( oSettings, oInit, loadedInit );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tloadedInit();\n\t\t\t}\n\t\t\t\n\t\t} );\n\t\t_that = null;\n\t\treturn this;\n\t};\n\t\n\t\n\t/*\n\t * It is useful to have variables which are scoped locally so only the\n\t * DataTables functions can access them and they don't leak into global space.\n\t * At the same time these functions are often useful over multiple files in the\n\t * core and API, so we list, or at least document, all variables which are used\n\t * by DataTables as private variables here. This also ensures that there is no\n\t * clashing of variable names and that they can easily referenced for reuse.\n\t */\n\t\n\t\n\t// Defined else where\n\t//  _selector_run\n\t//  _selector_opts\n\t//  _selector_first\n\t//  _selector_row_indexes\n\t\n\tvar _ext; // DataTable.ext\n\tvar _Api; // DataTable.Api\n\tvar _api_register; // DataTable.Api.register\n\tvar _api_registerPlural; // DataTable.Api.registerPlural\n\t\n\tvar _re_dic = {};\n\tvar _re_new_lines = /[\\r\\n\\u2028]/g;\n\tvar _re_html = /<.*?>/g;\n\t\n\t// This is not strict ISO8601 - Date.parse() is quite lax, although\n\t// implementations differ between browsers.\n\tvar _re_date = /^\\d{2,4}[\\.\\/\\-]\\d{1,2}[\\.\\/\\-]\\d{1,2}([T ]{1}\\d{1,2}[:\\.]\\d{2}([\\.:]\\d{2})?)?$/;\n\t\n\t// Escape regular expression special characters\n\tvar _re_escape_regex = new RegExp( '(\\\\' + [ '/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\\\', '$', '^', '-' ].join('|\\\\') + ')', 'g' );\n\t\n\t// http://en.wikipedia.org/wiki/Foreign_exchange_market\n\t// - \\u20BD - Russian ruble.\n\t// - \\u20a9 - South Korean Won\n\t// - \\u20BA - Turkish Lira\n\t// - \\u20B9 - Indian Rupee\n\t// - R - Brazil (R$) and South Africa\n\t// - fr - Swiss Franc\n\t// - kr - Swedish krona, Norwegian krone and Danish krone\n\t// - \\u2009 is thin space and \\u202F is narrow no-break space, both used in many\n\t// - Ƀ - Bitcoin\n\t// - Ξ - Ethereum\n\t//   standards as thousands separators.\n\tvar _re_formatted_numeric = /['\\u00A0,$£€¥%\\u2009\\u202F\\u20BD\\u20a9\\u20BArfkɃΞ]/gi;\n\t\n\t\n\tvar _empty = function ( d ) {\n\t\treturn !d || d === true || d === '-' ? true : false;\n\t};\n\t\n\t\n\tvar _intVal = function ( s ) {\n\t\tvar integer = parseInt( s, 10 );\n\t\treturn !isNaN(integer) && isFinite(s) ? integer : null;\n\t};\n\t\n\t// Convert from a formatted number with characters other than `.` as the\n\t// decimal place, to a Javascript number\n\tvar _numToDecimal = function ( num, decimalPoint ) {\n\t\t// Cache created regular expressions for speed as this function is called often\n\t\tif ( ! _re_dic[ decimalPoint ] ) {\n\t\t\t_re_dic[ decimalPoint ] = new RegExp( _fnEscapeRegex( decimalPoint ), 'g' );\n\t\t}\n\t\treturn typeof num === 'string' && decimalPoint !== '.' ?\n\t\t\tnum.replace( /\\./g, '' ).replace( _re_dic[ decimalPoint ], '.' ) :\n\t\t\tnum;\n\t};\n\t\n\t\n\tvar _isNumber = function ( d, decimalPoint, formatted ) {\n\t\tvar strType = typeof d === 'string';\n\t\n\t\t// If empty return immediately so there must be a number if it is a\n\t\t// formatted string (this stops the string \"k\", or \"kr\", etc being detected\n\t\t// as a formatted number for currency\n\t\tif ( _empty( d ) ) {\n\t\t\treturn true;\n\t\t}\n\t\n\t\tif ( decimalPoint && strType ) {\n\t\t\td = _numToDecimal( d, decimalPoint );\n\t\t}\n\t\n\t\tif ( formatted && strType ) {\n\t\t\td = d.replace( _re_formatted_numeric, '' );\n\t\t}\n\t\n\t\treturn !isNaN( parseFloat(d) ) && isFinite( d );\n\t};\n\t\n\t\n\t// A string without HTML in it can be considered to be HTML still\n\tvar _isHtml = function ( d ) {\n\t\treturn _empty( d ) || typeof d === 'string';\n\t};\n\t\n\t\n\tvar _htmlNumeric = function ( d, decimalPoint, formatted ) {\n\t\tif ( _empty( d ) ) {\n\t\t\treturn true;\n\t\t}\n\t\n\t\tvar html = _isHtml( d );\n\t\treturn ! html ?\n\t\t\tnull :\n\t\t\t_isNumber( _stripHtml( d ), decimalPoint, formatted ) ?\n\t\t\t\ttrue :\n\t\t\t\tnull;\n\t};\n\t\n\t\n\tvar _pluck = function ( a, prop, prop2 ) {\n\t\tvar out = [];\n\t\tvar i=0, ien=a.length;\n\t\n\t\t// Could have the test in the loop for slightly smaller code, but speed\n\t\t// is essential here\n\t\tif ( prop2 !== undefined ) {\n\t\t\tfor ( ; i<ien ; i++ ) {\n\t\t\t\tif ( a[i] && a[i][ prop ] ) {\n\t\t\t\t\tout.push( a[i][ prop ][ prop2 ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tfor ( ; i<ien ; i++ ) {\n\t\t\t\tif ( a[i] ) {\n\t\t\t\t\tout.push( a[i][ prop ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\n\t\treturn out;\n\t};\n\t\n\t\n\t// Basically the same as _pluck, but rather than looping over `a` we use `order`\n\t// as the indexes to pick from `a`\n\tvar _pluck_order = function ( a, order, prop, prop2 )\n\t{\n\t\tvar out = [];\n\t\tvar i=0, ien=order.length;\n\t\n\t\t// Could have the test in the loop for slightly smaller code, but speed\n\t\t// is essential here\n\t\tif ( prop2 !== undefined ) {\n\t\t\tfor ( ; i<ien ; i++ ) {\n\t\t\t\tif ( a[ order[i] ][ prop ] ) {\n\t\t\t\t\tout.push( a[ order[i] ][ prop ][ prop2 ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tfor ( ; i<ien ; i++ ) {\n\t\t\t\tout.push( a[ order[i] ][ prop ] );\n\t\t\t}\n\t\t}\n\t\n\t\treturn out;\n\t};\n\t\n\t\n\tvar _range = function ( len, start )\n\t{\n\t\tvar out = [];\n\t\tvar end;\n\t\n\t\tif ( start === undefined ) {\n\t\t\tstart = 0;\n\t\t\tend = len;\n\t\t}\n\t\telse {\n\t\t\tend = start;\n\t\t\tstart = len;\n\t\t}\n\t\n\t\tfor ( var i=start ; i<end ; i++ ) {\n\t\t\tout.push( i );\n\t\t}\n\t\n\t\treturn out;\n\t};\n\t\n\t\n\tvar _removeEmpty = function ( a )\n\t{\n\t\tvar out = [];\n\t\n\t\tfor ( var i=0, ien=a.length ; i<ien ; i++ ) {\n\t\t\tif ( a[i] ) { // careful - will remove all falsy values!\n\t\t\t\tout.push( a[i] );\n\t\t\t}\n\t\t}\n\t\n\t\treturn out;\n\t};\n\t\n\t\n\tvar _stripHtml = function ( d ) {\n\t\treturn d.replace( _re_html, '' );\n\t};\n\t\n\t\n\t/**\n\t * Determine if all values in the array are unique. This means we can short\n\t * cut the _unique method at the cost of a single loop. A sorted array is used\n\t * to easily check the values.\n\t *\n\t * @param  {array} src Source array\n\t * @return {boolean} true if all unique, false otherwise\n\t * @ignore\n\t */\n\tvar _areAllUnique = function ( src ) {\n\t\tif ( src.length < 2 ) {\n\t\t\treturn true;\n\t\t}\n\t\n\t\tvar sorted = src.slice().sort();\n\t\tvar last = sorted[0];\n\t\n\t\tfor ( var i=1, ien=sorted.length ; i<ien ; i++ ) {\n\t\t\tif ( sorted[i] === last ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\n\t\t\tlast = sorted[i];\n\t\t}\n\t\n\t\treturn true;\n\t};\n\t\n\t\n\t/**\n\t * Find the unique elements in a source array.\n\t *\n\t * @param  {array} src Source array\n\t * @return {array} Array of unique items\n\t * @ignore\n\t */\n\tvar _unique = function ( src )\n\t{\n\t\tif ( _areAllUnique( src ) ) {\n\t\t\treturn src.slice();\n\t\t}\n\t\n\t\t// A faster unique method is to use object keys to identify used values,\n\t\t// but this doesn't work with arrays or objects, which we must also\n\t\t// consider. See jsperf.com/compare-array-unique-versions/4 for more\n\t\t// information.\n\t\tvar\n\t\t\tout = [],\n\t\t\tval,\n\t\t\ti, ien=src.length,\n\t\t\tj, k=0;\n\t\n\t\tagain: for ( i=0 ; i<ien ; i++ ) {\n\t\t\tval = src[i];\n\t\n\t\t\tfor ( j=0 ; j<k ; j++ ) {\n\t\t\t\tif ( out[j] === val ) {\n\t\t\t\t\tcontinue again;\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\tout.push( val );\n\t\t\tk++;\n\t\t}\n\t\n\t\treturn out;\n\t};\n\t\n\t// Surprisingly this is faster than [].concat.apply\n\t// https://jsperf.com/flatten-an-array-loop-vs-reduce/2\n\tvar _flatten = function (out, val) {\n\t\tif (Array.isArray(val)) {\n\t\t\tfor (var i=0 ; i<val.length ; i++) {\n\t\t\t\t_flatten(out, val[i]);\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tout.push(val);\n\t\t}\n\t  \n\t\treturn out;\n\t}\n\t\n\tvar _includes = function (search, start) {\n\t\tif (start === undefined) {\n\t\t\tstart = 0;\n\t\t}\n\t\n\t\treturn this.indexOf(search, start) !== -1;\t\n\t};\n\t\n\t// Array.isArray polyfill.\n\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray\n\tif (! Array.isArray) {\n\t    Array.isArray = function(arg) {\n\t        return Object.prototype.toString.call(arg) === '[object Array]';\n\t    };\n\t}\n\t\n\tif (! Array.prototype.includes) {\n\t\tArray.prototype.includes = _includes;\n\t}\n\t\n\t// .trim() polyfill\n\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trim\n\tif (!String.prototype.trim) {\n\t  String.prototype.trim = function () {\n\t    return this.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n\t  };\n\t}\n\t\n\tif (! String.prototype.includes) {\n\t\tString.prototype.includes = _includes;\n\t}\n\t\n\t/**\n\t * DataTables utility methods\n\t * \n\t * This namespace provides helper methods that DataTables uses internally to\n\t * create a DataTable, but which are not exclusively used only for DataTables.\n\t * These methods can be used by extension authors to save the duplication of\n\t * code.\n\t *\n\t *  @namespace\n\t */\n\tDataTable.util = {\n\t\t/**\n\t\t * Throttle the calls to a function. Arguments and context are maintained\n\t\t * for the throttled function.\n\t\t *\n\t\t * @param {function} fn Function to be called\n\t\t * @param {integer} freq Call frequency in mS\n\t\t * @return {function} Wrapped function\n\t\t */\n\t\tthrottle: function ( fn, freq ) {\n\t\t\tvar\n\t\t\t\tfrequency = freq !== undefined ? freq : 200,\n\t\t\t\tlast,\n\t\t\t\ttimer;\n\t\n\t\t\treturn function () {\n\t\t\t\tvar\n\t\t\t\t\tthat = this,\n\t\t\t\t\tnow  = +new Date(),\n\t\t\t\t\targs = arguments;\n\t\n\t\t\t\tif ( last && now < last + frequency ) {\n\t\t\t\t\tclearTimeout( timer );\n\t\n\t\t\t\t\ttimer = setTimeout( function () {\n\t\t\t\t\t\tlast = undefined;\n\t\t\t\t\t\tfn.apply( that, args );\n\t\t\t\t\t}, frequency );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tlast = now;\n\t\t\t\t\tfn.apply( that, args );\n\t\t\t\t}\n\t\t\t};\n\t\t},\n\t\n\t\n\t\t/**\n\t\t * Escape a string such that it can be used in a regular expression\n\t\t *\n\t\t *  @param {string} val string to escape\n\t\t *  @returns {string} escaped string\n\t\t */\n\t\tescapeRegex: function ( val ) {\n\t\t\treturn val.replace( _re_escape_regex, '\\\\$1' );\n\t\t},\n\t\n\t\t/**\n\t\t * Create a function that will write to a nested object or array\n\t\t * @param {*} source JSON notation string\n\t\t * @returns Write function\n\t\t */\n\t\tset: function ( source ) {\n\t\t\tif ( $.isPlainObject( source ) ) {\n\t\t\t\t/* Unlike get, only the underscore (global) option is used for for\n\t\t\t\t * setting data since we don't know the type here. This is why an object\n\t\t\t\t * option is not documented for `mData` (which is read/write), but it is\n\t\t\t\t * for `mRender` which is read only.\n\t\t\t\t */\n\t\t\t\treturn DataTable.util.set( source._ );\n\t\t\t}\n\t\t\telse if ( source === null ) {\n\t\t\t\t// Nothing to do when the data source is null\n\t\t\t\treturn function () {};\n\t\t\t}\n\t\t\telse if ( typeof source === 'function' ) {\n\t\t\t\treturn function (data, val, meta) {\n\t\t\t\t\tsource( data, 'set', val, meta );\n\t\t\t\t};\n\t\t\t}\n\t\t\telse if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||\n\t\t\t\t\t  source.indexOf('[') !== -1 || source.indexOf('(') !== -1) )\n\t\t\t{\n\t\t\t\t// Like the get, we need to get data from a nested object\n\t\t\t\tvar setData = function (data, val, src) {\n\t\t\t\t\tvar a = _fnSplitObjNotation( src ), b;\n\t\t\t\t\tvar aLast = a[a.length-1];\n\t\t\t\t\tvar arrayNotation, funcNotation, o, innerSrc;\n\t\t\n\t\t\t\t\tfor ( var i=0, iLen=a.length-1 ; i<iLen ; i++ ) {\n\t\t\t\t\t\t// Protect against prototype pollution\n\t\t\t\t\t\tif (a[i] === '__proto__' || a[i] === 'constructor') {\n\t\t\t\t\t\t\tthrow new Error('Cannot set prototype values');\n\t\t\t\t\t\t}\n\t\t\n\t\t\t\t\t\t// Check if we are dealing with an array notation request\n\t\t\t\t\t\tarrayNotation = a[i].match(__reArray);\n\t\t\t\t\t\tfuncNotation = a[i].match(__reFn);\n\t\t\n\t\t\t\t\t\tif ( arrayNotation ) {\n\t\t\t\t\t\t\ta[i] = a[i].replace(__reArray, '');\n\t\t\t\t\t\t\tdata[ a[i] ] = [];\n\t\t\n\t\t\t\t\t\t\t// Get the remainder of the nested object to set so we can recurse\n\t\t\t\t\t\t\tb = a.slice();\n\t\t\t\t\t\t\tb.splice( 0, i+1 );\n\t\t\t\t\t\t\tinnerSrc = b.join('.');\n\t\t\n\t\t\t\t\t\t\t// Traverse each entry in the array setting the properties requested\n\t\t\t\t\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\t\t\t\t\tfor ( var j=0, jLen=val.length ; j<jLen ; j++ ) {\n\t\t\t\t\t\t\t\t\to = {};\n\t\t\t\t\t\t\t\t\tsetData( o, val[j], innerSrc );\n\t\t\t\t\t\t\t\t\tdata[ a[i] ].push( o );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t\t// We've been asked to save data to an array, but it\n\t\t\t\t\t\t\t\t// isn't array data to be saved. Best that can be done\n\t\t\t\t\t\t\t\t// is to just save the value.\n\t\t\t\t\t\t\t\tdata[ a[i] ] = val;\n\t\t\t\t\t\t\t}\n\t\t\n\t\t\t\t\t\t\t// The inner call to setData has already traversed through the remainder\n\t\t\t\t\t\t\t// of the source and has set the data, thus we can exit here\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if ( funcNotation ) {\n\t\t\t\t\t\t\t// Function call\n\t\t\t\t\t\t\ta[i] = a[i].replace(__reFn, '');\n\t\t\t\t\t\t\tdata = data[ a[i] ]( val );\n\t\t\t\t\t\t}\n\t\t\n\t\t\t\t\t\t// If the nested object doesn't currently exist - since we are\n\t\t\t\t\t\t// trying to set the value - create it\n\t\t\t\t\t\tif ( data[ a[i] ] === null || data[ a[i] ] === undefined ) {\n\t\t\t\t\t\t\tdata[ a[i] ] = {};\n\t\t\t\t\t\t}\n\t\t\t\t\t\tdata = data[ a[i] ];\n\t\t\t\t\t}\n\t\t\n\t\t\t\t\t// Last item in the input - i.e, the actual set\n\t\t\t\t\tif ( aLast.match(__reFn ) ) {\n\t\t\t\t\t\t// Function call\n\t\t\t\t\t\tdata = data[ aLast.replace(__reFn, '') ]( val );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\t// If array notation is used, we just want to strip it and use the property name\n\t\t\t\t\t\t// and assign the value. If it isn't used, then we get the result we want anyway\n\t\t\t\t\t\tdata[ aLast.replace(__reArray, '') ] = val;\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\n\t\t\t\treturn function (data, val) { // meta is also passed in, but not used\n\t\t\t\t\treturn setData( data, val, source );\n\t\t\t\t};\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Array or flat object mapping\n\t\t\t\treturn function (data, val) { // meta is also passed in, but not used\n\t\t\t\t\tdata[source] = val;\n\t\t\t\t};\n\t\t\t}\n\t\t},\n\t\n\t\t/**\n\t\t * Create a function that will read nested objects from arrays, based on JSON notation\n\t\t * @param {*} source JSON notation string\n\t\t * @returns Value read\n\t\t */\n\t\tget: function ( source ) {\n\t\t\tif ( $.isPlainObject( source ) ) {\n\t\t\t\t// Build an object of get functions, and wrap them in a single call\n\t\t\t\tvar o = {};\n\t\t\t\t$.each( source, function (key, val) {\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\to[key] = DataTable.util.get( val );\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\n\t\t\t\treturn function (data, type, row, meta) {\n\t\t\t\t\tvar t = o[type] || o._;\n\t\t\t\t\treturn t !== undefined ?\n\t\t\t\t\t\tt(data, type, row, meta) :\n\t\t\t\t\t\tdata;\n\t\t\t\t};\n\t\t\t}\n\t\t\telse if ( source === null ) {\n\t\t\t\t// Give an empty string for rendering / sorting etc\n\t\t\t\treturn function (data) { // type, row and meta also passed, but not used\n\t\t\t\t\treturn data;\n\t\t\t\t};\n\t\t\t}\n\t\t\telse if ( typeof source === 'function' ) {\n\t\t\t\treturn function (data, type, row, meta) {\n\t\t\t\t\treturn source( data, type, row, meta );\n\t\t\t\t};\n\t\t\t}\n\t\t\telse if ( typeof source === 'string' && (source.indexOf('.') !== -1 ||\n\t\t\t\t\t  source.indexOf('[') !== -1 || source.indexOf('(') !== -1) )\n\t\t\t{\n\t\t\t\t/* If there is a . in the source string then the data source is in a\n\t\t\t\t * nested object so we loop over the data for each level to get the next\n\t\t\t\t * level down. On each loop we test for undefined, and if found immediately\n\t\t\t\t * return. This allows entire objects to be missing and sDefaultContent to\n\t\t\t\t * be used if defined, rather than throwing an error\n\t\t\t\t */\n\t\t\t\tvar fetchData = function (data, type, src) {\n\t\t\t\t\tvar arrayNotation, funcNotation, out, innerSrc;\n\t\t\n\t\t\t\t\tif ( src !== \"\" ) {\n\t\t\t\t\t\tvar a = _fnSplitObjNotation( src );\n\t\t\n\t\t\t\t\t\tfor ( var i=0, iLen=a.length ; i<iLen ; i++ ) {\n\t\t\t\t\t\t\t// Check if we are dealing with special notation\n\t\t\t\t\t\t\tarrayNotation = a[i].match(__reArray);\n\t\t\t\t\t\t\tfuncNotation = a[i].match(__reFn);\n\t\t\n\t\t\t\t\t\t\tif ( arrayNotation ) {\n\t\t\t\t\t\t\t\t// Array notation\n\t\t\t\t\t\t\t\ta[i] = a[i].replace(__reArray, '');\n\t\t\n\t\t\t\t\t\t\t\t// Condition allows simply [] to be passed in\n\t\t\t\t\t\t\t\tif ( a[i] !== \"\" ) {\n\t\t\t\t\t\t\t\t\tdata = data[ a[i] ];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tout = [];\n\t\t\n\t\t\t\t\t\t\t\t// Get the remainder of the nested object to get\n\t\t\t\t\t\t\t\ta.splice( 0, i+1 );\n\t\t\t\t\t\t\t\tinnerSrc = a.join('.');\n\t\t\n\t\t\t\t\t\t\t\t// Traverse each entry in the array getting the properties requested\n\t\t\t\t\t\t\t\tif ( Array.isArray( data ) ) {\n\t\t\t\t\t\t\t\t\tfor ( var j=0, jLen=data.length ; j<jLen ; j++ ) {\n\t\t\t\t\t\t\t\t\t\tout.push( fetchData( data[j], type, innerSrc ) );\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\n\t\t\t\t\t\t\t\t// If a string is given in between the array notation indicators, that\n\t\t\t\t\t\t\t\t// is used to join the strings together, otherwise an array is returned\n\t\t\t\t\t\t\t\tvar join = arrayNotation[0].substring(1, arrayNotation[0].length-1);\n\t\t\t\t\t\t\t\tdata = (join===\"\") ? out : out.join(join);\n\t\t\n\t\t\t\t\t\t\t\t// The inner call to fetchData has already traversed through the remainder\n\t\t\t\t\t\t\t\t// of the source requested, so we exit from the loop\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\telse if ( funcNotation ) {\n\t\t\t\t\t\t\t\t// Function call\n\t\t\t\t\t\t\t\ta[i] = a[i].replace(__reFn, '');\n\t\t\t\t\t\t\t\tdata = data[ a[i] ]();\n\t\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t\t}\n\t\t\n\t\t\t\t\t\t\tif ( data === null || data[ a[i] ] === undefined ) {\n\t\t\t\t\t\t\t\treturn undefined;\n\t\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\t\tdata = data[ a[i] ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\n\t\t\t\t\treturn data;\n\t\t\t\t};\n\t\t\n\t\t\t\treturn function (data, type) { // row and meta also passed, but not used\n\t\t\t\t\treturn fetchData( data, type, source );\n\t\t\t\t};\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Array or flat object mapping\n\t\t\t\treturn function (data, type) { // row and meta also passed, but not used\n\t\t\t\t\treturn data[source];\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t};\n\t\n\t\n\t\n\t/**\n\t * Create a mapping object that allows camel case parameters to be looked up\n\t * for their Hungarian counterparts. The mapping is stored in a private\n\t * parameter called `_hungarianMap` which can be accessed on the source object.\n\t *  @param {object} o\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnHungarianMap ( o )\n\t{\n\t\tvar\n\t\t\thungarian = 'a aa ai ao as b fn i m o s ',\n\t\t\tmatch,\n\t\t\tnewKey,\n\t\t\tmap = {};\n\t\n\t\t$.each( o, function (key, val) {\n\t\t\tmatch = key.match(/^([^A-Z]+?)([A-Z])/);\n\t\n\t\t\tif ( match && hungarian.indexOf(match[1]+' ') !== -1 )\n\t\t\t{\n\t\t\t\tnewKey = key.replace( match[0], match[2].toLowerCase() );\n\t\t\t\tmap[ newKey ] = key;\n\t\n\t\t\t\tif ( match[1] === 'o' )\n\t\t\t\t{\n\t\t\t\t\t_fnHungarianMap( o[key] );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t\n\t\to._hungarianMap = map;\n\t}\n\t\n\t\n\t/**\n\t * Convert from camel case parameters to Hungarian, based on a Hungarian map\n\t * created by _fnHungarianMap.\n\t *  @param {object} src The model object which holds all parameters that can be\n\t *    mapped.\n\t *  @param {object} user The object to convert from camel case to Hungarian.\n\t *  @param {boolean} force When set to `true`, properties which already have a\n\t *    Hungarian value in the `user` object will be overwritten. Otherwise they\n\t *    won't be.\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnCamelToHungarian ( src, user, force )\n\t{\n\t\tif ( ! src._hungarianMap ) {\n\t\t\t_fnHungarianMap( src );\n\t\t}\n\t\n\t\tvar hungarianKey;\n\t\n\t\t$.each( user, function (key, val) {\n\t\t\thungarianKey = src._hungarianMap[ key ];\n\t\n\t\t\tif ( hungarianKey !== undefined && (force || user[hungarianKey] === undefined) )\n\t\t\t{\n\t\t\t\t// For objects, we need to buzz down into the object to copy parameters\n\t\t\t\tif ( hungarianKey.charAt(0) === 'o' )\n\t\t\t\t{\n\t\t\t\t\t// Copy the camelCase options over to the hungarian\n\t\t\t\t\tif ( ! user[ hungarianKey ] ) {\n\t\t\t\t\t\tuser[ hungarianKey ] = {};\n\t\t\t\t\t}\n\t\t\t\t\t$.extend( true, user[hungarianKey], user[key] );\n\t\n\t\t\t\t\t_fnCamelToHungarian( src[hungarianKey], user[hungarianKey], force );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tuser[hungarianKey] = user[ key ];\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t}\n\t\n\t\n\t/**\n\t * Language compatibility - when certain options are given, and others aren't, we\n\t * need to duplicate the values over, in order to provide backwards compatibility\n\t * with older language files.\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnLanguageCompat( lang )\n\t{\n\t\t// Note the use of the Hungarian notation for the parameters in this method as\n\t\t// this is called after the mapping of camelCase to Hungarian\n\t\tvar defaults = DataTable.defaults.oLanguage;\n\t\n\t\t// Default mapping\n\t\tvar defaultDecimal = defaults.sDecimal;\n\t\tif ( defaultDecimal ) {\n\t\t\t_addNumericSort( defaultDecimal );\n\t\t}\n\t\n\t\tif ( lang ) {\n\t\t\tvar zeroRecords = lang.sZeroRecords;\n\t\n\t\t\t// Backwards compatibility - if there is no sEmptyTable given, then use the same as\n\t\t\t// sZeroRecords - assuming that is given.\n\t\t\tif ( ! lang.sEmptyTable && zeroRecords &&\n\t\t\t\tdefaults.sEmptyTable === \"No data available in table\" )\n\t\t\t{\n\t\t\t\t_fnMap( lang, lang, 'sZeroRecords', 'sEmptyTable' );\n\t\t\t}\n\t\n\t\t\t// Likewise with loading records\n\t\t\tif ( ! lang.sLoadingRecords && zeroRecords &&\n\t\t\t\tdefaults.sLoadingRecords === \"Loading...\" )\n\t\t\t{\n\t\t\t\t_fnMap( lang, lang, 'sZeroRecords', 'sLoadingRecords' );\n\t\t\t}\n\t\n\t\t\t// Old parameter name of the thousands separator mapped onto the new\n\t\t\tif ( lang.sInfoThousands ) {\n\t\t\t\tlang.sThousands = lang.sInfoThousands;\n\t\t\t}\n\t\n\t\t\tvar decimal = lang.sDecimal;\n\t\t\tif ( decimal && defaultDecimal !== decimal ) {\n\t\t\t\t_addNumericSort( decimal );\n\t\t\t}\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Map one parameter onto another\n\t *  @param {object} o Object to map\n\t *  @param {*} knew The new parameter name\n\t *  @param {*} old The old parameter name\n\t */\n\tvar _fnCompatMap = function ( o, knew, old ) {\n\t\tif ( o[ knew ] !== undefined ) {\n\t\t\to[ old ] = o[ knew ];\n\t\t}\n\t};\n\t\n\t\n\t/**\n\t * Provide backwards compatibility for the main DT options. Note that the new\n\t * options are mapped onto the old parameters, so this is an external interface\n\t * change only.\n\t *  @param {object} init Object to map\n\t */\n\tfunction _fnCompatOpts ( init )\n\t{\n\t\t_fnCompatMap( init, 'ordering',      'bSort' );\n\t\t_fnCompatMap( init, 'orderMulti',    'bSortMulti' );\n\t\t_fnCompatMap( init, 'orderClasses',  'bSortClasses' );\n\t\t_fnCompatMap( init, 'orderCellsTop', 'bSortCellsTop' );\n\t\t_fnCompatMap( init, 'order',         'aaSorting' );\n\t\t_fnCompatMap( init, 'orderFixed',    'aaSortingFixed' );\n\t\t_fnCompatMap( init, 'paging',        'bPaginate' );\n\t\t_fnCompatMap( init, 'pagingType',    'sPaginationType' );\n\t\t_fnCompatMap( init, 'pageLength',    'iDisplayLength' );\n\t\t_fnCompatMap( init, 'searching',     'bFilter' );\n\t\n\t\t// Boolean initialisation of x-scrolling\n\t\tif ( typeof init.sScrollX === 'boolean' ) {\n\t\t\tinit.sScrollX = init.sScrollX ? '100%' : '';\n\t\t}\n\t\tif ( typeof init.scrollX === 'boolean' ) {\n\t\t\tinit.scrollX = init.scrollX ? '100%' : '';\n\t\t}\n\t\n\t\t// Column search objects are in an array, so it needs to be converted\n\t\t// element by element\n\t\tvar searchCols = init.aoSearchCols;\n\t\n\t\tif ( searchCols ) {\n\t\t\tfor ( var i=0, ien=searchCols.length ; i<ien ; i++ ) {\n\t\t\t\tif ( searchCols[i] ) {\n\t\t\t\t\t_fnCamelToHungarian( DataTable.models.oSearch, searchCols[i] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Provide backwards compatibility for column options. Note that the new options\n\t * are mapped onto the old parameters, so this is an external interface change\n\t * only.\n\t *  @param {object} init Object to map\n\t */\n\tfunction _fnCompatCols ( init )\n\t{\n\t\t_fnCompatMap( init, 'orderable',     'bSortable' );\n\t\t_fnCompatMap( init, 'orderData',     'aDataSort' );\n\t\t_fnCompatMap( init, 'orderSequence', 'asSorting' );\n\t\t_fnCompatMap( init, 'orderDataType', 'sortDataType' );\n\t\n\t\t// orderData can be given as an integer\n\t\tvar dataSort = init.aDataSort;\n\t\tif ( typeof dataSort === 'number' && ! Array.isArray( dataSort ) ) {\n\t\t\tinit.aDataSort = [ dataSort ];\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Browser feature detection for capabilities, quirks\n\t *  @param {object} settings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnBrowserDetect( settings )\n\t{\n\t\t// We don't need to do this every time DataTables is constructed, the values\n\t\t// calculated are specific to the browser and OS configuration which we\n\t\t// don't expect to change between initialisations\n\t\tif ( ! DataTable.__browser ) {\n\t\t\tvar browser = {};\n\t\t\tDataTable.__browser = browser;\n\t\n\t\t\t// Scrolling feature / quirks detection\n\t\t\tvar n = $('<div/>')\n\t\t\t\t.css( {\n\t\t\t\t\tposition: 'fixed',\n\t\t\t\t\ttop: 0,\n\t\t\t\t\tleft: $(window).scrollLeft()*-1, // allow for scrolling\n\t\t\t\t\theight: 1,\n\t\t\t\t\twidth: 1,\n\t\t\t\t\toverflow: 'hidden'\n\t\t\t\t} )\n\t\t\t\t.append(\n\t\t\t\t\t$('<div/>')\n\t\t\t\t\t\t.css( {\n\t\t\t\t\t\t\tposition: 'absolute',\n\t\t\t\t\t\t\ttop: 1,\n\t\t\t\t\t\t\tleft: 1,\n\t\t\t\t\t\t\twidth: 100,\n\t\t\t\t\t\t\toverflow: 'scroll'\n\t\t\t\t\t\t} )\n\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\t$('<div/>')\n\t\t\t\t\t\t\t\t.css( {\n\t\t\t\t\t\t\t\t\twidth: '100%',\n\t\t\t\t\t\t\t\t\theight: 10\n\t\t\t\t\t\t\t\t} )\n\t\t\t\t\t\t)\n\t\t\t\t)\n\t\t\t\t.appendTo( 'body' );\n\t\n\t\t\tvar outer = n.children();\n\t\t\tvar inner = outer.children();\n\t\n\t\t\t// Numbers below, in order, are:\n\t\t\t// inner.offsetWidth, inner.clientWidth, outer.offsetWidth, outer.clientWidth\n\t\t\t//\n\t\t\t// IE6 XP:                           100 100 100  83\n\t\t\t// IE7 Vista:                        100 100 100  83\n\t\t\t// IE 8+ Windows:                     83  83 100  83\n\t\t\t// Evergreen Windows:                 83  83 100  83\n\t\t\t// Evergreen Mac with scrollbars:     85  85 100  85\n\t\t\t// Evergreen Mac without scrollbars: 100 100 100 100\n\t\n\t\t\t// Get scrollbar width\n\t\t\tbrowser.barWidth = outer[0].offsetWidth - outer[0].clientWidth;\n\t\n\t\t\t// IE6/7 will oversize a width 100% element inside a scrolling element, to\n\t\t\t// include the width of the scrollbar, while other browsers ensure the inner\n\t\t\t// element is contained without forcing scrolling\n\t\t\tbrowser.bScrollOversize = inner[0].offsetWidth === 100 && outer[0].clientWidth !== 100;\n\t\n\t\t\t// In rtl text layout, some browsers (most, but not all) will place the\n\t\t\t// scrollbar on the left, rather than the right.\n\t\t\tbrowser.bScrollbarLeft = Math.round( inner.offset().left ) !== 1;\n\t\n\t\t\t// IE8- don't provide height and width for getBoundingClientRect\n\t\t\tbrowser.bBounding = n[0].getBoundingClientRect().width ? true : false;\n\t\n\t\t\tn.remove();\n\t\t}\n\t\n\t\t$.extend( settings.oBrowser, DataTable.__browser );\n\t\tsettings.oScroll.iBarWidth = DataTable.__browser.barWidth;\n\t}\n\t\n\t\n\t/**\n\t * Array.prototype reduce[Right] method, used for browsers which don't support\n\t * JS 1.6. Done this way to reduce code size, since we iterate either way\n\t *  @param {object} settings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnReduce ( that, fn, init, start, end, inc )\n\t{\n\t\tvar\n\t\t\ti = start,\n\t\t\tvalue,\n\t\t\tisSet = false;\n\t\n\t\tif ( init !== undefined ) {\n\t\t\tvalue = init;\n\t\t\tisSet = true;\n\t\t}\n\t\n\t\twhile ( i !== end ) {\n\t\t\tif ( ! that.hasOwnProperty(i) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\n\t\t\tvalue = isSet ?\n\t\t\t\tfn( value, that[i], i, that ) :\n\t\t\t\tthat[i];\n\t\n\t\t\tisSet = true;\n\t\t\ti += inc;\n\t\t}\n\t\n\t\treturn value;\n\t}\n\t\n\t/**\n\t * Add a column to the list used for the table with default values\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {node} nTh The th element for this column\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnAddColumn( oSettings, nTh )\n\t{\n\t\t// Add column to aoColumns array\n\t\tvar oDefaults = DataTable.defaults.column;\n\t\tvar iCol = oSettings.aoColumns.length;\n\t\tvar oCol = $.extend( {}, DataTable.models.oColumn, oDefaults, {\n\t\t\t\"nTh\": nTh ? nTh : document.createElement('th'),\n\t\t\t\"sTitle\":    oDefaults.sTitle    ? oDefaults.sTitle    : nTh ? nTh.innerHTML : '',\n\t\t\t\"aDataSort\": oDefaults.aDataSort ? oDefaults.aDataSort : [iCol],\n\t\t\t\"mData\": oDefaults.mData ? oDefaults.mData : iCol,\n\t\t\tidx: iCol\n\t\t} );\n\t\toSettings.aoColumns.push( oCol );\n\t\n\t\t// Add search object for column specific search. Note that the `searchCols[ iCol ]`\n\t\t// passed into extend can be undefined. This allows the user to give a default\n\t\t// with only some of the parameters defined, and also not give a default\n\t\tvar searchCols = oSettings.aoPreSearchCols;\n\t\tsearchCols[ iCol ] = $.extend( {}, DataTable.models.oSearch, searchCols[ iCol ] );\n\t\n\t\t// Use the default column options function to initialise classes etc\n\t\t_fnColumnOptions( oSettings, iCol, $(nTh).data() );\n\t}\n\t\n\t\n\t/**\n\t * Apply options for a column\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {int} iCol column index to consider\n\t *  @param {object} oOptions object with sType, bVisible and bSearchable etc\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnColumnOptions( oSettings, iCol, oOptions )\n\t{\n\t\tvar oCol = oSettings.aoColumns[ iCol ];\n\t\tvar oClasses = oSettings.oClasses;\n\t\tvar th = $(oCol.nTh);\n\t\n\t\t// Try to get width information from the DOM. We can't get it from CSS\n\t\t// as we'd need to parse the CSS stylesheet. `width` option can override\n\t\tif ( ! oCol.sWidthOrig ) {\n\t\t\t// Width attribute\n\t\t\toCol.sWidthOrig = th.attr('width') || null;\n\t\n\t\t\t// Style attribute\n\t\t\tvar t = (th.attr('style') || '').match(/width:\\s*(\\d+[pxem%]+)/);\n\t\t\tif ( t ) {\n\t\t\t\toCol.sWidthOrig = t[1];\n\t\t\t}\n\t\t}\n\t\n\t\t/* User specified column options */\n\t\tif ( oOptions !== undefined && oOptions !== null )\n\t\t{\n\t\t\t// Backwards compatibility\n\t\t\t_fnCompatCols( oOptions );\n\t\n\t\t\t// Map camel case parameters to their Hungarian counterparts\n\t\t\t_fnCamelToHungarian( DataTable.defaults.column, oOptions, true );\n\t\n\t\t\t/* Backwards compatibility for mDataProp */\n\t\t\tif ( oOptions.mDataProp !== undefined && !oOptions.mData )\n\t\t\t{\n\t\t\t\toOptions.mData = oOptions.mDataProp;\n\t\t\t}\n\t\n\t\t\tif ( oOptions.sType )\n\t\t\t{\n\t\t\t\toCol._sManualType = oOptions.sType;\n\t\t\t}\n\t\n\t\t\t// `class` is a reserved word in Javascript, so we need to provide\n\t\t\t// the ability to use a valid name for the camel case input\n\t\t\tif ( oOptions.className && ! oOptions.sClass )\n\t\t\t{\n\t\t\t\toOptions.sClass = oOptions.className;\n\t\t\t}\n\t\t\tif ( oOptions.sClass ) {\n\t\t\t\tth.addClass( oOptions.sClass );\n\t\t\t}\n\t\n\t\t\tvar origClass = oCol.sClass;\n\t\n\t\t\t$.extend( oCol, oOptions );\n\t\t\t_fnMap( oCol, oOptions, \"sWidth\", \"sWidthOrig\" );\n\t\n\t\t\t// Merge class from previously defined classes with this one, rather than just\n\t\t\t// overwriting it in the extend above\n\t\t\tif (origClass !== oCol.sClass) {\n\t\t\t\toCol.sClass = origClass + ' ' + oCol.sClass;\n\t\t\t}\n\t\n\t\t\t/* iDataSort to be applied (backwards compatibility), but aDataSort will take\n\t\t\t * priority if defined\n\t\t\t */\n\t\t\tif ( oOptions.iDataSort !== undefined )\n\t\t\t{\n\t\t\t\toCol.aDataSort = [ oOptions.iDataSort ];\n\t\t\t}\n\t\t\t_fnMap( oCol, oOptions, \"aDataSort\" );\n\t\t}\n\t\n\t\t/* Cache the data get and set functions for speed */\n\t\tvar mDataSrc = oCol.mData;\n\t\tvar mData = _fnGetObjectDataFn( mDataSrc );\n\t\tvar mRender = oCol.mRender ? _fnGetObjectDataFn( oCol.mRender ) : null;\n\t\n\t\tvar attrTest = function( src ) {\n\t\t\treturn typeof src === 'string' && src.indexOf('@') !== -1;\n\t\t};\n\t\toCol._bAttrSrc = $.isPlainObject( mDataSrc ) && (\n\t\t\tattrTest(mDataSrc.sort) || attrTest(mDataSrc.type) || attrTest(mDataSrc.filter)\n\t\t);\n\t\toCol._setter = null;\n\t\n\t\toCol.fnGetData = function (rowData, type, meta) {\n\t\t\tvar innerData = mData( rowData, type, undefined, meta );\n\t\n\t\t\treturn mRender && type ?\n\t\t\t\tmRender( innerData, type, rowData, meta ) :\n\t\t\t\tinnerData;\n\t\t};\n\t\toCol.fnSetData = function ( rowData, val, meta ) {\n\t\t\treturn _fnSetObjectDataFn( mDataSrc )( rowData, val, meta );\n\t\t};\n\t\n\t\t// Indicate if DataTables should read DOM data as an object or array\n\t\t// Used in _fnGetRowElements\n\t\tif ( typeof mDataSrc !== 'number' ) {\n\t\t\toSettings._rowReadObject = true;\n\t\t}\n\t\n\t\t/* Feature sorting overrides column specific when off */\n\t\tif ( !oSettings.oFeatures.bSort )\n\t\t{\n\t\t\toCol.bSortable = false;\n\t\t\tth.addClass( oClasses.sSortableNone ); // Have to add class here as order event isn't called\n\t\t}\n\t\n\t\t/* Check that the class assignment is correct for sorting */\n\t\tvar bAsc = $.inArray('asc', oCol.asSorting) !== -1;\n\t\tvar bDesc = $.inArray('desc', oCol.asSorting) !== -1;\n\t\tif ( !oCol.bSortable || (!bAsc && !bDesc) )\n\t\t{\n\t\t\toCol.sSortingClass = oClasses.sSortableNone;\n\t\t\toCol.sSortingClassJUI = \"\";\n\t\t}\n\t\telse if ( bAsc && !bDesc )\n\t\t{\n\t\t\toCol.sSortingClass = oClasses.sSortableAsc;\n\t\t\toCol.sSortingClassJUI = oClasses.sSortJUIAscAllowed;\n\t\t}\n\t\telse if ( !bAsc && bDesc )\n\t\t{\n\t\t\toCol.sSortingClass = oClasses.sSortableDesc;\n\t\t\toCol.sSortingClassJUI = oClasses.sSortJUIDescAllowed;\n\t\t}\n\t\telse\n\t\t{\n\t\t\toCol.sSortingClass = oClasses.sSortable;\n\t\t\toCol.sSortingClassJUI = oClasses.sSortJUI;\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Adjust the table column widths for new data. Note: you would probably want to\n\t * do a redraw after calling this function!\n\t *  @param {object} settings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnAdjustColumnSizing ( settings )\n\t{\n\t\t/* Not interested in doing column width calculation if auto-width is disabled */\n\t\tif ( settings.oFeatures.bAutoWidth !== false )\n\t\t{\n\t\t\tvar columns = settings.aoColumns;\n\t\n\t\t\t_fnCalculateColumnWidths( settings );\n\t\t\tfor ( var i=0 , iLen=columns.length ; i<iLen ; i++ )\n\t\t\t{\n\t\t\t\tcolumns[i].nTh.style.width = columns[i].sWidth;\n\t\t\t}\n\t\t}\n\t\n\t\tvar scroll = settings.oScroll;\n\t\tif ( scroll.sY !== '' || scroll.sX !== '')\n\t\t{\n\t\t\t_fnScrollDraw( settings );\n\t\t}\n\t\n\t\t_fnCallbackFire( settings, null, 'column-sizing', [settings] );\n\t}\n\t\n\t\n\t/**\n\t * Convert the index of a visible column to the index in the data array (take account\n\t * of hidden columns)\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {int} iMatch Visible column index to lookup\n\t *  @returns {int} i the data index\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnVisibleToColumnIndex( oSettings, iMatch )\n\t{\n\t\tvar aiVis = _fnGetColumns( oSettings, 'bVisible' );\n\t\n\t\treturn typeof aiVis[iMatch] === 'number' ?\n\t\t\taiVis[iMatch] :\n\t\t\tnull;\n\t}\n\t\n\t\n\t/**\n\t * Convert the index of an index in the data array and convert it to the visible\n\t *   column index (take account of hidden columns)\n\t *  @param {int} iMatch Column index to lookup\n\t *  @param {object} oSettings dataTables settings object\n\t *  @returns {int} i the data index\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnColumnIndexToVisible( oSettings, iMatch )\n\t{\n\t\tvar aiVis = _fnGetColumns( oSettings, 'bVisible' );\n\t\tvar iPos = $.inArray( iMatch, aiVis );\n\t\n\t\treturn iPos !== -1 ? iPos : null;\n\t}\n\t\n\t\n\t/**\n\t * Get the number of visible columns\n\t *  @param {object} oSettings dataTables settings object\n\t *  @returns {int} i the number of visible columns\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnVisbleColumns( oSettings )\n\t{\n\t\tvar vis = 0;\n\t\n\t\t// No reduce in IE8, use a loop for now\n\t\t$.each( oSettings.aoColumns, function ( i, col ) {\n\t\t\tif ( col.bVisible && $(col.nTh).css('display') !== 'none' ) {\n\t\t\t\tvis++;\n\t\t\t}\n\t\t} );\n\t\n\t\treturn vis;\n\t}\n\t\n\t\n\t/**\n\t * Get an array of column indexes that match a given property\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {string} sParam Parameter in aoColumns to look for - typically\n\t *    bVisible or bSearchable\n\t *  @returns {array} Array of indexes with matched properties\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnGetColumns( oSettings, sParam )\n\t{\n\t\tvar a = [];\n\t\n\t\t$.map( oSettings.aoColumns, function(val, i) {\n\t\t\tif ( val[sParam] ) {\n\t\t\t\ta.push( i );\n\t\t\t}\n\t\t} );\n\t\n\t\treturn a;\n\t}\n\t\n\t\n\t/**\n\t * Calculate the 'type' of a column\n\t *  @param {object} settings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnColumnTypes ( settings )\n\t{\n\t\tvar columns = settings.aoColumns;\n\t\tvar data = settings.aoData;\n\t\tvar types = DataTable.ext.type.detect;\n\t\tvar i, ien, j, jen, k, ken;\n\t\tvar col, cell, detectedType, cache;\n\t\n\t\t// For each column, spin over the \n\t\tfor ( i=0, ien=columns.length ; i<ien ; i++ ) {\n\t\t\tcol = columns[i];\n\t\t\tcache = [];\n\t\n\t\t\tif ( ! col.sType && col._sManualType ) {\n\t\t\t\tcol.sType = col._sManualType;\n\t\t\t}\n\t\t\telse if ( ! col.sType ) {\n\t\t\t\tfor ( j=0, jen=types.length ; j<jen ; j++ ) {\n\t\t\t\t\tfor ( k=0, ken=data.length ; k<ken ; k++ ) {\n\t\t\t\t\t\t// Use a cache array so we only need to get the type data\n\t\t\t\t\t\t// from the formatter once (when using multiple detectors)\n\t\t\t\t\t\tif ( cache[k] === undefined ) {\n\t\t\t\t\t\t\tcache[k] = _fnGetCellData( settings, k, i, 'type' );\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\tdetectedType = types[j]( cache[k], settings );\n\t\n\t\t\t\t\t\t// If null, then this type can't apply to this column, so\n\t\t\t\t\t\t// rather than testing all cells, break out. There is an\n\t\t\t\t\t\t// exception for the last type which is `html`. We need to\n\t\t\t\t\t\t// scan all rows since it is possible to mix string and HTML\n\t\t\t\t\t\t// types\n\t\t\t\t\t\tif ( ! detectedType && j !== types.length-1 ) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\t// Only a single match is needed for html type since it is\n\t\t\t\t\t\t// bottom of the pile and very similar to string - but it\n\t\t\t\t\t\t// must not be empty\n\t\t\t\t\t\tif ( detectedType === 'html' && ! _empty(cache[k]) ) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\n\t\t\t\t\t// Type is valid for all data points in the column - use this\n\t\t\t\t\t// type\n\t\t\t\t\tif ( detectedType ) {\n\t\t\t\t\t\tcol.sType = detectedType;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\n\t\t\t\t// Fall back - if no type was detected, always use string\n\t\t\t\tif ( ! col.sType ) {\n\t\t\t\t\tcol.sType = 'string';\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Take the column definitions and static columns arrays and calculate how\n\t * they relate to column indexes. The callback function will then apply the\n\t * definition found for a column to a suitable configuration object.\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {array} aoColDefs The aoColumnDefs array that is to be applied\n\t *  @param {array} aoCols The aoColumns array that defines columns individually\n\t *  @param {function} fn Callback function - takes two parameters, the calculated\n\t *    column index and the definition for that column.\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnApplyColumnDefs( oSettings, aoColDefs, aoCols, fn )\n\t{\n\t\tvar i, iLen, j, jLen, k, kLen, def;\n\t\tvar columns = oSettings.aoColumns;\n\t\n\t\t// Column definitions with aTargets\n\t\tif ( aoColDefs )\n\t\t{\n\t\t\t/* Loop over the definitions array - loop in reverse so first instance has priority */\n\t\t\tfor ( i=aoColDefs.length-1 ; i>=0 ; i-- )\n\t\t\t{\n\t\t\t\tdef = aoColDefs[i];\n\t\n\t\t\t\t/* Each definition can target multiple columns, as it is an array */\n\t\t\t\tvar aTargets = def.target !== undefined\n\t\t\t\t\t? def.target\n\t\t\t\t\t: def.targets !== undefined\n\t\t\t\t\t\t? def.targets\n\t\t\t\t\t\t: def.aTargets;\n\t\n\t\t\t\tif ( ! Array.isArray( aTargets ) )\n\t\t\t\t{\n\t\t\t\t\taTargets = [ aTargets ];\n\t\t\t\t}\n\t\n\t\t\t\tfor ( j=0, jLen=aTargets.length ; j<jLen ; j++ )\n\t\t\t\t{\n\t\t\t\t\tif ( typeof aTargets[j] === 'number' && aTargets[j] >= 0 )\n\t\t\t\t\t{\n\t\t\t\t\t\t/* Add columns that we don't yet know about */\n\t\t\t\t\t\twhile( columns.length <= aTargets[j] )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t_fnAddColumn( oSettings );\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\t/* Integer, basic index */\n\t\t\t\t\t\tfn( aTargets[j], def );\n\t\t\t\t\t}\n\t\t\t\t\telse if ( typeof aTargets[j] === 'number' && aTargets[j] < 0 )\n\t\t\t\t\t{\n\t\t\t\t\t\t/* Negative integer, right to left column counting */\n\t\t\t\t\t\tfn( columns.length+aTargets[j], def );\n\t\t\t\t\t}\n\t\t\t\t\telse if ( typeof aTargets[j] === 'string' )\n\t\t\t\t\t{\n\t\t\t\t\t\t/* Class name matching on TH element */\n\t\t\t\t\t\tfor ( k=0, kLen=columns.length ; k<kLen ; k++ )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tif ( aTargets[j] == \"_all\" ||\n\t\t\t\t\t\t\t     $(columns[k].nTh).hasClass( aTargets[j] ) )\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tfn( k, def );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\n\t\t// Statically defined columns array\n\t\tif ( aoCols )\n\t\t{\n\t\t\tfor ( i=0, iLen=aoCols.length ; i<iLen ; i++ )\n\t\t\t{\n\t\t\t\tfn( i, aoCols[i] );\n\t\t\t}\n\t\t}\n\t}\n\t\n\t/**\n\t * Add a data array to the table, creating DOM node etc. This is the parallel to\n\t * _fnGatherData, but for adding rows from a Javascript source, rather than a\n\t * DOM source.\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {array} aData data array to be added\n\t *  @param {node} [nTr] TR element to add to the table - optional. If not given,\n\t *    DataTables will create a row automatically\n\t *  @param {array} [anTds] Array of TD|TH elements for the row - must be given\n\t *    if nTr is.\n\t *  @returns {int} >=0 if successful (index of new aoData entry), -1 if failed\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnAddData ( oSettings, aDataIn, nTr, anTds )\n\t{\n\t\t/* Create the object for storing information about this new row */\n\t\tvar iRow = oSettings.aoData.length;\n\t\tvar oData = $.extend( true, {}, DataTable.models.oRow, {\n\t\t\tsrc: nTr ? 'dom' : 'data',\n\t\t\tidx: iRow\n\t\t} );\n\t\n\t\toData._aData = aDataIn;\n\t\toSettings.aoData.push( oData );\n\t\n\t\t/* Create the cells */\n\t\tvar nTd, sThisType;\n\t\tvar columns = oSettings.aoColumns;\n\t\n\t\t// Invalidate the column types as the new data needs to be revalidated\n\t\tfor ( var i=0, iLen=columns.length ; i<iLen ; i++ )\n\t\t{\n\t\t\tcolumns[i].sType = null;\n\t\t}\n\t\n\t\t/* Add to the display array */\n\t\toSettings.aiDisplayMaster.push( iRow );\n\t\n\t\tvar id = oSettings.rowIdFn( aDataIn );\n\t\tif ( id !== undefined ) {\n\t\t\toSettings.aIds[ id ] = oData;\n\t\t}\n\t\n\t\t/* Create the DOM information, or register it if already present */\n\t\tif ( nTr || ! oSettings.oFeatures.bDeferRender )\n\t\t{\n\t\t\t_fnCreateTr( oSettings, iRow, nTr, anTds );\n\t\t}\n\t\n\t\treturn iRow;\n\t}\n\t\n\t\n\t/**\n\t * Add one or more TR elements to the table. Generally we'd expect to\n\t * use this for reading data from a DOM sourced table, but it could be\n\t * used for an TR element. Note that if a TR is given, it is used (i.e.\n\t * it is not cloned).\n\t *  @param {object} settings dataTables settings object\n\t *  @param {array|node|jQuery} trs The TR element(s) to add to the table\n\t *  @returns {array} Array of indexes for the added rows\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnAddTr( settings, trs )\n\t{\n\t\tvar row;\n\t\n\t\t// Allow an individual node to be passed in\n\t\tif ( ! (trs instanceof $) ) {\n\t\t\ttrs = $(trs);\n\t\t}\n\t\n\t\treturn trs.map( function (i, el) {\n\t\t\trow = _fnGetRowElements( settings, el );\n\t\t\treturn _fnAddData( settings, row.data, el, row.cells );\n\t\t} );\n\t}\n\t\n\t\n\t/**\n\t * Take a TR element and convert it to an index in aoData\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {node} n the TR element to find\n\t *  @returns {int} index if the node is found, null if not\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnNodeToDataIndex( oSettings, n )\n\t{\n\t\treturn (n._DT_RowIndex!==undefined) ? n._DT_RowIndex : null;\n\t}\n\t\n\t\n\t/**\n\t * Take a TD element and convert it into a column data index (not the visible index)\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {int} iRow The row number the TD/TH can be found in\n\t *  @param {node} n The TD/TH element to find\n\t *  @returns {int} index if the node is found, -1 if not\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnNodeToColumnIndex( oSettings, iRow, n )\n\t{\n\t\treturn $.inArray( n, oSettings.aoData[ iRow ].anCells );\n\t}\n\t\n\t\n\t/**\n\t * Get the data for a given cell from the internal cache, taking into account data mapping\n\t *  @param {object} settings dataTables settings object\n\t *  @param {int} rowIdx aoData row id\n\t *  @param {int} colIdx Column index\n\t *  @param {string} type data get type ('display', 'type' 'filter|search' 'sort|order')\n\t *  @returns {*} Cell data\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnGetCellData( settings, rowIdx, colIdx, type )\n\t{\n\t\tif (type === 'search') {\n\t\t\ttype = 'filter';\n\t\t}\n\t\telse if (type === 'order') {\n\t\t\ttype = 'sort';\n\t\t}\n\t\n\t\tvar draw           = settings.iDraw;\n\t\tvar col            = settings.aoColumns[colIdx];\n\t\tvar rowData        = settings.aoData[rowIdx]._aData;\n\t\tvar defaultContent = col.sDefaultContent;\n\t\tvar cellData       = col.fnGetData( rowData, type, {\n\t\t\tsettings: settings,\n\t\t\trow:      rowIdx,\n\t\t\tcol:      colIdx\n\t\t} );\n\t\n\t\tif ( cellData === undefined ) {\n\t\t\tif ( settings.iDrawError != draw && defaultContent === null ) {\n\t\t\t\t_fnLog( settings, 0, \"Requested unknown parameter \"+\n\t\t\t\t\t(typeof col.mData=='function' ? '{function}' : \"'\"+col.mData+\"'\")+\n\t\t\t\t\t\" for row \"+rowIdx+\", column \"+colIdx, 4 );\n\t\t\t\tsettings.iDrawError = draw;\n\t\t\t}\n\t\t\treturn defaultContent;\n\t\t}\n\t\n\t\t// When the data source is null and a specific data type is requested (i.e.\n\t\t// not the original data), we can use default column data\n\t\tif ( (cellData === rowData || cellData === null) && defaultContent !== null && type !== undefined ) {\n\t\t\tcellData = defaultContent;\n\t\t}\n\t\telse if ( typeof cellData === 'function' ) {\n\t\t\t// If the data source is a function, then we run it and use the return,\n\t\t\t// executing in the scope of the data object (for instances)\n\t\t\treturn cellData.call( rowData );\n\t\t}\n\t\n\t\tif ( cellData === null && type === 'display' ) {\n\t\t\treturn '';\n\t\t}\n\t\n\t\tif ( type === 'filter' ) {\n\t\t\tvar fomatters = DataTable.ext.type.search;\n\t\n\t\t\tif ( fomatters[ col.sType ] ) {\n\t\t\t\tcellData = fomatters[ col.sType ]( cellData );\n\t\t\t}\n\t\t}\n\t\n\t\treturn cellData;\n\t}\n\t\n\t\n\t/**\n\t * Set the value for a specific cell, into the internal data cache\n\t *  @param {object} settings dataTables settings object\n\t *  @param {int} rowIdx aoData row id\n\t *  @param {int} colIdx Column index\n\t *  @param {*} val Value to set\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnSetCellData( settings, rowIdx, colIdx, val )\n\t{\n\t\tvar col     = settings.aoColumns[colIdx];\n\t\tvar rowData = settings.aoData[rowIdx]._aData;\n\t\n\t\tcol.fnSetData( rowData, val, {\n\t\t\tsettings: settings,\n\t\t\trow:      rowIdx,\n\t\t\tcol:      colIdx\n\t\t}  );\n\t}\n\t\n\t\n\t// Private variable that is used to match action syntax in the data property object\n\tvar __reArray = /\\[.*?\\]$/;\n\tvar __reFn = /\\(\\)$/;\n\t\n\t/**\n\t * Split string on periods, taking into account escaped periods\n\t * @param  {string} str String to split\n\t * @return {array} Split string\n\t */\n\tfunction _fnSplitObjNotation( str )\n\t{\n\t\treturn $.map( str.match(/(\\\\.|[^\\.])+/g) || [''], function ( s ) {\n\t\t\treturn s.replace(/\\\\\\./g, '.');\n\t\t} );\n\t}\n\t\n\t\n\t/**\n\t * Return a function that can be used to get data from a source object, taking\n\t * into account the ability to use nested objects as a source\n\t *  @param {string|int|function} mSource The data source for the object\n\t *  @returns {function} Data get function\n\t *  @memberof DataTable#oApi\n\t */\n\tvar _fnGetObjectDataFn = DataTable.util.get;\n\t\n\t\n\t/**\n\t * Return a function that can be used to set data from a source object, taking\n\t * into account the ability to use nested objects as a source\n\t *  @param {string|int|function} mSource The data source for the object\n\t *  @returns {function} Data set function\n\t *  @memberof DataTable#oApi\n\t */\n\tvar _fnSetObjectDataFn = DataTable.util.set;\n\t\n\t\n\t/**\n\t * Return an array with the full table data\n\t *  @param {object} oSettings dataTables settings object\n\t *  @returns array {array} aData Master data array\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnGetDataMaster ( settings )\n\t{\n\t\treturn _pluck( settings.aoData, '_aData' );\n\t}\n\t\n\t\n\t/**\n\t * Nuke the table\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnClearTable( settings )\n\t{\n\t\tsettings.aoData.length = 0;\n\t\tsettings.aiDisplayMaster.length = 0;\n\t\tsettings.aiDisplay.length = 0;\n\t\tsettings.aIds = {};\n\t}\n\t\n\t\n\t /**\n\t * Take an array of integers (index array) and remove a target integer (value - not\n\t * the key!)\n\t *  @param {array} a Index array to target\n\t *  @param {int} iTarget value to find\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnDeleteIndex( a, iTarget, splice )\n\t{\n\t\tvar iTargetIndex = -1;\n\t\n\t\tfor ( var i=0, iLen=a.length ; i<iLen ; i++ )\n\t\t{\n\t\t\tif ( a[i] == iTarget )\n\t\t\t{\n\t\t\t\tiTargetIndex = i;\n\t\t\t}\n\t\t\telse if ( a[i] > iTarget )\n\t\t\t{\n\t\t\t\ta[i]--;\n\t\t\t}\n\t\t}\n\t\n\t\tif ( iTargetIndex != -1 && splice === undefined )\n\t\t{\n\t\t\ta.splice( iTargetIndex, 1 );\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Mark cached data as invalid such that a re-read of the data will occur when\n\t * the cached data is next requested. Also update from the data source object.\n\t *\n\t * @param {object} settings DataTables settings object\n\t * @param {int}    rowIdx   Row index to invalidate\n\t * @param {string} [src]    Source to invalidate from: undefined, 'auto', 'dom'\n\t *     or 'data'\n\t * @param {int}    [colIdx] Column index to invalidate. If undefined the whole\n\t *     row will be invalidated\n\t * @memberof DataTable#oApi\n\t *\n\t * @todo For the modularisation of v1.11 this will need to become a callback, so\n\t *   the sort and filter methods can subscribe to it. That will required\n\t *   initialisation options for sorting, which is why it is not already baked in\n\t */\n\tfunction _fnInvalidate( settings, rowIdx, src, colIdx )\n\t{\n\t\tvar row = settings.aoData[ rowIdx ];\n\t\tvar i, ien;\n\t\tvar cellWrite = function ( cell, col ) {\n\t\t\t// This is very frustrating, but in IE if you just write directly\n\t\t\t// to innerHTML, and elements that are overwritten are GC'ed,\n\t\t\t// even if there is a reference to them elsewhere\n\t\t\twhile ( cell.childNodes.length ) {\n\t\t\t\tcell.removeChild( cell.firstChild );\n\t\t\t}\n\t\n\t\t\tcell.innerHTML = _fnGetCellData( settings, rowIdx, col, 'display' );\n\t\t};\n\t\n\t\t// Are we reading last data from DOM or the data object?\n\t\tif ( src === 'dom' || ((! src || src === 'auto') && row.src === 'dom') ) {\n\t\t\t// Read the data from the DOM\n\t\t\trow._aData = _fnGetRowElements(\n\t\t\t\t\tsettings, row, colIdx, colIdx === undefined ? undefined : row._aData\n\t\t\t\t)\n\t\t\t\t.data;\n\t\t}\n\t\telse {\n\t\t\t// Reading from data object, update the DOM\n\t\t\tvar cells = row.anCells;\n\t\n\t\t\tif ( cells ) {\n\t\t\t\tif ( colIdx !== undefined ) {\n\t\t\t\t\tcellWrite( cells[colIdx], colIdx );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tfor ( i=0, ien=cells.length ; i<ien ; i++ ) {\n\t\t\t\t\t\tcellWrite( cells[i], i );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\n\t\t// For both row and cell invalidation, the cached data for sorting and\n\t\t// filtering is nulled out\n\t\trow._aSortData = null;\n\t\trow._aFilterData = null;\n\t\n\t\t// Invalidate the type for a specific column (if given) or all columns since\n\t\t// the data might have changed\n\t\tvar cols = settings.aoColumns;\n\t\tif ( colIdx !== undefined ) {\n\t\t\tcols[ colIdx ].sType = null;\n\t\t}\n\t\telse {\n\t\t\tfor ( i=0, ien=cols.length ; i<ien ; i++ ) {\n\t\t\t\tcols[i].sType = null;\n\t\t\t}\n\t\n\t\t\t// Update DataTables special `DT_*` attributes for the row\n\t\t\t_fnRowAttributes( settings, row );\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Build a data source object from an HTML row, reading the contents of the\n\t * cells that are in the row.\n\t *\n\t * @param {object} settings DataTables settings object\n\t * @param {node|object} TR element from which to read data or existing row\n\t *   object from which to re-read the data from the cells\n\t * @param {int} [colIdx] Optional column index\n\t * @param {array|object} [d] Data source object. If `colIdx` is given then this\n\t *   parameter should also be given and will be used to write the data into.\n\t *   Only the column in question will be written\n\t * @returns {object} Object with two parameters: `data` the data read, in\n\t *   document order, and `cells` and array of nodes (they can be useful to the\n\t *   caller, so rather than needing a second traversal to get them, just return\n\t *   them from here).\n\t * @memberof DataTable#oApi\n\t */\n\tfunction _fnGetRowElements( settings, row, colIdx, d )\n\t{\n\t\tvar\n\t\t\ttds = [],\n\t\t\ttd = row.firstChild,\n\t\t\tname, col, o, i=0, contents,\n\t\t\tcolumns = settings.aoColumns,\n\t\t\tobjectRead = settings._rowReadObject;\n\t\n\t\t// Allow the data object to be passed in, or construct\n\t\td = d !== undefined ?\n\t\t\td :\n\t\t\tobjectRead ?\n\t\t\t\t{} :\n\t\t\t\t[];\n\t\n\t\tvar attr = function ( str, td  ) {\n\t\t\tif ( typeof str === 'string' ) {\n\t\t\t\tvar idx = str.indexOf('@');\n\t\n\t\t\t\tif ( idx !== -1 ) {\n\t\t\t\t\tvar attr = str.substring( idx+1 );\n\t\t\t\t\tvar setter = _fnSetObjectDataFn( str );\n\t\t\t\t\tsetter( d, td.getAttribute( attr ) );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\n\t\t// Read data from a cell and store into the data object\n\t\tvar cellProcess = function ( cell ) {\n\t\t\tif ( colIdx === undefined || colIdx === i ) {\n\t\t\t\tcol = columns[i];\n\t\t\t\tcontents = (cell.innerHTML).trim();\n\t\n\t\t\t\tif ( col && col._bAttrSrc ) {\n\t\t\t\t\tvar setter = _fnSetObjectDataFn( col.mData._ );\n\t\t\t\t\tsetter( d, contents );\n\t\n\t\t\t\t\tattr( col.mData.sort, cell );\n\t\t\t\t\tattr( col.mData.type, cell );\n\t\t\t\t\tattr( col.mData.filter, cell );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\t// Depending on the `data` option for the columns the data can\n\t\t\t\t\t// be read to either an object or an array.\n\t\t\t\t\tif ( objectRead ) {\n\t\t\t\t\t\tif ( ! col._setter ) {\n\t\t\t\t\t\t\t// Cache the setter function\n\t\t\t\t\t\t\tcol._setter = _fnSetObjectDataFn( col.mData );\n\t\t\t\t\t\t}\n\t\t\t\t\t\tcol._setter( d, contents );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\td[i] = contents;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\ti++;\n\t\t};\n\t\n\t\tif ( td ) {\n\t\t\t// `tr` element was passed in\n\t\t\twhile ( td ) {\n\t\t\t\tname = td.nodeName.toUpperCase();\n\t\n\t\t\t\tif ( name == \"TD\" || name == \"TH\" ) {\n\t\t\t\t\tcellProcess( td );\n\t\t\t\t\ttds.push( td );\n\t\t\t\t}\n\t\n\t\t\t\ttd = td.nextSibling;\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\t// Existing row object passed in\n\t\t\ttds = row.anCells;\n\t\n\t\t\tfor ( var j=0, jen=tds.length ; j<jen ; j++ ) {\n\t\t\t\tcellProcess( tds[j] );\n\t\t\t}\n\t\t}\n\t\n\t\t// Read the ID from the DOM if present\n\t\tvar rowNode = row.firstChild ? row : row.nTr;\n\t\n\t\tif ( rowNode ) {\n\t\t\tvar id = rowNode.getAttribute( 'id' );\n\t\n\t\t\tif ( id ) {\n\t\t\t\t_fnSetObjectDataFn( settings.rowId )( d, id );\n\t\t\t}\n\t\t}\n\t\n\t\treturn {\n\t\t\tdata: d,\n\t\t\tcells: tds\n\t\t};\n\t}\n\t/**\n\t * Create a new TR element (and it's TD children) for a row\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {int} iRow Row to consider\n\t *  @param {node} [nTrIn] TR element to add to the table - optional. If not given,\n\t *    DataTables will create a row automatically\n\t *  @param {array} [anTds] Array of TD|TH elements for the row - must be given\n\t *    if nTr is.\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnCreateTr ( oSettings, iRow, nTrIn, anTds )\n\t{\n\t\tvar\n\t\t\trow = oSettings.aoData[iRow],\n\t\t\trowData = row._aData,\n\t\t\tcells = [],\n\t\t\tnTr, nTd, oCol,\n\t\t\ti, iLen, create;\n\t\n\t\tif ( row.nTr === null )\n\t\t{\n\t\t\tnTr = nTrIn || document.createElement('tr');\n\t\n\t\t\trow.nTr = nTr;\n\t\t\trow.anCells = cells;\n\t\n\t\t\t/* Use a private property on the node to allow reserve mapping from the node\n\t\t\t * to the aoData array for fast look up\n\t\t\t */\n\t\t\tnTr._DT_RowIndex = iRow;\n\t\n\t\t\t/* Special parameters can be given by the data source to be used on the row */\n\t\t\t_fnRowAttributes( oSettings, row );\n\t\n\t\t\t/* Process each column */\n\t\t\tfor ( i=0, iLen=oSettings.aoColumns.length ; i<iLen ; i++ )\n\t\t\t{\n\t\t\t\toCol = oSettings.aoColumns[i];\n\t\t\t\tcreate = nTrIn ? false : true;\n\t\n\t\t\t\tnTd = create ? document.createElement( oCol.sCellType ) : anTds[i];\n\t\t\t\tnTd._DT_CellIndex = {\n\t\t\t\t\trow: iRow,\n\t\t\t\t\tcolumn: i\n\t\t\t\t};\n\t\t\t\t\n\t\t\t\tcells.push( nTd );\n\t\n\t\t\t\t// Need to create the HTML if new, or if a rendering function is defined\n\t\t\t\tif ( create || ((oCol.mRender || oCol.mData !== i) &&\n\t\t\t\t\t (!$.isPlainObject(oCol.mData) || oCol.mData._ !== i+'.display')\n\t\t\t\t)) {\n\t\t\t\t\tnTd.innerHTML = _fnGetCellData( oSettings, iRow, i, 'display' );\n\t\t\t\t}\n\t\n\t\t\t\t/* Add user defined class */\n\t\t\t\tif ( oCol.sClass )\n\t\t\t\t{\n\t\t\t\t\tnTd.className += ' '+oCol.sClass;\n\t\t\t\t}\n\t\n\t\t\t\t// Visibility - add or remove as required\n\t\t\t\tif ( oCol.bVisible && ! nTrIn )\n\t\t\t\t{\n\t\t\t\t\tnTr.appendChild( nTd );\n\t\t\t\t}\n\t\t\t\telse if ( ! oCol.bVisible && nTrIn )\n\t\t\t\t{\n\t\t\t\t\tnTd.parentNode.removeChild( nTd );\n\t\t\t\t}\n\t\n\t\t\t\tif ( oCol.fnCreatedCell )\n\t\t\t\t{\n\t\t\t\t\toCol.fnCreatedCell.call( oSettings.oInstance,\n\t\t\t\t\t\tnTd, _fnGetCellData( oSettings, iRow, i ), rowData, iRow, i\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t_fnCallbackFire( oSettings, 'aoRowCreatedCallback', null, [nTr, rowData, iRow, cells] );\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Add attributes to a row based on the special `DT_*` parameters in a data\n\t * source object.\n\t *  @param {object} settings DataTables settings object\n\t *  @param {object} DataTables row object for the row to be modified\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnRowAttributes( settings, row )\n\t{\n\t\tvar tr = row.nTr;\n\t\tvar data = row._aData;\n\t\n\t\tif ( tr ) {\n\t\t\tvar id = settings.rowIdFn( data );\n\t\n\t\t\tif ( id ) {\n\t\t\t\ttr.id = id;\n\t\t\t}\n\t\n\t\t\tif ( data.DT_RowClass ) {\n\t\t\t\t// Remove any classes added by DT_RowClass before\n\t\t\t\tvar a = data.DT_RowClass.split(' ');\n\t\t\t\trow.__rowc = row.__rowc ?\n\t\t\t\t\t_unique( row.__rowc.concat( a ) ) :\n\t\t\t\t\ta;\n\t\n\t\t\t\t$(tr)\n\t\t\t\t\t.removeClass( row.__rowc.join(' ') )\n\t\t\t\t\t.addClass( data.DT_RowClass );\n\t\t\t}\n\t\n\t\t\tif ( data.DT_RowAttr ) {\n\t\t\t\t$(tr).attr( data.DT_RowAttr );\n\t\t\t}\n\t\n\t\t\tif ( data.DT_RowData ) {\n\t\t\t\t$(tr).data( data.DT_RowData );\n\t\t\t}\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Create the HTML header for the table\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnBuildHead( oSettings )\n\t{\n\t\tvar i, ien, cell, row, column;\n\t\tvar thead = oSettings.nTHead;\n\t\tvar tfoot = oSettings.nTFoot;\n\t\tvar createHeader = $('th, td', thead).length === 0;\n\t\tvar classes = oSettings.oClasses;\n\t\tvar columns = oSettings.aoColumns;\n\t\n\t\tif ( createHeader ) {\n\t\t\trow = $('<tr/>').appendTo( thead );\n\t\t}\n\t\n\t\tfor ( i=0, ien=columns.length ; i<ien ; i++ ) {\n\t\t\tcolumn = columns[i];\n\t\t\tcell = $( column.nTh ).addClass( column.sClass );\n\t\n\t\t\tif ( createHeader ) {\n\t\t\t\tcell.appendTo( row );\n\t\t\t}\n\t\n\t\t\t// 1.11 move into sorting\n\t\t\tif ( oSettings.oFeatures.bSort ) {\n\t\t\t\tcell.addClass( column.sSortingClass );\n\t\n\t\t\t\tif ( column.bSortable !== false ) {\n\t\t\t\t\tcell\n\t\t\t\t\t\t.attr( 'tabindex', oSettings.iTabIndex )\n\t\t\t\t\t\t.attr( 'aria-controls', oSettings.sTableId );\n\t\n\t\t\t\t\t_fnSortAttachListener( oSettings, column.nTh, i );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\tif ( column.sTitle != cell[0].innerHTML ) {\n\t\t\t\tcell.html( column.sTitle );\n\t\t\t}\n\t\n\t\t\t_fnRenderer( oSettings, 'header' )(\n\t\t\t\toSettings, cell, column, classes\n\t\t\t);\n\t\t}\n\t\n\t\tif ( createHeader ) {\n\t\t\t_fnDetectHeader( oSettings.aoHeader, thead );\n\t\t}\n\t\n\t\t/* Deal with the footer - add classes if required */\n\t\t$(thead).children('tr').children('th, td').addClass( classes.sHeaderTH );\n\t\t$(tfoot).children('tr').children('th, td').addClass( classes.sFooterTH );\n\t\n\t\t// Cache the footer cells. Note that we only take the cells from the first\n\t\t// row in the footer. If there is more than one row the user wants to\n\t\t// interact with, they need to use the table().foot() method. Note also this\n\t\t// allows cells to be used for multiple columns using colspan\n\t\tif ( tfoot !== null ) {\n\t\t\tvar cells = oSettings.aoFooter[0];\n\t\n\t\t\tfor ( i=0, ien=cells.length ; i<ien ; i++ ) {\n\t\t\t\tcolumn = columns[i];\n\t\t\t\tcolumn.nTf = cells[i].cell;\n\t\n\t\t\t\tif ( column.sClass ) {\n\t\t\t\t\t$(column.nTf).addClass( column.sClass );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Draw the header (or footer) element based on the column visibility states. The\n\t * methodology here is to use the layout array from _fnDetectHeader, modified for\n\t * the instantaneous column visibility, to construct the new layout. The grid is\n\t * traversed over cell at a time in a rows x columns grid fashion, although each\n\t * cell insert can cover multiple elements in the grid - which is tracks using the\n\t * aApplied array. Cell inserts in the grid will only occur where there isn't\n\t * already a cell in that position.\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param array {objects} aoSource Layout array from _fnDetectHeader\n\t *  @param {boolean} [bIncludeHidden=false] If true then include the hidden columns in the calc,\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnDrawHead( oSettings, aoSource, bIncludeHidden )\n\t{\n\t\tvar i, iLen, j, jLen, k, kLen, n, nLocalTr;\n\t\tvar aoLocal = [];\n\t\tvar aApplied = [];\n\t\tvar iColumns = oSettings.aoColumns.length;\n\t\tvar iRowspan, iColspan;\n\t\n\t\tif ( ! aoSource )\n\t\t{\n\t\t\treturn;\n\t\t}\n\t\n\t\tif (  bIncludeHidden === undefined )\n\t\t{\n\t\t\tbIncludeHidden = false;\n\t\t}\n\t\n\t\t/* Make a copy of the master layout array, but without the visible columns in it */\n\t\tfor ( i=0, iLen=aoSource.length ; i<iLen ; i++ )\n\t\t{\n\t\t\taoLocal[i] = aoSource[i].slice();\n\t\t\taoLocal[i].nTr = aoSource[i].nTr;\n\t\n\t\t\t/* Remove any columns which are currently hidden */\n\t\t\tfor ( j=iColumns-1 ; j>=0 ; j-- )\n\t\t\t{\n\t\t\t\tif ( !oSettings.aoColumns[j].bVisible && !bIncludeHidden )\n\t\t\t\t{\n\t\t\t\t\taoLocal[i].splice( j, 1 );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t/* Prep the applied array - it needs an element for each row */\n\t\t\taApplied.push( [] );\n\t\t}\n\t\n\t\tfor ( i=0, iLen=aoLocal.length ; i<iLen ; i++ )\n\t\t{\n\t\t\tnLocalTr = aoLocal[i].nTr;\n\t\n\t\t\t/* All cells are going to be replaced, so empty out the row */\n\t\t\tif ( nLocalTr )\n\t\t\t{\n\t\t\t\twhile( (n = nLocalTr.firstChild) )\n\t\t\t\t{\n\t\t\t\t\tnLocalTr.removeChild( n );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\tfor ( j=0, jLen=aoLocal[i].length ; j<jLen ; j++ )\n\t\t\t{\n\t\t\t\tiRowspan = 1;\n\t\t\t\tiColspan = 1;\n\t\n\t\t\t\t/* Check to see if there is already a cell (row/colspan) covering our target\n\t\t\t\t * insert point. If there is, then there is nothing to do.\n\t\t\t\t */\n\t\t\t\tif ( aApplied[i][j] === undefined )\n\t\t\t\t{\n\t\t\t\t\tnLocalTr.appendChild( aoLocal[i][j].cell );\n\t\t\t\t\taApplied[i][j] = 1;\n\t\n\t\t\t\t\t/* Expand the cell to cover as many rows as needed */\n\t\t\t\t\twhile ( aoLocal[i+iRowspan] !== undefined &&\n\t\t\t\t\t        aoLocal[i][j].cell == aoLocal[i+iRowspan][j].cell )\n\t\t\t\t\t{\n\t\t\t\t\t\taApplied[i+iRowspan][j] = 1;\n\t\t\t\t\t\tiRowspan++;\n\t\t\t\t\t}\n\t\n\t\t\t\t\t/* Expand the cell to cover as many columns as needed */\n\t\t\t\t\twhile ( aoLocal[i][j+iColspan] !== undefined &&\n\t\t\t\t\t        aoLocal[i][j].cell == aoLocal[i][j+iColspan].cell )\n\t\t\t\t\t{\n\t\t\t\t\t\t/* Must update the applied array over the rows for the columns */\n\t\t\t\t\t\tfor ( k=0 ; k<iRowspan ; k++ )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\taApplied[i+k][j+iColspan] = 1;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tiColspan++;\n\t\t\t\t\t}\n\t\n\t\t\t\t\t/* Do the actual expansion in the DOM */\n\t\t\t\t\t$(aoLocal[i][j].cell)\n\t\t\t\t\t\t.attr('rowspan', iRowspan)\n\t\t\t\t\t\t.attr('colspan', iColspan);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Insert the required TR nodes into the table for display\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param ajaxComplete true after ajax call to complete rendering\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnDraw( oSettings, ajaxComplete )\n\t{\n\t\t// Allow for state saving and a custom start position\n\t\t_fnStart( oSettings );\n\t\n\t\t/* Provide a pre-callback function which can be used to cancel the draw is false is returned */\n\t\tvar aPreDraw = _fnCallbackFire( oSettings, 'aoPreDrawCallback', 'preDraw', [oSettings] );\n\t\tif ( $.inArray( false, aPreDraw ) !== -1 )\n\t\t{\n\t\t\t_fnProcessingDisplay( oSettings, false );\n\t\t\treturn;\n\t\t}\n\t\n\t\tvar anRows = [];\n\t\tvar iRowCount = 0;\n\t\tvar asStripeClasses = oSettings.asStripeClasses;\n\t\tvar iStripes = asStripeClasses.length;\n\t\tvar oLang = oSettings.oLanguage;\n\t\tvar bServerSide = _fnDataSource( oSettings ) == 'ssp';\n\t\tvar aiDisplay = oSettings.aiDisplay;\n\t\tvar iDisplayStart = oSettings._iDisplayStart;\n\t\tvar iDisplayEnd = oSettings.fnDisplayEnd();\n\t\n\t\toSettings.bDrawing = true;\n\t\n\t\t/* Server-side processing draw intercept */\n\t\tif ( oSettings.bDeferLoading )\n\t\t{\n\t\t\toSettings.bDeferLoading = false;\n\t\t\toSettings.iDraw++;\n\t\t\t_fnProcessingDisplay( oSettings, false );\n\t\t}\n\t\telse if ( !bServerSide )\n\t\t{\n\t\t\toSettings.iDraw++;\n\t\t}\n\t\telse if ( !oSettings.bDestroying && !ajaxComplete)\n\t\t{\n\t\t\t_fnAjaxUpdate( oSettings );\n\t\t\treturn;\n\t\t}\n\t\n\t\tif ( aiDisplay.length !== 0 )\n\t\t{\n\t\t\tvar iStart = bServerSide ? 0 : iDisplayStart;\n\t\t\tvar iEnd = bServerSide ? oSettings.aoData.length : iDisplayEnd;\n\t\n\t\t\tfor ( var j=iStart ; j<iEnd ; j++ )\n\t\t\t{\n\t\t\t\tvar iDataIndex = aiDisplay[j];\n\t\t\t\tvar aoData = oSettings.aoData[ iDataIndex ];\n\t\t\t\tif ( aoData.nTr === null )\n\t\t\t\t{\n\t\t\t\t\t_fnCreateTr( oSettings, iDataIndex );\n\t\t\t\t}\n\t\n\t\t\t\tvar nRow = aoData.nTr;\n\t\n\t\t\t\t/* Remove the old striping classes and then add the new one */\n\t\t\t\tif ( iStripes !== 0 )\n\t\t\t\t{\n\t\t\t\t\tvar sStripe = asStripeClasses[ iRowCount % iStripes ];\n\t\t\t\t\tif ( aoData._sRowStripe != sStripe )\n\t\t\t\t\t{\n\t\t\t\t\t\t$(nRow).removeClass( aoData._sRowStripe ).addClass( sStripe );\n\t\t\t\t\t\taoData._sRowStripe = sStripe;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\n\t\t\t\t// Row callback functions - might want to manipulate the row\n\t\t\t\t// iRowCount and j are not currently documented. Are they at all\n\t\t\t\t// useful?\n\t\t\t\t_fnCallbackFire( oSettings, 'aoRowCallback', null,\n\t\t\t\t\t[nRow, aoData._aData, iRowCount, j, iDataIndex] );\n\t\n\t\t\t\tanRows.push( nRow );\n\t\t\t\tiRowCount++;\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\t/* Table is empty - create a row with an empty message in it */\n\t\t\tvar sZero = oLang.sZeroRecords;\n\t\t\tif ( oSettings.iDraw == 1 &&  _fnDataSource( oSettings ) == 'ajax' )\n\t\t\t{\n\t\t\t\tsZero = oLang.sLoadingRecords;\n\t\t\t}\n\t\t\telse if ( oLang.sEmptyTable && oSettings.fnRecordsTotal() === 0 )\n\t\t\t{\n\t\t\t\tsZero = oLang.sEmptyTable;\n\t\t\t}\n\t\n\t\t\tanRows[ 0 ] = $( '<tr/>', { 'class': iStripes ? asStripeClasses[0] : '' } )\n\t\t\t\t.append( $('<td />', {\n\t\t\t\t\t'valign':  'top',\n\t\t\t\t\t'colSpan': _fnVisbleColumns( oSettings ),\n\t\t\t\t\t'class':   oSettings.oClasses.sRowEmpty\n\t\t\t\t} ).html( sZero ) )[0];\n\t\t}\n\t\n\t\t/* Header and footer callbacks */\n\t\t_fnCallbackFire( oSettings, 'aoHeaderCallback', 'header', [ $(oSettings.nTHead).children('tr')[0],\n\t\t\t_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );\n\t\n\t\t_fnCallbackFire( oSettings, 'aoFooterCallback', 'footer', [ $(oSettings.nTFoot).children('tr')[0],\n\t\t\t_fnGetDataMaster( oSettings ), iDisplayStart, iDisplayEnd, aiDisplay ] );\n\t\n\t\tvar body = $(oSettings.nTBody);\n\t\n\t\tbody.children().detach();\n\t\tbody.append( $(anRows) );\n\t\n\t\t/* Call all required callback functions for the end of a draw */\n\t\t_fnCallbackFire( oSettings, 'aoDrawCallback', 'draw', [oSettings] );\n\t\n\t\t/* Draw is complete, sorting and filtering must be as well */\n\t\toSettings.bSorted = false;\n\t\toSettings.bFiltered = false;\n\t\toSettings.bDrawing = false;\n\t}\n\t\n\t\n\t/**\n\t * Redraw the table - taking account of the various features which are enabled\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {boolean} [holdPosition] Keep the current paging position. By default\n\t *    the paging is reset to the first page\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnReDraw( settings, holdPosition )\n\t{\n\t\tvar\n\t\t\tfeatures = settings.oFeatures,\n\t\t\tsort     = features.bSort,\n\t\t\tfilter   = features.bFilter;\n\t\n\t\tif ( sort ) {\n\t\t\t_fnSort( settings );\n\t\t}\n\t\n\t\tif ( filter ) {\n\t\t\t_fnFilterComplete( settings, settings.oPreviousSearch );\n\t\t}\n\t\telse {\n\t\t\t// No filtering, so we want to just use the display master\n\t\t\tsettings.aiDisplay = settings.aiDisplayMaster.slice();\n\t\t}\n\t\n\t\tif ( holdPosition !== true ) {\n\t\t\tsettings._iDisplayStart = 0;\n\t\t}\n\t\n\t\t// Let any modules know about the draw hold position state (used by\n\t\t// scrolling internally)\n\t\tsettings._drawHold = holdPosition;\n\t\n\t\t_fnDraw( settings );\n\t\n\t\tsettings._drawHold = false;\n\t}\n\t\n\t\n\t/**\n\t * Add the options to the page HTML for the table\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnAddOptionsHtml ( oSettings )\n\t{\n\t\tvar classes = oSettings.oClasses;\n\t\tvar table = $(oSettings.nTable);\n\t\tvar holding = $('<div/>').insertBefore( table ); // Holding element for speed\n\t\tvar features = oSettings.oFeatures;\n\t\n\t\t// All DataTables are wrapped in a div\n\t\tvar insert = $('<div/>', {\n\t\t\tid:      oSettings.sTableId+'_wrapper',\n\t\t\t'class': classes.sWrapper + (oSettings.nTFoot ? '' : ' '+classes.sNoFooter)\n\t\t} );\n\t\n\t\toSettings.nHolding = holding[0];\n\t\toSettings.nTableWrapper = insert[0];\n\t\toSettings.nTableReinsertBefore = oSettings.nTable.nextSibling;\n\t\n\t\t/* Loop over the user set positioning and place the elements as needed */\n\t\tvar aDom = oSettings.sDom.split('');\n\t\tvar featureNode, cOption, nNewNode, cNext, sAttr, j;\n\t\tfor ( var i=0 ; i<aDom.length ; i++ )\n\t\t{\n\t\t\tfeatureNode = null;\n\t\t\tcOption = aDom[i];\n\t\n\t\t\tif ( cOption == '<' )\n\t\t\t{\n\t\t\t\t/* New container div */\n\t\t\t\tnNewNode = $('<div/>')[0];\n\t\n\t\t\t\t/* Check to see if we should append an id and/or a class name to the container */\n\t\t\t\tcNext = aDom[i+1];\n\t\t\t\tif ( cNext == \"'\" || cNext == '\"' )\n\t\t\t\t{\n\t\t\t\t\tsAttr = \"\";\n\t\t\t\t\tj = 2;\n\t\t\t\t\twhile ( aDom[i+j] != cNext )\n\t\t\t\t\t{\n\t\t\t\t\t\tsAttr += aDom[i+j];\n\t\t\t\t\t\tj++;\n\t\t\t\t\t}\n\t\n\t\t\t\t\t/* Replace jQuery UI constants @todo depreciated */\n\t\t\t\t\tif ( sAttr == \"H\" )\n\t\t\t\t\t{\n\t\t\t\t\t\tsAttr = classes.sJUIHeader;\n\t\t\t\t\t}\n\t\t\t\t\telse if ( sAttr == \"F\" )\n\t\t\t\t\t{\n\t\t\t\t\t\tsAttr = classes.sJUIFooter;\n\t\t\t\t\t}\n\t\n\t\t\t\t\t/* The attribute can be in the format of \"#id.class\", \"#id\" or \"class\" This logic\n\t\t\t\t\t * breaks the string into parts and applies them as needed\n\t\t\t\t\t */\n\t\t\t\t\tif ( sAttr.indexOf('.') != -1 )\n\t\t\t\t\t{\n\t\t\t\t\t\tvar aSplit = sAttr.split('.');\n\t\t\t\t\t\tnNewNode.id = aSplit[0].substr(1, aSplit[0].length-1);\n\t\t\t\t\t\tnNewNode.className = aSplit[1];\n\t\t\t\t\t}\n\t\t\t\t\telse if ( sAttr.charAt(0) == \"#\" )\n\t\t\t\t\t{\n\t\t\t\t\t\tnNewNode.id = sAttr.substr(1, sAttr.length-1);\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\tnNewNode.className = sAttr;\n\t\t\t\t\t}\n\t\n\t\t\t\t\ti += j; /* Move along the position array */\n\t\t\t\t}\n\t\n\t\t\t\tinsert.append( nNewNode );\n\t\t\t\tinsert = $(nNewNode);\n\t\t\t}\n\t\t\telse if ( cOption == '>' )\n\t\t\t{\n\t\t\t\t/* End container div */\n\t\t\t\tinsert = insert.parent();\n\t\t\t}\n\t\t\t// @todo Move options into their own plugins?\n\t\t\telse if ( cOption == 'l' && features.bPaginate && features.bLengthChange )\n\t\t\t{\n\t\t\t\t/* Length */\n\t\t\t\tfeatureNode = _fnFeatureHtmlLength( oSettings );\n\t\t\t}\n\t\t\telse if ( cOption == 'f' && features.bFilter )\n\t\t\t{\n\t\t\t\t/* Filter */\n\t\t\t\tfeatureNode = _fnFeatureHtmlFilter( oSettings );\n\t\t\t}\n\t\t\telse if ( cOption == 'r' && features.bProcessing )\n\t\t\t{\n\t\t\t\t/* pRocessing */\n\t\t\t\tfeatureNode = _fnFeatureHtmlProcessing( oSettings );\n\t\t\t}\n\t\t\telse if ( cOption == 't' )\n\t\t\t{\n\t\t\t\t/* Table */\n\t\t\t\tfeatureNode = _fnFeatureHtmlTable( oSettings );\n\t\t\t}\n\t\t\telse if ( cOption ==  'i' && features.bInfo )\n\t\t\t{\n\t\t\t\t/* Info */\n\t\t\t\tfeatureNode = _fnFeatureHtmlInfo( oSettings );\n\t\t\t}\n\t\t\telse if ( cOption == 'p' && features.bPaginate )\n\t\t\t{\n\t\t\t\t/* Pagination */\n\t\t\t\tfeatureNode = _fnFeatureHtmlPaginate( oSettings );\n\t\t\t}\n\t\t\telse if ( DataTable.ext.feature.length !== 0 )\n\t\t\t{\n\t\t\t\t/* Plug-in features */\n\t\t\t\tvar aoFeatures = DataTable.ext.feature;\n\t\t\t\tfor ( var k=0, kLen=aoFeatures.length ; k<kLen ; k++ )\n\t\t\t\t{\n\t\t\t\t\tif ( cOption == aoFeatures[k].cFeature )\n\t\t\t\t\t{\n\t\t\t\t\t\tfeatureNode = aoFeatures[k].fnInit( oSettings );\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t/* Add to the 2D features array */\n\t\t\tif ( featureNode )\n\t\t\t{\n\t\t\t\tvar aanFeatures = oSettings.aanFeatures;\n\t\n\t\t\t\tif ( ! aanFeatures[cOption] )\n\t\t\t\t{\n\t\t\t\t\taanFeatures[cOption] = [];\n\t\t\t\t}\n\t\n\t\t\t\taanFeatures[cOption].push( featureNode );\n\t\t\t\tinsert.append( featureNode );\n\t\t\t}\n\t\t}\n\t\n\t\t/* Built our DOM structure - replace the holding div with what we want */\n\t\tholding.replaceWith( insert );\n\t\toSettings.nHolding = null;\n\t}\n\t\n\t\n\t/**\n\t * Use the DOM source to create up an array of header cells. The idea here is to\n\t * create a layout grid (array) of rows x columns, which contains a reference\n\t * to the cell that that point in the grid (regardless of col/rowspan), such that\n\t * any column / row could be removed and the new grid constructed\n\t *  @param array {object} aLayout Array to store the calculated layout in\n\t *  @param {node} nThead The header/footer element for the table\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnDetectHeader ( aLayout, nThead )\n\t{\n\t\tvar nTrs = $(nThead).children('tr');\n\t\tvar nTr, nCell;\n\t\tvar i, k, l, iLen, jLen, iColShifted, iColumn, iColspan, iRowspan;\n\t\tvar bUnique;\n\t\tvar fnShiftCol = function ( a, i, j ) {\n\t\t\tvar k = a[i];\n\t                while ( k[j] ) {\n\t\t\t\tj++;\n\t\t\t}\n\t\t\treturn j;\n\t\t};\n\t\n\t\taLayout.splice( 0, aLayout.length );\n\t\n\t\t/* We know how many rows there are in the layout - so prep it */\n\t\tfor ( i=0, iLen=nTrs.length ; i<iLen ; i++ )\n\t\t{\n\t\t\taLayout.push( [] );\n\t\t}\n\t\n\t\t/* Calculate a layout array */\n\t\tfor ( i=0, iLen=nTrs.length ; i<iLen ; i++ )\n\t\t{\n\t\t\tnTr = nTrs[i];\n\t\t\tiColumn = 0;\n\t\n\t\t\t/* For every cell in the row... */\n\t\t\tnCell = nTr.firstChild;\n\t\t\twhile ( nCell ) {\n\t\t\t\tif ( nCell.nodeName.toUpperCase() == \"TD\" ||\n\t\t\t\t     nCell.nodeName.toUpperCase() == \"TH\" )\n\t\t\t\t{\n\t\t\t\t\t/* Get the col and rowspan attributes from the DOM and sanitise them */\n\t\t\t\t\tiColspan = nCell.getAttribute('colspan') * 1;\n\t\t\t\t\tiRowspan = nCell.getAttribute('rowspan') * 1;\n\t\t\t\t\tiColspan = (!iColspan || iColspan===0 || iColspan===1) ? 1 : iColspan;\n\t\t\t\t\tiRowspan = (!iRowspan || iRowspan===0 || iRowspan===1) ? 1 : iRowspan;\n\t\n\t\t\t\t\t/* There might be colspan cells already in this row, so shift our target\n\t\t\t\t\t * accordingly\n\t\t\t\t\t */\n\t\t\t\t\tiColShifted = fnShiftCol( aLayout, i, iColumn );\n\t\n\t\t\t\t\t/* Cache calculation for unique columns */\n\t\t\t\t\tbUnique = iColspan === 1 ? true : false;\n\t\n\t\t\t\t\t/* If there is col / rowspan, copy the information into the layout grid */\n\t\t\t\t\tfor ( l=0 ; l<iColspan ; l++ )\n\t\t\t\t\t{\n\t\t\t\t\t\tfor ( k=0 ; k<iRowspan ; k++ )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\taLayout[i+k][iColShifted+l] = {\n\t\t\t\t\t\t\t\t\"cell\": nCell,\n\t\t\t\t\t\t\t\t\"unique\": bUnique\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\taLayout[i+k].nTr = nTr;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tnCell = nCell.nextSibling;\n\t\t\t}\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Get an array of unique th elements, one for each column\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {node} nHeader automatically detect the layout from this node - optional\n\t *  @param {array} aLayout thead/tfoot layout from _fnDetectHeader - optional\n\t *  @returns array {node} aReturn list of unique th's\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnGetUniqueThs ( oSettings, nHeader, aLayout )\n\t{\n\t\tvar aReturn = [];\n\t\tif ( !aLayout )\n\t\t{\n\t\t\taLayout = oSettings.aoHeader;\n\t\t\tif ( nHeader )\n\t\t\t{\n\t\t\t\taLayout = [];\n\t\t\t\t_fnDetectHeader( aLayout, nHeader );\n\t\t\t}\n\t\t}\n\t\n\t\tfor ( var i=0, iLen=aLayout.length ; i<iLen ; i++ )\n\t\t{\n\t\t\tfor ( var j=0, jLen=aLayout[i].length ; j<jLen ; j++ )\n\t\t\t{\n\t\t\t\tif ( aLayout[i][j].unique &&\n\t\t\t\t\t (!aReturn[j] || !oSettings.bSortCellsTop) )\n\t\t\t\t{\n\t\t\t\t\taReturn[j] = aLayout[i][j].cell;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\n\t\treturn aReturn;\n\t}\n\t\n\t/**\n\t * Set the start position for draw\n\t *  @param {object} oSettings dataTables settings object\n\t */\n\tfunction _fnStart( oSettings )\n\t{\n\t\tvar bServerSide = _fnDataSource( oSettings ) == 'ssp';\n\t\tvar iInitDisplayStart = oSettings.iInitDisplayStart;\n\t\n\t\t// Check and see if we have an initial draw position from state saving\n\t\tif ( iInitDisplayStart !== undefined && iInitDisplayStart !== -1 )\n\t\t{\n\t\t\toSettings._iDisplayStart = bServerSide ?\n\t\t\t\tiInitDisplayStart :\n\t\t\t\tiInitDisplayStart >= oSettings.fnRecordsDisplay() ?\n\t\t\t\t\t0 :\n\t\t\t\t\tiInitDisplayStart;\n\t\n\t\t\toSettings.iInitDisplayStart = -1;\n\t\t}\n\t}\n\t\n\t/**\n\t * Create an Ajax call based on the table's settings, taking into account that\n\t * parameters can have multiple forms, and backwards compatibility.\n\t *\n\t * @param {object} oSettings dataTables settings object\n\t * @param {array} data Data to send to the server, required by\n\t *     DataTables - may be augmented by developer callbacks\n\t * @param {function} fn Callback function to run when data is obtained\n\t */\n\tfunction _fnBuildAjax( oSettings, data, fn )\n\t{\n\t\t// Compatibility with 1.9-, allow fnServerData and event to manipulate\n\t\t_fnCallbackFire( oSettings, 'aoServerParams', 'serverParams', [data] );\n\t\n\t\t// Convert to object based for 1.10+ if using the old array scheme which can\n\t\t// come from server-side processing or serverParams\n\t\tif ( data && Array.isArray(data) ) {\n\t\t\tvar tmp = {};\n\t\t\tvar rbracket = /(.*?)\\[\\]$/;\n\t\n\t\t\t$.each( data, function (key, val) {\n\t\t\t\tvar match = val.name.match(rbracket);\n\t\n\t\t\t\tif ( match ) {\n\t\t\t\t\t// Support for arrays\n\t\t\t\t\tvar name = match[0];\n\t\n\t\t\t\t\tif ( ! tmp[ name ] ) {\n\t\t\t\t\t\ttmp[ name ] = [];\n\t\t\t\t\t}\n\t\t\t\t\ttmp[ name ].push( val.value );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\ttmp[val.name] = val.value;\n\t\t\t\t}\n\t\t\t} );\n\t\t\tdata = tmp;\n\t\t}\n\t\n\t\tvar ajaxData;\n\t\tvar ajax = oSettings.ajax;\n\t\tvar instance = oSettings.oInstance;\n\t\tvar callback = function ( json ) {\n\t\t\tvar status = oSettings.jqXHR\n\t\t\t\t? oSettings.jqXHR.status\n\t\t\t\t: null;\n\t\n\t\t\tif ( json === null || (typeof status === 'number' && status == 204 ) ) {\n\t\t\t\tjson = {};\n\t\t\t\t_fnAjaxDataSrc( oSettings, json, [] );\n\t\t\t}\n\t\n\t\t\tvar error = json.error || json.sError;\n\t\t\tif ( error ) {\n\t\t\t\t_fnLog( oSettings, 0, error );\n\t\t\t}\n\t\n\t\t\toSettings.json = json;\n\t\n\t\t\t_fnCallbackFire( oSettings, null, 'xhr', [oSettings, json, oSettings.jqXHR] );\n\t\t\tfn( json );\n\t\t};\n\t\n\t\tif ( $.isPlainObject( ajax ) && ajax.data )\n\t\t{\n\t\t\tajaxData = ajax.data;\n\t\n\t\t\tvar newData = typeof ajaxData === 'function' ?\n\t\t\t\tajaxData( data, oSettings ) :  // fn can manipulate data or return\n\t\t\t\tajaxData;                      // an object object or array to merge\n\t\n\t\t\t// If the function returned something, use that alone\n\t\t\tdata = typeof ajaxData === 'function' && newData ?\n\t\t\t\tnewData :\n\t\t\t\t$.extend( true, data, newData );\n\t\n\t\t\t// Remove the data property as we've resolved it already and don't want\n\t\t\t// jQuery to do it again (it is restored at the end of the function)\n\t\t\tdelete ajax.data;\n\t\t}\n\t\n\t\tvar baseAjax = {\n\t\t\t\"data\": data,\n\t\t\t\"success\": callback,\n\t\t\t\"dataType\": \"json\",\n\t\t\t\"cache\": false,\n\t\t\t\"type\": oSettings.sServerMethod,\n\t\t\t\"error\": function (xhr, error, thrown) {\n\t\t\t\tvar ret = _fnCallbackFire( oSettings, null, 'xhr', [oSettings, null, oSettings.jqXHR] );\n\t\n\t\t\t\tif ( $.inArray( true, ret ) === -1 ) {\n\t\t\t\t\tif ( error == \"parsererror\" ) {\n\t\t\t\t\t\t_fnLog( oSettings, 0, 'Invalid JSON response', 1 );\n\t\t\t\t\t}\n\t\t\t\t\telse if ( xhr.readyState === 4 ) {\n\t\t\t\t\t\t_fnLog( oSettings, 0, 'Ajax error', 7 );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\n\t\t\t\t_fnProcessingDisplay( oSettings, false );\n\t\t\t}\n\t\t};\n\t\n\t\t// Store the data submitted for the API\n\t\toSettings.oAjaxData = data;\n\t\n\t\t// Allow plug-ins and external processes to modify the data\n\t\t_fnCallbackFire( oSettings, null, 'preXhr', [oSettings, data] );\n\t\n\t\tif ( oSettings.fnServerData )\n\t\t{\n\t\t\t// DataTables 1.9- compatibility\n\t\t\toSettings.fnServerData.call( instance,\n\t\t\t\toSettings.sAjaxSource,\n\t\t\t\t$.map( data, function (val, key) { // Need to convert back to 1.9 trad format\n\t\t\t\t\treturn { name: key, value: val };\n\t\t\t\t} ),\n\t\t\t\tcallback,\n\t\t\t\toSettings\n\t\t\t);\n\t\t}\n\t\telse if ( oSettings.sAjaxSource || typeof ajax === 'string' )\n\t\t{\n\t\t\t// DataTables 1.9- compatibility\n\t\t\toSettings.jqXHR = $.ajax( $.extend( baseAjax, {\n\t\t\t\turl: ajax || oSettings.sAjaxSource\n\t\t\t} ) );\n\t\t}\n\t\telse if ( typeof ajax === 'function' )\n\t\t{\n\t\t\t// Is a function - let the caller define what needs to be done\n\t\t\toSettings.jqXHR = ajax.call( instance, data, callback, oSettings );\n\t\t}\n\t\telse\n\t\t{\n\t\t\t// Object to extend the base settings\n\t\t\toSettings.jqXHR = $.ajax( $.extend( baseAjax, ajax ) );\n\t\n\t\t\t// Restore for next time around\n\t\t\tajax.data = ajaxData;\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Update the table using an Ajax call\n\t *  @param {object} settings dataTables settings object\n\t *  @returns {boolean} Block the table drawing or not\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnAjaxUpdate( settings )\n\t{\n\t\tsettings.iDraw++;\n\t\t_fnProcessingDisplay( settings, true );\n\t\n\t\t_fnBuildAjax(\n\t\t\tsettings,\n\t\t\t_fnAjaxParameters( settings ),\n\t\t\tfunction(json) {\n\t\t\t\t_fnAjaxUpdateDraw( settings, json );\n\t\t\t}\n\t\t);\n\t}\n\t\n\t\n\t/**\n\t * Build up the parameters in an object needed for a server-side processing\n\t * request. Note that this is basically done twice, is different ways - a modern\n\t * method which is used by default in DataTables 1.10 which uses objects and\n\t * arrays, or the 1.9- method with is name / value pairs. 1.9 method is used if\n\t * the sAjaxSource option is used in the initialisation, or the legacyAjax\n\t * option is set.\n\t *  @param {object} oSettings dataTables settings object\n\t *  @returns {bool} block the table drawing or not\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnAjaxParameters( settings )\n\t{\n\t\tvar\n\t\t\tcolumns = settings.aoColumns,\n\t\t\tcolumnCount = columns.length,\n\t\t\tfeatures = settings.oFeatures,\n\t\t\tpreSearch = settings.oPreviousSearch,\n\t\t\tpreColSearch = settings.aoPreSearchCols,\n\t\t\ti, data = [], dataProp, column, columnSearch,\n\t\t\tsort = _fnSortFlatten( settings ),\n\t\t\tdisplayStart = settings._iDisplayStart,\n\t\t\tdisplayLength = features.bPaginate !== false ?\n\t\t\t\tsettings._iDisplayLength :\n\t\t\t\t-1;\n\t\n\t\tvar param = function ( name, value ) {\n\t\t\tdata.push( { 'name': name, 'value': value } );\n\t\t};\n\t\n\t\t// DataTables 1.9- compatible method\n\t\tparam( 'sEcho',          settings.iDraw );\n\t\tparam( 'iColumns',       columnCount );\n\t\tparam( 'sColumns',       _pluck( columns, 'sName' ).join(',') );\n\t\tparam( 'iDisplayStart',  displayStart );\n\t\tparam( 'iDisplayLength', displayLength );\n\t\n\t\t// DataTables 1.10+ method\n\t\tvar d = {\n\t\t\tdraw:    settings.iDraw,\n\t\t\tcolumns: [],\n\t\t\torder:   [],\n\t\t\tstart:   displayStart,\n\t\t\tlength:  displayLength,\n\t\t\tsearch:  {\n\t\t\t\tvalue: preSearch.sSearch,\n\t\t\t\tregex: preSearch.bRegex\n\t\t\t}\n\t\t};\n\t\n\t\tfor ( i=0 ; i<columnCount ; i++ ) {\n\t\t\tcolumn = columns[i];\n\t\t\tcolumnSearch = preColSearch[i];\n\t\t\tdataProp = typeof column.mData==\"function\" ? 'function' : column.mData ;\n\t\n\t\t\td.columns.push( {\n\t\t\t\tdata:       dataProp,\n\t\t\t\tname:       column.sName,\n\t\t\t\tsearchable: column.bSearchable,\n\t\t\t\torderable:  column.bSortable,\n\t\t\t\tsearch:     {\n\t\t\t\t\tvalue: columnSearch.sSearch,\n\t\t\t\t\tregex: columnSearch.bRegex\n\t\t\t\t}\n\t\t\t} );\n\t\n\t\t\tparam( \"mDataProp_\"+i, dataProp );\n\t\n\t\t\tif ( features.bFilter ) {\n\t\t\t\tparam( 'sSearch_'+i,     columnSearch.sSearch );\n\t\t\t\tparam( 'bRegex_'+i,      columnSearch.bRegex );\n\t\t\t\tparam( 'bSearchable_'+i, column.bSearchable );\n\t\t\t}\n\t\n\t\t\tif ( features.bSort ) {\n\t\t\t\tparam( 'bSortable_'+i, column.bSortable );\n\t\t\t}\n\t\t}\n\t\n\t\tif ( features.bFilter ) {\n\t\t\tparam( 'sSearch', preSearch.sSearch );\n\t\t\tparam( 'bRegex', preSearch.bRegex );\n\t\t}\n\t\n\t\tif ( features.bSort ) {\n\t\t\t$.each( sort, function ( i, val ) {\n\t\t\t\td.order.push( { column: val.col, dir: val.dir } );\n\t\n\t\t\t\tparam( 'iSortCol_'+i, val.col );\n\t\t\t\tparam( 'sSortDir_'+i, val.dir );\n\t\t\t} );\n\t\n\t\t\tparam( 'iSortingCols', sort.length );\n\t\t}\n\t\n\t\t// If the legacy.ajax parameter is null, then we automatically decide which\n\t\t// form to use, based on sAjaxSource\n\t\tvar legacy = DataTable.ext.legacy.ajax;\n\t\tif ( legacy === null ) {\n\t\t\treturn settings.sAjaxSource ? data : d;\n\t\t}\n\t\n\t\t// Otherwise, if legacy has been specified then we use that to decide on the\n\t\t// form\n\t\treturn legacy ? data : d;\n\t}\n\t\n\t\n\t/**\n\t * Data the data from the server (nuking the old) and redraw the table\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {object} json json data return from the server.\n\t *  @param {string} json.sEcho Tracking flag for DataTables to match requests\n\t *  @param {int} json.iTotalRecords Number of records in the data set, not accounting for filtering\n\t *  @param {int} json.iTotalDisplayRecords Number of records in the data set, accounting for filtering\n\t *  @param {array} json.aaData The data to display on this page\n\t *  @param {string} [json.sColumns] Column ordering (sName, comma separated)\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnAjaxUpdateDraw ( settings, json )\n\t{\n\t\t// v1.10 uses camelCase variables, while 1.9 uses Hungarian notation.\n\t\t// Support both\n\t\tvar compat = function ( old, modern ) {\n\t\t\treturn json[old] !== undefined ? json[old] : json[modern];\n\t\t};\n\t\n\t\tvar data = _fnAjaxDataSrc( settings, json );\n\t\tvar draw            = compat( 'sEcho',                'draw' );\n\t\tvar recordsTotal    = compat( 'iTotalRecords',        'recordsTotal' );\n\t\tvar recordsFiltered = compat( 'iTotalDisplayRecords', 'recordsFiltered' );\n\t\n\t\tif ( draw !== undefined ) {\n\t\t\t// Protect against out of sequence returns\n\t\t\tif ( draw*1 < settings.iDraw ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tsettings.iDraw = draw * 1;\n\t\t}\n\t\n\t\t// No data in returned object, so rather than an array, we show an empty table\n\t\tif ( ! data ) {\n\t\t\tdata = [];\n\t\t}\n\t\n\t\t_fnClearTable( settings );\n\t\tsettings._iRecordsTotal   = parseInt(recordsTotal, 10);\n\t\tsettings._iRecordsDisplay = parseInt(recordsFiltered, 10);\n\t\n\t\tfor ( var i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\t_fnAddData( settings, data[i] );\n\t\t}\n\t\tsettings.aiDisplay = settings.aiDisplayMaster.slice();\n\t\n\t\t_fnDraw( settings, true );\n\t\n\t\tif ( ! settings._bInitComplete ) {\n\t\t\t_fnInitComplete( settings, json );\n\t\t}\n\t\n\t\t_fnProcessingDisplay( settings, false );\n\t}\n\t\n\t\n\t/**\n\t * Get the data from the JSON data source to use for drawing a table. Using\n\t * `_fnGetObjectDataFn` allows the data to be sourced from a property of the\n\t * source object, or from a processing function.\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param  {object} json Data source object / array from the server\n\t *  @return {array} Array of data to use\n\t */\n\t function _fnAjaxDataSrc ( oSettings, json, write )\n\t {\n\t\tvar dataSrc = $.isPlainObject( oSettings.ajax ) && oSettings.ajax.dataSrc !== undefined ?\n\t\t\toSettings.ajax.dataSrc :\n\t\t\toSettings.sAjaxDataProp; // Compatibility with 1.9-.\n\t\n\t\tif ( ! write ) {\n\t\t\tif ( dataSrc === 'data' ) {\n\t\t\t\t// If the default, then we still want to support the old style, and safely ignore\n\t\t\t\t// it if possible\n\t\t\t\treturn json.aaData || json[dataSrc];\n\t\t\t}\n\t\n\t\t\treturn dataSrc !== \"\" ?\n\t\t\t\t_fnGetObjectDataFn( dataSrc )( json ) :\n\t\t\t\tjson;\n\t\t}\n\t\n\t\t// set\n\t\t_fnSetObjectDataFn( dataSrc )( json, write );\n\t}\n\t\n\t/**\n\t * Generate the node required for filtering text\n\t *  @returns {node} Filter control element\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFeatureHtmlFilter ( settings )\n\t{\n\t\tvar classes = settings.oClasses;\n\t\tvar tableId = settings.sTableId;\n\t\tvar language = settings.oLanguage;\n\t\tvar previousSearch = settings.oPreviousSearch;\n\t\tvar features = settings.aanFeatures;\n\t\tvar input = '<input type=\"search\" class=\"'+classes.sFilterInput+'\"/>';\n\t\n\t\tvar str = language.sSearch;\n\t\tstr = str.match(/_INPUT_/) ?\n\t\t\tstr.replace('_INPUT_', input) :\n\t\t\tstr+input;\n\t\n\t\tvar filter = $('<div/>', {\n\t\t\t\t'id': ! features.f ? tableId+'_filter' : null,\n\t\t\t\t'class': classes.sFilter\n\t\t\t} )\n\t\t\t.append( $('<label/>' ).append( str ) );\n\t\n\t\tvar searchFn = function(event) {\n\t\t\t/* Update all other filter input elements for the new display */\n\t\t\tvar n = features.f;\n\t\t\tvar val = !this.value ? \"\" : this.value; // mental IE8 fix :-(\n\t\t\tif(previousSearch.return && event.key !== \"Enter\") {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\t/* Now do the filter */\n\t\t\tif ( val != previousSearch.sSearch ) {\n\t\t\t\t_fnFilterComplete( settings, {\n\t\t\t\t\t\"sSearch\": val,\n\t\t\t\t\t\"bRegex\": previousSearch.bRegex,\n\t\t\t\t\t\"bSmart\": previousSearch.bSmart ,\n\t\t\t\t\t\"bCaseInsensitive\": previousSearch.bCaseInsensitive,\n\t\t\t\t\t\"return\": previousSearch.return\n\t\t\t\t} );\n\t\n\t\t\t\t// Need to redraw, without resorting\n\t\t\t\tsettings._iDisplayStart = 0;\n\t\t\t\t_fnDraw( settings );\n\t\t\t}\n\t\t};\n\t\n\t\tvar searchDelay = settings.searchDelay !== null ?\n\t\t\tsettings.searchDelay :\n\t\t\t_fnDataSource( settings ) === 'ssp' ?\n\t\t\t\t400 :\n\t\t\t\t0;\n\t\n\t\tvar jqFilter = $('input', filter)\n\t\t\t.val( previousSearch.sSearch )\n\t\t\t.attr( 'placeholder', language.sSearchPlaceholder )\n\t\t\t.on(\n\t\t\t\t'keyup.DT search.DT input.DT paste.DT cut.DT',\n\t\t\t\tsearchDelay ?\n\t\t\t\t\t_fnThrottle( searchFn, searchDelay ) :\n\t\t\t\t\tsearchFn\n\t\t\t)\n\t\t\t.on( 'mouseup', function(e) {\n\t\t\t\t// Edge fix! Edge 17 does not trigger anything other than mouse events when clicking\n\t\t\t\t// on the clear icon (Edge bug 17584515). This is safe in other browsers as `searchFn`\n\t\t\t\t// checks the value to see if it has changed. In other browsers it won't have.\n\t\t\t\tsetTimeout( function () {\n\t\t\t\t\tsearchFn.call(jqFilter[0], e);\n\t\t\t\t}, 10);\n\t\t\t} )\n\t\t\t.on( 'keypress.DT', function(e) {\n\t\t\t\t/* Prevent form submission */\n\t\t\t\tif ( e.keyCode == 13 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t} )\n\t\t\t.attr('aria-controls', tableId);\n\t\n\t\t// Update the input elements whenever the table is filtered\n\t\t$(settings.nTable).on( 'search.dt.DT', function ( ev, s ) {\n\t\t\tif ( settings === s ) {\n\t\t\t\t// IE9 throws an 'unknown error' if document.activeElement is used\n\t\t\t\t// inside an iframe or frame...\n\t\t\t\ttry {\n\t\t\t\t\tif ( jqFilter[0] !== document.activeElement ) {\n\t\t\t\t\t\tjqFilter.val( previousSearch.sSearch );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tcatch ( e ) {}\n\t\t\t}\n\t\t} );\n\t\n\t\treturn filter[0];\n\t}\n\t\n\t\n\t/**\n\t * Filter the table using both the global filter and column based filtering\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {object} oSearch search information\n\t *  @param {int} [iForce] force a research of the master array (1) or not (undefined or 0)\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFilterComplete ( oSettings, oInput, iForce )\n\t{\n\t\tvar oPrevSearch = oSettings.oPreviousSearch;\n\t\tvar aoPrevSearch = oSettings.aoPreSearchCols;\n\t\tvar fnSaveFilter = function ( oFilter ) {\n\t\t\t/* Save the filtering values */\n\t\t\toPrevSearch.sSearch = oFilter.sSearch;\n\t\t\toPrevSearch.bRegex = oFilter.bRegex;\n\t\t\toPrevSearch.bSmart = oFilter.bSmart;\n\t\t\toPrevSearch.bCaseInsensitive = oFilter.bCaseInsensitive;\n\t\t\toPrevSearch.return = oFilter.return;\n\t\t};\n\t\tvar fnRegex = function ( o ) {\n\t\t\t// Backwards compatibility with the bEscapeRegex option\n\t\t\treturn o.bEscapeRegex !== undefined ? !o.bEscapeRegex : o.bRegex;\n\t\t};\n\t\n\t\t// Resolve any column types that are unknown due to addition or invalidation\n\t\t// @todo As per sort - can this be moved into an event handler?\n\t\t_fnColumnTypes( oSettings );\n\t\n\t\t/* In server-side processing all filtering is done by the server, so no point hanging around here */\n\t\tif ( _fnDataSource( oSettings ) != 'ssp' )\n\t\t{\n\t\t\t/* Global filter */\n\t\t\t_fnFilter( oSettings, oInput.sSearch, iForce, fnRegex(oInput), oInput.bSmart, oInput.bCaseInsensitive, oInput.return );\n\t\t\tfnSaveFilter( oInput );\n\t\n\t\t\t/* Now do the individual column filter */\n\t\t\tfor ( var i=0 ; i<aoPrevSearch.length ; i++ )\n\t\t\t{\n\t\t\t\t_fnFilterColumn( oSettings, aoPrevSearch[i].sSearch, i, fnRegex(aoPrevSearch[i]),\n\t\t\t\t\taoPrevSearch[i].bSmart, aoPrevSearch[i].bCaseInsensitive );\n\t\t\t}\n\t\n\t\t\t/* Custom filtering */\n\t\t\t_fnFilterCustom( oSettings );\n\t\t}\n\t\telse\n\t\t{\n\t\t\tfnSaveFilter( oInput );\n\t\t}\n\t\n\t\t/* Tell the draw function we have been filtering */\n\t\toSettings.bFiltered = true;\n\t\t_fnCallbackFire( oSettings, null, 'search', [oSettings] );\n\t}\n\t\n\t\n\t/**\n\t * Apply custom filtering functions\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFilterCustom( settings )\n\t{\n\t\tvar filters = DataTable.ext.search;\n\t\tvar displayRows = settings.aiDisplay;\n\t\tvar row, rowIdx;\n\t\n\t\tfor ( var i=0, ien=filters.length ; i<ien ; i++ ) {\n\t\t\tvar rows = [];\n\t\n\t\t\t// Loop over each row and see if it should be included\n\t\t\tfor ( var j=0, jen=displayRows.length ; j<jen ; j++ ) {\n\t\t\t\trowIdx = displayRows[ j ];\n\t\t\t\trow = settings.aoData[ rowIdx ];\n\t\n\t\t\t\tif ( filters[i]( settings, row._aFilterData, rowIdx, row._aData, j ) ) {\n\t\t\t\t\trows.push( rowIdx );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t// So the array reference doesn't break set the results into the\n\t\t\t// existing array\n\t\t\tdisplayRows.length = 0;\n\t\t\t$.merge( displayRows, rows );\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Filter the table on a per-column basis\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {string} sInput string to filter on\n\t *  @param {int} iColumn column to filter\n\t *  @param {bool} bRegex treat search string as a regular expression or not\n\t *  @param {bool} bSmart use smart filtering or not\n\t *  @param {bool} bCaseInsensitive Do case insensitive matching or not\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFilterColumn ( settings, searchStr, colIdx, regex, smart, caseInsensitive )\n\t{\n\t\tif ( searchStr === '' ) {\n\t\t\treturn;\n\t\t}\n\t\n\t\tvar data;\n\t\tvar out = [];\n\t\tvar display = settings.aiDisplay;\n\t\tvar rpSearch = _fnFilterCreateSearch( searchStr, regex, smart, caseInsensitive );\n\t\n\t\tfor ( var i=0 ; i<display.length ; i++ ) {\n\t\t\tdata = settings.aoData[ display[i] ]._aFilterData[ colIdx ];\n\t\n\t\t\tif ( rpSearch.test( data ) ) {\n\t\t\t\tout.push( display[i] );\n\t\t\t}\n\t\t}\n\t\n\t\tsettings.aiDisplay = out;\n\t}\n\t\n\t\n\t/**\n\t * Filter the data table based on user input and draw the table\n\t *  @param {object} settings dataTables settings object\n\t *  @param {string} input string to filter on\n\t *  @param {int} force optional - force a research of the master array (1) or not (undefined or 0)\n\t *  @param {bool} regex treat as a regular expression or not\n\t *  @param {bool} smart perform smart filtering or not\n\t *  @param {bool} caseInsensitive Do case insensitive matching or not\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFilter( settings, input, force, regex, smart, caseInsensitive )\n\t{\n\t\tvar rpSearch = _fnFilterCreateSearch( input, regex, smart, caseInsensitive );\n\t\tvar prevSearch = settings.oPreviousSearch.sSearch;\n\t\tvar displayMaster = settings.aiDisplayMaster;\n\t\tvar display, invalidated, i;\n\t\tvar filtered = [];\n\t\n\t\t// Need to take account of custom filtering functions - always filter\n\t\tif ( DataTable.ext.search.length !== 0 ) {\n\t\t\tforce = true;\n\t\t}\n\t\n\t\t// Check if any of the rows were invalidated\n\t\tinvalidated = _fnFilterData( settings );\n\t\n\t\t// If the input is blank - we just want the full data set\n\t\tif ( input.length <= 0 ) {\n\t\t\tsettings.aiDisplay = displayMaster.slice();\n\t\t}\n\t\telse {\n\t\t\t// New search - start from the master array\n\t\t\tif ( invalidated ||\n\t\t\t\t force ||\n\t\t\t\t regex ||\n\t\t\t\t prevSearch.length > input.length ||\n\t\t\t\t input.indexOf(prevSearch) !== 0 ||\n\t\t\t\t settings.bSorted // On resort, the display master needs to be\n\t\t\t\t                  // re-filtered since indexes will have changed\n\t\t\t) {\n\t\t\t\tsettings.aiDisplay = displayMaster.slice();\n\t\t\t}\n\t\n\t\t\t// Search the display array\n\t\t\tdisplay = settings.aiDisplay;\n\t\n\t\t\tfor ( i=0 ; i<display.length ; i++ ) {\n\t\t\t\tif ( rpSearch.test( settings.aoData[ display[i] ]._sFilterRow ) ) {\n\t\t\t\t\tfiltered.push( display[i] );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\tsettings.aiDisplay = filtered;\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Build a regular expression object suitable for searching a table\n\t *  @param {string} sSearch string to search for\n\t *  @param {bool} bRegex treat as a regular expression or not\n\t *  @param {bool} bSmart perform smart filtering or not\n\t *  @param {bool} bCaseInsensitive Do case insensitive matching or not\n\t *  @returns {RegExp} constructed object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFilterCreateSearch( search, regex, smart, caseInsensitive )\n\t{\n\t\tsearch = regex ?\n\t\t\tsearch :\n\t\t\t_fnEscapeRegex( search );\n\t\t\n\t\tif ( smart ) {\n\t\t\t/* For smart filtering we want to allow the search to work regardless of\n\t\t\t * word order. We also want double quoted text to be preserved, so word\n\t\t\t * order is important - a la google. So this is what we want to\n\t\t\t * generate:\n\t\t\t * \n\t\t\t * ^(?=.*?\\bone\\b)(?=.*?\\btwo three\\b)(?=.*?\\bfour\\b).*$\n\t\t\t */\n\t\t\tvar a = $.map( search.match( /\"[^\"]+\"|[^ ]+/g ) || [''], function ( word ) {\n\t\t\t\tif ( word.charAt(0) === '\"' ) {\n\t\t\t\t\tvar m = word.match( /^\"(.*)\"$/ );\n\t\t\t\t\tword = m ? m[1] : word;\n\t\t\t\t}\n\t\n\t\t\t\treturn word.replace('\"', '');\n\t\t\t} );\n\t\n\t\t\tsearch = '^(?=.*?'+a.join( ')(?=.*?' )+').*$';\n\t\t}\n\t\n\t\treturn new RegExp( search, caseInsensitive ? 'i' : '' );\n\t}\n\t\n\t\n\t/**\n\t * Escape a string such that it can be used in a regular expression\n\t *  @param {string} sVal string to escape\n\t *  @returns {string} escaped string\n\t *  @memberof DataTable#oApi\n\t */\n\tvar _fnEscapeRegex = DataTable.util.escapeRegex;\n\t\n\tvar __filter_div = $('<div>')[0];\n\tvar __filter_div_textContent = __filter_div.textContent !== undefined;\n\t\n\t// Update the filtering data for each row if needed (by invalidation or first run)\n\tfunction _fnFilterData ( settings )\n\t{\n\t\tvar columns = settings.aoColumns;\n\t\tvar column;\n\t\tvar i, j, ien, jen, filterData, cellData, row;\n\t\tvar wasInvalidated = false;\n\t\n\t\tfor ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\t\trow = settings.aoData[i];\n\t\n\t\t\tif ( ! row._aFilterData ) {\n\t\t\t\tfilterData = [];\n\t\n\t\t\t\tfor ( j=0, jen=columns.length ; j<jen ; j++ ) {\n\t\t\t\t\tcolumn = columns[j];\n\t\n\t\t\t\t\tif ( column.bSearchable ) {\n\t\t\t\t\t\tcellData = _fnGetCellData( settings, i, j, 'filter' );\n\t\n\t\t\t\t\t\t// Search in DataTables 1.10 is string based. In 1.11 this\n\t\t\t\t\t\t// should be altered to also allow strict type checking.\n\t\t\t\t\t\tif ( cellData === null ) {\n\t\t\t\t\t\t\tcellData = '';\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\tif ( typeof cellData !== 'string' && cellData.toString ) {\n\t\t\t\t\t\t\tcellData = cellData.toString();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tcellData = '';\n\t\t\t\t\t}\n\t\n\t\t\t\t\t// If it looks like there is an HTML entity in the string,\n\t\t\t\t\t// attempt to decode it so sorting works as expected. Note that\n\t\t\t\t\t// we could use a single line of jQuery to do this, but the DOM\n\t\t\t\t\t// method used here is much faster http://jsperf.com/html-decode\n\t\t\t\t\tif ( cellData.indexOf && cellData.indexOf('&') !== -1 ) {\n\t\t\t\t\t\t__filter_div.innerHTML = cellData;\n\t\t\t\t\t\tcellData = __filter_div_textContent ?\n\t\t\t\t\t\t\t__filter_div.textContent :\n\t\t\t\t\t\t\t__filter_div.innerText;\n\t\t\t\t\t}\n\t\n\t\t\t\t\tif ( cellData.replace ) {\n\t\t\t\t\t\tcellData = cellData.replace(/[\\r\\n\\u2028]/g, '');\n\t\t\t\t\t}\n\t\n\t\t\t\t\tfilterData.push( cellData );\n\t\t\t\t}\n\t\n\t\t\t\trow._aFilterData = filterData;\n\t\t\t\trow._sFilterRow = filterData.join('  ');\n\t\t\t\twasInvalidated = true;\n\t\t\t}\n\t\t}\n\t\n\t\treturn wasInvalidated;\n\t}\n\t\n\t\n\t/**\n\t * Convert from the internal Hungarian notation to camelCase for external\n\t * interaction\n\t *  @param {object} obj Object to convert\n\t *  @returns {object} Inverted object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnSearchToCamel ( obj )\n\t{\n\t\treturn {\n\t\t\tsearch:          obj.sSearch,\n\t\t\tsmart:           obj.bSmart,\n\t\t\tregex:           obj.bRegex,\n\t\t\tcaseInsensitive: obj.bCaseInsensitive\n\t\t};\n\t}\n\t\n\t\n\t\n\t/**\n\t * Convert from camelCase notation to the internal Hungarian. We could use the\n\t * Hungarian convert function here, but this is cleaner\n\t *  @param {object} obj Object to convert\n\t *  @returns {object} Inverted object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnSearchToHung ( obj )\n\t{\n\t\treturn {\n\t\t\tsSearch:          obj.search,\n\t\t\tbSmart:           obj.smart,\n\t\t\tbRegex:           obj.regex,\n\t\t\tbCaseInsensitive: obj.caseInsensitive\n\t\t};\n\t}\n\t\n\t/**\n\t * Generate the node required for the info display\n\t *  @param {object} oSettings dataTables settings object\n\t *  @returns {node} Information element\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFeatureHtmlInfo ( settings )\n\t{\n\t\tvar\n\t\t\ttid = settings.sTableId,\n\t\t\tnodes = settings.aanFeatures.i,\n\t\t\tn = $('<div/>', {\n\t\t\t\t'class': settings.oClasses.sInfo,\n\t\t\t\t'id': ! nodes ? tid+'_info' : null\n\t\t\t} );\n\t\n\t\tif ( ! nodes ) {\n\t\t\t// Update display on each draw\n\t\t\tsettings.aoDrawCallback.push( {\n\t\t\t\t\"fn\": _fnUpdateInfo,\n\t\t\t\t\"sName\": \"information\"\n\t\t\t} );\n\t\n\t\t\tn\n\t\t\t\t.attr( 'role', 'status' )\n\t\t\t\t.attr( 'aria-live', 'polite' );\n\t\n\t\t\t// Table is described by our info div\n\t\t\t$(settings.nTable).attr( 'aria-describedby', tid+'_info' );\n\t\t}\n\t\n\t\treturn n[0];\n\t}\n\t\n\t\n\t/**\n\t * Update the information elements in the display\n\t *  @param {object} settings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnUpdateInfo ( settings )\n\t{\n\t\t/* Show information about the table */\n\t\tvar nodes = settings.aanFeatures.i;\n\t\tif ( nodes.length === 0 ) {\n\t\t\treturn;\n\t\t}\n\t\n\t\tvar\n\t\t\tlang  = settings.oLanguage,\n\t\t\tstart = settings._iDisplayStart+1,\n\t\t\tend   = settings.fnDisplayEnd(),\n\t\t\tmax   = settings.fnRecordsTotal(),\n\t\t\ttotal = settings.fnRecordsDisplay(),\n\t\t\tout   = total ?\n\t\t\t\tlang.sInfo :\n\t\t\t\tlang.sInfoEmpty;\n\t\n\t\tif ( total !== max ) {\n\t\t\t/* Record set after filtering */\n\t\t\tout += ' ' + lang.sInfoFiltered;\n\t\t}\n\t\n\t\t// Convert the macros\n\t\tout += lang.sInfoPostFix;\n\t\tout = _fnInfoMacros( settings, out );\n\t\n\t\tvar callback = lang.fnInfoCallback;\n\t\tif ( callback !== null ) {\n\t\t\tout = callback.call( settings.oInstance,\n\t\t\t\tsettings, start, end, max, total, out\n\t\t\t);\n\t\t}\n\t\n\t\t$(nodes).html( out );\n\t}\n\t\n\t\n\tfunction _fnInfoMacros ( settings, str )\n\t{\n\t\t// When infinite scrolling, we are always starting at 1. _iDisplayStart is used only\n\t\t// internally\n\t\tvar\n\t\t\tformatter  = settings.fnFormatNumber,\n\t\t\tstart      = settings._iDisplayStart+1,\n\t\t\tlen        = settings._iDisplayLength,\n\t\t\tvis        = settings.fnRecordsDisplay(),\n\t\t\tall        = len === -1;\n\t\n\t\treturn str.\n\t\t\treplace(/_START_/g, formatter.call( settings, start ) ).\n\t\t\treplace(/_END_/g,   formatter.call( settings, settings.fnDisplayEnd() ) ).\n\t\t\treplace(/_MAX_/g,   formatter.call( settings, settings.fnRecordsTotal() ) ).\n\t\t\treplace(/_TOTAL_/g, formatter.call( settings, vis ) ).\n\t\t\treplace(/_PAGE_/g,  formatter.call( settings, all ? 1 : Math.ceil( start / len ) ) ).\n\t\t\treplace(/_PAGES_/g, formatter.call( settings, all ? 1 : Math.ceil( vis / len ) ) );\n\t}\n\t\n\t\n\t\n\t/**\n\t * Draw the table for the first time, adding all required features\n\t *  @param {object} settings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnInitialise ( settings )\n\t{\n\t\tvar i, iLen, iAjaxStart=settings.iInitDisplayStart;\n\t\tvar columns = settings.aoColumns, column;\n\t\tvar features = settings.oFeatures;\n\t\tvar deferLoading = settings.bDeferLoading; // value modified by the draw\n\t\n\t\t/* Ensure that the table data is fully initialised */\n\t\tif ( ! settings.bInitialised ) {\n\t\t\tsetTimeout( function(){ _fnInitialise( settings ); }, 200 );\n\t\t\treturn;\n\t\t}\n\t\n\t\t/* Show the display HTML options */\n\t\t_fnAddOptionsHtml( settings );\n\t\n\t\t/* Build and draw the header / footer for the table */\n\t\t_fnBuildHead( settings );\n\t\t_fnDrawHead( settings, settings.aoHeader );\n\t\t_fnDrawHead( settings, settings.aoFooter );\n\t\n\t\t/* Okay to show that something is going on now */\n\t\t_fnProcessingDisplay( settings, true );\n\t\n\t\t/* Calculate sizes for columns */\n\t\tif ( features.bAutoWidth ) {\n\t\t\t_fnCalculateColumnWidths( settings );\n\t\t}\n\t\n\t\tfor ( i=0, iLen=columns.length ; i<iLen ; i++ ) {\n\t\t\tcolumn = columns[i];\n\t\n\t\t\tif ( column.sWidth ) {\n\t\t\t\tcolumn.nTh.style.width = _fnStringToCss( column.sWidth );\n\t\t\t}\n\t\t}\n\t\n\t\t_fnCallbackFire( settings, null, 'preInit', [settings] );\n\t\n\t\t// If there is default sorting required - let's do it. The sort function\n\t\t// will do the drawing for us. Otherwise we draw the table regardless of the\n\t\t// Ajax source - this allows the table to look initialised for Ajax sourcing\n\t\t// data (show 'loading' message possibly)\n\t\t_fnReDraw( settings );\n\t\n\t\t// Server-side processing init complete is done by _fnAjaxUpdateDraw\n\t\tvar dataSrc = _fnDataSource( settings );\n\t\tif ( dataSrc != 'ssp' || deferLoading ) {\n\t\t\t// if there is an ajax source load the data\n\t\t\tif ( dataSrc == 'ajax' ) {\n\t\t\t\t_fnBuildAjax( settings, [], function(json) {\n\t\t\t\t\tvar aData = _fnAjaxDataSrc( settings, json );\n\t\n\t\t\t\t\t// Got the data - add it to the table\n\t\t\t\t\tfor ( i=0 ; i<aData.length ; i++ ) {\n\t\t\t\t\t\t_fnAddData( settings, aData[i] );\n\t\t\t\t\t}\n\t\n\t\t\t\t\t// Reset the init display for cookie saving. We've already done\n\t\t\t\t\t// a filter, and therefore cleared it before. So we need to make\n\t\t\t\t\t// it appear 'fresh'\n\t\t\t\t\tsettings.iInitDisplayStart = iAjaxStart;\n\t\n\t\t\t\t\t_fnReDraw( settings );\n\t\n\t\t\t\t\t_fnProcessingDisplay( settings, false );\n\t\t\t\t\t_fnInitComplete( settings, json );\n\t\t\t\t}, settings );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t_fnProcessingDisplay( settings, false );\n\t\t\t\t_fnInitComplete( settings );\n\t\t\t}\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Draw the table for the first time, adding all required features\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {object} [json] JSON from the server that completed the table, if using Ajax source\n\t *    with client-side processing (optional)\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnInitComplete ( settings, json )\n\t{\n\t\tsettings._bInitComplete = true;\n\t\n\t\t// When data was added after the initialisation (data or Ajax) we need to\n\t\t// calculate the column sizing\n\t\tif ( json || settings.oInit.aaData ) {\n\t\t\t_fnAdjustColumnSizing( settings );\n\t\t}\n\t\n\t\t_fnCallbackFire( settings, null, 'plugin-init', [settings, json] );\n\t\t_fnCallbackFire( settings, 'aoInitComplete', 'init', [settings, json] );\n\t}\n\t\n\t\n\tfunction _fnLengthChange ( settings, val )\n\t{\n\t\tvar len = parseInt( val, 10 );\n\t\tsettings._iDisplayLength = len;\n\t\n\t\t_fnLengthOverflow( settings );\n\t\n\t\t// Fire length change event\n\t\t_fnCallbackFire( settings, null, 'length', [settings, len] );\n\t}\n\t\n\t\n\t/**\n\t * Generate the node required for user display length changing\n\t *  @param {object} settings dataTables settings object\n\t *  @returns {node} Display length feature node\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFeatureHtmlLength ( settings )\n\t{\n\t\tvar\n\t\t\tclasses  = settings.oClasses,\n\t\t\ttableId  = settings.sTableId,\n\t\t\tmenu     = settings.aLengthMenu,\n\t\t\td2       = Array.isArray( menu[0] ),\n\t\t\tlengths  = d2 ? menu[0] : menu,\n\t\t\tlanguage = d2 ? menu[1] : menu;\n\t\n\t\tvar select = $('<select/>', {\n\t\t\t'name':          tableId+'_length',\n\t\t\t'aria-controls': tableId,\n\t\t\t'class':         classes.sLengthSelect\n\t\t} );\n\t\n\t\tfor ( var i=0, ien=lengths.length ; i<ien ; i++ ) {\n\t\t\tselect[0][ i ] = new Option(\n\t\t\t\ttypeof language[i] === 'number' ?\n\t\t\t\t\tsettings.fnFormatNumber( language[i] ) :\n\t\t\t\t\tlanguage[i],\n\t\t\t\tlengths[i]\n\t\t\t);\n\t\t}\n\t\n\t\tvar div = $('<div><label/></div>').addClass( classes.sLength );\n\t\tif ( ! settings.aanFeatures.l ) {\n\t\t\tdiv[0].id = tableId+'_length';\n\t\t}\n\t\n\t\tdiv.children().append(\n\t\t\tsettings.oLanguage.sLengthMenu.replace( '_MENU_', select[0].outerHTML )\n\t\t);\n\t\n\t\t// Can't use `select` variable as user might provide their own and the\n\t\t// reference is broken by the use of outerHTML\n\t\t$('select', div)\n\t\t\t.val( settings._iDisplayLength )\n\t\t\t.on( 'change.DT', function(e) {\n\t\t\t\t_fnLengthChange( settings, $(this).val() );\n\t\t\t\t_fnDraw( settings );\n\t\t\t} );\n\t\n\t\t// Update node value whenever anything changes the table's length\n\t\t$(settings.nTable).on( 'length.dt.DT', function (e, s, len) {\n\t\t\tif ( settings === s ) {\n\t\t\t\t$('select', div).val( len );\n\t\t\t}\n\t\t} );\n\t\n\t\treturn div[0];\n\t}\n\t\n\t\n\t\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Note that most of the paging logic is done in\n\t * DataTable.ext.pager\n\t */\n\t\n\t/**\n\t * Generate the node required for default pagination\n\t *  @param {object} oSettings dataTables settings object\n\t *  @returns {node} Pagination feature node\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFeatureHtmlPaginate ( settings )\n\t{\n\t\tvar\n\t\t\ttype   = settings.sPaginationType,\n\t\t\tplugin = DataTable.ext.pager[ type ],\n\t\t\tmodern = typeof plugin === 'function',\n\t\t\tredraw = function( settings ) {\n\t\t\t\t_fnDraw( settings );\n\t\t\t},\n\t\t\tnode = $('<div/>').addClass( settings.oClasses.sPaging + type )[0],\n\t\t\tfeatures = settings.aanFeatures;\n\t\n\t\tif ( ! modern ) {\n\t\t\tplugin.fnInit( settings, node, redraw );\n\t\t}\n\t\n\t\t/* Add a draw callback for the pagination on first instance, to update the paging display */\n\t\tif ( ! features.p )\n\t\t{\n\t\t\tnode.id = settings.sTableId+'_paginate';\n\t\n\t\t\tsettings.aoDrawCallback.push( {\n\t\t\t\t\"fn\": function( settings ) {\n\t\t\t\t\tif ( modern ) {\n\t\t\t\t\t\tvar\n\t\t\t\t\t\t\tstart      = settings._iDisplayStart,\n\t\t\t\t\t\t\tlen        = settings._iDisplayLength,\n\t\t\t\t\t\t\tvisRecords = settings.fnRecordsDisplay(),\n\t\t\t\t\t\t\tall        = len === -1,\n\t\t\t\t\t\t\tpage = all ? 0 : Math.ceil( start / len ),\n\t\t\t\t\t\t\tpages = all ? 1 : Math.ceil( visRecords / len ),\n\t\t\t\t\t\t\tbuttons = plugin(page, pages),\n\t\t\t\t\t\t\ti, ien;\n\t\n\t\t\t\t\t\tfor ( i=0, ien=features.p.length ; i<ien ; i++ ) {\n\t\t\t\t\t\t\t_fnRenderer( settings, 'pageButton' )(\n\t\t\t\t\t\t\t\tsettings, features.p[i], i, buttons, page, pages\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tplugin.fnUpdate( settings, redraw );\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\t\"sName\": \"pagination\"\n\t\t\t} );\n\t\t}\n\t\n\t\treturn node;\n\t}\n\t\n\t\n\t/**\n\t * Alter the display settings to change the page\n\t *  @param {object} settings DataTables settings object\n\t *  @param {string|int} action Paging action to take: \"first\", \"previous\",\n\t *    \"next\" or \"last\" or page number to jump to (integer)\n\t *  @param [bool] redraw Automatically draw the update or not\n\t *  @returns {bool} true page has changed, false - no change\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnPageChange ( settings, action, redraw )\n\t{\n\t\tvar\n\t\t\tstart     = settings._iDisplayStart,\n\t\t\tlen       = settings._iDisplayLength,\n\t\t\trecords   = settings.fnRecordsDisplay();\n\t\n\t\tif ( records === 0 || len === -1 )\n\t\t{\n\t\t\tstart = 0;\n\t\t}\n\t\telse if ( typeof action === \"number\" )\n\t\t{\n\t\t\tstart = action * len;\n\t\n\t\t\tif ( start > records )\n\t\t\t{\n\t\t\t\tstart = 0;\n\t\t\t}\n\t\t}\n\t\telse if ( action == \"first\" )\n\t\t{\n\t\t\tstart = 0;\n\t\t}\n\t\telse if ( action == \"previous\" )\n\t\t{\n\t\t\tstart = len >= 0 ?\n\t\t\t\tstart - len :\n\t\t\t\t0;\n\t\n\t\t\tif ( start < 0 )\n\t\t\t{\n\t\t\t  start = 0;\n\t\t\t}\n\t\t}\n\t\telse if ( action == \"next\" )\n\t\t{\n\t\t\tif ( start + len < records )\n\t\t\t{\n\t\t\t\tstart += len;\n\t\t\t}\n\t\t}\n\t\telse if ( action == \"last\" )\n\t\t{\n\t\t\tstart = Math.floor( (records-1) / len) * len;\n\t\t}\n\t\telse\n\t\t{\n\t\t\t_fnLog( settings, 0, \"Unknown paging action: \"+action, 5 );\n\t\t}\n\t\n\t\tvar changed = settings._iDisplayStart !== start;\n\t\tsettings._iDisplayStart = start;\n\t\n\t\tif ( changed ) {\n\t\t\t_fnCallbackFire( settings, null, 'page', [settings] );\n\t\n\t\t\tif ( redraw ) {\n\t\t\t\t_fnDraw( settings );\n\t\t\t}\n\t\t}\n\t\n\t\treturn changed;\n\t}\n\t\n\t\n\t\n\t/**\n\t * Generate the node required for the processing node\n\t *  @param {object} settings dataTables settings object\n\t *  @returns {node} Processing element\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFeatureHtmlProcessing ( settings )\n\t{\n\t\treturn $('<div/>', {\n\t\t\t\t'id': ! settings.aanFeatures.r ? settings.sTableId+'_processing' : null,\n\t\t\t\t'class': settings.oClasses.sProcessing\n\t\t\t} )\n\t\t\t.html( settings.oLanguage.sProcessing )\n\t\t\t.append('<div><div></div><div></div><div></div><div></div></div>')\n\t\t\t.insertBefore( settings.nTable )[0];\n\t}\n\t\n\t\n\t/**\n\t * Display or hide the processing indicator\n\t *  @param {object} settings dataTables settings object\n\t *  @param {bool} show Show the processing indicator (true) or not (false)\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnProcessingDisplay ( settings, show )\n\t{\n\t\tif ( settings.oFeatures.bProcessing ) {\n\t\t\t$(settings.aanFeatures.r).css( 'display', show ? 'block' : 'none' );\n\t\t}\n\t\n\t\t_fnCallbackFire( settings, null, 'processing', [settings, show] );\n\t}\n\t\n\t/**\n\t * Add any control elements for the table - specifically scrolling\n\t *  @param {object} settings dataTables settings object\n\t *  @returns {node} Node to add to the DOM\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnFeatureHtmlTable ( settings )\n\t{\n\t\tvar table = $(settings.nTable);\n\t\n\t\t// Scrolling from here on in\n\t\tvar scroll = settings.oScroll;\n\t\n\t\tif ( scroll.sX === '' && scroll.sY === '' ) {\n\t\t\treturn settings.nTable;\n\t\t}\n\t\n\t\tvar scrollX = scroll.sX;\n\t\tvar scrollY = scroll.sY;\n\t\tvar classes = settings.oClasses;\n\t\tvar caption = table.children('caption');\n\t\tvar captionSide = caption.length ? caption[0]._captionSide : null;\n\t\tvar headerClone = $( table[0].cloneNode(false) );\n\t\tvar footerClone = $( table[0].cloneNode(false) );\n\t\tvar footer = table.children('tfoot');\n\t\tvar _div = '<div/>';\n\t\tvar size = function ( s ) {\n\t\t\treturn !s ? null : _fnStringToCss( s );\n\t\t};\n\t\n\t\tif ( ! footer.length ) {\n\t\t\tfooter = null;\n\t\t}\n\t\n\t\t/*\n\t\t * The HTML structure that we want to generate in this function is:\n\t\t *  div - scroller\n\t\t *    div - scroll head\n\t\t *      div - scroll head inner\n\t\t *        table - scroll head table\n\t\t *          thead - thead\n\t\t *    div - scroll body\n\t\t *      table - table (master table)\n\t\t *        thead - thead clone for sizing\n\t\t *        tbody - tbody\n\t\t *    div - scroll foot\n\t\t *      div - scroll foot inner\n\t\t *        table - scroll foot table\n\t\t *          tfoot - tfoot\n\t\t */\n\t\tvar scroller = $( _div, { 'class': classes.sScrollWrapper } )\n\t\t\t.append(\n\t\t\t\t$(_div, { 'class': classes.sScrollHead } )\n\t\t\t\t\t.css( {\n\t\t\t\t\t\toverflow: 'hidden',\n\t\t\t\t\t\tposition: 'relative',\n\t\t\t\t\t\tborder: 0,\n\t\t\t\t\t\twidth: scrollX ? size(scrollX) : '100%'\n\t\t\t\t\t} )\n\t\t\t\t\t.append(\n\t\t\t\t\t\t$(_div, { 'class': classes.sScrollHeadInner } )\n\t\t\t\t\t\t\t.css( {\n\t\t\t\t\t\t\t\t'box-sizing': 'content-box',\n\t\t\t\t\t\t\t\twidth: scroll.sXInner || '100%'\n\t\t\t\t\t\t\t} )\n\t\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\t\theaderClone\n\t\t\t\t\t\t\t\t\t.removeAttr('id')\n\t\t\t\t\t\t\t\t\t.css( 'margin-left', 0 )\n\t\t\t\t\t\t\t\t\t.append( captionSide === 'top' ? caption : null )\n\t\t\t\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\t\t\t\ttable.children('thead')\n\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t)\n\t\t\t\t\t)\n\t\t\t)\n\t\t\t.append(\n\t\t\t\t$(_div, { 'class': classes.sScrollBody } )\n\t\t\t\t\t.css( {\n\t\t\t\t\t\tposition: 'relative',\n\t\t\t\t\t\toverflow: 'auto',\n\t\t\t\t\t\twidth: size( scrollX )\n\t\t\t\t\t} )\n\t\t\t\t\t.append( table )\n\t\t\t);\n\t\n\t\tif ( footer ) {\n\t\t\tscroller.append(\n\t\t\t\t$(_div, { 'class': classes.sScrollFoot } )\n\t\t\t\t\t.css( {\n\t\t\t\t\t\toverflow: 'hidden',\n\t\t\t\t\t\tborder: 0,\n\t\t\t\t\t\twidth: scrollX ? size(scrollX) : '100%'\n\t\t\t\t\t} )\n\t\t\t\t\t.append(\n\t\t\t\t\t\t$(_div, { 'class': classes.sScrollFootInner } )\n\t\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\t\tfooterClone\n\t\t\t\t\t\t\t\t\t.removeAttr('id')\n\t\t\t\t\t\t\t\t\t.css( 'margin-left', 0 )\n\t\t\t\t\t\t\t\t\t.append( captionSide === 'bottom' ? caption : null )\n\t\t\t\t\t\t\t\t\t.append(\n\t\t\t\t\t\t\t\t\t\ttable.children('tfoot')\n\t\t\t\t\t\t\t\t\t)\n\t\t\t\t\t\t\t)\n\t\t\t\t\t)\n\t\t\t);\n\t\t}\n\t\n\t\tvar children = scroller.children();\n\t\tvar scrollHead = children[0];\n\t\tvar scrollBody = children[1];\n\t\tvar scrollFoot = footer ? children[2] : null;\n\t\n\t\t// When the body is scrolled, then we also want to scroll the headers\n\t\tif ( scrollX ) {\n\t\t\t$(scrollBody).on( 'scroll.DT', function (e) {\n\t\t\t\tvar scrollLeft = this.scrollLeft;\n\t\n\t\t\t\tscrollHead.scrollLeft = scrollLeft;\n\t\n\t\t\t\tif ( footer ) {\n\t\t\t\t\tscrollFoot.scrollLeft = scrollLeft;\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\t\n\t\t$(scrollBody).css('max-height', scrollY);\n\t\tif (! scroll.bCollapse) {\n\t\t\t$(scrollBody).css('height', scrollY);\n\t\t}\n\t\n\t\tsettings.nScrollHead = scrollHead;\n\t\tsettings.nScrollBody = scrollBody;\n\t\tsettings.nScrollFoot = scrollFoot;\n\t\n\t\t// On redraw - align columns\n\t\tsettings.aoDrawCallback.push( {\n\t\t\t\"fn\": _fnScrollDraw,\n\t\t\t\"sName\": \"scrolling\"\n\t\t} );\n\t\n\t\treturn scroller[0];\n\t}\n\t\n\t\n\t\n\t/**\n\t * Update the header, footer and body tables for resizing - i.e. column\n\t * alignment.\n\t *\n\t * Welcome to the most horrible function DataTables. The process that this\n\t * function follows is basically:\n\t *   1. Re-create the table inside the scrolling div\n\t *   2. Take live measurements from the DOM\n\t *   3. Apply the measurements to align the columns\n\t *   4. Clean up\n\t *\n\t *  @param {object} settings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnScrollDraw ( settings )\n\t{\n\t\t// Given that this is such a monster function, a lot of variables are use\n\t\t// to try and keep the minimised size as small as possible\n\t\tvar\n\t\t\tscroll         = settings.oScroll,\n\t\t\tscrollX        = scroll.sX,\n\t\t\tscrollXInner   = scroll.sXInner,\n\t\t\tscrollY        = scroll.sY,\n\t\t\tbarWidth       = scroll.iBarWidth,\n\t\t\tdivHeader      = $(settings.nScrollHead),\n\t\t\tdivHeaderStyle = divHeader[0].style,\n\t\t\tdivHeaderInner = divHeader.children('div'),\n\t\t\tdivHeaderInnerStyle = divHeaderInner[0].style,\n\t\t\tdivHeaderTable = divHeaderInner.children('table'),\n\t\t\tdivBodyEl      = settings.nScrollBody,\n\t\t\tdivBody        = $(divBodyEl),\n\t\t\tdivBodyStyle   = divBodyEl.style,\n\t\t\tdivFooter      = $(settings.nScrollFoot),\n\t\t\tdivFooterInner = divFooter.children('div'),\n\t\t\tdivFooterTable = divFooterInner.children('table'),\n\t\t\theader         = $(settings.nTHead),\n\t\t\ttable          = $(settings.nTable),\n\t\t\ttableEl        = table[0],\n\t\t\ttableStyle     = tableEl.style,\n\t\t\tfooter         = settings.nTFoot ? $(settings.nTFoot) : null,\n\t\t\tbrowser        = settings.oBrowser,\n\t\t\tie67           = browser.bScrollOversize,\n\t\t\tdtHeaderCells  = _pluck( settings.aoColumns, 'nTh' ),\n\t\t\theaderTrgEls, footerTrgEls,\n\t\t\theaderSrcEls, footerSrcEls,\n\t\t\theaderCopy, footerCopy,\n\t\t\theaderWidths=[], footerWidths=[],\n\t\t\theaderContent=[], footerContent=[],\n\t\t\tidx, correction, sanityWidth,\n\t\t\tzeroOut = function(nSizer) {\n\t\t\t\tvar style = nSizer.style;\n\t\t\t\tstyle.paddingTop = \"0\";\n\t\t\t\tstyle.paddingBottom = \"0\";\n\t\t\t\tstyle.borderTopWidth = \"0\";\n\t\t\t\tstyle.borderBottomWidth = \"0\";\n\t\t\t\tstyle.height = 0;\n\t\t\t};\n\t\n\t\t// If the scrollbar visibility has changed from the last draw, we need to\n\t\t// adjust the column sizes as the table width will have changed to account\n\t\t// for the scrollbar\n\t\tvar scrollBarVis = divBodyEl.scrollHeight > divBodyEl.clientHeight;\n\t\t\n\t\tif ( settings.scrollBarVis !== scrollBarVis && settings.scrollBarVis !== undefined ) {\n\t\t\tsettings.scrollBarVis = scrollBarVis;\n\t\t\t_fnAdjustColumnSizing( settings );\n\t\t\treturn; // adjust column sizing will call this function again\n\t\t}\n\t\telse {\n\t\t\tsettings.scrollBarVis = scrollBarVis;\n\t\t}\n\t\n\t\t/*\n\t\t * 1. Re-create the table inside the scrolling div\n\t\t */\n\t\n\t\t// Remove the old minimised thead and tfoot elements in the inner table\n\t\ttable.children('thead, tfoot').remove();\n\t\n\t\tif ( footer ) {\n\t\t\tfooterCopy = footer.clone().prependTo( table );\n\t\t\tfooterTrgEls = footer.find('tr'); // the original tfoot is in its own table and must be sized\n\t\t\tfooterSrcEls = footerCopy.find('tr');\n\t\t\tfooterCopy.find('[id]').removeAttr('id');\n\t\t}\n\t\n\t\t// Clone the current header and footer elements and then place it into the inner table\n\t\theaderCopy = header.clone().prependTo( table );\n\t\theaderTrgEls = header.find('tr'); // original header is in its own table\n\t\theaderSrcEls = headerCopy.find('tr');\n\t\theaderCopy.find('th, td').removeAttr('tabindex');\n\t\theaderCopy.find('[id]').removeAttr('id');\n\t\n\t\n\t\t/*\n\t\t * 2. Take live measurements from the DOM - do not alter the DOM itself!\n\t\t */\n\t\n\t\t// Remove old sizing and apply the calculated column widths\n\t\t// Get the unique column headers in the newly created (cloned) header. We want to apply the\n\t\t// calculated sizes to this header\n\t\tif ( ! scrollX )\n\t\t{\n\t\t\tdivBodyStyle.width = '100%';\n\t\t\tdivHeader[0].style.width = '100%';\n\t\t}\n\t\n\t\t$.each( _fnGetUniqueThs( settings, headerCopy ), function ( i, el ) {\n\t\t\tidx = _fnVisibleToColumnIndex( settings, i );\n\t\t\tel.style.width = settings.aoColumns[idx].sWidth;\n\t\t} );\n\t\n\t\tif ( footer ) {\n\t\t\t_fnApplyToChildren( function(n) {\n\t\t\t\tn.style.width = \"\";\n\t\t\t}, footerSrcEls );\n\t\t}\n\t\n\t\t// Size the table as a whole\n\t\tsanityWidth = table.outerWidth();\n\t\tif ( scrollX === \"\" ) {\n\t\t\t// No x scrolling\n\t\t\ttableStyle.width = \"100%\";\n\t\n\t\t\t// IE7 will make the width of the table when 100% include the scrollbar\n\t\t\t// - which is shouldn't. When there is a scrollbar we need to take this\n\t\t\t// into account.\n\t\t\tif ( ie67 && (table.find('tbody').height() > divBodyEl.offsetHeight ||\n\t\t\t\tdivBody.css('overflow-y') == \"scroll\")\n\t\t\t) {\n\t\t\t\ttableStyle.width = _fnStringToCss( table.outerWidth() - barWidth);\n\t\t\t}\n\t\n\t\t\t// Recalculate the sanity width\n\t\t\tsanityWidth = table.outerWidth();\n\t\t}\n\t\telse if ( scrollXInner !== \"\" ) {\n\t\t\t// legacy x scroll inner has been given - use it\n\t\t\ttableStyle.width = _fnStringToCss(scrollXInner);\n\t\n\t\t\t// Recalculate the sanity width\n\t\t\tsanityWidth = table.outerWidth();\n\t\t}\n\t\n\t\t// Hidden header should have zero height, so remove padding and borders. Then\n\t\t// set the width based on the real headers\n\t\n\t\t// Apply all styles in one pass\n\t\t_fnApplyToChildren( zeroOut, headerSrcEls );\n\t\n\t\t// Read all widths in next pass\n\t\t_fnApplyToChildren( function(nSizer) {\n\t\t\tvar style = window.getComputedStyle ?\n\t\t\t\twindow.getComputedStyle(nSizer).width :\n\t\t\t\t_fnStringToCss( $(nSizer).width() );\n\t\n\t\t\theaderContent.push( nSizer.innerHTML );\n\t\t\theaderWidths.push( style );\n\t\t}, headerSrcEls );\n\t\n\t\t// Apply all widths in final pass\n\t\t_fnApplyToChildren( function(nToSize, i) {\n\t\t\tnToSize.style.width = headerWidths[i];\n\t\t}, headerTrgEls );\n\t\n\t\t$(headerSrcEls).css('height', 0);\n\t\n\t\t/* Same again with the footer if we have one */\n\t\tif ( footer )\n\t\t{\n\t\t\t_fnApplyToChildren( zeroOut, footerSrcEls );\n\t\n\t\t\t_fnApplyToChildren( function(nSizer) {\n\t\t\t\tfooterContent.push( nSizer.innerHTML );\n\t\t\t\tfooterWidths.push( _fnStringToCss( $(nSizer).css('width') ) );\n\t\t\t}, footerSrcEls );\n\t\n\t\t\t_fnApplyToChildren( function(nToSize, i) {\n\t\t\t\tnToSize.style.width = footerWidths[i];\n\t\t\t}, footerTrgEls );\n\t\n\t\t\t$(footerSrcEls).height(0);\n\t\t}\n\t\n\t\n\t\t/*\n\t\t * 3. Apply the measurements\n\t\t */\n\t\n\t\t// \"Hide\" the header and footer that we used for the sizing. We need to keep\n\t\t// the content of the cell so that the width applied to the header and body\n\t\t// both match, but we want to hide it completely. We want to also fix their\n\t\t// width to what they currently are\n\t\t_fnApplyToChildren( function(nSizer, i) {\n\t\t\tnSizer.innerHTML = '<div class=\"dataTables_sizing\">'+headerContent[i]+'</div>';\n\t\t\tnSizer.childNodes[0].style.height = \"0\";\n\t\t\tnSizer.childNodes[0].style.overflow = \"hidden\";\n\t\t\tnSizer.style.width = headerWidths[i];\n\t\t}, headerSrcEls );\n\t\n\t\tif ( footer )\n\t\t{\n\t\t\t_fnApplyToChildren( function(nSizer, i) {\n\t\t\t\tnSizer.innerHTML = '<div class=\"dataTables_sizing\">'+footerContent[i]+'</div>';\n\t\t\t\tnSizer.childNodes[0].style.height = \"0\";\n\t\t\t\tnSizer.childNodes[0].style.overflow = \"hidden\";\n\t\t\t\tnSizer.style.width = footerWidths[i];\n\t\t\t}, footerSrcEls );\n\t\t}\n\t\n\t\t// Sanity check that the table is of a sensible width. If not then we are going to get\n\t\t// misalignment - try to prevent this by not allowing the table to shrink below its min width\n\t\tif ( Math.round(table.outerWidth()) < Math.round(sanityWidth) )\n\t\t{\n\t\t\t// The min width depends upon if we have a vertical scrollbar visible or not */\n\t\t\tcorrection = ((divBodyEl.scrollHeight > divBodyEl.offsetHeight ||\n\t\t\t\tdivBody.css('overflow-y') == \"scroll\")) ?\n\t\t\t\t\tsanityWidth+barWidth :\n\t\t\t\t\tsanityWidth;\n\t\n\t\t\t// IE6/7 are a law unto themselves...\n\t\t\tif ( ie67 && (divBodyEl.scrollHeight >\n\t\t\t\tdivBodyEl.offsetHeight || divBody.css('overflow-y') == \"scroll\")\n\t\t\t) {\n\t\t\t\ttableStyle.width = _fnStringToCss( correction-barWidth );\n\t\t\t}\n\t\n\t\t\t// And give the user a warning that we've stopped the table getting too small\n\t\t\tif ( scrollX === \"\" || scrollXInner !== \"\" ) {\n\t\t\t\t_fnLog( settings, 1, 'Possible column misalignment', 6 );\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tcorrection = '100%';\n\t\t}\n\t\n\t\t// Apply to the container elements\n\t\tdivBodyStyle.width = _fnStringToCss( correction );\n\t\tdivHeaderStyle.width = _fnStringToCss( correction );\n\t\n\t\tif ( footer ) {\n\t\t\tsettings.nScrollFoot.style.width = _fnStringToCss( correction );\n\t\t}\n\t\n\t\n\t\t/*\n\t\t * 4. Clean up\n\t\t */\n\t\tif ( ! scrollY ) {\n\t\t\t/* IE7< puts a vertical scrollbar in place (when it shouldn't be) due to subtracting\n\t\t\t * the scrollbar height from the visible display, rather than adding it on. We need to\n\t\t\t * set the height in order to sort this. Don't want to do it in any other browsers.\n\t\t\t */\n\t\t\tif ( ie67 ) {\n\t\t\t\tdivBodyStyle.height = _fnStringToCss( tableEl.offsetHeight+barWidth );\n\t\t\t}\n\t\t}\n\t\n\t\t/* Finally set the width's of the header and footer tables */\n\t\tvar iOuterWidth = table.outerWidth();\n\t\tdivHeaderTable[0].style.width = _fnStringToCss( iOuterWidth );\n\t\tdivHeaderInnerStyle.width = _fnStringToCss( iOuterWidth );\n\t\n\t\t// Figure out if there are scrollbar present - if so then we need a the header and footer to\n\t\t// provide a bit more space to allow \"overflow\" scrolling (i.e. past the scrollbar)\n\t\tvar bScrolling = table.height() > divBodyEl.clientHeight || divBody.css('overflow-y') == \"scroll\";\n\t\tvar padding = 'padding' + (browser.bScrollbarLeft ? 'Left' : 'Right' );\n\t\tdivHeaderInnerStyle[ padding ] = bScrolling ? barWidth+\"px\" : \"0px\";\n\t\n\t\tif ( footer ) {\n\t\t\tdivFooterTable[0].style.width = _fnStringToCss( iOuterWidth );\n\t\t\tdivFooterInner[0].style.width = _fnStringToCss( iOuterWidth );\n\t\t\tdivFooterInner[0].style[padding] = bScrolling ? barWidth+\"px\" : \"0px\";\n\t\t}\n\t\n\t\t// Correct DOM ordering for colgroup - comes before the thead\n\t\ttable.children('colgroup').insertBefore( table.children('thead') );\n\t\n\t\t/* Adjust the position of the header in case we loose the y-scrollbar */\n\t\tdivBody.trigger('scroll');\n\t\n\t\t// If sorting or filtering has occurred, jump the scrolling back to the top\n\t\t// only if we aren't holding the position\n\t\tif ( (settings.bSorted || settings.bFiltered) && ! settings._drawHold ) {\n\t\t\tdivBodyEl.scrollTop = 0;\n\t\t}\n\t}\n\t\n\t\n\t\n\t/**\n\t * Apply a given function to the display child nodes of an element array (typically\n\t * TD children of TR rows\n\t *  @param {function} fn Method to apply to the objects\n\t *  @param array {nodes} an1 List of elements to look through for display children\n\t *  @param array {nodes} an2 Another list (identical structure to the first) - optional\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnApplyToChildren( fn, an1, an2 )\n\t{\n\t\tvar index=0, i=0, iLen=an1.length;\n\t\tvar nNode1, nNode2;\n\t\n\t\twhile ( i < iLen ) {\n\t\t\tnNode1 = an1[i].firstChild;\n\t\t\tnNode2 = an2 ? an2[i].firstChild : null;\n\t\n\t\t\twhile ( nNode1 ) {\n\t\t\t\tif ( nNode1.nodeType === 1 ) {\n\t\t\t\t\tif ( an2 ) {\n\t\t\t\t\t\tfn( nNode1, nNode2, index );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tfn( nNode1, index );\n\t\t\t\t\t}\n\t\n\t\t\t\t\tindex++;\n\t\t\t\t}\n\t\n\t\t\t\tnNode1 = nNode1.nextSibling;\n\t\t\t\tnNode2 = an2 ? nNode2.nextSibling : null;\n\t\t\t}\n\t\n\t\t\ti++;\n\t\t}\n\t}\n\t\n\t\n\t\n\tvar __re_html_remove = /<.*?>/g;\n\t\n\t\n\t/**\n\t * Calculate the width of columns for the table\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnCalculateColumnWidths ( oSettings )\n\t{\n\t\tvar\n\t\t\ttable = oSettings.nTable,\n\t\t\tcolumns = oSettings.aoColumns,\n\t\t\tscroll = oSettings.oScroll,\n\t\t\tscrollY = scroll.sY,\n\t\t\tscrollX = scroll.sX,\n\t\t\tscrollXInner = scroll.sXInner,\n\t\t\tcolumnCount = columns.length,\n\t\t\tvisibleColumns = _fnGetColumns( oSettings, 'bVisible' ),\n\t\t\theaderCells = $('th', oSettings.nTHead),\n\t\t\ttableWidthAttr = table.getAttribute('width'), // from DOM element\n\t\t\ttableContainer = table.parentNode,\n\t\t\tuserInputs = false,\n\t\t\ti, column, columnIdx, width, outerWidth,\n\t\t\tbrowser = oSettings.oBrowser,\n\t\t\tie67 = browser.bScrollOversize;\n\t\n\t\tvar styleWidth = table.style.width;\n\t\tif ( styleWidth && styleWidth.indexOf('%') !== -1 ) {\n\t\t\ttableWidthAttr = styleWidth;\n\t\t}\n\t\n\t\t/* Convert any user input sizes into pixel sizes */\n\t\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\t\tcolumn = columns[ visibleColumns[i] ];\n\t\n\t\t\tif ( column.sWidth !== null ) {\n\t\t\t\tcolumn.sWidth = _fnConvertToWidth( column.sWidthOrig, tableContainer );\n\t\n\t\t\t\tuserInputs = true;\n\t\t\t}\n\t\t}\n\t\n\t\t/* If the number of columns in the DOM equals the number that we have to\n\t\t * process in DataTables, then we can use the offsets that are created by\n\t\t * the web- browser. No custom sizes can be set in order for this to happen,\n\t\t * nor scrolling used\n\t\t */\n\t\tif ( ie67 || ! userInputs && ! scrollX && ! scrollY &&\n\t\t     columnCount == _fnVisbleColumns( oSettings ) &&\n\t\t     columnCount == headerCells.length\n\t\t) {\n\t\t\tfor ( i=0 ; i<columnCount ; i++ ) {\n\t\t\t\tvar colIdx = _fnVisibleToColumnIndex( oSettings, i );\n\t\n\t\t\t\tif ( colIdx !== null ) {\n\t\t\t\t\tcolumns[ colIdx ].sWidth = _fnStringToCss( headerCells.eq(i).width() );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\t// Otherwise construct a single row, worst case, table with the widest\n\t\t\t// node in the data, assign any user defined widths, then insert it into\n\t\t\t// the DOM and allow the browser to do all the hard work of calculating\n\t\t\t// table widths\n\t\t\tvar tmpTable = $(table).clone() // don't use cloneNode - IE8 will remove events on the main table\n\t\t\t\t.css( 'visibility', 'hidden' )\n\t\t\t\t.removeAttr( 'id' );\n\t\n\t\t\t// Clean up the table body\n\t\t\ttmpTable.find('tbody tr').remove();\n\t\t\tvar tr = $('<tr/>').appendTo( tmpTable.find('tbody') );\n\t\n\t\t\t// Clone the table header and footer - we can't use the header / footer\n\t\t\t// from the cloned table, since if scrolling is active, the table's\n\t\t\t// real header and footer are contained in different table tags\n\t\t\ttmpTable.find('thead, tfoot').remove();\n\t\t\ttmpTable\n\t\t\t\t.append( $(oSettings.nTHead).clone() )\n\t\t\t\t.append( $(oSettings.nTFoot).clone() );\n\t\n\t\t\t// Remove any assigned widths from the footer (from scrolling)\n\t\t\ttmpTable.find('tfoot th, tfoot td').css('width', '');\n\t\n\t\t\t// Apply custom sizing to the cloned header\n\t\t\theaderCells = _fnGetUniqueThs( oSettings, tmpTable.find('thead')[0] );\n\t\n\t\t\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\t\t\tcolumn = columns[ visibleColumns[i] ];\n\t\n\t\t\t\theaderCells[i].style.width = column.sWidthOrig !== null && column.sWidthOrig !== '' ?\n\t\t\t\t\t_fnStringToCss( column.sWidthOrig ) :\n\t\t\t\t\t'';\n\t\n\t\t\t\t// For scrollX we need to force the column width otherwise the\n\t\t\t\t// browser will collapse it. If this width is smaller than the\n\t\t\t\t// width the column requires, then it will have no effect\n\t\t\t\tif ( column.sWidthOrig && scrollX ) {\n\t\t\t\t\t$( headerCells[i] ).append( $('<div/>').css( {\n\t\t\t\t\t\twidth: column.sWidthOrig,\n\t\t\t\t\t\tmargin: 0,\n\t\t\t\t\t\tpadding: 0,\n\t\t\t\t\t\tborder: 0,\n\t\t\t\t\t\theight: 1\n\t\t\t\t\t} ) );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t// Find the widest cell for each column and put it into the table\n\t\t\tif ( oSettings.aoData.length ) {\n\t\t\t\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\t\t\t\tcolumnIdx = visibleColumns[i];\n\t\t\t\t\tcolumn = columns[ columnIdx ];\n\t\n\t\t\t\t\t$( _fnGetWidestNode( oSettings, columnIdx ) )\n\t\t\t\t\t\t.clone( false )\n\t\t\t\t\t\t.append( column.sContentPadding )\n\t\t\t\t\t\t.appendTo( tr );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t// Tidy the temporary table - remove name attributes so there aren't\n\t\t\t// duplicated in the dom (radio elements for example)\n\t\t\t$('[name]', tmpTable).removeAttr('name');\n\t\n\t\t\t// Table has been built, attach to the document so we can work with it.\n\t\t\t// A holding element is used, positioned at the top of the container\n\t\t\t// with minimal height, so it has no effect on if the container scrolls\n\t\t\t// or not. Otherwise it might trigger scrolling when it actually isn't\n\t\t\t// needed\n\t\t\tvar holder = $('<div/>').css( scrollX || scrollY ?\n\t\t\t\t\t{\n\t\t\t\t\t\tposition: 'absolute',\n\t\t\t\t\t\ttop: 0,\n\t\t\t\t\t\tleft: 0,\n\t\t\t\t\t\theight: 1,\n\t\t\t\t\t\tright: 0,\n\t\t\t\t\t\toverflow: 'hidden'\n\t\t\t\t\t} :\n\t\t\t\t\t{}\n\t\t\t\t)\n\t\t\t\t.append( tmpTable )\n\t\t\t\t.appendTo( tableContainer );\n\t\n\t\t\t// When scrolling (X or Y) we want to set the width of the table as \n\t\t\t// appropriate. However, when not scrolling leave the table width as it\n\t\t\t// is. This results in slightly different, but I think correct behaviour\n\t\t\tif ( scrollX && scrollXInner ) {\n\t\t\t\ttmpTable.width( scrollXInner );\n\t\t\t}\n\t\t\telse if ( scrollX ) {\n\t\t\t\ttmpTable.css( 'width', 'auto' );\n\t\t\t\ttmpTable.removeAttr('width');\n\t\n\t\t\t\t// If there is no width attribute or style, then allow the table to\n\t\t\t\t// collapse\n\t\t\t\tif ( tmpTable.width() < tableContainer.clientWidth && tableWidthAttr ) {\n\t\t\t\t\ttmpTable.width( tableContainer.clientWidth );\n\t\t\t\t}\n\t\t\t}\n\t\t\telse if ( scrollY ) {\n\t\t\t\ttmpTable.width( tableContainer.clientWidth );\n\t\t\t}\n\t\t\telse if ( tableWidthAttr ) {\n\t\t\t\ttmpTable.width( tableWidthAttr );\n\t\t\t}\n\t\n\t\t\t// Get the width of each column in the constructed table - we need to\n\t\t\t// know the inner width (so it can be assigned to the other table's\n\t\t\t// cells) and the outer width so we can calculate the full width of the\n\t\t\t// table. This is safe since DataTables requires a unique cell for each\n\t\t\t// column, but if ever a header can span multiple columns, this will\n\t\t\t// need to be modified.\n\t\t\tvar total = 0;\n\t\t\tfor ( i=0 ; i<visibleColumns.length ; i++ ) {\n\t\t\t\tvar cell = $(headerCells[i]);\n\t\t\t\tvar border = cell.outerWidth() - cell.width();\n\t\n\t\t\t\t// Use getBounding... where possible (not IE8-) because it can give\n\t\t\t\t// sub-pixel accuracy, which we then want to round up!\n\t\t\t\tvar bounding = browser.bBounding ?\n\t\t\t\t\tMath.ceil( headerCells[i].getBoundingClientRect().width ) :\n\t\t\t\t\tcell.outerWidth();\n\t\n\t\t\t\t// Total is tracked to remove any sub-pixel errors as the outerWidth\n\t\t\t\t// of the table might not equal the total given here (IE!).\n\t\t\t\ttotal += bounding;\n\t\n\t\t\t\t// Width for each column to use\n\t\t\t\tcolumns[ visibleColumns[i] ].sWidth = _fnStringToCss( bounding - border );\n\t\t\t}\n\t\n\t\t\ttable.style.width = _fnStringToCss( total );\n\t\n\t\t\t// Finished with the table - ditch it\n\t\t\tholder.remove();\n\t\t}\n\t\n\t\t// If there is a width attr, we want to attach an event listener which\n\t\t// allows the table sizing to automatically adjust when the window is\n\t\t// resized. Use the width attr rather than CSS, since we can't know if the\n\t\t// CSS is a relative value or absolute - DOM read is always px.\n\t\tif ( tableWidthAttr ) {\n\t\t\ttable.style.width = _fnStringToCss( tableWidthAttr );\n\t\t}\n\t\n\t\tif ( (tableWidthAttr || scrollX) && ! oSettings._reszEvt ) {\n\t\t\tvar bindResize = function () {\n\t\t\t\t$(window).on('resize.DT-'+oSettings.sInstance, _fnThrottle( function () {\n\t\t\t\t\t_fnAdjustColumnSizing( oSettings );\n\t\t\t\t} ) );\n\t\t\t};\n\t\n\t\t\t// IE6/7 will crash if we bind a resize event handler on page load.\n\t\t\t// To be removed in 1.11 which drops IE6/7 support\n\t\t\tif ( ie67 ) {\n\t\t\t\tsetTimeout( bindResize, 1000 );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tbindResize();\n\t\t\t}\n\t\n\t\t\toSettings._reszEvt = true;\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Throttle the calls to a function. Arguments and context are maintained for\n\t * the throttled function\n\t *  @param {function} fn Function to be called\n\t *  @param {int} [freq=200] call frequency in mS\n\t *  @returns {function} wrapped function\n\t *  @memberof DataTable#oApi\n\t */\n\tvar _fnThrottle = DataTable.util.throttle;\n\t\n\t\n\t/**\n\t * Convert a CSS unit width to pixels (e.g. 2em)\n\t *  @param {string} width width to be converted\n\t *  @param {node} parent parent to get the with for (required for relative widths) - optional\n\t *  @returns {int} width in pixels\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnConvertToWidth ( width, parent )\n\t{\n\t\tif ( ! width ) {\n\t\t\treturn 0;\n\t\t}\n\t\n\t\tvar n = $('<div/>')\n\t\t\t.css( 'width', _fnStringToCss( width ) )\n\t\t\t.appendTo( parent || document.body );\n\t\n\t\tvar val = n[0].offsetWidth;\n\t\tn.remove();\n\t\n\t\treturn val;\n\t}\n\t\n\t\n\t/**\n\t * Get the widest node\n\t *  @param {object} settings dataTables settings object\n\t *  @param {int} colIdx column of interest\n\t *  @returns {node} widest table node\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnGetWidestNode( settings, colIdx )\n\t{\n\t\tvar idx = _fnGetMaxLenString( settings, colIdx );\n\t\tif ( idx < 0 ) {\n\t\t\treturn null;\n\t\t}\n\t\n\t\tvar data = settings.aoData[ idx ];\n\t\treturn ! data.nTr ? // Might not have been created when deferred rendering\n\t\t\t$('<td/>').html( _fnGetCellData( settings, idx, colIdx, 'display' ) )[0] :\n\t\t\tdata.anCells[ colIdx ];\n\t}\n\t\n\t\n\t/**\n\t * Get the maximum strlen for each data column\n\t *  @param {object} settings dataTables settings object\n\t *  @param {int} colIdx column of interest\n\t *  @returns {string} max string length for each column\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnGetMaxLenString( settings, colIdx )\n\t{\n\t\tvar s, max=-1, maxIdx = -1;\n\t\n\t\tfor ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\t\ts = _fnGetCellData( settings, i, colIdx, 'display' )+'';\n\t\t\ts = s.replace( __re_html_remove, '' );\n\t\t\ts = s.replace( /&nbsp;/g, ' ' );\n\t\n\t\t\tif ( s.length > max ) {\n\t\t\t\tmax = s.length;\n\t\t\t\tmaxIdx = i;\n\t\t\t}\n\t\t}\n\t\n\t\treturn maxIdx;\n\t}\n\t\n\t\n\t/**\n\t * Append a CSS unit (only if required) to a string\n\t *  @param {string} value to css-ify\n\t *  @returns {string} value with css unit\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnStringToCss( s )\n\t{\n\t\tif ( s === null ) {\n\t\t\treturn '0px';\n\t\t}\n\t\n\t\tif ( typeof s == 'number' ) {\n\t\t\treturn s < 0 ?\n\t\t\t\t'0px' :\n\t\t\t\ts+'px';\n\t\t}\n\t\n\t\t// Check it has a unit character already\n\t\treturn s.match(/\\d$/) ?\n\t\t\ts+'px' :\n\t\t\ts;\n\t}\n\t\n\t\n\t\n\tfunction _fnSortFlatten ( settings )\n\t{\n\t\tvar\n\t\t\ti, iLen, k, kLen,\n\t\t\taSort = [],\n\t\t\taiOrig = [],\n\t\t\taoColumns = settings.aoColumns,\n\t\t\taDataSort, iCol, sType, srcCol,\n\t\t\tfixed = settings.aaSortingFixed,\n\t\t\tfixedObj = $.isPlainObject( fixed ),\n\t\t\tnestedSort = [],\n\t\t\tadd = function ( a ) {\n\t\t\t\tif ( a.length && ! Array.isArray( a[0] ) ) {\n\t\t\t\t\t// 1D array\n\t\t\t\t\tnestedSort.push( a );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\t// 2D array\n\t\t\t\t\t$.merge( nestedSort, a );\n\t\t\t\t}\n\t\t\t};\n\t\n\t\t// Build the sort array, with pre-fix and post-fix options if they have been\n\t\t// specified\n\t\tif ( Array.isArray( fixed ) ) {\n\t\t\tadd( fixed );\n\t\t}\n\t\n\t\tif ( fixedObj && fixed.pre ) {\n\t\t\tadd( fixed.pre );\n\t\t}\n\t\n\t\tadd( settings.aaSorting );\n\t\n\t\tif (fixedObj && fixed.post ) {\n\t\t\tadd( fixed.post );\n\t\t}\n\t\n\t\tfor ( i=0 ; i<nestedSort.length ; i++ )\n\t\t{\n\t\t\tsrcCol = nestedSort[i][0];\n\t\t\taDataSort = aoColumns[ srcCol ].aDataSort;\n\t\n\t\t\tfor ( k=0, kLen=aDataSort.length ; k<kLen ; k++ )\n\t\t\t{\n\t\t\t\tiCol = aDataSort[k];\n\t\t\t\tsType = aoColumns[ iCol ].sType || 'string';\n\t\n\t\t\t\tif ( nestedSort[i]._idx === undefined ) {\n\t\t\t\t\tnestedSort[i]._idx = $.inArray( nestedSort[i][1], aoColumns[iCol].asSorting );\n\t\t\t\t}\n\t\n\t\t\t\taSort.push( {\n\t\t\t\t\tsrc:       srcCol,\n\t\t\t\t\tcol:       iCol,\n\t\t\t\t\tdir:       nestedSort[i][1],\n\t\t\t\t\tindex:     nestedSort[i]._idx,\n\t\t\t\t\ttype:      sType,\n\t\t\t\t\tformatter: DataTable.ext.type.order[ sType+\"-pre\" ]\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t\n\t\treturn aSort;\n\t}\n\t\n\t/**\n\t * Change the order of the table\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t *  @todo This really needs split up!\n\t */\n\tfunction _fnSort ( oSettings )\n\t{\n\t\tvar\n\t\t\ti, ien, iLen, j, jLen, k, kLen,\n\t\t\tsDataType, nTh,\n\t\t\taiOrig = [],\n\t\t\toExtSort = DataTable.ext.type.order,\n\t\t\taoData = oSettings.aoData,\n\t\t\taoColumns = oSettings.aoColumns,\n\t\t\taDataSort, data, iCol, sType, oSort,\n\t\t\tformatters = 0,\n\t\t\tsortCol,\n\t\t\tdisplayMaster = oSettings.aiDisplayMaster,\n\t\t\taSort;\n\t\n\t\t// Resolve any column types that are unknown due to addition or invalidation\n\t\t// @todo Can this be moved into a 'data-ready' handler which is called when\n\t\t//   data is going to be used in the table?\n\t\t_fnColumnTypes( oSettings );\n\t\n\t\taSort = _fnSortFlatten( oSettings );\n\t\n\t\tfor ( i=0, ien=aSort.length ; i<ien ; i++ ) {\n\t\t\tsortCol = aSort[i];\n\t\n\t\t\t// Track if we can use the fast sort algorithm\n\t\t\tif ( sortCol.formatter ) {\n\t\t\t\tformatters++;\n\t\t\t}\n\t\n\t\t\t// Load the data needed for the sort, for each cell\n\t\t\t_fnSortData( oSettings, sortCol.col );\n\t\t}\n\t\n\t\t/* No sorting required if server-side or no sorting array */\n\t\tif ( _fnDataSource( oSettings ) != 'ssp' && aSort.length !== 0 )\n\t\t{\n\t\t\t// Create a value - key array of the current row positions such that we can use their\n\t\t\t// current position during the sort, if values match, in order to perform stable sorting\n\t\t\tfor ( i=0, iLen=displayMaster.length ; i<iLen ; i++ ) {\n\t\t\t\taiOrig[ displayMaster[i] ] = i;\n\t\t\t}\n\t\n\t\t\t/* Do the sort - here we want multi-column sorting based on a given data source (column)\n\t\t\t * and sorting function (from oSort) in a certain direction. It's reasonably complex to\n\t\t\t * follow on it's own, but this is what we want (example two column sorting):\n\t\t\t *  fnLocalSorting = function(a,b){\n\t\t\t *    var iTest;\n\t\t\t *    iTest = oSort['string-asc']('data11', 'data12');\n\t\t\t *      if (iTest !== 0)\n\t\t\t *        return iTest;\n\t\t\t *    iTest = oSort['numeric-desc']('data21', 'data22');\n\t\t\t *    if (iTest !== 0)\n\t\t\t *      return iTest;\n\t\t\t *    return oSort['numeric-asc']( aiOrig[a], aiOrig[b] );\n\t\t\t *  }\n\t\t\t * Basically we have a test for each sorting column, if the data in that column is equal,\n\t\t\t * test the next column. If all columns match, then we use a numeric sort on the row\n\t\t\t * positions in the original data array to provide a stable sort.\n\t\t\t *\n\t\t\t * Note - I know it seems excessive to have two sorting methods, but the first is around\n\t\t\t * 15% faster, so the second is only maintained for backwards compatibility with sorting\n\t\t\t * methods which do not have a pre-sort formatting function.\n\t\t\t */\n\t\t\tif ( formatters === aSort.length ) {\n\t\t\t\t// All sort types have formatting functions\n\t\t\t\tdisplayMaster.sort( function ( a, b ) {\n\t\t\t\t\tvar\n\t\t\t\t\t\tx, y, k, test, sort,\n\t\t\t\t\t\tlen=aSort.length,\n\t\t\t\t\t\tdataA = aoData[a]._aSortData,\n\t\t\t\t\t\tdataB = aoData[b]._aSortData;\n\t\n\t\t\t\t\tfor ( k=0 ; k<len ; k++ ) {\n\t\t\t\t\t\tsort = aSort[k];\n\t\n\t\t\t\t\t\tx = dataA[ sort.col ];\n\t\t\t\t\t\ty = dataB[ sort.col ];\n\t\n\t\t\t\t\t\ttest = x<y ? -1 : x>y ? 1 : 0;\n\t\t\t\t\t\tif ( test !== 0 ) {\n\t\t\t\t\t\t\treturn sort.dir === 'asc' ? test : -test;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\n\t\t\t\t\tx = aiOrig[a];\n\t\t\t\t\ty = aiOrig[b];\n\t\t\t\t\treturn x<y ? -1 : x>y ? 1 : 0;\n\t\t\t\t} );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Depreciated - remove in 1.11 (providing a plug-in option)\n\t\t\t\t// Not all sort types have formatting methods, so we have to call their sorting\n\t\t\t\t// methods.\n\t\t\t\tdisplayMaster.sort( function ( a, b ) {\n\t\t\t\t\tvar\n\t\t\t\t\t\tx, y, k, l, test, sort, fn,\n\t\t\t\t\t\tlen=aSort.length,\n\t\t\t\t\t\tdataA = aoData[a]._aSortData,\n\t\t\t\t\t\tdataB = aoData[b]._aSortData;\n\t\n\t\t\t\t\tfor ( k=0 ; k<len ; k++ ) {\n\t\t\t\t\t\tsort = aSort[k];\n\t\n\t\t\t\t\t\tx = dataA[ sort.col ];\n\t\t\t\t\t\ty = dataB[ sort.col ];\n\t\n\t\t\t\t\t\tfn = oExtSort[ sort.type+\"-\"+sort.dir ] || oExtSort[ \"string-\"+sort.dir ];\n\t\t\t\t\t\ttest = fn( x, y );\n\t\t\t\t\t\tif ( test !== 0 ) {\n\t\t\t\t\t\t\treturn test;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\n\t\t\t\t\tx = aiOrig[a];\n\t\t\t\t\ty = aiOrig[b];\n\t\t\t\t\treturn x<y ? -1 : x>y ? 1 : 0;\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t\n\t\t/* Tell the draw function that we have sorted the data */\n\t\toSettings.bSorted = true;\n\t}\n\t\n\t\n\tfunction _fnSortAria ( settings )\n\t{\n\t\tvar label;\n\t\tvar nextSort;\n\t\tvar columns = settings.aoColumns;\n\t\tvar aSort = _fnSortFlatten( settings );\n\t\tvar oAria = settings.oLanguage.oAria;\n\t\n\t\t// ARIA attributes - need to loop all columns, to update all (removing old\n\t\t// attributes as needed)\n\t\tfor ( var i=0, iLen=columns.length ; i<iLen ; i++ )\n\t\t{\n\t\t\tvar col = columns[i];\n\t\t\tvar asSorting = col.asSorting;\n\t\t\tvar sTitle = col.ariaTitle || col.sTitle.replace( /<.*?>/g, \"\" );\n\t\t\tvar th = col.nTh;\n\t\n\t\t\t// IE7 is throwing an error when setting these properties with jQuery's\n\t\t\t// attr() and removeAttr() methods...\n\t\t\tth.removeAttribute('aria-sort');\n\t\n\t\t\t/* In ARIA only the first sorting column can be marked as sorting - no multi-sort option */\n\t\t\tif ( col.bSortable ) {\n\t\t\t\tif ( aSort.length > 0 && aSort[0].col == i ) {\n\t\t\t\t\tth.setAttribute('aria-sort', aSort[0].dir==\"asc\" ? \"ascending\" : \"descending\" );\n\t\t\t\t\tnextSort = asSorting[ aSort[0].index+1 ] || asSorting[0];\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tnextSort = asSorting[0];\n\t\t\t\t}\n\t\n\t\t\t\tlabel = sTitle + ( nextSort === \"asc\" ?\n\t\t\t\t\toAria.sSortAscending :\n\t\t\t\t\toAria.sSortDescending\n\t\t\t\t);\n\t\t\t}\n\t\t\telse {\n\t\t\t\tlabel = sTitle;\n\t\t\t}\n\t\n\t\t\tth.setAttribute('aria-label', label);\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Function to run on user sort request\n\t *  @param {object} settings dataTables settings object\n\t *  @param {node} attachTo node to attach the handler to\n\t *  @param {int} colIdx column sorting index\n\t *  @param {boolean} [append=false] Append the requested sort to the existing\n\t *    sort if true (i.e. multi-column sort)\n\t *  @param {function} [callback] callback function\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnSortListener ( settings, colIdx, append, callback )\n\t{\n\t\tvar col = settings.aoColumns[ colIdx ];\n\t\tvar sorting = settings.aaSorting;\n\t\tvar asSorting = col.asSorting;\n\t\tvar nextSortIdx;\n\t\tvar next = function ( a, overflow ) {\n\t\t\tvar idx = a._idx;\n\t\t\tif ( idx === undefined ) {\n\t\t\t\tidx = $.inArray( a[1], asSorting );\n\t\t\t}\n\t\n\t\t\treturn idx+1 < asSorting.length ?\n\t\t\t\tidx+1 :\n\t\t\t\toverflow ?\n\t\t\t\t\tnull :\n\t\t\t\t\t0;\n\t\t};\n\t\n\t\t// Convert to 2D array if needed\n\t\tif ( typeof sorting[0] === 'number' ) {\n\t\t\tsorting = settings.aaSorting = [ sorting ];\n\t\t}\n\t\n\t\t// If appending the sort then we are multi-column sorting\n\t\tif ( append && settings.oFeatures.bSortMulti ) {\n\t\t\t// Are we already doing some kind of sort on this column?\n\t\t\tvar sortIdx = $.inArray( colIdx, _pluck(sorting, '0') );\n\t\n\t\t\tif ( sortIdx !== -1 ) {\n\t\t\t\t// Yes, modify the sort\n\t\t\t\tnextSortIdx = next( sorting[sortIdx], true );\n\t\n\t\t\t\tif ( nextSortIdx === null && sorting.length === 1 ) {\n\t\t\t\t\tnextSortIdx = 0; // can't remove sorting completely\n\t\t\t\t}\n\t\n\t\t\t\tif ( nextSortIdx === null ) {\n\t\t\t\t\tsorting.splice( sortIdx, 1 );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tsorting[sortIdx][1] = asSorting[ nextSortIdx ];\n\t\t\t\t\tsorting[sortIdx]._idx = nextSortIdx;\n\t\t\t\t}\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// No sort on this column yet\n\t\t\t\tsorting.push( [ colIdx, asSorting[0], 0 ] );\n\t\t\t\tsorting[sorting.length-1]._idx = 0;\n\t\t\t}\n\t\t}\n\t\telse if ( sorting.length && sorting[0][0] == colIdx ) {\n\t\t\t// Single column - already sorting on this column, modify the sort\n\t\t\tnextSortIdx = next( sorting[0] );\n\t\n\t\t\tsorting.length = 1;\n\t\t\tsorting[0][1] = asSorting[ nextSortIdx ];\n\t\t\tsorting[0]._idx = nextSortIdx;\n\t\t}\n\t\telse {\n\t\t\t// Single column - sort only on this column\n\t\t\tsorting.length = 0;\n\t\t\tsorting.push( [ colIdx, asSorting[0] ] );\n\t\t\tsorting[0]._idx = 0;\n\t\t}\n\t\n\t\t// Run the sort by calling a full redraw\n\t\t_fnReDraw( settings );\n\t\n\t\t// callback used for async user interaction\n\t\tif ( typeof callback == 'function' ) {\n\t\t\tcallback( settings );\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Attach a sort handler (click) to a node\n\t *  @param {object} settings dataTables settings object\n\t *  @param {node} attachTo node to attach the handler to\n\t *  @param {int} colIdx column sorting index\n\t *  @param {function} [callback] callback function\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnSortAttachListener ( settings, attachTo, colIdx, callback )\n\t{\n\t\tvar col = settings.aoColumns[ colIdx ];\n\t\n\t\t_fnBindAction( attachTo, {}, function (e) {\n\t\t\t/* If the column is not sortable - don't to anything */\n\t\t\tif ( col.bSortable === false ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\n\t\t\t// If processing is enabled use a timeout to allow the processing\n\t\t\t// display to be shown - otherwise to it synchronously\n\t\t\tif ( settings.oFeatures.bProcessing ) {\n\t\t\t\t_fnProcessingDisplay( settings, true );\n\t\n\t\t\t\tsetTimeout( function() {\n\t\t\t\t\t_fnSortListener( settings, colIdx, e.shiftKey, callback );\n\t\n\t\t\t\t\t// In server-side processing, the draw callback will remove the\n\t\t\t\t\t// processing display\n\t\t\t\t\tif ( _fnDataSource( settings ) !== 'ssp' ) {\n\t\t\t\t\t\t_fnProcessingDisplay( settings, false );\n\t\t\t\t\t}\n\t\t\t\t}, 0 );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t_fnSortListener( settings, colIdx, e.shiftKey, callback );\n\t\t\t}\n\t\t} );\n\t}\n\t\n\t\n\t/**\n\t * Set the sorting classes on table's body, Note: it is safe to call this function\n\t * when bSort and bSortClasses are false\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnSortingClasses( settings )\n\t{\n\t\tvar oldSort = settings.aLastSort;\n\t\tvar sortClass = settings.oClasses.sSortColumn;\n\t\tvar sort = _fnSortFlatten( settings );\n\t\tvar features = settings.oFeatures;\n\t\tvar i, ien, colIdx;\n\t\n\t\tif ( features.bSort && features.bSortClasses ) {\n\t\t\t// Remove old sorting classes\n\t\t\tfor ( i=0, ien=oldSort.length ; i<ien ; i++ ) {\n\t\t\t\tcolIdx = oldSort[i].src;\n\t\n\t\t\t\t// Remove column sorting\n\t\t\t\t$( _pluck( settings.aoData, 'anCells', colIdx ) )\n\t\t\t\t\t.removeClass( sortClass + (i<2 ? i+1 : 3) );\n\t\t\t}\n\t\n\t\t\t// Add new column sorting\n\t\t\tfor ( i=0, ien=sort.length ; i<ien ; i++ ) {\n\t\t\t\tcolIdx = sort[i].src;\n\t\n\t\t\t\t$( _pluck( settings.aoData, 'anCells', colIdx ) )\n\t\t\t\t\t.addClass( sortClass + (i<2 ? i+1 : 3) );\n\t\t\t}\n\t\t}\n\t\n\t\tsettings.aLastSort = sort;\n\t}\n\t\n\t\n\t// Get the data to sort a column, be it from cache, fresh (populating the\n\t// cache), or from a sort formatter\n\tfunction _fnSortData( settings, idx )\n\t{\n\t\t// Custom sorting function - provided by the sort data type\n\t\tvar column = settings.aoColumns[ idx ];\n\t\tvar customSort = DataTable.ext.order[ column.sSortDataType ];\n\t\tvar customData;\n\t\n\t\tif ( customSort ) {\n\t\t\tcustomData = customSort.call( settings.oInstance, settings, idx,\n\t\t\t\t_fnColumnIndexToVisible( settings, idx )\n\t\t\t);\n\t\t}\n\t\n\t\t// Use / populate cache\n\t\tvar row, cellData;\n\t\tvar formatter = DataTable.ext.type.order[ column.sType+\"-pre\" ];\n\t\n\t\tfor ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\t\trow = settings.aoData[i];\n\t\n\t\t\tif ( ! row._aSortData ) {\n\t\t\t\trow._aSortData = [];\n\t\t\t}\n\t\n\t\t\tif ( ! row._aSortData[idx] || customSort ) {\n\t\t\t\tcellData = customSort ?\n\t\t\t\t\tcustomData[i] : // If there was a custom sort function, use data from there\n\t\t\t\t\t_fnGetCellData( settings, i, idx, 'sort' );\n\t\n\t\t\t\trow._aSortData[ idx ] = formatter ?\n\t\t\t\t\tformatter( cellData ) :\n\t\t\t\t\tcellData;\n\t\t\t}\n\t\t}\n\t}\n\t\n\t\n\t\n\t/**\n\t * Save the state of a table\n\t *  @param {object} oSettings dataTables settings object\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnSaveState ( settings )\n\t{\n\t\tif (settings._bLoadingState) {\n\t\t\treturn;\n\t\t}\n\t\n\t\t/* Store the interesting variables */\n\t\tvar state = {\n\t\t\ttime:    +new Date(),\n\t\t\tstart:   settings._iDisplayStart,\n\t\t\tlength:  settings._iDisplayLength,\n\t\t\torder:   $.extend( true, [], settings.aaSorting ),\n\t\t\tsearch:  _fnSearchToCamel( settings.oPreviousSearch ),\n\t\t\tcolumns: $.map( settings.aoColumns, function ( col, i ) {\n\t\t\t\treturn {\n\t\t\t\t\tvisible: col.bVisible,\n\t\t\t\t\tsearch: _fnSearchToCamel( settings.aoPreSearchCols[i] )\n\t\t\t\t};\n\t\t\t} )\n\t\t};\n\t\n\t\tsettings.oSavedState = state;\n\t\t_fnCallbackFire( settings, \"aoStateSaveParams\", 'stateSaveParams', [settings, state] );\n\t\t\n\t\tif ( settings.oFeatures.bStateSave && !settings.bDestroying )\n\t\t{\n\t\t\tsettings.fnStateSaveCallback.call( settings.oInstance, settings, state );\n\t\t}\t\n\t}\n\t\n\t\n\t/**\n\t * Attempt to load a saved table state\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {object} oInit DataTables init object so we can override settings\n\t *  @param {function} callback Callback to execute when the state has been loaded\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnLoadState ( settings, oInit, callback )\n\t{\n\t\tif ( ! settings.oFeatures.bStateSave ) {\n\t\t\tcallback();\n\t\t\treturn;\n\t\t}\n\t\n\t\tvar loaded = function(state) {\n\t\t\t_fnImplementState(settings, state, callback);\n\t\t}\n\t\n\t\tvar state = settings.fnStateLoadCallback.call( settings.oInstance, settings, loaded );\n\t\n\t\tif ( state !== undefined ) {\n\t\t\t_fnImplementState( settings, state, callback );\n\t\t}\n\t\t// otherwise, wait for the loaded callback to be executed\n\t\n\t\treturn true;\n\t}\n\t\n\tfunction _fnImplementState ( settings, s, callback) {\n\t\tvar i, ien;\n\t\tvar columns = settings.aoColumns;\n\t\tsettings._bLoadingState = true;\n\t\n\t\t// When StateRestore was introduced the state could now be implemented at any time\n\t\t// Not just initialisation. To do this an api instance is required in some places\n\t\tvar api = settings._bInitComplete ? new DataTable.Api(settings) : null;\n\t\n\t\tif ( ! s || ! s.time ) {\n\t\t\tsettings._bLoadingState = false;\n\t\t\tcallback();\n\t\t\treturn;\n\t\t}\n\t\n\t\t// Allow custom and plug-in manipulation functions to alter the saved data set and\n\t\t// cancelling of loading by returning false\n\t\tvar abStateLoad = _fnCallbackFire( settings, 'aoStateLoadParams', 'stateLoadParams', [settings, s] );\n\t\tif ( $.inArray( false, abStateLoad ) !== -1 ) {\n\t\t\tsettings._bLoadingState = false;\n\t\t\tcallback();\n\t\t\treturn;\n\t\t}\n\t\n\t\t// Reject old data\n\t\tvar duration = settings.iStateDuration;\n\t\tif ( duration > 0 && s.time < +new Date() - (duration*1000) ) {\n\t\t\tsettings._bLoadingState = false;\n\t\t\tcallback();\n\t\t\treturn;\n\t\t}\n\t\n\t\t// Number of columns have changed - all bets are off, no restore of settings\n\t\tif ( s.columns && columns.length !== s.columns.length ) {\n\t\t\tsettings._bLoadingState = false;\n\t\t\tcallback();\n\t\t\treturn;\n\t\t}\n\t\n\t\t// Store the saved state so it might be accessed at any time\n\t\tsettings.oLoadedState = $.extend( true, {}, s );\n\t\n\t\t// Page Length\n\t\tif ( s.length !== undefined ) {\n\t\t\t// If already initialised just set the value directly so that the select element is also updated\n\t\t\tif (api) {\n\t\t\t\tapi.page.len(s.length)\n\t\t\t}\n\t\t\telse {\n\t\t\t\tsettings._iDisplayLength   = s.length;\n\t\t\t}\n\t\t}\n\t\n\t\t// Restore key features - todo - for 1.11 this needs to be done by\n\t\t// subscribed events\n\t\tif ( s.start !== undefined ) {\n\t\t\tif(api === null) {\n\t\t\t\tsettings._iDisplayStart    = s.start;\n\t\t\t\tsettings.iInitDisplayStart = s.start;\n\t\t\t}\n\t\t\telse {\n\t\t\t\t_fnPageChange(settings, s.start/settings._iDisplayLength);\n\t\t\t}\n\t\t}\n\t\n\t\t// Order\n\t\tif ( s.order !== undefined ) {\n\t\t\tsettings.aaSorting = [];\n\t\t\t$.each( s.order, function ( i, col ) {\n\t\t\t\tsettings.aaSorting.push( col[0] >= columns.length ?\n\t\t\t\t\t[ 0, col[1] ] :\n\t\t\t\t\tcol\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\t\n\t\t// Search\n\t\tif ( s.search !== undefined ) {\n\t\t\t$.extend( settings.oPreviousSearch, _fnSearchToHung( s.search ) );\n\t\t}\n\t\n\t\t// Columns\n\t\tif ( s.columns ) {\n\t\t\tfor ( i=0, ien=s.columns.length ; i<ien ; i++ ) {\n\t\t\t\tvar col = s.columns[i];\n\t\n\t\t\t\t// Visibility\n\t\t\t\tif ( col.visible !== undefined ) {\n\t\t\t\t\t// If the api is defined, the table has been initialised so we need to use it rather than internal settings\n\t\t\t\t\tif (api) {\n\t\t\t\t\t\t// Don't redraw the columns on every iteration of this loop, we will do this at the end instead\n\t\t\t\t\t\tapi.column(i).visible(col.visible, false);\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tcolumns[i].bVisible = col.visible;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\n\t\t\t\t// Search\n\t\t\t\tif ( col.search !== undefined ) {\n\t\t\t\t\t$.extend( settings.aoPreSearchCols[i], _fnSearchToHung( col.search ) );\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t// If the api is defined then we need to adjust the columns once the visibility has been changed\n\t\t\tif (api) {\n\t\t\t\tapi.columns.adjust();\n\t\t\t}\n\t\t}\n\t\n\t\tsettings._bLoadingState = false;\n\t\t_fnCallbackFire( settings, 'aoStateLoaded', 'stateLoaded', [settings, s] );\n\t\tcallback();\n\t};\n\t\n\t\n\t/**\n\t * Return the settings object for a particular table\n\t *  @param {node} table table we are using as a dataTable\n\t *  @returns {object} Settings object - or null if not found\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnSettingsFromNode ( table )\n\t{\n\t\tvar settings = DataTable.settings;\n\t\tvar idx = $.inArray( table, _pluck( settings, 'nTable' ) );\n\t\n\t\treturn idx !== -1 ?\n\t\t\tsettings[ idx ] :\n\t\t\tnull;\n\t}\n\t\n\t\n\t/**\n\t * Log an error message\n\t *  @param {object} settings dataTables settings object\n\t *  @param {int} level log error messages, or display them to the user\n\t *  @param {string} msg error message\n\t *  @param {int} tn Technical note id to get more information about the error.\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnLog( settings, level, msg, tn )\n\t{\n\t\tmsg = 'DataTables warning: '+\n\t\t\t(settings ? 'table id='+settings.sTableId+' - ' : '')+msg;\n\t\n\t\tif ( tn ) {\n\t\t\tmsg += '. For more information about this error, please see '+\n\t\t\t'http://datatables.net/tn/'+tn;\n\t\t}\n\t\n\t\tif ( ! level  ) {\n\t\t\t// Backwards compatibility pre 1.10\n\t\t\tvar ext = DataTable.ext;\n\t\t\tvar type = ext.sErrMode || ext.errMode;\n\t\n\t\t\tif ( settings ) {\n\t\t\t\t_fnCallbackFire( settings, null, 'error', [ settings, tn, msg ] );\n\t\t\t}\n\t\n\t\t\tif ( type == 'alert' ) {\n\t\t\t\talert( msg );\n\t\t\t}\n\t\t\telse if ( type == 'throw' ) {\n\t\t\t\tthrow new Error(msg);\n\t\t\t}\n\t\t\telse if ( typeof type == 'function' ) {\n\t\t\t\ttype( settings, tn, msg );\n\t\t\t}\n\t\t}\n\t\telse if ( window.console && console.log ) {\n\t\t\tconsole.log( msg );\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * See if a property is defined on one object, if so assign it to the other object\n\t *  @param {object} ret target object\n\t *  @param {object} src source object\n\t *  @param {string} name property\n\t *  @param {string} [mappedName] name to map too - optional, name used if not given\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnMap( ret, src, name, mappedName )\n\t{\n\t\tif ( Array.isArray( name ) ) {\n\t\t\t$.each( name, function (i, val) {\n\t\t\t\tif ( Array.isArray( val ) ) {\n\t\t\t\t\t_fnMap( ret, src, val[0], val[1] );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\t_fnMap( ret, src, val );\n\t\t\t\t}\n\t\t\t} );\n\t\n\t\t\treturn;\n\t\t}\n\t\n\t\tif ( mappedName === undefined ) {\n\t\t\tmappedName = name;\n\t\t}\n\t\n\t\tif ( src[name] !== undefined ) {\n\t\t\tret[mappedName] = src[name];\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Extend objects - very similar to jQuery.extend, but deep copy objects, and\n\t * shallow copy arrays. The reason we need to do this, is that we don't want to\n\t * deep copy array init values (such as aaSorting) since the dev wouldn't be\n\t * able to override them, but we do want to deep copy arrays.\n\t *  @param {object} out Object to extend\n\t *  @param {object} extender Object from which the properties will be applied to\n\t *      out\n\t *  @param {boolean} breakRefs If true, then arrays will be sliced to take an\n\t *      independent copy with the exception of the `data` or `aaData` parameters\n\t *      if they are present. This is so you can pass in a collection to\n\t *      DataTables and have that used as your data source without breaking the\n\t *      references\n\t *  @returns {object} out Reference, just for convenience - out === the return.\n\t *  @memberof DataTable#oApi\n\t *  @todo This doesn't take account of arrays inside the deep copied objects.\n\t */\n\tfunction _fnExtend( out, extender, breakRefs )\n\t{\n\t\tvar val;\n\t\n\t\tfor ( var prop in extender ) {\n\t\t\tif ( extender.hasOwnProperty(prop) ) {\n\t\t\t\tval = extender[prop];\n\t\n\t\t\t\tif ( $.isPlainObject( val ) ) {\n\t\t\t\t\tif ( ! $.isPlainObject( out[prop] ) ) {\n\t\t\t\t\t\tout[prop] = {};\n\t\t\t\t\t}\n\t\t\t\t\t$.extend( true, out[prop], val );\n\t\t\t\t}\n\t\t\t\telse if ( breakRefs && prop !== 'data' && prop !== 'aaData' && Array.isArray(val) ) {\n\t\t\t\t\tout[prop] = val.slice();\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tout[prop] = val;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\n\t\treturn out;\n\t}\n\t\n\t\n\t/**\n\t * Bind an event handers to allow a click or return key to activate the callback.\n\t * This is good for accessibility since a return on the keyboard will have the\n\t * same effect as a click, if the element has focus.\n\t *  @param {element} n Element to bind the action to\n\t *  @param {object} oData Data object to pass to the triggered function\n\t *  @param {function} fn Callback function for when the event is triggered\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnBindAction( n, oData, fn )\n\t{\n\t\t$(n)\n\t\t\t.on( 'click.DT', oData, function (e) {\n\t\t\t\t\t$(n).trigger('blur'); // Remove focus outline for mouse users\n\t\t\t\t\tfn(e);\n\t\t\t\t} )\n\t\t\t.on( 'keypress.DT', oData, function (e){\n\t\t\t\t\tif ( e.which === 13 ) {\n\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\tfn(e);\n\t\t\t\t\t}\n\t\t\t\t} )\n\t\t\t.on( 'selectstart.DT', function () {\n\t\t\t\t\t/* Take the brutal approach to cancelling text selection */\n\t\t\t\t\treturn false;\n\t\t\t\t} );\n\t}\n\t\n\t\n\t/**\n\t * Register a callback function. Easily allows a callback function to be added to\n\t * an array store of callback functions that can then all be called together.\n\t *  @param {object} oSettings dataTables settings object\n\t *  @param {string} sStore Name of the array storage for the callbacks in oSettings\n\t *  @param {function} fn Function to be called back\n\t *  @param {string} sName Identifying name for the callback (i.e. a label)\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnCallbackReg( oSettings, sStore, fn, sName )\n\t{\n\t\tif ( fn )\n\t\t{\n\t\t\toSettings[sStore].push( {\n\t\t\t\t\"fn\": fn,\n\t\t\t\t\"sName\": sName\n\t\t\t} );\n\t\t}\n\t}\n\t\n\t\n\t/**\n\t * Fire callback functions and trigger events. Note that the loop over the\n\t * callback array store is done backwards! Further note that you do not want to\n\t * fire off triggers in time sensitive applications (for example cell creation)\n\t * as its slow.\n\t *  @param {object} settings dataTables settings object\n\t *  @param {string} callbackArr Name of the array storage for the callbacks in\n\t *      oSettings\n\t *  @param {string} eventName Name of the jQuery custom event to trigger. If\n\t *      null no trigger is fired\n\t *  @param {array} args Array of arguments to pass to the callback function /\n\t *      trigger\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnCallbackFire( settings, callbackArr, eventName, args )\n\t{\n\t\tvar ret = [];\n\t\n\t\tif ( callbackArr ) {\n\t\t\tret = $.map( settings[callbackArr].slice().reverse(), function (val, i) {\n\t\t\t\treturn val.fn.apply( settings.oInstance, args );\n\t\t\t} );\n\t\t}\n\t\n\t\tif ( eventName !== null ) {\n\t\t\tvar e = $.Event( eventName+'.dt' );\n\t\n\t\t\t$(settings.nTable).trigger( e, args );\n\t\n\t\t\tret.push( e.result );\n\t\t}\n\t\n\t\treturn ret;\n\t}\n\t\n\t\n\tfunction _fnLengthOverflow ( settings )\n\t{\n\t\tvar\n\t\t\tstart = settings._iDisplayStart,\n\t\t\tend = settings.fnDisplayEnd(),\n\t\t\tlen = settings._iDisplayLength;\n\t\n\t\t/* If we have space to show extra rows (backing up from the end point - then do so */\n\t\tif ( start >= end )\n\t\t{\n\t\t\tstart = end - len;\n\t\t}\n\t\n\t\t// Keep the start record on the current page\n\t\tstart -= (start % len);\n\t\n\t\tif ( len === -1 || start < 0 )\n\t\t{\n\t\t\tstart = 0;\n\t\t}\n\t\n\t\tsettings._iDisplayStart = start;\n\t}\n\t\n\t\n\tfunction _fnRenderer( settings, type )\n\t{\n\t\tvar renderer = settings.renderer;\n\t\tvar host = DataTable.ext.renderer[type];\n\t\n\t\tif ( $.isPlainObject( renderer ) && renderer[type] ) {\n\t\t\t// Specific renderer for this type. If available use it, otherwise use\n\t\t\t// the default.\n\t\t\treturn host[renderer[type]] || host._;\n\t\t}\n\t\telse if ( typeof renderer === 'string' ) {\n\t\t\t// Common renderer - if there is one available for this type use it,\n\t\t\t// otherwise use the default\n\t\t\treturn host[renderer] || host._;\n\t\t}\n\t\n\t\t// Use the default\n\t\treturn host._;\n\t}\n\t\n\t\n\t/**\n\t * Detect the data source being used for the table. Used to simplify the code\n\t * a little (ajax) and to make it compress a little smaller.\n\t *\n\t *  @param {object} settings dataTables settings object\n\t *  @returns {string} Data source\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnDataSource ( settings )\n\t{\n\t\tif ( settings.oFeatures.bServerSide ) {\n\t\t\treturn 'ssp';\n\t\t}\n\t\telse if ( settings.ajax || settings.sAjaxSource ) {\n\t\t\treturn 'ajax';\n\t\t}\n\t\treturn 'dom';\n\t}\n\t\n\t\n\t\n\t\n\t/**\n\t * Computed structure of the DataTables API, defined by the options passed to\n\t * `DataTable.Api.register()` when building the API.\n\t *\n\t * The structure is built in order to speed creation and extension of the Api\n\t * objects since the extensions are effectively pre-parsed.\n\t *\n\t * The array is an array of objects with the following structure, where this\n\t * base array represents the Api prototype base:\n\t *\n\t *     [\n\t *       {\n\t *         name:      'data'                -- string   - Property name\n\t *         val:       function () {},       -- function - Api method (or undefined if just an object\n\t *         methodExt: [ ... ],              -- array    - Array of Api object definitions to extend the method result\n\t *         propExt:   [ ... ]               -- array    - Array of Api object definitions to extend the property\n\t *       },\n\t *       {\n\t *         name:     'row'\n\t *         val:       {},\n\t *         methodExt: [ ... ],\n\t *         propExt:   [\n\t *           {\n\t *             name:      'data'\n\t *             val:       function () {},\n\t *             methodExt: [ ... ],\n\t *             propExt:   [ ... ]\n\t *           },\n\t *           ...\n\t *         ]\n\t *       }\n\t *     ]\n\t *\n\t * @type {Array}\n\t * @ignore\n\t */\n\tvar __apiStruct = [];\n\t\n\t\n\t/**\n\t * `Array.prototype` reference.\n\t *\n\t * @type object\n\t * @ignore\n\t */\n\tvar __arrayProto = Array.prototype;\n\t\n\t\n\t/**\n\t * Abstraction for `context` parameter of the `Api` constructor to allow it to\n\t * take several different forms for ease of use.\n\t *\n\t * Each of the input parameter types will be converted to a DataTables settings\n\t * object where possible.\n\t *\n\t * @param  {string|node|jQuery|object} mixed DataTable identifier. Can be one\n\t *   of:\n\t *\n\t *   * `string` - jQuery selector. Any DataTables' matching the given selector\n\t *     with be found and used.\n\t *   * `node` - `TABLE` node which has already been formed into a DataTable.\n\t *   * `jQuery` - A jQuery object of `TABLE` nodes.\n\t *   * `object` - DataTables settings object\n\t *   * `DataTables.Api` - API instance\n\t * @return {array|null} Matching DataTables settings objects. `null` or\n\t *   `undefined` is returned if no matching DataTable is found.\n\t * @ignore\n\t */\n\tvar _toSettings = function ( mixed )\n\t{\n\t\tvar idx, jq;\n\t\tvar settings = DataTable.settings;\n\t\tvar tables = $.map( settings, function (el, i) {\n\t\t\treturn el.nTable;\n\t\t} );\n\t\n\t\tif ( ! mixed ) {\n\t\t\treturn [];\n\t\t}\n\t\telse if ( mixed.nTable && mixed.oApi ) {\n\t\t\t// DataTables settings object\n\t\t\treturn [ mixed ];\n\t\t}\n\t\telse if ( mixed.nodeName && mixed.nodeName.toLowerCase() === 'table' ) {\n\t\t\t// Table node\n\t\t\tidx = $.inArray( mixed, tables );\n\t\t\treturn idx !== -1 ? [ settings[idx] ] : null;\n\t\t}\n\t\telse if ( mixed && typeof mixed.settings === 'function' ) {\n\t\t\treturn mixed.settings().toArray();\n\t\t}\n\t\telse if ( typeof mixed === 'string' ) {\n\t\t\t// jQuery selector\n\t\t\tjq = $(mixed);\n\t\t}\n\t\telse if ( mixed instanceof $ ) {\n\t\t\t// jQuery object (also DataTables instance)\n\t\t\tjq = mixed;\n\t\t}\n\t\n\t\tif ( jq ) {\n\t\t\treturn jq.map( function(i) {\n\t\t\t\tidx = $.inArray( this, tables );\n\t\t\t\treturn idx !== -1 ? settings[idx] : null;\n\t\t\t} ).toArray();\n\t\t}\n\t};\n\t\n\t\n\t/**\n\t * DataTables API class - used to control and interface with  one or more\n\t * DataTables enhanced tables.\n\t *\n\t * The API class is heavily based on jQuery, presenting a chainable interface\n\t * that you can use to interact with tables. Each instance of the API class has\n\t * a \"context\" - i.e. the tables that it will operate on. This could be a single\n\t * table, all tables on a page or a sub-set thereof.\n\t *\n\t * Additionally the API is designed to allow you to easily work with the data in\n\t * the tables, retrieving and manipulating it as required. This is done by\n\t * presenting the API class as an array like interface. The contents of the\n\t * array depend upon the actions requested by each method (for example\n\t * `rows().nodes()` will return an array of nodes, while `rows().data()` will\n\t * return an array of objects or arrays depending upon your table's\n\t * configuration). The API object has a number of array like methods (`push`,\n\t * `pop`, `reverse` etc) as well as additional helper methods (`each`, `pluck`,\n\t * `unique` etc) to assist your working with the data held in a table.\n\t *\n\t * Most methods (those which return an Api instance) are chainable, which means\n\t * the return from a method call also has all of the methods available that the\n\t * top level object had. For example, these two calls are equivalent:\n\t *\n\t *     // Not chained\n\t *     api.row.add( {...} );\n\t *     api.draw();\n\t *\n\t *     // Chained\n\t *     api.row.add( {...} ).draw();\n\t *\n\t * @class DataTable.Api\n\t * @param {array|object|string|jQuery} context DataTable identifier. This is\n\t *   used to define which DataTables enhanced tables this API will operate on.\n\t *   Can be one of:\n\t *\n\t *   * `string` - jQuery selector. Any DataTables' matching the given selector\n\t *     with be found and used.\n\t *   * `node` - `TABLE` node which has already been formed into a DataTable.\n\t *   * `jQuery` - A jQuery object of `TABLE` nodes.\n\t *   * `object` - DataTables settings object\n\t * @param {array} [data] Data to initialise the Api instance with.\n\t *\n\t * @example\n\t *   // Direct initialisation during DataTables construction\n\t *   var api = $('#example').DataTable();\n\t *\n\t * @example\n\t *   // Initialisation using a DataTables jQuery object\n\t *   var api = $('#example').dataTable().api();\n\t *\n\t * @example\n\t *   // Initialisation as a constructor\n\t *   var api = new $.fn.DataTable.Api( 'table.dataTable' );\n\t */\n\t_Api = function ( context, data )\n\t{\n\t\tif ( ! (this instanceof _Api) ) {\n\t\t\treturn new _Api( context, data );\n\t\t}\n\t\n\t\tvar settings = [];\n\t\tvar ctxSettings = function ( o ) {\n\t\t\tvar a = _toSettings( o );\n\t\t\tif ( a ) {\n\t\t\t\tsettings.push.apply( settings, a );\n\t\t\t}\n\t\t};\n\t\n\t\tif ( Array.isArray( context ) ) {\n\t\t\tfor ( var i=0, ien=context.length ; i<ien ; i++ ) {\n\t\t\t\tctxSettings( context[i] );\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tctxSettings( context );\n\t\t}\n\t\n\t\t// Remove duplicates\n\t\tthis.context = _unique( settings );\n\t\n\t\t// Initial data\n\t\tif ( data ) {\n\t\t\t$.merge( this, data );\n\t\t}\n\t\n\t\t// selector\n\t\tthis.selector = {\n\t\t\trows: null,\n\t\t\tcols: null,\n\t\t\topts: null\n\t\t};\n\t\n\t\t_Api.extend( this, this, __apiStruct );\n\t};\n\t\n\tDataTable.Api = _Api;\n\t\n\t// Don't destroy the existing prototype, just extend it. Required for jQuery 2's\n\t// isPlainObject.\n\t$.extend( _Api.prototype, {\n\t\tany: function ()\n\t\t{\n\t\t\treturn this.count() !== 0;\n\t\t},\n\t\n\t\n\t\tconcat:  __arrayProto.concat,\n\t\n\t\n\t\tcontext: [], // array of table settings objects\n\t\n\t\n\t\tcount: function ()\n\t\t{\n\t\t\treturn this.flatten().length;\n\t\t},\n\t\n\t\n\t\teach: function ( fn )\n\t\t{\n\t\t\tfor ( var i=0, ien=this.length ; i<ien; i++ ) {\n\t\t\t\tfn.call( this, this[i], i, this );\n\t\t\t}\n\t\n\t\t\treturn this;\n\t\t},\n\t\n\t\n\t\teq: function ( idx )\n\t\t{\n\t\t\tvar ctx = this.context;\n\t\n\t\t\treturn ctx.length > idx ?\n\t\t\t\tnew _Api( ctx[idx], this[idx] ) :\n\t\t\t\tnull;\n\t\t},\n\t\n\t\n\t\tfilter: function ( fn )\n\t\t{\n\t\t\tvar a = [];\n\t\n\t\t\tif ( __arrayProto.filter ) {\n\t\t\t\ta = __arrayProto.filter.call( this, fn, this );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Compatibility for browsers without EMCA-252-5 (JS 1.6)\n\t\t\t\tfor ( var i=0, ien=this.length ; i<ien ; i++ ) {\n\t\t\t\t\tif ( fn.call( this, this[i], i, this ) ) {\n\t\t\t\t\t\ta.push( this[i] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\treturn new _Api( this.context, a );\n\t\t},\n\t\n\t\n\t\tflatten: function ()\n\t\t{\n\t\t\tvar a = [];\n\t\t\treturn new _Api( this.context, a.concat.apply( a, this.toArray() ) );\n\t\t},\n\t\n\t\n\t\tjoin:    __arrayProto.join,\n\t\n\t\n\t\tindexOf: __arrayProto.indexOf || function (obj, start)\n\t\t{\n\t\t\tfor ( var i=(start || 0), ien=this.length ; i<ien ; i++ ) {\n\t\t\t\tif ( this[i] === obj ) {\n\t\t\t\t\treturn i;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn -1;\n\t\t},\n\t\n\t\titerator: function ( flatten, type, fn, alwaysNew ) {\n\t\t\tvar\n\t\t\t\ta = [], ret,\n\t\t\t\ti, ien, j, jen,\n\t\t\t\tcontext = this.context,\n\t\t\t\trows, items, item,\n\t\t\t\tselector = this.selector;\n\t\n\t\t\t// Argument shifting\n\t\t\tif ( typeof flatten === 'string' ) {\n\t\t\t\talwaysNew = fn;\n\t\t\t\tfn = type;\n\t\t\t\ttype = flatten;\n\t\t\t\tflatten = false;\n\t\t\t}\n\t\n\t\t\tfor ( i=0, ien=context.length ; i<ien ; i++ ) {\n\t\t\t\tvar apiInst = new _Api( context[i] );\n\t\n\t\t\t\tif ( type === 'table' ) {\n\t\t\t\t\tret = fn.call( apiInst, context[i], i );\n\t\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\ta.push( ret );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if ( type === 'columns' || type === 'rows' ) {\n\t\t\t\t\t// this has same length as context - one entry for each table\n\t\t\t\t\tret = fn.call( apiInst, context[i], this[i], i );\n\t\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\ta.push( ret );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if ( type === 'column' || type === 'column-rows' || type === 'row' || type === 'cell' ) {\n\t\t\t\t\t// columns and rows share the same structure.\n\t\t\t\t\t// 'this' is an array of column indexes for each context\n\t\t\t\t\titems = this[i];\n\t\n\t\t\t\t\tif ( type === 'column-rows' ) {\n\t\t\t\t\t\trows = _selector_row_indexes( context[i], selector.opts );\n\t\t\t\t\t}\n\t\n\t\t\t\t\tfor ( j=0, jen=items.length ; j<jen ; j++ ) {\n\t\t\t\t\t\titem = items[j];\n\t\n\t\t\t\t\t\tif ( type === 'cell' ) {\n\t\t\t\t\t\t\tret = fn.call( apiInst, context[i], item.row, item.column, i, j );\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tret = fn.call( apiInst, context[i], item, i, j, rows );\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\t\ta.push( ret );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\tif ( a.length || alwaysNew ) {\n\t\t\t\tvar api = new _Api( context, flatten ? a.concat.apply( [], a ) : a );\n\t\t\t\tvar apiSelector = api.selector;\n\t\t\t\tapiSelector.rows = selector.rows;\n\t\t\t\tapiSelector.cols = selector.cols;\n\t\t\t\tapiSelector.opts = selector.opts;\n\t\t\t\treturn api;\n\t\t\t}\n\t\t\treturn this;\n\t\t},\n\t\n\t\n\t\tlastIndexOf: __arrayProto.lastIndexOf || function (obj, start)\n\t\t{\n\t\t\t// Bit cheeky...\n\t\t\treturn this.indexOf.apply( this.toArray.reverse(), arguments );\n\t\t},\n\t\n\t\n\t\tlength:  0,\n\t\n\t\n\t\tmap: function ( fn )\n\t\t{\n\t\t\tvar a = [];\n\t\n\t\t\tif ( __arrayProto.map ) {\n\t\t\t\ta = __arrayProto.map.call( this, fn, this );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Compatibility for browsers without EMCA-252-5 (JS 1.6)\n\t\t\t\tfor ( var i=0, ien=this.length ; i<ien ; i++ ) {\n\t\t\t\t\ta.push( fn.call( this, this[i], i ) );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\treturn new _Api( this.context, a );\n\t\t},\n\t\n\t\n\t\tpluck: function ( prop )\n\t\t{\n\t\t\tlet fn = DataTable.util.get(prop);\n\t\n\t\t\treturn this.map( function ( el ) {\n\t\t\t\treturn fn(el);\n\t\t\t} );\n\t\t},\n\t\n\t\tpop:     __arrayProto.pop,\n\t\n\t\n\t\tpush:    __arrayProto.push,\n\t\n\t\n\t\t// Does not return an API instance\n\t\treduce: __arrayProto.reduce || function ( fn, init )\n\t\t{\n\t\t\treturn _fnReduce( this, fn, init, 0, this.length, 1 );\n\t\t},\n\t\n\t\n\t\treduceRight: __arrayProto.reduceRight || function ( fn, init )\n\t\t{\n\t\t\treturn _fnReduce( this, fn, init, this.length-1, -1, -1 );\n\t\t},\n\t\n\t\n\t\treverse: __arrayProto.reverse,\n\t\n\t\n\t\t// Object with rows, columns and opts\n\t\tselector: null,\n\t\n\t\n\t\tshift:   __arrayProto.shift,\n\t\n\t\n\t\tslice: function () {\n\t\t\treturn new _Api( this.context, this );\n\t\t},\n\t\n\t\n\t\tsort:    __arrayProto.sort, // ? name - order?\n\t\n\t\n\t\tsplice:  __arrayProto.splice,\n\t\n\t\n\t\ttoArray: function ()\n\t\t{\n\t\t\treturn __arrayProto.slice.call( this );\n\t\t},\n\t\n\t\n\t\tto$: function ()\n\t\t{\n\t\t\treturn $( this );\n\t\t},\n\t\n\t\n\t\ttoJQuery: function ()\n\t\t{\n\t\t\treturn $( this );\n\t\t},\n\t\n\t\n\t\tunique: function ()\n\t\t{\n\t\t\treturn new _Api( this.context, _unique(this) );\n\t\t},\n\t\n\t\n\t\tunshift: __arrayProto.unshift\n\t} );\n\t\n\t\n\t_Api.extend = function ( scope, obj, ext )\n\t{\n\t\t// Only extend API instances and static properties of the API\n\t\tif ( ! ext.length || ! obj || ( ! (obj instanceof _Api) && ! obj.__dt_wrapper ) ) {\n\t\t\treturn;\n\t\t}\n\t\n\t\tvar\n\t\t\ti, ien,\n\t\t\tstruct,\n\t\t\tmethodScoping = function ( scope, fn, struc ) {\n\t\t\t\treturn function () {\n\t\t\t\t\tvar ret = fn.apply( scope, arguments );\n\t\n\t\t\t\t\t// Method extension\n\t\t\t\t\t_Api.extend( ret, ret, struc.methodExt );\n\t\t\t\t\treturn ret;\n\t\t\t\t};\n\t\t\t};\n\t\n\t\tfor ( i=0, ien=ext.length ; i<ien ; i++ ) {\n\t\t\tstruct = ext[i];\n\t\n\t\t\t// Value\n\t\t\tobj[ struct.name ] = struct.type === 'function' ?\n\t\t\t\tmethodScoping( scope, struct.val, struct ) :\n\t\t\t\tstruct.type === 'object' ?\n\t\t\t\t\t{} :\n\t\t\t\t\tstruct.val;\n\t\n\t\t\tobj[ struct.name ].__dt_wrapper = true;\n\t\n\t\t\t// Property extension\n\t\t\t_Api.extend( scope, obj[ struct.name ], struct.propExt );\n\t\t}\n\t};\n\t\n\t\n\t// @todo - Is there need for an augment function?\n\t// _Api.augment = function ( inst, name )\n\t// {\n\t// \t// Find src object in the structure from the name\n\t// \tvar parts = name.split('.');\n\t\n\t// \t_Api.extend( inst, obj );\n\t// };\n\t\n\t\n\t//     [\n\t//       {\n\t//         name:      'data'                -- string   - Property name\n\t//         val:       function () {},       -- function - Api method (or undefined if just an object\n\t//         methodExt: [ ... ],              -- array    - Array of Api object definitions to extend the method result\n\t//         propExt:   [ ... ]               -- array    - Array of Api object definitions to extend the property\n\t//       },\n\t//       {\n\t//         name:     'row'\n\t//         val:       {},\n\t//         methodExt: [ ... ],\n\t//         propExt:   [\n\t//           {\n\t//             name:      'data'\n\t//             val:       function () {},\n\t//             methodExt: [ ... ],\n\t//             propExt:   [ ... ]\n\t//           },\n\t//           ...\n\t//         ]\n\t//       }\n\t//     ]\n\t\n\t_Api.register = _api_register = function ( name, val )\n\t{\n\t\tif ( Array.isArray( name ) ) {\n\t\t\tfor ( var j=0, jen=name.length ; j<jen ; j++ ) {\n\t\t\t\t_Api.register( name[j], val );\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\t\n\t\tvar\n\t\t\ti, ien,\n\t\t\their = name.split('.'),\n\t\t\tstruct = __apiStruct,\n\t\t\tkey, method;\n\t\n\t\tvar find = function ( src, name ) {\n\t\t\tfor ( var i=0, ien=src.length ; i<ien ; i++ ) {\n\t\t\t\tif ( src[i].name === name ) {\n\t\t\t\t\treturn src[i];\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn null;\n\t\t};\n\t\n\t\tfor ( i=0, ien=heir.length ; i<ien ; i++ ) {\n\t\t\tmethod = heir[i].indexOf('()') !== -1;\n\t\t\tkey = method ?\n\t\t\t\their[i].replace('()', '') :\n\t\t\t\their[i];\n\t\n\t\t\tvar src = find( struct, key );\n\t\t\tif ( ! src ) {\n\t\t\t\tsrc = {\n\t\t\t\t\tname:      key,\n\t\t\t\t\tval:       {},\n\t\t\t\t\tmethodExt: [],\n\t\t\t\t\tpropExt:   [],\n\t\t\t\t\ttype:      'object'\n\t\t\t\t};\n\t\t\t\tstruct.push( src );\n\t\t\t}\n\t\n\t\t\tif ( i === ien-1 ) {\n\t\t\t\tsrc.val = val;\n\t\t\t\tsrc.type = typeof val === 'function' ?\n\t\t\t\t\t'function' :\n\t\t\t\t\t$.isPlainObject( val ) ?\n\t\t\t\t\t\t'object' :\n\t\t\t\t\t\t'other';\n\t\t\t}\n\t\t\telse {\n\t\t\t\tstruct = method ?\n\t\t\t\t\tsrc.methodExt :\n\t\t\t\t\tsrc.propExt;\n\t\t\t}\n\t\t}\n\t};\n\t\n\t_Api.registerPlural = _api_registerPlural = function ( pluralName, singularName, val ) {\n\t\t_Api.register( pluralName, val );\n\t\n\t\t_Api.register( singularName, function () {\n\t\t\tvar ret = val.apply( this, arguments );\n\t\n\t\t\tif ( ret === this ) {\n\t\t\t\t// Returned item is the API instance that was passed in, return it\n\t\t\t\treturn this;\n\t\t\t}\n\t\t\telse if ( ret instanceof _Api ) {\n\t\t\t\t// New API instance returned, want the value from the first item\n\t\t\t\t// in the returned array for the singular result.\n\t\t\t\treturn ret.length ?\n\t\t\t\t\tArray.isArray( ret[0] ) ?\n\t\t\t\t\t\tnew _Api( ret.context, ret[0] ) : // Array results are 'enhanced'\n\t\t\t\t\t\tret[0] :\n\t\t\t\t\tundefined;\n\t\t\t}\n\t\n\t\t\t// Non-API return - just fire it back\n\t\t\treturn ret;\n\t\t} );\n\t};\n\t\n\t\n\t/**\n\t * Selector for HTML tables. Apply the given selector to the give array of\n\t * DataTables settings objects.\n\t *\n\t * @param {string|integer} [selector] jQuery selector string or integer\n\t * @param  {array} Array of DataTables settings objects to be filtered\n\t * @return {array}\n\t * @ignore\n\t */\n\tvar __table_selector = function ( selector, a )\n\t{\n\t\tif ( Array.isArray(selector) ) {\n\t\t\treturn $.map( selector, function (item) {\n\t\t\t\treturn __table_selector(item, a);\n\t\t\t} );\n\t\t}\n\t\n\t\t// Integer is used to pick out a table by index\n\t\tif ( typeof selector === 'number' ) {\n\t\t\treturn [ a[ selector ] ];\n\t\t}\n\t\n\t\t// Perform a jQuery selector on the table nodes\n\t\tvar nodes = $.map( a, function (el, i) {\n\t\t\treturn el.nTable;\n\t\t} );\n\t\n\t\treturn $(nodes)\n\t\t\t.filter( selector )\n\t\t\t.map( function (i) {\n\t\t\t\t// Need to translate back from the table node to the settings\n\t\t\t\tvar idx = $.inArray( this, nodes );\n\t\t\t\treturn a[ idx ];\n\t\t\t} )\n\t\t\t.toArray();\n\t};\n\t\n\t\n\t\n\t/**\n\t * Context selector for the API's context (i.e. the tables the API instance\n\t * refers to.\n\t *\n\t * @name    DataTable.Api#tables\n\t * @param {string|integer} [selector] Selector to pick which tables the iterator\n\t *   should operate on. If not given, all tables in the current context are\n\t *   used. This can be given as a jQuery selector (for example `':gt(0)'`) to\n\t *   select multiple tables or as an integer to select a single table.\n\t * @returns {DataTable.Api} Returns a new API instance if a selector is given.\n\t */\n\t_api_register( 'tables()', function ( selector ) {\n\t\t// A new instance is created if there was a selector specified\n\t\treturn selector !== undefined && selector !== null ?\n\t\t\tnew _Api( __table_selector( selector, this.context ) ) :\n\t\t\tthis;\n\t} );\n\t\n\t\n\t_api_register( 'table()', function ( selector ) {\n\t\tvar tables = this.tables( selector );\n\t\tvar ctx = tables.context;\n\t\n\t\t// Truncate to the first matched table\n\t\treturn ctx.length ?\n\t\t\tnew _Api( ctx[0] ) :\n\t\t\ttables;\n\t} );\n\t\n\t\n\t_api_registerPlural( 'tables().nodes()', 'table().node()' , function () {\n\t\treturn this.iterator( 'table', function ( ctx ) {\n\t\t\treturn ctx.nTable;\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t_api_registerPlural( 'tables().body()', 'table().body()' , function () {\n\t\treturn this.iterator( 'table', function ( ctx ) {\n\t\t\treturn ctx.nTBody;\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t_api_registerPlural( 'tables().header()', 'table().header()' , function () {\n\t\treturn this.iterator( 'table', function ( ctx ) {\n\t\t\treturn ctx.nTHead;\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t_api_registerPlural( 'tables().footer()', 'table().footer()' , function () {\n\t\treturn this.iterator( 'table', function ( ctx ) {\n\t\t\treturn ctx.nTFoot;\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t_api_registerPlural( 'tables().containers()', 'table().container()' , function () {\n\t\treturn this.iterator( 'table', function ( ctx ) {\n\t\t\treturn ctx.nTableWrapper;\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t\n\t/**\n\t * Redraw the tables in the current context.\n\t */\n\t_api_register( 'draw()', function ( paging ) {\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\tif ( paging === 'page' ) {\n\t\t\t\t_fnDraw( settings );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tif ( typeof paging === 'string' ) {\n\t\t\t\t\tpaging = paging === 'full-hold' ?\n\t\t\t\t\t\tfalse :\n\t\t\t\t\t\ttrue;\n\t\t\t\t}\n\t\n\t\t\t\t_fnReDraw( settings, paging===false );\n\t\t\t}\n\t\t} );\n\t} );\n\t\n\t\n\t\n\t/**\n\t * Get the current page index.\n\t *\n\t * @return {integer} Current page index (zero based)\n\t *//**\n\t * Set the current page.\n\t *\n\t * Note that if you attempt to show a page which does not exist, DataTables will\n\t * not throw an error, but rather reset the paging.\n\t *\n\t * @param {integer|string} action The paging action to take. This can be one of:\n\t *  * `integer` - The page index to jump to\n\t *  * `string` - An action to take:\n\t *    * `first` - Jump to first page.\n\t *    * `next` - Jump to the next page\n\t *    * `previous` - Jump to previous page\n\t *    * `last` - Jump to the last page.\n\t * @returns {DataTables.Api} this\n\t */\n\t_api_register( 'page()', function ( action ) {\n\t\tif ( action === undefined ) {\n\t\t\treturn this.page.info().page; // not an expensive call\n\t\t}\n\t\n\t\t// else, have an action to take on all tables\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\t_fnPageChange( settings, action );\n\t\t} );\n\t} );\n\t\n\t\n\t/**\n\t * Paging information for the first table in the current context.\n\t *\n\t * If you require paging information for another table, use the `table()` method\n\t * with a suitable selector.\n\t *\n\t * @return {object} Object with the following properties set:\n\t *  * `page` - Current page index (zero based - i.e. the first page is `0`)\n\t *  * `pages` - Total number of pages\n\t *  * `start` - Display index for the first record shown on the current page\n\t *  * `end` - Display index for the last record shown on the current page\n\t *  * `length` - Display length (number of records). Note that generally `start\n\t *    + length = end`, but this is not always true, for example if there are\n\t *    only 2 records to show on the final page, with a length of 10.\n\t *  * `recordsTotal` - Full data set length\n\t *  * `recordsDisplay` - Data set length once the current filtering criterion\n\t *    are applied.\n\t */\n\t_api_register( 'page.info()', function ( action ) {\n\t\tif ( this.context.length === 0 ) {\n\t\t\treturn undefined;\n\t\t}\n\t\n\t\tvar\n\t\t\tsettings   = this.context[0],\n\t\t\tstart      = settings._iDisplayStart,\n\t\t\tlen        = settings.oFeatures.bPaginate ? settings._iDisplayLength : -1,\n\t\t\tvisRecords = settings.fnRecordsDisplay(),\n\t\t\tall        = len === -1;\n\t\n\t\treturn {\n\t\t\t\"page\":           all ? 0 : Math.floor( start / len ),\n\t\t\t\"pages\":          all ? 1 : Math.ceil( visRecords / len ),\n\t\t\t\"start\":          start,\n\t\t\t\"end\":            settings.fnDisplayEnd(),\n\t\t\t\"length\":         len,\n\t\t\t\"recordsTotal\":   settings.fnRecordsTotal(),\n\t\t\t\"recordsDisplay\": visRecords,\n\t\t\t\"serverSide\":     _fnDataSource( settings ) === 'ssp'\n\t\t};\n\t} );\n\t\n\t\n\t/**\n\t * Get the current page length.\n\t *\n\t * @return {integer} Current page length. Note `-1` indicates that all records\n\t *   are to be shown.\n\t *//**\n\t * Set the current page length.\n\t *\n\t * @param {integer} Page length to set. Use `-1` to show all records.\n\t * @returns {DataTables.Api} this\n\t */\n\t_api_register( 'page.len()', function ( len ) {\n\t\t// Note that we can't call this function 'length()' because `length`\n\t\t// is a Javascript property of functions which defines how many arguments\n\t\t// the function expects.\n\t\tif ( len === undefined ) {\n\t\t\treturn this.context.length !== 0 ?\n\t\t\t\tthis.context[0]._iDisplayLength :\n\t\t\t\tundefined;\n\t\t}\n\t\n\t\t// else, set the page length\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\t_fnLengthChange( settings, len );\n\t\t} );\n\t} );\n\t\n\t\n\t\n\tvar __reload = function ( settings, holdPosition, callback ) {\n\t\t// Use the draw event to trigger a callback\n\t\tif ( callback ) {\n\t\t\tvar api = new _Api( settings );\n\t\n\t\t\tapi.one( 'draw', function () {\n\t\t\t\tcallback( api.ajax.json() );\n\t\t\t} );\n\t\t}\n\t\n\t\tif ( _fnDataSource( settings ) == 'ssp' ) {\n\t\t\t_fnReDraw( settings, holdPosition );\n\t\t}\n\t\telse {\n\t\t\t_fnProcessingDisplay( settings, true );\n\t\n\t\t\t// Cancel an existing request\n\t\t\tvar xhr = settings.jqXHR;\n\t\t\tif ( xhr && xhr.readyState !== 4 ) {\n\t\t\t\txhr.abort();\n\t\t\t}\n\t\n\t\t\t// Trigger xhr\n\t\t\t_fnBuildAjax( settings, [], function( json ) {\n\t\t\t\t_fnClearTable( settings );\n\t\n\t\t\t\tvar data = _fnAjaxDataSrc( settings, json );\n\t\t\t\tfor ( var i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\t\t\t_fnAddData( settings, data[i] );\n\t\t\t\t}\n\t\n\t\t\t\t_fnReDraw( settings, holdPosition );\n\t\t\t\t_fnProcessingDisplay( settings, false );\n\t\t\t} );\n\t\t}\n\t};\n\t\n\t\n\t/**\n\t * Get the JSON response from the last Ajax request that DataTables made to the\n\t * server. Note that this returns the JSON from the first table in the current\n\t * context.\n\t *\n\t * @return {object} JSON received from the server.\n\t */\n\t_api_register( 'ajax.json()', function () {\n\t\tvar ctx = this.context;\n\t\n\t\tif ( ctx.length > 0 ) {\n\t\t\treturn ctx[0].json;\n\t\t}\n\t\n\t\t// else return undefined;\n\t} );\n\t\n\t\n\t/**\n\t * Get the data submitted in the last Ajax request\n\t */\n\t_api_register( 'ajax.params()', function () {\n\t\tvar ctx = this.context;\n\t\n\t\tif ( ctx.length > 0 ) {\n\t\t\treturn ctx[0].oAjaxData;\n\t\t}\n\t\n\t\t// else return undefined;\n\t} );\n\t\n\t\n\t/**\n\t * Reload tables from the Ajax data source. Note that this function will\n\t * automatically re-draw the table when the remote data has been loaded.\n\t *\n\t * @param {boolean} [reset=true] Reset (default) or hold the current paging\n\t *   position. A full re-sort and re-filter is performed when this method is\n\t *   called, which is why the pagination reset is the default action.\n\t * @returns {DataTables.Api} this\n\t */\n\t_api_register( 'ajax.reload()', function ( callback, resetPaging ) {\n\t\treturn this.iterator( 'table', function (settings) {\n\t\t\t__reload( settings, resetPaging===false, callback );\n\t\t} );\n\t} );\n\t\n\t\n\t/**\n\t * Get the current Ajax URL. Note that this returns the URL from the first\n\t * table in the current context.\n\t *\n\t * @return {string} Current Ajax source URL\n\t *//**\n\t * Set the Ajax URL. Note that this will set the URL for all tables in the\n\t * current context.\n\t *\n\t * @param {string} url URL to set.\n\t * @returns {DataTables.Api} this\n\t */\n\t_api_register( 'ajax.url()', function ( url ) {\n\t\tvar ctx = this.context;\n\t\n\t\tif ( url === undefined ) {\n\t\t\t// get\n\t\t\tif ( ctx.length === 0 ) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tctx = ctx[0];\n\t\n\t\t\treturn ctx.ajax ?\n\t\t\t\t$.isPlainObject( ctx.ajax ) ?\n\t\t\t\t\tctx.ajax.url :\n\t\t\t\t\tctx.ajax :\n\t\t\t\tctx.sAjaxSource;\n\t\t}\n\t\n\t\t// set\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\tif ( $.isPlainObject( settings.ajax ) ) {\n\t\t\t\tsettings.ajax.url = url;\n\t\t\t}\n\t\t\telse {\n\t\t\t\tsettings.ajax = url;\n\t\t\t}\n\t\t\t// No need to consider sAjaxSource here since DataTables gives priority\n\t\t\t// to `ajax` over `sAjaxSource`. So setting `ajax` here, renders any\n\t\t\t// value of `sAjaxSource` redundant.\n\t\t} );\n\t} );\n\t\n\t\n\t/**\n\t * Load data from the newly set Ajax URL. Note that this method is only\n\t * available when `ajax.url()` is used to set a URL. Additionally, this method\n\t * has the same effect as calling `ajax.reload()` but is provided for\n\t * convenience when setting a new URL. Like `ajax.reload()` it will\n\t * automatically redraw the table once the remote data has been loaded.\n\t *\n\t * @returns {DataTables.Api} this\n\t */\n\t_api_register( 'ajax.url().load()', function ( callback, resetPaging ) {\n\t\t// Same as a reload, but makes sense to present it for easy access after a\n\t\t// url change\n\t\treturn this.iterator( 'table', function ( ctx ) {\n\t\t\t__reload( ctx, resetPaging===false, callback );\n\t\t} );\n\t} );\n\t\n\t\n\t\n\t\n\tvar _selector_run = function ( type, selector, selectFn, settings, opts )\n\t{\n\t\tvar\n\t\t\tout = [], res,\n\t\t\ta, i, ien, j, jen,\n\t\t\tselectorType = typeof selector;\n\t\n\t\t// Can't just check for isArray here, as an API or jQuery instance might be\n\t\t// given with their array like look\n\t\tif ( ! selector || selectorType === 'string' || selectorType === 'function' || selector.length === undefined ) {\n\t\t\tselector = [ selector ];\n\t\t}\n\t\n\t\tfor ( i=0, ien=selector.length ; i<ien ; i++ ) {\n\t\t\t// Only split on simple strings - complex expressions will be jQuery selectors\n\t\t\ta = selector[i] && selector[i].split && ! selector[i].match(/[\\[\\(:]/) ?\n\t\t\t\tselector[i].split(',') :\n\t\t\t\t[ selector[i] ];\n\t\n\t\t\tfor ( j=0, jen=a.length ; j<jen ; j++ ) {\n\t\t\t\tres = selectFn( typeof a[j] === 'string' ? (a[j]).trim() : a[j] );\n\t\n\t\t\t\tif ( res && res.length ) {\n\t\t\t\t\tout = out.concat( res );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\n\t\t// selector extensions\n\t\tvar ext = _ext.selector[ type ];\n\t\tif ( ext.length ) {\n\t\t\tfor ( i=0, ien=ext.length ; i<ien ; i++ ) {\n\t\t\t\tout = ext[i]( settings, opts, out );\n\t\t\t}\n\t\t}\n\t\n\t\treturn _unique( out );\n\t};\n\t\n\t\n\tvar _selector_opts = function ( opts )\n\t{\n\t\tif ( ! opts ) {\n\t\t\topts = {};\n\t\t}\n\t\n\t\t// Backwards compatibility for 1.9- which used the terminology filter rather\n\t\t// than search\n\t\tif ( opts.filter && opts.search === undefined ) {\n\t\t\topts.search = opts.filter;\n\t\t}\n\t\n\t\treturn $.extend( {\n\t\t\tsearch: 'none',\n\t\t\torder: 'current',\n\t\t\tpage: 'all'\n\t\t}, opts );\n\t};\n\t\n\t\n\tvar _selector_first = function ( inst )\n\t{\n\t\t// Reduce the API instance to the first item found\n\t\tfor ( var i=0, ien=inst.length ; i<ien ; i++ ) {\n\t\t\tif ( inst[i].length > 0 ) {\n\t\t\t\t// Assign the first element to the first item in the instance\n\t\t\t\t// and truncate the instance and context\n\t\t\t\tinst[0] = inst[i];\n\t\t\t\tinst[0].length = 1;\n\t\t\t\tinst.length = 1;\n\t\t\t\tinst.context = [ inst.context[i] ];\n\t\n\t\t\t\treturn inst;\n\t\t\t}\n\t\t}\n\t\n\t\t// Not found - return an empty instance\n\t\tinst.length = 0;\n\t\treturn inst;\n\t};\n\t\n\t\n\tvar _selector_row_indexes = function ( settings, opts )\n\t{\n\t\tvar\n\t\t\ti, ien, tmp, a=[],\n\t\t\tdisplayFiltered = settings.aiDisplay,\n\t\t\tdisplayMaster = settings.aiDisplayMaster;\n\t\n\t\tvar\n\t\t\tsearch = opts.search,  // none, applied, removed\n\t\t\torder  = opts.order,   // applied, current, index (original - compatibility with 1.9)\n\t\t\tpage   = opts.page;    // all, current\n\t\n\t\tif ( _fnDataSource( settings ) == 'ssp' ) {\n\t\t\t// In server-side processing mode, most options are irrelevant since\n\t\t\t// rows not shown don't exist and the index order is the applied order\n\t\t\t// Removed is a special case - for consistency just return an empty\n\t\t\t// array\n\t\t\treturn search === 'removed' ?\n\t\t\t\t[] :\n\t\t\t\t_range( 0, displayMaster.length );\n\t\t}\n\t\telse if ( page == 'current' ) {\n\t\t\t// Current page implies that order=current and filter=applied, since it is\n\t\t\t// fairly senseless otherwise, regardless of what order and search actually\n\t\t\t// are\n\t\t\tfor ( i=settings._iDisplayStart, ien=settings.fnDisplayEnd() ; i<ien ; i++ ) {\n\t\t\t\ta.push( displayFiltered[i] );\n\t\t\t}\n\t\t}\n\t\telse if ( order == 'current' || order == 'applied' ) {\n\t\t\tif ( search == 'none') {\n\t\t\t\ta = displayMaster.slice();\n\t\t\t}\n\t\t\telse if ( search == 'applied' ) {\n\t\t\t\ta = displayFiltered.slice();\n\t\t\t}\n\t\t\telse if ( search == 'removed' ) {\n\t\t\t\t// O(n+m) solution by creating a hash map\n\t\t\t\tvar displayFilteredMap = {};\n\t\n\t\t\t\tfor ( var i=0, ien=displayFiltered.length ; i<ien ; i++ ) {\n\t\t\t\t\tdisplayFilteredMap[displayFiltered[i]] = null;\n\t\t\t\t}\n\t\n\t\t\t\ta = $.map( displayMaster, function (el) {\n\t\t\t\t\treturn ! displayFilteredMap.hasOwnProperty(el) ?\n\t\t\t\t\t\tel :\n\t\t\t\t\t\tnull;\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t\telse if ( order == 'index' || order == 'original' ) {\n\t\t\tfor ( i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\t\t\tif ( search == 'none' ) {\n\t\t\t\t\ta.push( i );\n\t\t\t\t}\n\t\t\t\telse { // applied | removed\n\t\t\t\t\ttmp = $.inArray( i, displayFiltered );\n\t\n\t\t\t\t\tif ((tmp === -1 && search == 'removed') ||\n\t\t\t\t\t\t(tmp >= 0   && search == 'applied') )\n\t\t\t\t\t{\n\t\t\t\t\t\ta.push( i );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\n\t\treturn a;\n\t};\n\t\n\t\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Rows\n\t *\n\t * {}          - no selector - use all available rows\n\t * {integer}   - row aoData index\n\t * {node}      - TR node\n\t * {string}    - jQuery selector to apply to the TR elements\n\t * {array}     - jQuery array of nodes, or simply an array of TR nodes\n\t *\n\t */\n\tvar __row_selector = function ( settings, selector, opts )\n\t{\n\t\tvar rows;\n\t\tvar run = function ( sel ) {\n\t\t\tvar selInt = _intVal( sel );\n\t\t\tvar i, ien;\n\t\t\tvar aoData = settings.aoData;\n\t\n\t\t\t// Short cut - selector is a number and no options provided (default is\n\t\t\t// all records, so no need to check if the index is in there, since it\n\t\t\t// must be - dev error if the index doesn't exist).\n\t\t\tif ( selInt !== null && ! opts ) {\n\t\t\t\treturn [ selInt ];\n\t\t\t}\n\t\n\t\t\tif ( ! rows ) {\n\t\t\t\trows = _selector_row_indexes( settings, opts );\n\t\t\t}\n\t\n\t\t\tif ( selInt !== null && $.inArray( selInt, rows ) !== -1 ) {\n\t\t\t\t// Selector - integer\n\t\t\t\treturn [ selInt ];\n\t\t\t}\n\t\t\telse if ( sel === null || sel === undefined || sel === '' ) {\n\t\t\t\t// Selector - none\n\t\t\t\treturn rows;\n\t\t\t}\n\t\n\t\t\t// Selector - function\n\t\t\tif ( typeof sel === 'function' ) {\n\t\t\t\treturn $.map( rows, function (idx) {\n\t\t\t\t\tvar row = aoData[ idx ];\n\t\t\t\t\treturn sel( idx, row._aData, row.nTr ) ? idx : null;\n\t\t\t\t} );\n\t\t\t}\n\t\n\t\t\t// Selector - node\n\t\t\tif ( sel.nodeName ) {\n\t\t\t\tvar rowIdx = sel._DT_RowIndex;  // Property added by DT for fast lookup\n\t\t\t\tvar cellIdx = sel._DT_CellIndex;\n\t\n\t\t\t\tif ( rowIdx !== undefined ) {\n\t\t\t\t\t// Make sure that the row is actually still present in the table\n\t\t\t\t\treturn aoData[ rowIdx ] && aoData[ rowIdx ].nTr === sel ?\n\t\t\t\t\t\t[ rowIdx ] :\n\t\t\t\t\t\t[];\n\t\t\t\t}\n\t\t\t\telse if ( cellIdx ) {\n\t\t\t\t\treturn aoData[ cellIdx.row ] && aoData[ cellIdx.row ].nTr === sel.parentNode ?\n\t\t\t\t\t\t[ cellIdx.row ] :\n\t\t\t\t\t\t[];\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tvar host = $(sel).closest('*[data-dt-row]');\n\t\t\t\t\treturn host.length ?\n\t\t\t\t\t\t[ host.data('dt-row') ] :\n\t\t\t\t\t\t[];\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t// ID selector. Want to always be able to select rows by id, regardless\n\t\t\t// of if the tr element has been created or not, so can't rely upon\n\t\t\t// jQuery here - hence a custom implementation. This does not match\n\t\t\t// Sizzle's fast selector or HTML4 - in HTML5 the ID can be anything,\n\t\t\t// but to select it using a CSS selector engine (like Sizzle or\n\t\t\t// querySelect) it would need to need to be escaped for some characters.\n\t\t\t// DataTables simplifies this for row selectors since you can select\n\t\t\t// only a row. A # indicates an id any anything that follows is the id -\n\t\t\t// unescaped.\n\t\t\tif ( typeof sel === 'string' && sel.charAt(0) === '#' ) {\n\t\t\t\t// get row index from id\n\t\t\t\tvar rowObj = settings.aIds[ sel.replace( /^#/, '' ) ];\n\t\t\t\tif ( rowObj !== undefined ) {\n\t\t\t\t\treturn [ rowObj.idx ];\n\t\t\t\t}\n\t\n\t\t\t\t// need to fall through to jQuery in case there is DOM id that\n\t\t\t\t// matches\n\t\t\t}\n\t\t\t\n\t\t\t// Get nodes in the order from the `rows` array with null values removed\n\t\t\tvar nodes = _removeEmpty(\n\t\t\t\t_pluck_order( settings.aoData, rows, 'nTr' )\n\t\t\t);\n\t\n\t\t\t// Selector - jQuery selector string, array of nodes or jQuery object/\n\t\t\t// As jQuery's .filter() allows jQuery objects to be passed in filter,\n\t\t\t// it also allows arrays, so this will cope with all three options\n\t\t\treturn $(nodes)\n\t\t\t\t.filter( sel )\n\t\t\t\t.map( function () {\n\t\t\t\t\treturn this._DT_RowIndex;\n\t\t\t\t} )\n\t\t\t\t.toArray();\n\t\t};\n\t\n\t\treturn _selector_run( 'row', selector, run, settings, opts );\n\t};\n\t\n\t\n\t_api_register( 'rows()', function ( selector, opts ) {\n\t\t// argument shifting\n\t\tif ( selector === undefined ) {\n\t\t\tselector = '';\n\t\t}\n\t\telse if ( $.isPlainObject( selector ) ) {\n\t\t\topts = selector;\n\t\t\tselector = '';\n\t\t}\n\t\n\t\topts = _selector_opts( opts );\n\t\n\t\tvar inst = this.iterator( 'table', function ( settings ) {\n\t\t\treturn __row_selector( settings, selector, opts );\n\t\t}, 1 );\n\t\n\t\t// Want argument shifting here and in __row_selector?\n\t\tinst.selector.rows = selector;\n\t\tinst.selector.opts = opts;\n\t\n\t\treturn inst;\n\t} );\n\t\n\t_api_register( 'rows().nodes()', function () {\n\t\treturn this.iterator( 'row', function ( settings, row ) {\n\t\t\treturn settings.aoData[ row ].nTr || undefined;\n\t\t}, 1 );\n\t} );\n\t\n\t_api_register( 'rows().data()', function () {\n\t\treturn this.iterator( true, 'rows', function ( settings, rows ) {\n\t\t\treturn _pluck_order( settings.aoData, rows, '_aData' );\n\t\t}, 1 );\n\t} );\n\t\n\t_api_registerPlural( 'rows().cache()', 'row().cache()', function ( type ) {\n\t\treturn this.iterator( 'row', function ( settings, row ) {\n\t\t\tvar r = settings.aoData[ row ];\n\t\t\treturn type === 'search' ? r._aFilterData : r._aSortData;\n\t\t}, 1 );\n\t} );\n\t\n\t_api_registerPlural( 'rows().invalidate()', 'row().invalidate()', function ( src ) {\n\t\treturn this.iterator( 'row', function ( settings, row ) {\n\t\t\t_fnInvalidate( settings, row, src );\n\t\t} );\n\t} );\n\t\n\t_api_registerPlural( 'rows().indexes()', 'row().index()', function () {\n\t\treturn this.iterator( 'row', function ( settings, row ) {\n\t\t\treturn row;\n\t\t}, 1 );\n\t} );\n\t\n\t_api_registerPlural( 'rows().ids()', 'row().id()', function ( hash ) {\n\t\tvar a = [];\n\t\tvar context = this.context;\n\t\n\t\t// `iterator` will drop undefined values, but in this case we want them\n\t\tfor ( var i=0, ien=context.length ; i<ien ; i++ ) {\n\t\t\tfor ( var j=0, jen=this[i].length ; j<jen ; j++ ) {\n\t\t\t\tvar id = context[i].rowIdFn( context[i].aoData[ this[i][j] ]._aData );\n\t\t\t\ta.push( (hash === true ? '#' : '' )+ id );\n\t\t\t}\n\t\t}\n\t\n\t\treturn new _Api( context, a );\n\t} );\n\t\n\t_api_registerPlural( 'rows().remove()', 'row().remove()', function () {\n\t\tvar that = this;\n\t\n\t\tthis.iterator( 'row', function ( settings, row, thatIdx ) {\n\t\t\tvar data = settings.aoData;\n\t\t\tvar rowData = data[ row ];\n\t\t\tvar i, ien, j, jen;\n\t\t\tvar loopRow, loopCells;\n\t\n\t\t\tdata.splice( row, 1 );\n\t\n\t\t\t// Update the cached indexes\n\t\t\tfor ( i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\t\tloopRow = data[i];\n\t\t\t\tloopCells = loopRow.anCells;\n\t\n\t\t\t\t// Rows\n\t\t\t\tif ( loopRow.nTr !== null ) {\n\t\t\t\t\tloopRow.nTr._DT_RowIndex = i;\n\t\t\t\t}\n\t\n\t\t\t\t// Cells\n\t\t\t\tif ( loopCells !== null ) {\n\t\t\t\t\tfor ( j=0, jen=loopCells.length ; j<jen ; j++ ) {\n\t\t\t\t\t\tloopCells[j]._DT_CellIndex.row = i;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t// Delete from the display arrays\n\t\t\t_fnDeleteIndex( settings.aiDisplayMaster, row );\n\t\t\t_fnDeleteIndex( settings.aiDisplay, row );\n\t\t\t_fnDeleteIndex( that[ thatIdx ], row, false ); // maintain local indexes\n\t\n\t\t\t// For server-side processing tables - subtract the deleted row from the count\n\t\t\tif ( settings._iRecordsDisplay > 0 ) {\n\t\t\t\tsettings._iRecordsDisplay--;\n\t\t\t}\n\t\n\t\t\t// Check for an 'overflow' they case for displaying the table\n\t\t\t_fnLengthOverflow( settings );\n\t\n\t\t\t// Remove the row's ID reference if there is one\n\t\t\tvar id = settings.rowIdFn( rowData._aData );\n\t\t\tif ( id !== undefined ) {\n\t\t\t\tdelete settings.aIds[ id ];\n\t\t\t}\n\t\t} );\n\t\n\t\tthis.iterator( 'table', function ( settings ) {\n\t\t\tfor ( var i=0, ien=settings.aoData.length ; i<ien ; i++ ) {\n\t\t\t\tsettings.aoData[i].idx = i;\n\t\t\t}\n\t\t} );\n\t\n\t\treturn this;\n\t} );\n\t\n\t\n\t_api_register( 'rows.add()', function ( rows ) {\n\t\tvar newRows = this.iterator( 'table', function ( settings ) {\n\t\t\t\tvar row, i, ien;\n\t\t\t\tvar out = [];\n\t\n\t\t\t\tfor ( i=0, ien=rows.length ; i<ien ; i++ ) {\n\t\t\t\t\trow = rows[i];\n\t\n\t\t\t\t\tif ( row.nodeName && row.nodeName.toUpperCase() === 'TR' ) {\n\t\t\t\t\t\tout.push( _fnAddTr( settings, row )[0] );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tout.push( _fnAddData( settings, row ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\n\t\t\t\treturn out;\n\t\t\t}, 1 );\n\t\n\t\t// Return an Api.rows() extended instance, so rows().nodes() etc can be used\n\t\tvar modRows = this.rows( -1 );\n\t\tmodRows.pop();\n\t\t$.merge( modRows, newRows );\n\t\n\t\treturn modRows;\n\t} );\n\t\n\t\n\t\n\t\n\t\n\t/**\n\t *\n\t */\n\t_api_register( 'row()', function ( selector, opts ) {\n\t\treturn _selector_first( this.rows( selector, opts ) );\n\t} );\n\t\n\t\n\t_api_register( 'row().data()', function ( data ) {\n\t\tvar ctx = this.context;\n\t\n\t\tif ( data === undefined ) {\n\t\t\t// Get\n\t\t\treturn ctx.length && this.length ?\n\t\t\t\tctx[0].aoData[ this[0] ]._aData :\n\t\t\t\tundefined;\n\t\t}\n\t\n\t\t// Set\n\t\tvar row = ctx[0].aoData[ this[0] ];\n\t\trow._aData = data;\n\t\n\t\t// If the DOM has an id, and the data source is an array\n\t\tif ( Array.isArray( data ) && row.nTr && row.nTr.id ) {\n\t\t\t_fnSetObjectDataFn( ctx[0].rowId )( data, row.nTr.id );\n\t\t}\n\t\n\t\t// Automatically invalidate\n\t\t_fnInvalidate( ctx[0], this[0], 'data' );\n\t\n\t\treturn this;\n\t} );\n\t\n\t\n\t_api_register( 'row().node()', function () {\n\t\tvar ctx = this.context;\n\t\n\t\treturn ctx.length && this.length ?\n\t\t\tctx[0].aoData[ this[0] ].nTr || null :\n\t\t\tnull;\n\t} );\n\t\n\t\n\t_api_register( 'row.add()', function ( row ) {\n\t\t// Allow a jQuery object to be passed in - only a single row is added from\n\t\t// it though - the first element in the set\n\t\tif ( row instanceof $ && row.length ) {\n\t\t\trow = row[0];\n\t\t}\n\t\n\t\tvar rows = this.iterator( 'table', function ( settings ) {\n\t\t\tif ( row.nodeName && row.nodeName.toUpperCase() === 'TR' ) {\n\t\t\t\treturn _fnAddTr( settings, row )[0];\n\t\t\t}\n\t\t\treturn _fnAddData( settings, row );\n\t\t} );\n\t\n\t\t// Return an Api.rows() extended instance, with the newly added row selected\n\t\treturn this.row( rows[0] );\n\t} );\n\t\n\t\n\t$(document).on('plugin-init.dt', function (e, context) {\n\t\tvar api = new _Api( context );\n\t\n\t\tapi.on( 'stateSaveParams', function ( e, settings, d ) {\n\t\t\t// This could be more compact with the API, but it is a lot faster as a simple\n\t\t\t// internal loop\n\t\t\tvar idFn = settings.rowIdFn;\n\t\t\tvar data = settings.aoData;\n\t\t\tvar ids = [];\n\t\n\t\t\tfor (var i=0 ; i<data.length ; i++) {\n\t\t\t\tif (data[i]._detailsShow) {\n\t\t\t\t\tids.push( '#' + idFn(data[i]._aData) );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\td.childRows = ids;\n\t\t})\n\t\n\t\tvar loaded = api.state.loaded();\n\t\n\t\tif ( loaded && loaded.childRows ) {\n\t\t\tapi\n\t\t\t\t.rows( $.map(loaded.childRows, function (id){\n\t\t\t\t\treturn id.replace(/:/g, '\\\\:')\n\t\t\t\t}) )\n\t\t\t\t.every( function () {\n\t\t\t\t\t_fnCallbackFire( context, null, 'requestChild', [ this ] )\n\t\t\t\t});\n\t\t}\n\t});\n\t\n\tvar __details_add = function ( ctx, row, data, klass )\n\t{\n\t\t// Convert to array of TR elements\n\t\tvar rows = [];\n\t\tvar addRow = function ( r, k ) {\n\t\t\t// Recursion to allow for arrays of jQuery objects\n\t\t\tif ( Array.isArray( r ) || r instanceof $ ) {\n\t\t\t\tfor ( var i=0, ien=r.length ; i<ien ; i++ ) {\n\t\t\t\t\taddRow( r[i], k );\n\t\t\t\t}\n\t\t\t\treturn;\n\t\t\t}\n\t\n\t\t\t// If we get a TR element, then just add it directly - up to the dev\n\t\t\t// to add the correct number of columns etc\n\t\t\tif ( r.nodeName && r.nodeName.toLowerCase() === 'tr' ) {\n\t\t\t\trows.push( r );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Otherwise create a row with a wrapper\n\t\t\t\tvar created = $('<tr><td></td></tr>').addClass( k );\n\t\t\t\t$('td', created)\n\t\t\t\t\t.addClass( k )\n\t\t\t\t\t.html( r )\n\t\t\t\t\t[0].colSpan = _fnVisbleColumns( ctx );\n\t\n\t\t\t\trows.push( created[0] );\n\t\t\t}\n\t\t};\n\t\n\t\taddRow( data, klass );\n\t\n\t\tif ( row._details ) {\n\t\t\trow._details.detach();\n\t\t}\n\t\n\t\trow._details = $(rows);\n\t\n\t\t// If the children were already shown, that state should be retained\n\t\tif ( row._detailsShow ) {\n\t\t\trow._details.insertAfter( row.nTr );\n\t\t}\n\t};\n\t\n\t\n\t// Make state saving of child row details async to allow them to be batch processed\n\tvar __details_state = DataTable.util.throttle(\n\t\tfunction (ctx) {\n\t\t\t_fnSaveState( ctx[0] )\n\t\t},\n\t\t500\n\t);\n\t\n\t\n\tvar __details_remove = function ( api, idx )\n\t{\n\t\tvar ctx = api.context;\n\t\n\t\tif ( ctx.length ) {\n\t\t\tvar row = ctx[0].aoData[ idx !== undefined ? idx : api[0] ];\n\t\n\t\t\tif ( row && row._details ) {\n\t\t\t\trow._details.remove();\n\t\n\t\t\t\trow._detailsShow = undefined;\n\t\t\t\trow._details = undefined;\n\t\t\t\t$( row.nTr ).removeClass( 'dt-hasChild' );\n\t\t\t\t__details_state( ctx );\n\t\t\t}\n\t\t}\n\t};\n\t\n\t\n\tvar __details_display = function ( api, show ) {\n\t\tvar ctx = api.context;\n\t\n\t\tif ( ctx.length && api.length ) {\n\t\t\tvar row = ctx[0].aoData[ api[0] ];\n\t\n\t\t\tif ( row._details ) {\n\t\t\t\trow._detailsShow = show;\n\t\n\t\t\t\tif ( show ) {\n\t\t\t\t\trow._details.insertAfter( row.nTr );\n\t\t\t\t\t$( row.nTr ).addClass( 'dt-hasChild' );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\trow._details.detach();\n\t\t\t\t\t$( row.nTr ).removeClass( 'dt-hasChild' );\n\t\t\t\t}\n\t\n\t\t\t\t_fnCallbackFire( ctx[0], null, 'childRow', [ show, api.row( api[0] ) ] )\n\t\n\t\t\t\t__details_events( ctx[0] );\n\t\t\t\t__details_state( ctx );\n\t\t\t}\n\t\t}\n\t};\n\t\n\t\n\tvar __details_events = function ( settings )\n\t{\n\t\tvar api = new _Api( settings );\n\t\tvar namespace = '.dt.DT_details';\n\t\tvar drawEvent = 'draw'+namespace;\n\t\tvar colvisEvent = 'column-sizing'+namespace;\n\t\tvar destroyEvent = 'destroy'+namespace;\n\t\tvar data = settings.aoData;\n\t\n\t\tapi.off( drawEvent +' '+ colvisEvent +' '+ destroyEvent );\n\t\n\t\tif ( _pluck( data, '_details' ).length > 0 ) {\n\t\t\t// On each draw, insert the required elements into the document\n\t\t\tapi.on( drawEvent, function ( e, ctx ) {\n\t\t\t\tif ( settings !== ctx ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\n\t\t\t\tapi.rows( {page:'current'} ).eq(0).each( function (idx) {\n\t\t\t\t\t// Internal data grab\n\t\t\t\t\tvar row = data[ idx ];\n\t\n\t\t\t\t\tif ( row._detailsShow ) {\n\t\t\t\t\t\trow._details.insertAfter( row.nTr );\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t} );\n\t\n\t\t\t// Column visibility change - update the colspan\n\t\t\tapi.on( colvisEvent, function ( e, ctx, idx, vis ) {\n\t\t\t\tif ( settings !== ctx ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\n\t\t\t\t// Update the colspan for the details rows (note, only if it already has\n\t\t\t\t// a colspan)\n\t\t\t\tvar row, visible = _fnVisbleColumns( ctx );\n\t\n\t\t\t\tfor ( var i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\t\t\trow = data[i];\n\t\n\t\t\t\t\tif ( row._details ) {\n\t\t\t\t\t\trow._details.children('td[colspan]').attr('colspan', visible );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\n\t\t\t// Table destroyed - nuke any child rows\n\t\t\tapi.on( destroyEvent, function ( e, ctx ) {\n\t\t\t\tif ( settings !== ctx ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\n\t\t\t\tfor ( var i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\t\t\tif ( data[i]._details ) {\n\t\t\t\t\t\t__details_remove( api, i );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\t\t}\n\t};\n\t\n\t// Strings for the method names to help minification\n\tvar _emp = '';\n\tvar _child_obj = _emp+'row().child';\n\tvar _child_mth = _child_obj+'()';\n\t\n\t// data can be:\n\t//  tr\n\t//  string\n\t//  jQuery or array of any of the above\n\t_api_register( _child_mth, function ( data, klass ) {\n\t\tvar ctx = this.context;\n\t\n\t\tif ( data === undefined ) {\n\t\t\t// get\n\t\t\treturn ctx.length && this.length ?\n\t\t\t\tctx[0].aoData[ this[0] ]._details :\n\t\t\t\tundefined;\n\t\t}\n\t\telse if ( data === true ) {\n\t\t\t// show\n\t\t\tthis.child.show();\n\t\t}\n\t\telse if ( data === false ) {\n\t\t\t// remove\n\t\t\t__details_remove( this );\n\t\t}\n\t\telse if ( ctx.length && this.length ) {\n\t\t\t// set\n\t\t\t__details_add( ctx[0], ctx[0].aoData[ this[0] ], data, klass );\n\t\t}\n\t\n\t\treturn this;\n\t} );\n\t\n\t\n\t_api_register( [\n\t\t_child_obj+'.show()',\n\t\t_child_mth+'.show()' // only when `child()` was called with parameters (without\n\t], function ( show ) {   // it returns an object and this method is not executed)\n\t\t__details_display( this, true );\n\t\treturn this;\n\t} );\n\t\n\t\n\t_api_register( [\n\t\t_child_obj+'.hide()',\n\t\t_child_mth+'.hide()' // only when `child()` was called with parameters (without\n\t], function () {         // it returns an object and this method is not executed)\n\t\t__details_display( this, false );\n\t\treturn this;\n\t} );\n\t\n\t\n\t_api_register( [\n\t\t_child_obj+'.remove()',\n\t\t_child_mth+'.remove()' // only when `child()` was called with parameters (without\n\t], function () {           // it returns an object and this method is not executed)\n\t\t__details_remove( this );\n\t\treturn this;\n\t} );\n\t\n\t\n\t_api_register( _child_obj+'.isShown()', function () {\n\t\tvar ctx = this.context;\n\t\n\t\tif ( ctx.length && this.length ) {\n\t\t\t// _detailsShown as false or undefined will fall through to return false\n\t\t\treturn ctx[0].aoData[ this[0] ]._detailsShow || false;\n\t\t}\n\t\treturn false;\n\t} );\n\t\n\t\n\t\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Columns\n\t *\n\t * {integer}           - column index (>=0 count from left, <0 count from right)\n\t * \"{integer}:visIdx\"  - visible column index (i.e. translate to column index)  (>=0 count from left, <0 count from right)\n\t * \"{integer}:visible\" - alias for {integer}:visIdx  (>=0 count from left, <0 count from right)\n\t * \"{string}:name\"     - column name\n\t * \"{string}\"          - jQuery selector on column header nodes\n\t *\n\t */\n\t\n\t// can be an array of these items, comma separated list, or an array of comma\n\t// separated lists\n\t\n\tvar __re_column_selector = /^([^:]+):(name|visIdx|visible)$/;\n\t\n\t\n\t// r1 and r2 are redundant - but it means that the parameters match for the\n\t// iterator callback in columns().data()\n\tvar __columnData = function ( settings, column, r1, r2, rows ) {\n\t\tvar a = [];\n\t\tfor ( var row=0, ien=rows.length ; row<ien ; row++ ) {\n\t\t\ta.push( _fnGetCellData( settings, rows[row], column ) );\n\t\t}\n\t\treturn a;\n\t};\n\t\n\t\n\tvar __column_selector = function ( settings, selector, opts )\n\t{\n\t\tvar\n\t\t\tcolumns = settings.aoColumns,\n\t\t\tnames = _pluck( columns, 'sName' ),\n\t\t\tnodes = _pluck( columns, 'nTh' );\n\t\n\t\tvar run = function ( s ) {\n\t\t\tvar selInt = _intVal( s );\n\t\n\t\t\t// Selector - all\n\t\t\tif ( s === '' ) {\n\t\t\t\treturn _range( columns.length );\n\t\t\t}\n\t\n\t\t\t// Selector - index\n\t\t\tif ( selInt !== null ) {\n\t\t\t\treturn [ selInt >= 0 ?\n\t\t\t\t\tselInt : // Count from left\n\t\t\t\t\tcolumns.length + selInt // Count from right (+ because its a negative value)\n\t\t\t\t];\n\t\t\t}\n\t\n\t\t\t// Selector = function\n\t\t\tif ( typeof s === 'function' ) {\n\t\t\t\tvar rows = _selector_row_indexes( settings, opts );\n\t\n\t\t\t\treturn $.map( columns, function (col, idx) {\n\t\t\t\t\treturn s(\n\t\t\t\t\t\t\tidx,\n\t\t\t\t\t\t\t__columnData( settings, idx, 0, 0, rows ),\n\t\t\t\t\t\t\tnodes[ idx ]\n\t\t\t\t\t\t) ? idx : null;\n\t\t\t\t} );\n\t\t\t}\n\t\n\t\t\t// jQuery or string selector\n\t\t\tvar match = typeof s === 'string' ?\n\t\t\t\ts.match( __re_column_selector ) :\n\t\t\t\t'';\n\t\n\t\t\tif ( match ) {\n\t\t\t\tswitch( match[2] ) {\n\t\t\t\t\tcase 'visIdx':\n\t\t\t\t\tcase 'visible':\n\t\t\t\t\t\tvar idx = parseInt( match[1], 10 );\n\t\t\t\t\t\t// Visible index given, convert to column index\n\t\t\t\t\t\tif ( idx < 0 ) {\n\t\t\t\t\t\t\t// Counting from the right\n\t\t\t\t\t\t\tvar visColumns = $.map( columns, function (col,i) {\n\t\t\t\t\t\t\t\treturn col.bVisible ? i : null;\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\treturn [ visColumns[ visColumns.length + idx ] ];\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Counting from the left\n\t\t\t\t\t\treturn [ _fnVisibleToColumnIndex( settings, idx ) ];\n\t\n\t\t\t\t\tcase 'name':\n\t\t\t\t\t\t// match by name. `names` is column index complete and in order\n\t\t\t\t\t\treturn $.map( names, function (name, i) {\n\t\t\t\t\t\t\treturn name === match[1] ? i : null;\n\t\t\t\t\t\t} );\n\t\n\t\t\t\t\tdefault:\n\t\t\t\t\t\treturn [];\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t// Cell in the table body\n\t\t\tif ( s.nodeName && s._DT_CellIndex ) {\n\t\t\t\treturn [ s._DT_CellIndex.column ];\n\t\t\t}\n\t\n\t\t\t// jQuery selector on the TH elements for the columns\n\t\t\tvar jqResult = $( nodes )\n\t\t\t\t.filter( s )\n\t\t\t\t.map( function () {\n\t\t\t\t\treturn $.inArray( this, nodes ); // `nodes` is column index complete and in order\n\t\t\t\t} )\n\t\t\t\t.toArray();\n\t\n\t\t\tif ( jqResult.length || ! s.nodeName ) {\n\t\t\t\treturn jqResult;\n\t\t\t}\n\t\n\t\t\t// Otherwise a node which might have a `dt-column` data attribute, or be\n\t\t\t// a child or such an element\n\t\t\tvar host = $(s).closest('*[data-dt-column]');\n\t\t\treturn host.length ?\n\t\t\t\t[ host.data('dt-column') ] :\n\t\t\t\t[];\n\t\t};\n\t\n\t\treturn _selector_run( 'column', selector, run, settings, opts );\n\t};\n\t\n\t\n\tvar __setColumnVis = function ( settings, column, vis ) {\n\t\tvar\n\t\t\tcols = settings.aoColumns,\n\t\t\tcol  = cols[ column ],\n\t\t\tdata = settings.aoData,\n\t\t\trow, cells, i, ien, tr;\n\t\n\t\t// Get\n\t\tif ( vis === undefined ) {\n\t\t\treturn col.bVisible;\n\t\t}\n\t\n\t\t// Set\n\t\t// No change\n\t\tif ( col.bVisible === vis ) {\n\t\t\treturn;\n\t\t}\n\t\n\t\tif ( vis ) {\n\t\t\t// Insert column\n\t\t\t// Need to decide if we should use appendChild or insertBefore\n\t\t\tvar insertBefore = $.inArray( true, _pluck(cols, 'bVisible'), column+1 );\n\t\n\t\t\tfor ( i=0, ien=data.length ; i<ien ; i++ ) {\n\t\t\t\ttr = data[i].nTr;\n\t\t\t\tcells = data[i].anCells;\n\t\n\t\t\t\tif ( tr ) {\n\t\t\t\t\t// insertBefore can act like appendChild if 2nd arg is null\n\t\t\t\t\ttr.insertBefore( cells[ column ], cells[ insertBefore ] || null );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\t// Remove column\n\t\t\t$( _pluck( settings.aoData, 'anCells', column ) ).detach();\n\t\t}\n\t\n\t\t// Common actions\n\t\tcol.bVisible = vis;\n\t};\n\t\n\t\n\t_api_register( 'columns()', function ( selector, opts ) {\n\t\t// argument shifting\n\t\tif ( selector === undefined ) {\n\t\t\tselector = '';\n\t\t}\n\t\telse if ( $.isPlainObject( selector ) ) {\n\t\t\topts = selector;\n\t\t\tselector = '';\n\t\t}\n\t\n\t\topts = _selector_opts( opts );\n\t\n\t\tvar inst = this.iterator( 'table', function ( settings ) {\n\t\t\treturn __column_selector( settings, selector, opts );\n\t\t}, 1 );\n\t\n\t\t// Want argument shifting here and in _row_selector?\n\t\tinst.selector.cols = selector;\n\t\tinst.selector.opts = opts;\n\t\n\t\treturn inst;\n\t} );\n\t\n\t_api_registerPlural( 'columns().header()', 'column().header()', function ( selector, opts ) {\n\t\treturn this.iterator( 'column', function ( settings, column ) {\n\t\t\treturn settings.aoColumns[column].nTh;\n\t\t}, 1 );\n\t} );\n\t\n\t_api_registerPlural( 'columns().footer()', 'column().footer()', function ( selector, opts ) {\n\t\treturn this.iterator( 'column', function ( settings, column ) {\n\t\t\treturn settings.aoColumns[column].nTf;\n\t\t}, 1 );\n\t} );\n\t\n\t_api_registerPlural( 'columns().data()', 'column().data()', function () {\n\t\treturn this.iterator( 'column-rows', __columnData, 1 );\n\t} );\n\t\n\t_api_registerPlural( 'columns().dataSrc()', 'column().dataSrc()', function () {\n\t\treturn this.iterator( 'column', function ( settings, column ) {\n\t\t\treturn settings.aoColumns[column].mData;\n\t\t}, 1 );\n\t} );\n\t\n\t_api_registerPlural( 'columns().cache()', 'column().cache()', function ( type ) {\n\t\treturn this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {\n\t\t\treturn _pluck_order( settings.aoData, rows,\n\t\t\t\ttype === 'search' ? '_aFilterData' : '_aSortData', column\n\t\t\t);\n\t\t}, 1 );\n\t} );\n\t\n\t_api_registerPlural( 'columns().nodes()', 'column().nodes()', function () {\n\t\treturn this.iterator( 'column-rows', function ( settings, column, i, j, rows ) {\n\t\t\treturn _pluck_order( settings.aoData, rows, 'anCells', column ) ;\n\t\t}, 1 );\n\t} );\n\t\n\t_api_registerPlural( 'columns().visible()', 'column().visible()', function ( vis, calc ) {\n\t\tvar that = this;\n\t\tvar ret = this.iterator( 'column', function ( settings, column ) {\n\t\t\tif ( vis === undefined ) {\n\t\t\t\treturn settings.aoColumns[ column ].bVisible;\n\t\t\t} // else\n\t\t\t__setColumnVis( settings, column, vis );\n\t\t} );\n\t\n\t\t// Group the column visibility changes\n\t\tif ( vis !== undefined ) {\n\t\t\tthis.iterator( 'table', function ( settings ) {\n\t\t\t\t// Redraw the header after changes\n\t\t\t\t_fnDrawHead( settings, settings.aoHeader );\n\t\t\t\t_fnDrawHead( settings, settings.aoFooter );\n\t\t\n\t\t\t\t// Update colspan for no records display. Child rows and extensions will use their own\n\t\t\t\t// listeners to do this - only need to update the empty table item here\n\t\t\t\tif ( ! settings.aiDisplay.length ) {\n\t\t\t\t\t$(settings.nTBody).find('td[colspan]').attr('colspan', _fnVisbleColumns(settings));\n\t\t\t\t}\n\t\t\n\t\t\t\t_fnSaveState( settings );\n\t\n\t\t\t\t// Second loop once the first is done for events\n\t\t\t\tthat.iterator( 'column', function ( settings, column ) {\n\t\t\t\t\t_fnCallbackFire( settings, null, 'column-visibility', [settings, column, vis, calc] );\n\t\t\t\t} );\n\t\n\t\t\t\tif ( calc === undefined || calc ) {\n\t\t\t\t\tthat.columns.adjust();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\n\t\treturn ret;\n\t} );\n\t\n\t_api_registerPlural( 'columns().indexes()', 'column().index()', function ( type ) {\n\t\treturn this.iterator( 'column', function ( settings, column ) {\n\t\t\treturn type === 'visible' ?\n\t\t\t\t_fnColumnIndexToVisible( settings, column ) :\n\t\t\t\tcolumn;\n\t\t}, 1 );\n\t} );\n\t\n\t_api_register( 'columns.adjust()', function () {\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\t_fnAdjustColumnSizing( settings );\n\t\t}, 1 );\n\t} );\n\t\n\t_api_register( 'column.index()', function ( type, idx ) {\n\t\tif ( this.context.length !== 0 ) {\n\t\t\tvar ctx = this.context[0];\n\t\n\t\t\tif ( type === 'fromVisible' || type === 'toData' ) {\n\t\t\t\treturn _fnVisibleToColumnIndex( ctx, idx );\n\t\t\t}\n\t\t\telse if ( type === 'fromData' || type === 'toVisible' ) {\n\t\t\t\treturn _fnColumnIndexToVisible( ctx, idx );\n\t\t\t}\n\t\t}\n\t} );\n\t\n\t_api_register( 'column()', function ( selector, opts ) {\n\t\treturn _selector_first( this.columns( selector, opts ) );\n\t} );\n\t\n\tvar __cell_selector = function ( settings, selector, opts )\n\t{\n\t\tvar data = settings.aoData;\n\t\tvar rows = _selector_row_indexes( settings, opts );\n\t\tvar cells = _removeEmpty( _pluck_order( data, rows, 'anCells' ) );\n\t\tvar allCells = $(_flatten( [], cells ));\n\t\tvar row;\n\t\tvar columns = settings.aoColumns.length;\n\t\tvar a, i, ien, j, o, host;\n\t\n\t\tvar run = function ( s ) {\n\t\t\tvar fnSelector = typeof s === 'function';\n\t\n\t\t\tif ( s === null || s === undefined || fnSelector ) {\n\t\t\t\t// All cells and function selectors\n\t\t\t\ta = [];\n\t\n\t\t\t\tfor ( i=0, ien=rows.length ; i<ien ; i++ ) {\n\t\t\t\t\trow = rows[i];\n\t\n\t\t\t\t\tfor ( j=0 ; j<columns ; j++ ) {\n\t\t\t\t\t\to = {\n\t\t\t\t\t\t\trow: row,\n\t\t\t\t\t\t\tcolumn: j\n\t\t\t\t\t\t};\n\t\n\t\t\t\t\t\tif ( fnSelector ) {\n\t\t\t\t\t\t\t// Selector - function\n\t\t\t\t\t\t\thost = data[ row ];\n\t\n\t\t\t\t\t\t\tif ( s( o, _fnGetCellData(settings, row, j), host.anCells ? host.anCells[j] : null ) ) {\n\t\t\t\t\t\t\t\ta.push( o );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\t// Selector - all\n\t\t\t\t\t\t\ta.push( o );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\n\t\t\t\treturn a;\n\t\t\t}\n\t\t\t\n\t\t\t// Selector - index\n\t\t\tif ( $.isPlainObject( s ) ) {\n\t\t\t\t// Valid cell index and its in the array of selectable rows\n\t\t\t\treturn s.column !== undefined && s.row !== undefined && $.inArray( s.row, rows ) !== -1 ?\n\t\t\t\t\t[s] :\n\t\t\t\t\t[];\n\t\t\t}\n\t\n\t\t\t// Selector - jQuery filtered cells\n\t\t\tvar jqResult = allCells\n\t\t\t\t.filter( s )\n\t\t\t\t.map( function (i, el) {\n\t\t\t\t\treturn { // use a new object, in case someone changes the values\n\t\t\t\t\t\trow:    el._DT_CellIndex.row,\n\t\t\t\t\t\tcolumn: el._DT_CellIndex.column\n\t \t\t\t\t};\n\t\t\t\t} )\n\t\t\t\t.toArray();\n\t\n\t\t\tif ( jqResult.length || ! s.nodeName ) {\n\t\t\t\treturn jqResult;\n\t\t\t}\n\t\n\t\t\t// Otherwise the selector is a node, and there is one last option - the\n\t\t\t// element might be a child of an element which has dt-row and dt-column\n\t\t\t// data attributes\n\t\t\thost = $(s).closest('*[data-dt-row]');\n\t\t\treturn host.length ?\n\t\t\t\t[ {\n\t\t\t\t\trow: host.data('dt-row'),\n\t\t\t\t\tcolumn: host.data('dt-column')\n\t\t\t\t} ] :\n\t\t\t\t[];\n\t\t};\n\t\n\t\treturn _selector_run( 'cell', selector, run, settings, opts );\n\t};\n\t\n\t\n\t\n\t\n\t_api_register( 'cells()', function ( rowSelector, columnSelector, opts ) {\n\t\t// Argument shifting\n\t\tif ( $.isPlainObject( rowSelector ) ) {\n\t\t\t// Indexes\n\t\t\tif ( rowSelector.row === undefined ) {\n\t\t\t\t// Selector options in first parameter\n\t\t\t\topts = rowSelector;\n\t\t\t\trowSelector = null;\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Cell index objects in first parameter\n\t\t\t\topts = columnSelector;\n\t\t\t\tcolumnSelector = null;\n\t\t\t}\n\t\t}\n\t\tif ( $.isPlainObject( columnSelector ) ) {\n\t\t\topts = columnSelector;\n\t\t\tcolumnSelector = null;\n\t\t}\n\t\n\t\t// Cell selector\n\t\tif ( columnSelector === null || columnSelector === undefined ) {\n\t\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\t\treturn __cell_selector( settings, rowSelector, _selector_opts( opts ) );\n\t\t\t} );\n\t\t}\n\t\n\t\t// The default built in options need to apply to row and columns\n\t\tvar internalOpts = opts ? {\n\t\t\tpage: opts.page,\n\t\t\torder: opts.order,\n\t\t\tsearch: opts.search\n\t\t} : {};\n\t\n\t\t// Row + column selector\n\t\tvar columns = this.columns( columnSelector, internalOpts );\n\t\tvar rows = this.rows( rowSelector, internalOpts );\n\t\tvar i, ien, j, jen;\n\t\n\t\tvar cellsNoOpts = this.iterator( 'table', function ( settings, idx ) {\n\t\t\tvar a = [];\n\t\n\t\t\tfor ( i=0, ien=rows[idx].length ; i<ien ; i++ ) {\n\t\t\t\tfor ( j=0, jen=columns[idx].length ; j<jen ; j++ ) {\n\t\t\t\t\ta.push( {\n\t\t\t\t\t\trow:    rows[idx][i],\n\t\t\t\t\t\tcolumn: columns[idx][j]\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\treturn a;\n\t\t}, 1 );\n\t\n\t\t// There is currently only one extension which uses a cell selector extension\n\t\t// It is a _major_ performance drag to run this if it isn't needed, so this is\n\t\t// an extension specific check at the moment\n\t\tvar cells = opts && opts.selected ?\n\t\t\tthis.cells( cellsNoOpts, opts ) :\n\t\t\tcellsNoOpts;\n\t\n\t\t$.extend( cells.selector, {\n\t\t\tcols: columnSelector,\n\t\t\trows: rowSelector,\n\t\t\topts: opts\n\t\t} );\n\t\n\t\treturn cells;\n\t} );\n\t\n\t\n\t_api_registerPlural( 'cells().nodes()', 'cell().node()', function () {\n\t\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\t\tvar data = settings.aoData[ row ];\n\t\n\t\t\treturn data && data.anCells ?\n\t\t\t\tdata.anCells[ column ] :\n\t\t\t\tundefined;\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t_api_register( 'cells().data()', function () {\n\t\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\t\treturn _fnGetCellData( settings, row, column );\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t_api_registerPlural( 'cells().cache()', 'cell().cache()', function ( type ) {\n\t\ttype = type === 'search' ? '_aFilterData' : '_aSortData';\n\t\n\t\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\t\treturn settings.aoData[ row ][ type ][ column ];\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t_api_registerPlural( 'cells().render()', 'cell().render()', function ( type ) {\n\t\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\t\treturn _fnGetCellData( settings, row, column, type );\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t_api_registerPlural( 'cells().indexes()', 'cell().index()', function () {\n\t\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\t\treturn {\n\t\t\t\trow: row,\n\t\t\t\tcolumn: column,\n\t\t\t\tcolumnVisible: _fnColumnIndexToVisible( settings, column )\n\t\t\t};\n\t\t}, 1 );\n\t} );\n\t\n\t\n\t_api_registerPlural( 'cells().invalidate()', 'cell().invalidate()', function ( src ) {\n\t\treturn this.iterator( 'cell', function ( settings, row, column ) {\n\t\t\t_fnInvalidate( settings, row, src, column );\n\t\t} );\n\t} );\n\t\n\t\n\t\n\t_api_register( 'cell()', function ( rowSelector, columnSelector, opts ) {\n\t\treturn _selector_first( this.cells( rowSelector, columnSelector, opts ) );\n\t} );\n\t\n\t\n\t_api_register( 'cell().data()', function ( data ) {\n\t\tvar ctx = this.context;\n\t\tvar cell = this[0];\n\t\n\t\tif ( data === undefined ) {\n\t\t\t// Get\n\t\t\treturn ctx.length && cell.length ?\n\t\t\t\t_fnGetCellData( ctx[0], cell[0].row, cell[0].column ) :\n\t\t\t\tundefined;\n\t\t}\n\t\n\t\t// Set\n\t\t_fnSetCellData( ctx[0], cell[0].row, cell[0].column, data );\n\t\t_fnInvalidate( ctx[0], cell[0].row, 'data', cell[0].column );\n\t\n\t\treturn this;\n\t} );\n\t\n\t\n\t\n\t/**\n\t * Get current ordering (sorting) that has been applied to the table.\n\t *\n\t * @returns {array} 2D array containing the sorting information for the first\n\t *   table in the current context. Each element in the parent array represents\n\t *   a column being sorted upon (i.e. multi-sorting with two columns would have\n\t *   2 inner arrays). The inner arrays may have 2 or 3 elements. The first is\n\t *   the column index that the sorting condition applies to, the second is the\n\t *   direction of the sort (`desc` or `asc`) and, optionally, the third is the\n\t *   index of the sorting order from the `column.sorting` initialisation array.\n\t *//**\n\t * Set the ordering for the table.\n\t *\n\t * @param {integer} order Column index to sort upon.\n\t * @param {string} direction Direction of the sort to be applied (`asc` or `desc`)\n\t * @returns {DataTables.Api} this\n\t *//**\n\t * Set the ordering for the table.\n\t *\n\t * @param {array} order 1D array of sorting information to be applied.\n\t * @param {array} [...] Optional additional sorting conditions\n\t * @returns {DataTables.Api} this\n\t *//**\n\t * Set the ordering for the table.\n\t *\n\t * @param {array} order 2D array of sorting information to be applied.\n\t * @returns {DataTables.Api} this\n\t */\n\t_api_register( 'order()', function ( order, dir ) {\n\t\tvar ctx = this.context;\n\t\n\t\tif ( order === undefined ) {\n\t\t\t// get\n\t\t\treturn ctx.length !== 0 ?\n\t\t\t\tctx[0].aaSorting :\n\t\t\t\tundefined;\n\t\t}\n\t\n\t\t// set\n\t\tif ( typeof order === 'number' ) {\n\t\t\t// Simple column / direction passed in\n\t\t\torder = [ [ order, dir ] ];\n\t\t}\n\t\telse if ( order.length && ! Array.isArray( order[0] ) ) {\n\t\t\t// Arguments passed in (list of 1D arrays)\n\t\t\torder = Array.prototype.slice.call( arguments );\n\t\t}\n\t\t// otherwise a 2D array was passed in\n\t\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\tsettings.aaSorting = order.slice();\n\t\t} );\n\t} );\n\t\n\t\n\t/**\n\t * Attach a sort listener to an element for a given column\n\t *\n\t * @param {node|jQuery|string} node Identifier for the element(s) to attach the\n\t *   listener to. This can take the form of a single DOM node, a jQuery\n\t *   collection of nodes or a jQuery selector which will identify the node(s).\n\t * @param {integer} column the column that a click on this node will sort on\n\t * @param {function} [callback] callback function when sort is run\n\t * @returns {DataTables.Api} this\n\t */\n\t_api_register( 'order.listener()', function ( node, column, callback ) {\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\t_fnSortAttachListener( settings, node, column, callback );\n\t\t} );\n\t} );\n\t\n\t\n\t_api_register( 'order.fixed()', function ( set ) {\n\t\tif ( ! set ) {\n\t\t\tvar ctx = this.context;\n\t\t\tvar fixed = ctx.length ?\n\t\t\t\tctx[0].aaSortingFixed :\n\t\t\t\tundefined;\n\t\n\t\t\treturn Array.isArray( fixed ) ?\n\t\t\t\t{ pre: fixed } :\n\t\t\t\tfixed;\n\t\t}\n\t\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\tsettings.aaSortingFixed = $.extend( true, {}, set );\n\t\t} );\n\t} );\n\t\n\t\n\t// Order by the selected column(s)\n\t_api_register( [\n\t\t'columns().order()',\n\t\t'column().order()'\n\t], function ( dir ) {\n\t\tvar that = this;\n\t\n\t\treturn this.iterator( 'table', function ( settings, i ) {\n\t\t\tvar sort = [];\n\t\n\t\t\t$.each( that[i], function (j, col) {\n\t\t\t\tsort.push( [ col, dir ] );\n\t\t\t} );\n\t\n\t\t\tsettings.aaSorting = sort;\n\t\t} );\n\t} );\n\t\n\t\n\t\n\t_api_register( 'search()', function ( input, regex, smart, caseInsen ) {\n\t\tvar ctx = this.context;\n\t\n\t\tif ( input === undefined ) {\n\t\t\t// get\n\t\t\treturn ctx.length !== 0 ?\n\t\t\t\tctx[0].oPreviousSearch.sSearch :\n\t\t\t\tundefined;\n\t\t}\n\t\n\t\t// set\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\tif ( ! settings.oFeatures.bFilter ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\n\t\t\t_fnFilterComplete( settings, $.extend( {}, settings.oPreviousSearch, {\n\t\t\t\t\"sSearch\": input+\"\",\n\t\t\t\t\"bRegex\":  regex === null ? false : regex,\n\t\t\t\t\"bSmart\":  smart === null ? true  : smart,\n\t\t\t\t\"bCaseInsensitive\": caseInsen === null ? true : caseInsen\n\t\t\t} ), 1 );\n\t\t} );\n\t} );\n\t\n\t\n\t_api_registerPlural(\n\t\t'columns().search()',\n\t\t'column().search()',\n\t\tfunction ( input, regex, smart, caseInsen ) {\n\t\t\treturn this.iterator( 'column', function ( settings, column ) {\n\t\t\t\tvar preSearch = settings.aoPreSearchCols;\n\t\n\t\t\t\tif ( input === undefined ) {\n\t\t\t\t\t// get\n\t\t\t\t\treturn preSearch[ column ].sSearch;\n\t\t\t\t}\n\t\n\t\t\t\t// set\n\t\t\t\tif ( ! settings.oFeatures.bFilter ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\n\t\t\t\t$.extend( preSearch[ column ], {\n\t\t\t\t\t\"sSearch\": input+\"\",\n\t\t\t\t\t\"bRegex\":  regex === null ? false : regex,\n\t\t\t\t\t\"bSmart\":  smart === null ? true  : smart,\n\t\t\t\t\t\"bCaseInsensitive\": caseInsen === null ? true : caseInsen\n\t\t\t\t} );\n\t\n\t\t\t\t_fnFilterComplete( settings, settings.oPreviousSearch, 1 );\n\t\t\t} );\n\t\t}\n\t);\n\t\n\t/*\n\t * State API methods\n\t */\n\t\n\t_api_register( 'state()', function () {\n\t\treturn this.context.length ?\n\t\t\tthis.context[0].oSavedState :\n\t\t\tnull;\n\t} );\n\t\n\t\n\t_api_register( 'state.clear()', function () {\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\t// Save an empty object\n\t\t\tsettings.fnStateSaveCallback.call( settings.oInstance, settings, {} );\n\t\t} );\n\t} );\n\t\n\t\n\t_api_register( 'state.loaded()', function () {\n\t\treturn this.context.length ?\n\t\t\tthis.context[0].oLoadedState :\n\t\t\tnull;\n\t} );\n\t\n\t\n\t_api_register( 'state.save()', function () {\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\t_fnSaveState( settings );\n\t\t} );\n\t} );\n\t\n\t\n\t\n\t/**\n\t * Provide a common method for plug-ins to check the version of DataTables being\n\t * used, in order to ensure compatibility.\n\t *\n\t *  @param {string} version Version string to check for, in the format \"X.Y.Z\".\n\t *    Note that the formats \"X\" and \"X.Y\" are also acceptable.\n\t *  @returns {boolean} true if this version of DataTables is greater or equal to\n\t *    the required version, or false if this version of DataTales is not\n\t *    suitable\n\t *  @static\n\t *  @dtopt API-Static\n\t *\n\t *  @example\n\t *    alert( $.fn.dataTable.versionCheck( '1.9.0' ) );\n\t */\n\tDataTable.versionCheck = DataTable.fnVersionCheck = function( version )\n\t{\n\t\tvar aThis = DataTable.version.split('.');\n\t\tvar aThat = version.split('.');\n\t\tvar iThis, iThat;\n\t\n\t\tfor ( var i=0, iLen=aThat.length ; i<iLen ; i++ ) {\n\t\t\tiThis = parseInt( aThis[i], 10 ) || 0;\n\t\t\tiThat = parseInt( aThat[i], 10 ) || 0;\n\t\n\t\t\t// Parts are the same, keep comparing\n\t\t\tif (iThis === iThat) {\n\t\t\t\tcontinue;\n\t\t\t}\n\t\n\t\t\t// Parts are different, return immediately\n\t\t\treturn iThis > iThat;\n\t\t}\n\t\n\t\treturn true;\n\t};\n\t\n\t\n\t/**\n\t * Check if a `<table>` node is a DataTable table already or not.\n\t *\n\t *  @param {node|jquery|string} table Table node, jQuery object or jQuery\n\t *      selector for the table to test. Note that if more than more than one\n\t *      table is passed on, only the first will be checked\n\t *  @returns {boolean} true the table given is a DataTable, or false otherwise\n\t *  @static\n\t *  @dtopt API-Static\n\t *\n\t *  @example\n\t *    if ( ! $.fn.DataTable.isDataTable( '#example' ) ) {\n\t *      $('#example').dataTable();\n\t *    }\n\t */\n\tDataTable.isDataTable = DataTable.fnIsDataTable = function ( table )\n\t{\n\t\tvar t = $(table).get(0);\n\t\tvar is = false;\n\t\n\t\tif ( table instanceof DataTable.Api ) {\n\t\t\treturn true;\n\t\t}\n\t\n\t\t$.each( DataTable.settings, function (i, o) {\n\t\t\tvar head = o.nScrollHead ? $('table', o.nScrollHead)[0] : null;\n\t\t\tvar foot = o.nScrollFoot ? $('table', o.nScrollFoot)[0] : null;\n\t\n\t\t\tif ( o.nTable === t || head === t || foot === t ) {\n\t\t\t\tis = true;\n\t\t\t}\n\t\t} );\n\t\n\t\treturn is;\n\t};\n\t\n\t\n\t/**\n\t * Get all DataTable tables that have been initialised - optionally you can\n\t * select to get only currently visible tables.\n\t *\n\t *  @param {boolean} [visible=false] Flag to indicate if you want all (default)\n\t *    or visible tables only.\n\t *  @returns {array} Array of `table` nodes (not DataTable instances) which are\n\t *    DataTables\n\t *  @static\n\t *  @dtopt API-Static\n\t *\n\t *  @example\n\t *    $.each( $.fn.dataTable.tables(true), function () {\n\t *      $(table).DataTable().columns.adjust();\n\t *    } );\n\t */\n\tDataTable.tables = DataTable.fnTables = function ( visible )\n\t{\n\t\tvar api = false;\n\t\n\t\tif ( $.isPlainObject( visible ) ) {\n\t\t\tapi = visible.api;\n\t\t\tvisible = visible.visible;\n\t\t}\n\t\n\t\tvar a = $.map( DataTable.settings, function (o) {\n\t\t\tif ( !visible || (visible && $(o.nTable).is(':visible')) ) {\n\t\t\t\treturn o.nTable;\n\t\t\t}\n\t\t} );\n\t\n\t\treturn api ?\n\t\t\tnew _Api( a ) :\n\t\t\ta;\n\t};\n\t\n\t\n\t/**\n\t * Convert from camel case parameters to Hungarian notation. This is made public\n\t * for the extensions to provide the same ability as DataTables core to accept\n\t * either the 1.9 style Hungarian notation, or the 1.10+ style camelCase\n\t * parameters.\n\t *\n\t *  @param {object} src The model object which holds all parameters that can be\n\t *    mapped.\n\t *  @param {object} user The object to convert from camel case to Hungarian.\n\t *  @param {boolean} force When set to `true`, properties which already have a\n\t *    Hungarian value in the `user` object will be overwritten. Otherwise they\n\t *    won't be.\n\t */\n\tDataTable.camelToHungarian = _fnCamelToHungarian;\n\t\n\t\n\t\n\t/**\n\t *\n\t */\n\t_api_register( '$()', function ( selector, opts ) {\n\t\tvar\n\t\t\trows   = this.rows( opts ).nodes(), // Get all rows\n\t\t\tjqRows = $(rows);\n\t\n\t\treturn $( [].concat(\n\t\t\tjqRows.filter( selector ).toArray(),\n\t\t\tjqRows.find( selector ).toArray()\n\t\t) );\n\t} );\n\t\n\t\n\t// jQuery functions to operate on the tables\n\t$.each( [ 'on', 'one', 'off' ], function (i, key) {\n\t\t_api_register( key+'()', function ( /* event, handler */ ) {\n\t\t\tvar args = Array.prototype.slice.call(arguments);\n\t\n\t\t\t// Add the `dt` namespace automatically if it isn't already present\n\t\t\targs[0] = $.map( args[0].split( /\\s/ ), function ( e ) {\n\t\t\t\treturn ! e.match(/\\.dt\\b/) ?\n\t\t\t\t\te+'.dt' :\n\t\t\t\t\te;\n\t\t\t\t} ).join( ' ' );\n\t\n\t\t\tvar inst = $( this.tables().nodes() );\n\t\t\tinst[key].apply( inst, args );\n\t\t\treturn this;\n\t\t} );\n\t} );\n\t\n\t\n\t_api_register( 'clear()', function () {\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\t_fnClearTable( settings );\n\t\t} );\n\t} );\n\t\n\t\n\t_api_register( 'settings()', function () {\n\t\treturn new _Api( this.context, this.context );\n\t} );\n\t\n\t\n\t_api_register( 'init()', function () {\n\t\tvar ctx = this.context;\n\t\treturn ctx.length ? ctx[0].oInit : null;\n\t} );\n\t\n\t\n\t_api_register( 'data()', function () {\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\treturn _pluck( settings.aoData, '_aData' );\n\t\t} ).flatten();\n\t} );\n\t\n\t\n\t_api_register( 'destroy()', function ( remove ) {\n\t\tremove = remove || false;\n\t\n\t\treturn this.iterator( 'table', function ( settings ) {\n\t\t\tvar classes   = settings.oClasses;\n\t\t\tvar table     = settings.nTable;\n\t\t\tvar tbody     = settings.nTBody;\n\t\t\tvar thead     = settings.nTHead;\n\t\t\tvar tfoot     = settings.nTFoot;\n\t\t\tvar jqTable   = $(table);\n\t\t\tvar jqTbody   = $(tbody);\n\t\t\tvar jqWrapper = $(settings.nTableWrapper);\n\t\t\tvar rows      = $.map( settings.aoData, function (r) { return r.nTr; } );\n\t\t\tvar i, ien;\n\t\n\t\t\t// Flag to note that the table is currently being destroyed - no action\n\t\t\t// should be taken\n\t\t\tsettings.bDestroying = true;\n\t\n\t\t\t// Fire off the destroy callbacks for plug-ins etc\n\t\t\t_fnCallbackFire( settings, \"aoDestroyCallback\", \"destroy\", [settings] );\n\t\n\t\t\t// If not being removed from the document, make all columns visible\n\t\t\tif ( ! remove ) {\n\t\t\t\tnew _Api( settings ).columns().visible( true );\n\t\t\t}\n\t\n\t\t\t// Blitz all `DT` namespaced events (these are internal events, the\n\t\t\t// lowercase, `dt` events are user subscribed and they are responsible\n\t\t\t// for removing them\n\t\t\tjqWrapper.off('.DT').find(':not(tbody *)').off('.DT');\n\t\t\t$(window).off('.DT-'+settings.sInstance);\n\t\n\t\t\t// When scrolling we had to break the table up - restore it\n\t\t\tif ( table != thead.parentNode ) {\n\t\t\t\tjqTable.children('thead').detach();\n\t\t\t\tjqTable.append( thead );\n\t\t\t}\n\t\n\t\t\tif ( tfoot && table != tfoot.parentNode ) {\n\t\t\t\tjqTable.children('tfoot').detach();\n\t\t\t\tjqTable.append( tfoot );\n\t\t\t}\n\t\n\t\t\tsettings.aaSorting = [];\n\t\t\tsettings.aaSortingFixed = [];\n\t\t\t_fnSortingClasses( settings );\n\t\n\t\t\t$( rows ).removeClass( settings.asStripeClasses.join(' ') );\n\t\n\t\t\t$('th, td', thead).removeClass( classes.sSortable+' '+\n\t\t\t\tclasses.sSortableAsc+' '+classes.sSortableDesc+' '+classes.sSortableNone\n\t\t\t);\n\t\n\t\t\t// Add the TR elements back into the table in their original order\n\t\t\tjqTbody.children().detach();\n\t\t\tjqTbody.append( rows );\n\t\n\t\t\tvar orig = settings.nTableWrapper.parentNode;\n\t\n\t\t\t// Remove the DataTables generated nodes, events and classes\n\t\t\tvar removedMethod = remove ? 'remove' : 'detach';\n\t\t\tjqTable[ removedMethod ]();\n\t\t\tjqWrapper[ removedMethod ]();\n\t\n\t\t\t// If we need to reattach the table to the document\n\t\t\tif ( ! remove && orig ) {\n\t\t\t\t// insertBefore acts like appendChild if !arg[1]\n\t\t\t\torig.insertBefore( table, settings.nTableReinsertBefore );\n\t\n\t\t\t\t// Restore the width of the original table - was read from the style property,\n\t\t\t\t// so we can restore directly to that\n\t\t\t\tjqTable\n\t\t\t\t\t.css( 'width', settings.sDestroyWidth )\n\t\t\t\t\t.removeClass( classes.sTable );\n\t\n\t\t\t\t// If the were originally stripe classes - then we add them back here.\n\t\t\t\t// Note this is not fool proof (for example if not all rows had stripe\n\t\t\t\t// classes - but it's a good effort without getting carried away\n\t\t\t\tien = settings.asDestroyStripes.length;\n\t\n\t\t\t\tif ( ien ) {\n\t\t\t\t\tjqTbody.children().each( function (i) {\n\t\t\t\t\t\t$(this).addClass( settings.asDestroyStripes[i % ien] );\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t/* Remove the settings object from the settings array */\n\t\t\tvar idx = $.inArray( settings, DataTable.settings );\n\t\t\tif ( idx !== -1 ) {\n\t\t\t\tDataTable.settings.splice( idx, 1 );\n\t\t\t}\n\t\t} );\n\t} );\n\t\n\t\n\t// Add the `every()` method for rows, columns and cells in a compact form\n\t$.each( [ 'column', 'row', 'cell' ], function ( i, type ) {\n\t\t_api_register( type+'s().every()', function ( fn ) {\n\t\t\tvar opts = this.selector.opts;\n\t\t\tvar api = this;\n\t\n\t\t\treturn this.iterator( type, function ( settings, arg1, arg2, arg3, arg4 ) {\n\t\t\t\t// Rows and columns:\n\t\t\t\t//  arg1 - index\n\t\t\t\t//  arg2 - table counter\n\t\t\t\t//  arg3 - loop counter\n\t\t\t\t//  arg4 - undefined\n\t\t\t\t// Cells:\n\t\t\t\t//  arg1 - row index\n\t\t\t\t//  arg2 - column index\n\t\t\t\t//  arg3 - table counter\n\t\t\t\t//  arg4 - loop counter\n\t\t\t\tfn.call(\n\t\t\t\t\tapi[ type ](\n\t\t\t\t\t\targ1,\n\t\t\t\t\t\ttype==='cell' ? arg2 : opts,\n\t\t\t\t\t\ttype==='cell' ? opts : undefined\n\t\t\t\t\t),\n\t\t\t\t\targ1, arg2, arg3, arg4\n\t\t\t\t);\n\t\t\t} );\n\t\t} );\n\t} );\n\t\n\t\n\t// i18n method for extensions to be able to use the language object from the\n\t// DataTable\n\t_api_register( 'i18n()', function ( token, def, plural ) {\n\t\tvar ctx = this.context[0];\n\t\tvar resolved = _fnGetObjectDataFn( token )( ctx.oLanguage );\n\t\n\t\tif ( resolved === undefined ) {\n\t\t\tresolved = def;\n\t\t}\n\t\n\t\tif ( plural !== undefined && $.isPlainObject( resolved ) ) {\n\t\t\tresolved = resolved[ plural ] !== undefined ?\n\t\t\t\tresolved[ plural ] :\n\t\t\t\tresolved._;\n\t\t}\n\t\n\t\treturn resolved.replace( '%d', plural ); // nb: plural might be undefined,\n\t} );\t\n\t/**\n\t * Version string for plug-ins to check compatibility. Allowed format is\n\t * `a.b.c-d` where: a:int, b:int, c:int, d:string(dev|beta|alpha). `d` is used\n\t * only for non-release builds. See http://semver.org/ for more information.\n\t *  @member\n\t *  @type string\n\t *  @default Version number\n\t */\n\tDataTable.version = \"1.12.1\";\n\t\n\t/**\n\t * Private data store, containing all of the settings objects that are\n\t * created for the tables on a given page.\n\t *\n\t * Note that the `DataTable.settings` object is aliased to\n\t * `jQuery.fn.dataTableExt` through which it may be accessed and\n\t * manipulated, or `jQuery.fn.dataTable.settings`.\n\t *  @member\n\t *  @type array\n\t *  @default []\n\t *  @private\n\t */\n\tDataTable.settings = [];\n\t\n\t/**\n\t * Object models container, for the various models that DataTables has\n\t * available to it. These models define the objects that are used to hold\n\t * the active state and configuration of the table.\n\t *  @namespace\n\t */\n\tDataTable.models = {};\n\t\n\t\n\t\n\t/**\n\t * Template object for the way in which DataTables holds information about\n\t * search information for the global filter and individual column filters.\n\t *  @namespace\n\t */\n\tDataTable.models.oSearch = {\n\t\t/**\n\t\t * Flag to indicate if the filtering should be case insensitive or not\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t */\n\t\t\"bCaseInsensitive\": true,\n\t\n\t\t/**\n\t\t * Applied search term\n\t\t *  @type string\n\t\t *  @default <i>Empty string</i>\n\t\t */\n\t\t\"sSearch\": \"\",\n\t\n\t\t/**\n\t\t * Flag to indicate if the search term should be interpreted as a\n\t\t * regular expression (true) or not (false) and therefore and special\n\t\t * regex characters escaped.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t */\n\t\t\"bRegex\": false,\n\t\n\t\t/**\n\t\t * Flag to indicate if DataTables is to use its smart filtering or not.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t */\n\t\t\"bSmart\": true,\n\t\n\t\t/**\n\t\t * Flag to indicate if DataTables should only trigger a search when\n\t\t * the return key is pressed.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t */\n\t\t\"return\": false\n\t};\n\t\n\t\n\t\n\t\n\t/**\n\t * Template object for the way in which DataTables holds information about\n\t * each individual row. This is the object format used for the settings\n\t * aoData array.\n\t *  @namespace\n\t */\n\tDataTable.models.oRow = {\n\t\t/**\n\t\t * TR element for the row\n\t\t *  @type node\n\t\t *  @default null\n\t\t */\n\t\t\"nTr\": null,\n\t\n\t\t/**\n\t\t * Array of TD elements for each row. This is null until the row has been\n\t\t * created.\n\t\t *  @type array nodes\n\t\t *  @default []\n\t\t */\n\t\t\"anCells\": null,\n\t\n\t\t/**\n\t\t * Data object from the original data source for the row. This is either\n\t\t * an array if using the traditional form of DataTables, or an object if\n\t\t * using mData options. The exact type will depend on the passed in\n\t\t * data from the data source, or will be an array if using DOM a data\n\t\t * source.\n\t\t *  @type array|object\n\t\t *  @default []\n\t\t */\n\t\t\"_aData\": [],\n\t\n\t\t/**\n\t\t * Sorting data cache - this array is ostensibly the same length as the\n\t\t * number of columns (although each index is generated only as it is\n\t\t * needed), and holds the data that is used for sorting each column in the\n\t\t * row. We do this cache generation at the start of the sort in order that\n\t\t * the formatting of the sort data need be done only once for each cell\n\t\t * per sort. This array should not be read from or written to by anything\n\t\t * other than the master sorting methods.\n\t\t *  @type array\n\t\t *  @default null\n\t\t *  @private\n\t\t */\n\t\t\"_aSortData\": null,\n\t\n\t\t/**\n\t\t * Per cell filtering data cache. As per the sort data cache, used to\n\t\t * increase the performance of the filtering in DataTables\n\t\t *  @type array\n\t\t *  @default null\n\t\t *  @private\n\t\t */\n\t\t\"_aFilterData\": null,\n\t\n\t\t/**\n\t\t * Filtering data cache. This is the same as the cell filtering cache, but\n\t\t * in this case a string rather than an array. This is easily computed with\n\t\t * a join on `_aFilterData`, but is provided as a cache so the join isn't\n\t\t * needed on every search (memory traded for performance)\n\t\t *  @type array\n\t\t *  @default null\n\t\t *  @private\n\t\t */\n\t\t\"_sFilterRow\": null,\n\t\n\t\t/**\n\t\t * Cache of the class name that DataTables has applied to the row, so we\n\t\t * can quickly look at this variable rather than needing to do a DOM check\n\t\t * on className for the nTr property.\n\t\t *  @type string\n\t\t *  @default <i>Empty string</i>\n\t\t *  @private\n\t\t */\n\t\t\"_sRowStripe\": \"\",\n\t\n\t\t/**\n\t\t * Denote if the original data source was from the DOM, or the data source\n\t\t * object. This is used for invalidating data, so DataTables can\n\t\t * automatically read data from the original source, unless uninstructed\n\t\t * otherwise.\n\t\t *  @type string\n\t\t *  @default null\n\t\t *  @private\n\t\t */\n\t\t\"src\": null,\n\t\n\t\t/**\n\t\t * Index in the aoData array. This saves an indexOf lookup when we have the\n\t\t * object, but want to know the index\n\t\t *  @type integer\n\t\t *  @default -1\n\t\t *  @private\n\t\t */\n\t\t\"idx\": -1\n\t};\n\t\n\t\n\t/**\n\t * Template object for the column information object in DataTables. This object\n\t * is held in the settings aoColumns array and contains all the information that\n\t * DataTables needs about each individual column.\n\t *\n\t * Note that this object is related to {@link DataTable.defaults.column}\n\t * but this one is the internal data store for DataTables's cache of columns.\n\t * It should NOT be manipulated outside of DataTables. Any configuration should\n\t * be done through the initialisation options.\n\t *  @namespace\n\t */\n\tDataTable.models.oColumn = {\n\t\t/**\n\t\t * Column index. This could be worked out on-the-fly with $.inArray, but it\n\t\t * is faster to just hold it as a variable\n\t\t *  @type integer\n\t\t *  @default null\n\t\t */\n\t\t\"idx\": null,\n\t\n\t\t/**\n\t\t * A list of the columns that sorting should occur on when this column\n\t\t * is sorted. That this property is an array allows multi-column sorting\n\t\t * to be defined for a column (for example first name / last name columns\n\t\t * would benefit from this). The values are integers pointing to the\n\t\t * columns to be sorted on (typically it will be a single integer pointing\n\t\t * at itself, but that doesn't need to be the case).\n\t\t *  @type array\n\t\t */\n\t\t\"aDataSort\": null,\n\t\n\t\t/**\n\t\t * Define the sorting directions that are applied to the column, in sequence\n\t\t * as the column is repeatedly sorted upon - i.e. the first value is used\n\t\t * as the sorting direction when the column if first sorted (clicked on).\n\t\t * Sort it again (click again) and it will move on to the next index.\n\t\t * Repeat until loop.\n\t\t *  @type array\n\t\t */\n\t\t\"asSorting\": null,\n\t\n\t\t/**\n\t\t * Flag to indicate if the column is searchable, and thus should be included\n\t\t * in the filtering or not.\n\t\t *  @type boolean\n\t\t */\n\t\t\"bSearchable\": null,\n\t\n\t\t/**\n\t\t * Flag to indicate if the column is sortable or not.\n\t\t *  @type boolean\n\t\t */\n\t\t\"bSortable\": null,\n\t\n\t\t/**\n\t\t * Flag to indicate if the column is currently visible in the table or not\n\t\t *  @type boolean\n\t\t */\n\t\t\"bVisible\": null,\n\t\n\t\t/**\n\t\t * Store for manual type assignment using the `column.type` option. This\n\t\t * is held in store so we can manipulate the column's `sType` property.\n\t\t *  @type string\n\t\t *  @default null\n\t\t *  @private\n\t\t */\n\t\t\"_sManualType\": null,\n\t\n\t\t/**\n\t\t * Flag to indicate if HTML5 data attributes should be used as the data\n\t\t * source for filtering or sorting. True is either are.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *  @private\n\t\t */\n\t\t\"_bAttrSrc\": false,\n\t\n\t\t/**\n\t\t * Developer definable function that is called whenever a cell is created (Ajax source,\n\t\t * etc) or processed for input (DOM source). This can be used as a compliment to mRender\n\t\t * allowing you to modify the DOM element (add background colour for example) when the\n\t\t * element is available.\n\t\t *  @type function\n\t\t *  @param {element} nTd The TD node that has been created\n\t\t *  @param {*} sData The Data for the cell\n\t\t *  @param {array|object} oData The data for the whole row\n\t\t *  @param {int} iRow The row index for the aoData data store\n\t\t *  @default null\n\t\t */\n\t\t\"fnCreatedCell\": null,\n\t\n\t\t/**\n\t\t * Function to get data from a cell in a column. You should <b>never</b>\n\t\t * access data directly through _aData internally in DataTables - always use\n\t\t * the method attached to this property. It allows mData to function as\n\t\t * required. This function is automatically assigned by the column\n\t\t * initialisation method\n\t\t *  @type function\n\t\t *  @param {array|object} oData The data array/object for the array\n\t\t *    (i.e. aoData[]._aData)\n\t\t *  @param {string} sSpecific The specific data type you want to get -\n\t\t *    'display', 'type' 'filter' 'sort'\n\t\t *  @returns {*} The data for the cell from the given row's data\n\t\t *  @default null\n\t\t */\n\t\t\"fnGetData\": null,\n\t\n\t\t/**\n\t\t * Function to set data for a cell in the column. You should <b>never</b>\n\t\t * set the data directly to _aData internally in DataTables - always use\n\t\t * this method. It allows mData to function as required. This function\n\t\t * is automatically assigned by the column initialisation method\n\t\t *  @type function\n\t\t *  @param {array|object} oData The data array/object for the array\n\t\t *    (i.e. aoData[]._aData)\n\t\t *  @param {*} sValue Value to set\n\t\t *  @default null\n\t\t */\n\t\t\"fnSetData\": null,\n\t\n\t\t/**\n\t\t * Property to read the value for the cells in the column from the data\n\t\t * source array / object. If null, then the default content is used, if a\n\t\t * function is given then the return from the function is used.\n\t\t *  @type function|int|string|null\n\t\t *  @default null\n\t\t */\n\t\t\"mData\": null,\n\t\n\t\t/**\n\t\t * Partner property to mData which is used (only when defined) to get\n\t\t * the data - i.e. it is basically the same as mData, but without the\n\t\t * 'set' option, and also the data fed to it is the result from mData.\n\t\t * This is the rendering method to match the data method of mData.\n\t\t *  @type function|int|string|null\n\t\t *  @default null\n\t\t */\n\t\t\"mRender\": null,\n\t\n\t\t/**\n\t\t * Unique header TH/TD element for this column - this is what the sorting\n\t\t * listener is attached to (if sorting is enabled.)\n\t\t *  @type node\n\t\t *  @default null\n\t\t */\n\t\t\"nTh\": null,\n\t\n\t\t/**\n\t\t * Unique footer TH/TD element for this column (if there is one). Not used\n\t\t * in DataTables as such, but can be used for plug-ins to reference the\n\t\t * footer for each column.\n\t\t *  @type node\n\t\t *  @default null\n\t\t */\n\t\t\"nTf\": null,\n\t\n\t\t/**\n\t\t * The class to apply to all TD elements in the table's TBODY for the column\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sClass\": null,\n\t\n\t\t/**\n\t\t * When DataTables calculates the column widths to assign to each column,\n\t\t * it finds the longest string in each column and then constructs a\n\t\t * temporary table and reads the widths from that. The problem with this\n\t\t * is that \"mmm\" is much wider then \"iiii\", but the latter is a longer\n\t\t * string - thus the calculation can go wrong (doing it properly and putting\n\t\t * it into an DOM object and measuring that is horribly(!) slow). Thus as\n\t\t * a \"work around\" we provide this option. It will append its value to the\n\t\t * text that is found to be the longest string for the column - i.e. padding.\n\t\t *  @type string\n\t\t */\n\t\t\"sContentPadding\": null,\n\t\n\t\t/**\n\t\t * Allows a default value to be given for a column's data, and will be used\n\t\t * whenever a null data source is encountered (this can be because mData\n\t\t * is set to null, or because the data source itself is null).\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sDefaultContent\": null,\n\t\n\t\t/**\n\t\t * Name for the column, allowing reference to the column by name as well as\n\t\t * by index (needs a lookup to work by name).\n\t\t *  @type string\n\t\t */\n\t\t\"sName\": null,\n\t\n\t\t/**\n\t\t * Custom sorting data type - defines which of the available plug-ins in\n\t\t * afnSortData the custom sorting will use - if any is defined.\n\t\t *  @type string\n\t\t *  @default std\n\t\t */\n\t\t\"sSortDataType\": 'std',\n\t\n\t\t/**\n\t\t * Class to be applied to the header element when sorting on this column\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sSortingClass\": null,\n\t\n\t\t/**\n\t\t * Class to be applied to the header element when sorting on this column -\n\t\t * when jQuery UI theming is used.\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sSortingClassJUI\": null,\n\t\n\t\t/**\n\t\t * Title of the column - what is seen in the TH element (nTh).\n\t\t *  @type string\n\t\t */\n\t\t\"sTitle\": null,\n\t\n\t\t/**\n\t\t * Column sorting and filtering type\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sType\": null,\n\t\n\t\t/**\n\t\t * Width of the column\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sWidth\": null,\n\t\n\t\t/**\n\t\t * Width of the column when it was first \"encountered\"\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sWidthOrig\": null\n\t};\n\t\n\t\n\t/*\n\t * Developer note: The properties of the object below are given in Hungarian\n\t * notation, that was used as the interface for DataTables prior to v1.10, however\n\t * from v1.10 onwards the primary interface is camel case. In order to avoid\n\t * breaking backwards compatibility utterly with this change, the Hungarian\n\t * version is still, internally the primary interface, but is is not documented\n\t * - hence the @name tags in each doc comment. This allows a Javascript function\n\t * to create a map from Hungarian notation to camel case (going the other direction\n\t * would require each property to be listed, which would add around 3K to the size\n\t * of DataTables, while this method is about a 0.5K hit).\n\t *\n\t * Ultimately this does pave the way for Hungarian notation to be dropped\n\t * completely, but that is a massive amount of work and will break current\n\t * installs (therefore is on-hold until v2).\n\t */\n\t\n\t/**\n\t * Initialisation options that can be given to DataTables at initialisation\n\t * time.\n\t *  @namespace\n\t */\n\tDataTable.defaults = {\n\t\t/**\n\t\t * An array of data to use for the table, passed in at initialisation which\n\t\t * will be used in preference to any data which is already in the DOM. This is\n\t\t * particularly useful for constructing tables purely in Javascript, for\n\t\t * example with a custom Ajax call.\n\t\t *  @type array\n\t\t *  @default null\n\t\t *\n\t\t *  @dtopt Option\n\t\t *  @name DataTable.defaults.data\n\t\t *\n\t\t *  @example\n\t\t *    // Using a 2D array data source\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"data\": [\n\t\t *          ['Trident', 'Internet Explorer 4.0', 'Win 95+', 4, 'X'],\n\t\t *          ['Trident', 'Internet Explorer 5.0', 'Win 95+', 5, 'C'],\n\t\t *        ],\n\t\t *        \"columns\": [\n\t\t *          { \"title\": \"Engine\" },\n\t\t *          { \"title\": \"Browser\" },\n\t\t *          { \"title\": \"Platform\" },\n\t\t *          { \"title\": \"Version\" },\n\t\t *          { \"title\": \"Grade\" }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using an array of objects as a data source (`data`)\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"data\": [\n\t\t *          {\n\t\t *            \"engine\":   \"Trident\",\n\t\t *            \"browser\":  \"Internet Explorer 4.0\",\n\t\t *            \"platform\": \"Win 95+\",\n\t\t *            \"version\":  4,\n\t\t *            \"grade\":    \"X\"\n\t\t *          },\n\t\t *          {\n\t\t *            \"engine\":   \"Trident\",\n\t\t *            \"browser\":  \"Internet Explorer 5.0\",\n\t\t *            \"platform\": \"Win 95+\",\n\t\t *            \"version\":  5,\n\t\t *            \"grade\":    \"C\"\n\t\t *          }\n\t\t *        ],\n\t\t *        \"columns\": [\n\t\t *          { \"title\": \"Engine\",   \"data\": \"engine\" },\n\t\t *          { \"title\": \"Browser\",  \"data\": \"browser\" },\n\t\t *          { \"title\": \"Platform\", \"data\": \"platform\" },\n\t\t *          { \"title\": \"Version\",  \"data\": \"version\" },\n\t\t *          { \"title\": \"Grade\",    \"data\": \"grade\" }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"aaData\": null,\n\t\n\t\n\t\t/**\n\t\t * If ordering is enabled, then DataTables will perform a first pass sort on\n\t\t * initialisation. You can define which column(s) the sort is performed\n\t\t * upon, and the sorting direction, with this variable. The `sorting` array\n\t\t * should contain an array for each column to be sorted initially containing\n\t\t * the column's index and a direction string ('asc' or 'desc').\n\t\t *  @type array\n\t\t *  @default [[0,'asc']]\n\t\t *\n\t\t *  @dtopt Option\n\t\t *  @name DataTable.defaults.order\n\t\t *\n\t\t *  @example\n\t\t *    // Sort by 3rd column first, and then 4th column\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"order\": [[2,'asc'], [3,'desc']]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *    // No initial sorting\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"order\": []\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"aaSorting\": [[0,'asc']],\n\t\n\t\n\t\t/**\n\t\t * This parameter is basically identical to the `sorting` parameter, but\n\t\t * cannot be overridden by user interaction with the table. What this means\n\t\t * is that you could have a column (visible or hidden) which the sorting\n\t\t * will always be forced on first - any sorting after that (from the user)\n\t\t * will then be performed as required. This can be useful for grouping rows\n\t\t * together.\n\t\t *  @type array\n\t\t *  @default null\n\t\t *\n\t\t *  @dtopt Option\n\t\t *  @name DataTable.defaults.orderFixed\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"orderFixed\": [[0,'asc']]\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"aaSortingFixed\": [],\n\t\n\t\n\t\t/**\n\t\t * DataTables can be instructed to load data to display in the table from a\n\t\t * Ajax source. This option defines how that Ajax call is made and where to.\n\t\t *\n\t\t * The `ajax` property has three different modes of operation, depending on\n\t\t * how it is defined. These are:\n\t\t *\n\t\t * * `string` - Set the URL from where the data should be loaded from.\n\t\t * * `object` - Define properties for `jQuery.ajax`.\n\t\t * * `function` - Custom data get function\n\t\t *\n\t\t * `string`\n\t\t * --------\n\t\t *\n\t\t * As a string, the `ajax` property simply defines the URL from which\n\t\t * DataTables will load data.\n\t\t *\n\t\t * `object`\n\t\t * --------\n\t\t *\n\t\t * As an object, the parameters in the object are passed to\n\t\t * [jQuery.ajax](http://api.jquery.com/jQuery.ajax/) allowing fine control\n\t\t * of the Ajax request. DataTables has a number of default parameters which\n\t\t * you can override using this option. Please refer to the jQuery\n\t\t * documentation for a full description of the options available, although\n\t\t * the following parameters provide additional options in DataTables or\n\t\t * require special consideration:\n\t\t *\n\t\t * * `data` - As with jQuery, `data` can be provided as an object, but it\n\t\t *   can also be used as a function to manipulate the data DataTables sends\n\t\t *   to the server. The function takes a single parameter, an object of\n\t\t *   parameters with the values that DataTables has readied for sending. An\n\t\t *   object may be returned which will be merged into the DataTables\n\t\t *   defaults, or you can add the items to the object that was passed in and\n\t\t *   not return anything from the function. This supersedes `fnServerParams`\n\t\t *   from DataTables 1.9-.\n\t\t *\n\t\t * * `dataSrc` - By default DataTables will look for the property `data` (or\n\t\t *   `aaData` for compatibility with DataTables 1.9-) when obtaining data\n\t\t *   from an Ajax source or for server-side processing - this parameter\n\t\t *   allows that property to be changed. You can use Javascript dotted\n\t\t *   object notation to get a data source for multiple levels of nesting, or\n\t\t *   it my be used as a function. As a function it takes a single parameter,\n\t\t *   the JSON returned from the server, which can be manipulated as\n\t\t *   required, with the returned value being that used by DataTables as the\n\t\t *   data source for the table. This supersedes `sAjaxDataProp` from\n\t\t *   DataTables 1.9-.\n\t\t *\n\t\t * * `success` - Should not be overridden it is used internally in\n\t\t *   DataTables. To manipulate / transform the data returned by the server\n\t\t *   use `ajax.dataSrc`, or use `ajax` as a function (see below).\n\t\t *\n\t\t * `function`\n\t\t * ----------\n\t\t *\n\t\t * As a function, making the Ajax call is left up to yourself allowing\n\t\t * complete control of the Ajax request. Indeed, if desired, a method other\n\t\t * than Ajax could be used to obtain the required data, such as Web storage\n\t\t * or an AIR database.\n\t\t *\n\t\t * The function is given four parameters and no return is required. The\n\t\t * parameters are:\n\t\t *\n\t\t * 1. _object_ - Data to send to the server\n\t\t * 2. _function_ - Callback function that must be executed when the required\n\t\t *    data has been obtained. That data should be passed into the callback\n\t\t *    as the only parameter\n\t\t * 3. _object_ - DataTables settings object for the table\n\t\t *\n\t\t * Note that this supersedes `fnServerData` from DataTables 1.9-.\n\t\t *\n\t\t *  @type string|object|function\n\t\t *  @default null\n\t\t *\n\t\t *  @dtopt Option\n\t\t *  @name DataTable.defaults.ajax\n\t\t *  @since 1.10.0\n\t\t *\n\t\t * @example\n\t\t *   // Get JSON data from a file via Ajax.\n\t\t *   // Note DataTables expects data in the form `{ data: [ ...data... ] }` by default).\n\t\t *   $('#example').dataTable( {\n\t\t *     \"ajax\": \"data.json\"\n\t\t *   } );\n\t\t *\n\t\t * @example\n\t\t *   // Get JSON data from a file via Ajax, using `dataSrc` to change\n\t\t *   // `data` to `tableData` (i.e. `{ tableData: [ ...data... ] }`)\n\t\t *   $('#example').dataTable( {\n\t\t *     \"ajax\": {\n\t\t *       \"url\": \"data.json\",\n\t\t *       \"dataSrc\": \"tableData\"\n\t\t *     }\n\t\t *   } );\n\t\t *\n\t\t * @example\n\t\t *   // Get JSON data from a file via Ajax, using `dataSrc` to read data\n\t\t *   // from a plain array rather than an array in an object\n\t\t *   $('#example').dataTable( {\n\t\t *     \"ajax\": {\n\t\t *       \"url\": \"data.json\",\n\t\t *       \"dataSrc\": \"\"\n\t\t *     }\n\t\t *   } );\n\t\t *\n\t\t * @example\n\t\t *   // Manipulate the data returned from the server - add a link to data\n\t\t *   // (note this can, should, be done using `render` for the column - this\n\t\t *   // is just a simple example of how the data can be manipulated).\n\t\t *   $('#example').dataTable( {\n\t\t *     \"ajax\": {\n\t\t *       \"url\": \"data.json\",\n\t\t *       \"dataSrc\": function ( json ) {\n\t\t *         for ( var i=0, ien=json.length ; i<ien ; i++ ) {\n\t\t *           json[i][0] = '<a href=\"/message/'+json[i][0]+'>View message</a>';\n\t\t *         }\n\t\t *         return json;\n\t\t *       }\n\t\t *     }\n\t\t *   } );\n\t\t *\n\t\t * @example\n\t\t *   // Add data to the request\n\t\t *   $('#example').dataTable( {\n\t\t *     \"ajax\": {\n\t\t *       \"url\": \"data.json\",\n\t\t *       \"data\": function ( d ) {\n\t\t *         return {\n\t\t *           \"extra_search\": $('#extra').val()\n\t\t *         };\n\t\t *       }\n\t\t *     }\n\t\t *   } );\n\t\t *\n\t\t * @example\n\t\t *   // Send request as POST\n\t\t *   $('#example').dataTable( {\n\t\t *     \"ajax\": {\n\t\t *       \"url\": \"data.json\",\n\t\t *       \"type\": \"POST\"\n\t\t *     }\n\t\t *   } );\n\t\t *\n\t\t * @example\n\t\t *   // Get the data from localStorage (could interface with a form for\n\t\t *   // adding, editing and removing rows).\n\t\t *   $('#example').dataTable( {\n\t\t *     \"ajax\": function (data, callback, settings) {\n\t\t *       callback(\n\t\t *         JSON.parse( localStorage.getItem('dataTablesData') )\n\t\t *       );\n\t\t *     }\n\t\t *   } );\n\t\t */\n\t\t\"ajax\": null,\n\t\n\t\n\t\t/**\n\t\t * This parameter allows you to readily specify the entries in the length drop\n\t\t * down menu that DataTables shows when pagination is enabled. It can be\n\t\t * either a 1D array of options which will be used for both the displayed\n\t\t * option and the value, or a 2D array which will use the array in the first\n\t\t * position as the value, and the array in the second position as the\n\t\t * displayed options (useful for language strings such as 'All').\n\t\t *\n\t\t * Note that the `pageLength` property will be automatically set to the\n\t\t * first value given in this array, unless `pageLength` is also provided.\n\t\t *  @type array\n\t\t *  @default [ 10, 25, 50, 100 ]\n\t\t *\n\t\t *  @dtopt Option\n\t\t *  @name DataTable.defaults.lengthMenu\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"lengthMenu\": [[10, 25, 50, -1], [10, 25, 50, \"All\"]]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"aLengthMenu\": [ 10, 25, 50, 100 ],\n\t\n\t\n\t\t/**\n\t\t * The `columns` option in the initialisation parameter allows you to define\n\t\t * details about the way individual columns behave. For a full list of\n\t\t * column options that can be set, please see\n\t\t * {@link DataTable.defaults.column}. Note that if you use `columns` to\n\t\t * define your columns, you must have an entry in the array for every single\n\t\t * column that you have in your table (these can be null if you don't which\n\t\t * to specify any options).\n\t\t *  @member\n\t\t *\n\t\t *  @name DataTable.defaults.column\n\t\t */\n\t\t\"aoColumns\": null,\n\t\n\t\t/**\n\t\t * Very similar to `columns`, `columnDefs` allows you to target a specific\n\t\t * column, multiple columns, or all columns, using the `targets` property of\n\t\t * each object in the array. This allows great flexibility when creating\n\t\t * tables, as the `columnDefs` arrays can be of any length, targeting the\n\t\t * columns you specifically want. `columnDefs` may use any of the column\n\t\t * options available: {@link DataTable.defaults.column}, but it _must_\n\t\t * have `targets` defined in each object in the array. Values in the `targets`\n\t\t * array may be:\n\t\t *   <ul>\n\t\t *     <li>a string - class name will be matched on the TH for the column</li>\n\t\t *     <li>0 or a positive integer - column index counting from the left</li>\n\t\t *     <li>a negative integer - column index counting from the right</li>\n\t\t *     <li>the string \"_all\" - all columns (i.e. assign a default)</li>\n\t\t *   </ul>\n\t\t *  @member\n\t\t *\n\t\t *  @name DataTable.defaults.columnDefs\n\t\t */\n\t\t\"aoColumnDefs\": null,\n\t\n\t\n\t\t/**\n\t\t * Basically the same as `search`, this parameter defines the individual column\n\t\t * filtering state at initialisation time. The array must be of the same size\n\t\t * as the number of columns, and each element be an object with the parameters\n\t\t * `search` and `escapeRegex` (the latter is optional). 'null' is also\n\t\t * accepted and the default will be used.\n\t\t *  @type array\n\t\t *  @default []\n\t\t *\n\t\t *  @dtopt Option\n\t\t *  @name DataTable.defaults.searchCols\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"searchCols\": [\n\t\t *          null,\n\t\t *          { \"search\": \"My filter\" },\n\t\t *          null,\n\t\t *          { \"search\": \"^[0-9]\", \"escapeRegex\": false }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"aoSearchCols\": [],\n\t\n\t\n\t\t/**\n\t\t * An array of CSS classes that should be applied to displayed rows. This\n\t\t * array may be of any length, and DataTables will apply each class\n\t\t * sequentially, looping when required.\n\t\t *  @type array\n\t\t *  @default null <i>Will take the values determined by the `oClasses.stripe*`\n\t\t *    options</i>\n\t\t *\n\t\t *  @dtopt Option\n\t\t *  @name DataTable.defaults.stripeClasses\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"stripeClasses\": [ 'strip1', 'strip2', 'strip3' ]\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"asStripeClasses\": null,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable automatic column width calculation. This can be disabled\n\t\t * as an optimisation (it takes some time to calculate the widths) if the\n\t\t * tables widths are passed in using `columns`.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.autoWidth\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"autoWidth\": false\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bAutoWidth\": true,\n\t\n\t\n\t\t/**\n\t\t * Deferred rendering can provide DataTables with a huge speed boost when you\n\t\t * are using an Ajax or JS data source for the table. This option, when set to\n\t\t * true, will cause DataTables to defer the creation of the table elements for\n\t\t * each row until they are needed for a draw - saving a significant amount of\n\t\t * time.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.deferRender\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"ajax\": \"sources/arrays.txt\",\n\t\t *        \"deferRender\": true\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bDeferRender\": false,\n\t\n\t\n\t\t/**\n\t\t * Replace a DataTable which matches the given selector and replace it with\n\t\t * one which has the properties of the new initialisation object passed. If no\n\t\t * table matches the selector, then the new DataTable will be constructed as\n\t\t * per normal.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.destroy\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"srollY\": \"200px\",\n\t\t *        \"paginate\": false\n\t\t *      } );\n\t\t *\n\t\t *      // Some time later....\n\t\t *      $('#example').dataTable( {\n\t\t *        \"filter\": false,\n\t\t *        \"destroy\": true\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bDestroy\": false,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable filtering of data. Filtering in DataTables is \"smart\" in\n\t\t * that it allows the end user to input multiple words (space separated) and\n\t\t * will match a row containing those words, even if not in the order that was\n\t\t * specified (this allow matching across multiple columns). Note that if you\n\t\t * wish to use filtering in DataTables this must remain 'true' - to remove the\n\t\t * default filtering input box and retain filtering abilities, please use\n\t\t * {@link DataTable.defaults.dom}.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.searching\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"searching\": false\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bFilter\": true,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable the table information display. This shows information\n\t\t * about the data that is currently visible on the page, including information\n\t\t * about filtered data if that action is being performed.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.info\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"info\": false\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bInfo\": true,\n\t\n\t\n\t\t/**\n\t\t * Allows the end user to select the size of a formatted page from a select\n\t\t * menu (sizes are 10, 25, 50 and 100). Requires pagination (`paginate`).\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.lengthChange\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"lengthChange\": false\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bLengthChange\": true,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable pagination.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.paging\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"paging\": false\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bPaginate\": true,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable the display of a 'processing' indicator when the table is\n\t\t * being processed (e.g. a sort). This is particularly useful for tables with\n\t\t * large amounts of data where it can take a noticeable amount of time to sort\n\t\t * the entries.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.processing\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"processing\": true\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bProcessing\": false,\n\t\n\t\n\t\t/**\n\t\t * Retrieve the DataTables object for the given selector. Note that if the\n\t\t * table has already been initialised, this parameter will cause DataTables\n\t\t * to simply return the object that has already been set up - it will not take\n\t\t * account of any changes you might have made to the initialisation object\n\t\t * passed to DataTables (setting this parameter to true is an acknowledgement\n\t\t * that you understand this). `destroy` can be used to reinitialise a table if\n\t\t * you need.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.retrieve\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      initTable();\n\t\t *      tableActions();\n\t\t *    } );\n\t\t *\n\t\t *    function initTable ()\n\t\t *    {\n\t\t *      return $('#example').dataTable( {\n\t\t *        \"scrollY\": \"200px\",\n\t\t *        \"paginate\": false,\n\t\t *        \"retrieve\": true\n\t\t *      } );\n\t\t *    }\n\t\t *\n\t\t *    function tableActions ()\n\t\t *    {\n\t\t *      var table = initTable();\n\t\t *      // perform API operations with oTable\n\t\t *    }\n\t\t */\n\t\t\"bRetrieve\": false,\n\t\n\t\n\t\t/**\n\t\t * When vertical (y) scrolling is enabled, DataTables will force the height of\n\t\t * the table's viewport to the given height at all times (useful for layout).\n\t\t * However, this can look odd when filtering data down to a small data set,\n\t\t * and the footer is left \"floating\" further down. This parameter (when\n\t\t * enabled) will cause DataTables to collapse the table's viewport down when\n\t\t * the result set will fit within the given Y height.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.scrollCollapse\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"scrollY\": \"200\",\n\t\t *        \"scrollCollapse\": true\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bScrollCollapse\": false,\n\t\n\t\n\t\t/**\n\t\t * Configure DataTables to use server-side processing. Note that the\n\t\t * `ajax` parameter must also be given in order to give DataTables a\n\t\t * source to obtain the required data for each draw.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @dtopt Server-side\n\t\t *  @name DataTable.defaults.serverSide\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"serverSide\": true,\n\t\t *        \"ajax\": \"xhr.php\"\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bServerSide\": false,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable sorting of columns. Sorting of individual columns can be\n\t\t * disabled by the `sortable` option for each column.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.ordering\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"ordering\": false\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bSort\": true,\n\t\n\t\n\t\t/**\n\t\t * Enable or display DataTables' ability to sort multiple columns at the\n\t\t * same time (activated by shift-click by the user).\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.orderMulti\n\t\t *\n\t\t *  @example\n\t\t *    // Disable multiple column sorting ability\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"orderMulti\": false\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bSortMulti\": true,\n\t\n\t\n\t\t/**\n\t\t * Allows control over whether DataTables should use the top (true) unique\n\t\t * cell that is found for a single column, or the bottom (false - default).\n\t\t * This is useful when using complex headers.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.orderCellsTop\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"orderCellsTop\": true\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bSortCellsTop\": false,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable the addition of the classes `sorting\\_1`, `sorting\\_2` and\n\t\t * `sorting\\_3` to the columns which are currently being sorted on. This is\n\t\t * presented as a feature switch as it can increase processing time (while\n\t\t * classes are removed and added) so for large data sets you might want to\n\t\t * turn this off.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.orderClasses\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"orderClasses\": false\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bSortClasses\": true,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable state saving. When enabled HTML5 `localStorage` will be\n\t\t * used to save table display information such as pagination information,\n\t\t * display length, filtering and sorting. As such when the end user reloads\n\t\t * the page the display display will match what thy had previously set up.\n\t\t *\n\t\t * Due to the use of `localStorage` the default state saving is not supported\n\t\t * in IE6 or 7. If state saving is required in those browsers, use\n\t\t * `stateSaveCallback` to provide a storage solution such as cookies.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.stateSave\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function () {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"stateSave\": true\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"bStateSave\": false,\n\t\n\t\n\t\t/**\n\t\t * This function is called when a TR element is created (and all TD child\n\t\t * elements have been inserted), or registered if using a DOM source, allowing\n\t\t * manipulation of the TR element (adding classes etc).\n\t\t *  @type function\n\t\t *  @param {node} row \"TR\" element for the current row\n\t\t *  @param {array} data Raw data array for this row\n\t\t *  @param {int} dataIndex The index of this row in the internal aoData array\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.createdRow\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"createdRow\": function( row, data, dataIndex ) {\n\t\t *          // Bold the grade for all 'A' grade browsers\n\t\t *          if ( data[4] == \"A\" )\n\t\t *          {\n\t\t *            $('td:eq(4)', row).html( '<b>A</b>' );\n\t\t *          }\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnCreatedRow\": null,\n\t\n\t\n\t\t/**\n\t\t * This function is called on every 'draw' event, and allows you to\n\t\t * dynamically modify any aspect you want about the created DOM.\n\t\t *  @type function\n\t\t *  @param {object} settings DataTables settings object\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.drawCallback\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"drawCallback\": function( settings ) {\n\t\t *          alert( 'DataTables has redrawn the table' );\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnDrawCallback\": null,\n\t\n\t\n\t\t/**\n\t\t * Identical to fnHeaderCallback() but for the table footer this function\n\t\t * allows you to modify the table footer on every 'draw' event.\n\t\t *  @type function\n\t\t *  @param {node} foot \"TR\" element for the footer\n\t\t *  @param {array} data Full table data (as derived from the original HTML)\n\t\t *  @param {int} start Index for the current display starting point in the\n\t\t *    display array\n\t\t *  @param {int} end Index for the current display ending point in the\n\t\t *    display array\n\t\t *  @param {array int} display Index array to translate the visual position\n\t\t *    to the full data array\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.footerCallback\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"footerCallback\": function( tfoot, data, start, end, display ) {\n\t\t *          tfoot.getElementsByTagName('th')[0].innerHTML = \"Starting index is \"+start;\n\t\t *        }\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"fnFooterCallback\": null,\n\t\n\t\n\t\t/**\n\t\t * When rendering large numbers in the information element for the table\n\t\t * (i.e. \"Showing 1 to 10 of 57 entries\") DataTables will render large numbers\n\t\t * to have a comma separator for the 'thousands' units (e.g. 1 million is\n\t\t * rendered as \"1,000,000\") to help readability for the end user. This\n\t\t * function will override the default method DataTables uses.\n\t\t *  @type function\n\t\t *  @member\n\t\t *  @param {int} toFormat number to be formatted\n\t\t *  @returns {string} formatted string for DataTables to show the number\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.formatNumber\n\t\t *\n\t\t *  @example\n\t\t *    // Format a number using a single quote for the separator (note that\n\t\t *    // this can also be done with the language.thousands option)\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"formatNumber\": function ( toFormat ) {\n\t\t *          return toFormat.toString().replace(\n\t\t *            /\\B(?=(\\d{3})+(?!\\d))/g, \"'\"\n\t\t *          );\n\t\t *        };\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnFormatNumber\": function ( toFormat ) {\n\t\t\treturn toFormat.toString().replace(\n\t\t\t\t/\\B(?=(\\d{3})+(?!\\d))/g,\n\t\t\t\tthis.oLanguage.sThousands\n\t\t\t);\n\t\t},\n\t\n\t\n\t\t/**\n\t\t * This function is called on every 'draw' event, and allows you to\n\t\t * dynamically modify the header row. This can be used to calculate and\n\t\t * display useful information about the table.\n\t\t *  @type function\n\t\t *  @param {node} head \"TR\" element for the header\n\t\t *  @param {array} data Full table data (as derived from the original HTML)\n\t\t *  @param {int} start Index for the current display starting point in the\n\t\t *    display array\n\t\t *  @param {int} end Index for the current display ending point in the\n\t\t *    display array\n\t\t *  @param {array int} display Index array to translate the visual position\n\t\t *    to the full data array\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.headerCallback\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"fheaderCallback\": function( head, data, start, end, display ) {\n\t\t *          head.getElementsByTagName('th')[0].innerHTML = \"Displaying \"+(end-start)+\" records\";\n\t\t *        }\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"fnHeaderCallback\": null,\n\t\n\t\n\t\t/**\n\t\t * The information element can be used to convey information about the current\n\t\t * state of the table. Although the internationalisation options presented by\n\t\t * DataTables are quite capable of dealing with most customisations, there may\n\t\t * be times where you wish to customise the string further. This callback\n\t\t * allows you to do exactly that.\n\t\t *  @type function\n\t\t *  @param {object} oSettings DataTables settings object\n\t\t *  @param {int} start Starting position in data for the draw\n\t\t *  @param {int} end End position in data for the draw\n\t\t *  @param {int} max Total number of rows in the table (regardless of\n\t\t *    filtering)\n\t\t *  @param {int} total Total number of rows in the data set, after filtering\n\t\t *  @param {string} pre The string that DataTables has formatted using it's\n\t\t *    own rules\n\t\t *  @returns {string} The string to be displayed in the information element.\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.infoCallback\n\t\t *\n\t\t *  @example\n\t\t *    $('#example').dataTable( {\n\t\t *      \"infoCallback\": function( settings, start, end, max, total, pre ) {\n\t\t *        return start +\" to \"+ end;\n\t\t *      }\n\t\t *    } );\n\t\t */\n\t\t\"fnInfoCallback\": null,\n\t\n\t\n\t\t/**\n\t\t * Called when the table has been initialised. Normally DataTables will\n\t\t * initialise sequentially and there will be no need for this function,\n\t\t * however, this does not hold true when using external language information\n\t\t * since that is obtained using an async XHR call.\n\t\t *  @type function\n\t\t *  @param {object} settings DataTables settings object\n\t\t *  @param {object} json The JSON object request from the server - only\n\t\t *    present if client-side Ajax sourced data is used\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.initComplete\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"initComplete\": function(settings, json) {\n\t\t *          alert( 'DataTables has finished its initialisation.' );\n\t\t *        }\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"fnInitComplete\": null,\n\t\n\t\n\t\t/**\n\t\t * Called at the very start of each table draw and can be used to cancel the\n\t\t * draw by returning false, any other return (including undefined) results in\n\t\t * the full draw occurring).\n\t\t *  @type function\n\t\t *  @param {object} settings DataTables settings object\n\t\t *  @returns {boolean} False will cancel the draw, anything else (including no\n\t\t *    return) will allow it to complete.\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.preDrawCallback\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"preDrawCallback\": function( settings ) {\n\t\t *          if ( $('#test').val() == 1 ) {\n\t\t *            return false;\n\t\t *          }\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnPreDrawCallback\": null,\n\t\n\t\n\t\t/**\n\t\t * This function allows you to 'post process' each row after it have been\n\t\t * generated for each table draw, but before it is rendered on screen. This\n\t\t * function might be used for setting the row class name etc.\n\t\t *  @type function\n\t\t *  @param {node} row \"TR\" element for the current row\n\t\t *  @param {array} data Raw data array for this row\n\t\t *  @param {int} displayIndex The display index for the current table draw\n\t\t *  @param {int} displayIndexFull The index of the data in the full list of\n\t\t *    rows (after filtering)\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.rowCallback\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"rowCallback\": function( row, data, displayIndex, displayIndexFull ) {\n\t\t *          // Bold the grade for all 'A' grade browsers\n\t\t *          if ( data[4] == \"A\" ) {\n\t\t *            $('td:eq(4)', row).html( '<b>A</b>' );\n\t\t *          }\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnRowCallback\": null,\n\t\n\t\n\t\t/**\n\t\t * __Deprecated__ The functionality provided by this parameter has now been\n\t\t * superseded by that provided through `ajax`, which should be used instead.\n\t\t *\n\t\t * This parameter allows you to override the default function which obtains\n\t\t * the data from the server so something more suitable for your application.\n\t\t * For example you could use POST data, or pull information from a Gears or\n\t\t * AIR database.\n\t\t *  @type function\n\t\t *  @member\n\t\t *  @param {string} source HTTP source to obtain the data from (`ajax`)\n\t\t *  @param {array} data A key/value pair object containing the data to send\n\t\t *    to the server\n\t\t *  @param {function} callback to be called on completion of the data get\n\t\t *    process that will draw the data on the page.\n\t\t *  @param {object} settings DataTables settings object\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @dtopt Server-side\n\t\t *  @name DataTable.defaults.serverData\n\t\t *\n\t\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t\t */\n\t\t\"fnServerData\": null,\n\t\n\t\n\t\t/**\n\t\t * __Deprecated__ The functionality provided by this parameter has now been\n\t\t * superseded by that provided through `ajax`, which should be used instead.\n\t\t *\n\t\t *  It is often useful to send extra data to the server when making an Ajax\n\t\t * request - for example custom filtering information, and this callback\n\t\t * function makes it trivial to send extra information to the server. The\n\t\t * passed in parameter is the data set that has been constructed by\n\t\t * DataTables, and you can add to this or modify it as you require.\n\t\t *  @type function\n\t\t *  @param {array} data Data array (array of objects which are name/value\n\t\t *    pairs) that has been constructed by DataTables and will be sent to the\n\t\t *    server. In the case of Ajax sourced data with server-side processing\n\t\t *    this will be an empty array, for server-side processing there will be a\n\t\t *    significant number of parameters!\n\t\t *  @returns {undefined} Ensure that you modify the data array passed in,\n\t\t *    as this is passed by reference.\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @dtopt Server-side\n\t\t *  @name DataTable.defaults.serverParams\n\t\t *\n\t\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t\t */\n\t\t\"fnServerParams\": null,\n\t\n\t\n\t\t/**\n\t\t * Load the table state. With this function you can define from where, and how, the\n\t\t * state of a table is loaded. By default DataTables will load from `localStorage`\n\t\t * but you might wish to use a server-side database or cookies.\n\t\t *  @type function\n\t\t *  @member\n\t\t *  @param {object} settings DataTables settings object\n\t\t *  @param {object} callback Callback that can be executed when done. It\n\t\t *    should be passed the loaded state object.\n\t\t *  @return {object} The DataTables state object to be loaded\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.stateLoadCallback\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"stateSave\": true,\n\t\t *        \"stateLoadCallback\": function (settings, callback) {\n\t\t *          $.ajax( {\n\t\t *            \"url\": \"/state_load\",\n\t\t *            \"dataType\": \"json\",\n\t\t *            \"success\": function (json) {\n\t\t *              callback( json );\n\t\t *            }\n\t\t *          } );\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnStateLoadCallback\": function ( settings ) {\n\t\t\ttry {\n\t\t\t\treturn JSON.parse(\n\t\t\t\t\t(settings.iStateDuration === -1 ? sessionStorage : localStorage).getItem(\n\t\t\t\t\t\t'DataTables_'+settings.sInstance+'_'+location.pathname\n\t\t\t\t\t)\n\t\t\t\t);\n\t\t\t} catch (e) {\n\t\t\t\treturn {};\n\t\t\t}\n\t\t},\n\t\n\t\n\t\t/**\n\t\t * Callback which allows modification of the saved state prior to loading that state.\n\t\t * This callback is called when the table is loading state from the stored data, but\n\t\t * prior to the settings object being modified by the saved state. Note that for\n\t\t * plug-in authors, you should use the `stateLoadParams` event to load parameters for\n\t\t * a plug-in.\n\t\t *  @type function\n\t\t *  @param {object} settings DataTables settings object\n\t\t *  @param {object} data The state object that is to be loaded\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.stateLoadParams\n\t\t *\n\t\t *  @example\n\t\t *    // Remove a saved filter, so filtering is never loaded\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"stateSave\": true,\n\t\t *        \"stateLoadParams\": function (settings, data) {\n\t\t *          data.oSearch.sSearch = \"\";\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Disallow state loading by returning false\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"stateSave\": true,\n\t\t *        \"stateLoadParams\": function (settings, data) {\n\t\t *          return false;\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnStateLoadParams\": null,\n\t\n\t\n\t\t/**\n\t\t * Callback that is called when the state has been loaded from the state saving method\n\t\t * and the DataTables settings object has been modified as a result of the loaded state.\n\t\t *  @type function\n\t\t *  @param {object} settings DataTables settings object\n\t\t *  @param {object} data The state object that was loaded\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.stateLoaded\n\t\t *\n\t\t *  @example\n\t\t *    // Show an alert with the filtering value that was saved\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"stateSave\": true,\n\t\t *        \"stateLoaded\": function (settings, data) {\n\t\t *          alert( 'Saved filter was: '+data.oSearch.sSearch );\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnStateLoaded\": null,\n\t\n\t\n\t\t/**\n\t\t * Save the table state. This function allows you to define where and how the state\n\t\t * information for the table is stored By default DataTables will use `localStorage`\n\t\t * but you might wish to use a server-side database or cookies.\n\t\t *  @type function\n\t\t *  @member\n\t\t *  @param {object} settings DataTables settings object\n\t\t *  @param {object} data The state object to be saved\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.stateSaveCallback\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"stateSave\": true,\n\t\t *        \"stateSaveCallback\": function (settings, data) {\n\t\t *          // Send an Ajax request to the server with the state object\n\t\t *          $.ajax( {\n\t\t *            \"url\": \"/state_save\",\n\t\t *            \"data\": data,\n\t\t *            \"dataType\": \"json\",\n\t\t *            \"method\": \"POST\"\n\t\t *            \"success\": function () {}\n\t\t *          } );\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnStateSaveCallback\": function ( settings, data ) {\n\t\t\ttry {\n\t\t\t\t(settings.iStateDuration === -1 ? sessionStorage : localStorage).setItem(\n\t\t\t\t\t'DataTables_'+settings.sInstance+'_'+location.pathname,\n\t\t\t\t\tJSON.stringify( data )\n\t\t\t\t);\n\t\t\t} catch (e) {}\n\t\t},\n\t\n\t\n\t\t/**\n\t\t * Callback which allows modification of the state to be saved. Called when the table\n\t\t * has changed state a new state save is required. This method allows modification of\n\t\t * the state saving object prior to actually doing the save, including addition or\n\t\t * other state properties or modification. Note that for plug-in authors, you should\n\t\t * use the `stateSaveParams` event to save parameters for a plug-in.\n\t\t *  @type function\n\t\t *  @param {object} settings DataTables settings object\n\t\t *  @param {object} data The state object to be saved\n\t\t *\n\t\t *  @dtopt Callbacks\n\t\t *  @name DataTable.defaults.stateSaveParams\n\t\t *\n\t\t *  @example\n\t\t *    // Remove a saved filter, so filtering is never saved\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"stateSave\": true,\n\t\t *        \"stateSaveParams\": function (settings, data) {\n\t\t *          data.oSearch.sSearch = \"\";\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"fnStateSaveParams\": null,\n\t\n\t\n\t\t/**\n\t\t * Duration for which the saved state information is considered valid. After this period\n\t\t * has elapsed the state will be returned to the default.\n\t\t * Value is given in seconds.\n\t\t *  @type int\n\t\t *  @default 7200 <i>(2 hours)</i>\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.stateDuration\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"stateDuration\": 60*60*24; // 1 day\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"iStateDuration\": 7200,\n\t\n\t\n\t\t/**\n\t\t * When enabled DataTables will not make a request to the server for the first\n\t\t * page draw - rather it will use the data already on the page (no sorting etc\n\t\t * will be applied to it), thus saving on an XHR at load time. `deferLoading`\n\t\t * is used to indicate that deferred loading is required, but it is also used\n\t\t * to tell DataTables how many records there are in the full table (allowing\n\t\t * the information element and pagination to be displayed correctly). In the case\n\t\t * where a filtering is applied to the table on initial load, this can be\n\t\t * indicated by giving the parameter as an array, where the first element is\n\t\t * the number of records available after filtering and the second element is the\n\t\t * number of records without filtering (allowing the table information element\n\t\t * to be shown correctly).\n\t\t *  @type int | array\n\t\t *  @default null\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.deferLoading\n\t\t *\n\t\t *  @example\n\t\t *    // 57 records available in the table, no filtering applied\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"serverSide\": true,\n\t\t *        \"ajax\": \"scripts/server_processing.php\",\n\t\t *        \"deferLoading\": 57\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // 57 records after filtering, 100 without filtering (an initial filter applied)\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"serverSide\": true,\n\t\t *        \"ajax\": \"scripts/server_processing.php\",\n\t\t *        \"deferLoading\": [ 57, 100 ],\n\t\t *        \"search\": {\n\t\t *          \"search\": \"my_filter\"\n\t\t *        }\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"iDeferLoading\": null,\n\t\n\t\n\t\t/**\n\t\t * Number of rows to display on a single page when using pagination. If\n\t\t * feature enabled (`lengthChange`) then the end user will be able to override\n\t\t * this to a custom setting using a pop-up menu.\n\t\t *  @type int\n\t\t *  @default 10\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.pageLength\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"pageLength\": 50\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"iDisplayLength\": 10,\n\t\n\t\n\t\t/**\n\t\t * Define the starting point for data display when using DataTables with\n\t\t * pagination. Note that this parameter is the number of records, rather than\n\t\t * the page number, so if you have 10 records per page and want to start on\n\t\t * the third page, it should be \"20\".\n\t\t *  @type int\n\t\t *  @default 0\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.displayStart\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"displayStart\": 20\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"iDisplayStart\": 0,\n\t\n\t\n\t\t/**\n\t\t * By default DataTables allows keyboard navigation of the table (sorting, paging,\n\t\t * and filtering) by adding a `tabindex` attribute to the required elements. This\n\t\t * allows you to tab through the controls and press the enter key to activate them.\n\t\t * The tabindex is default 0, meaning that the tab follows the flow of the document.\n\t\t * You can overrule this using this parameter if you wish. Use a value of -1 to\n\t\t * disable built-in keyboard navigation.\n\t\t *  @type int\n\t\t *  @default 0\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.tabIndex\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"tabIndex\": 1\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"iTabIndex\": 0,\n\t\n\t\n\t\t/**\n\t\t * Classes that DataTables assigns to the various components and features\n\t\t * that it adds to the HTML table. This allows classes to be configured\n\t\t * during initialisation in addition to through the static\n\t\t * {@link DataTable.ext.oStdClasses} object).\n\t\t *  @namespace\n\t\t *  @name DataTable.defaults.classes\n\t\t */\n\t\t\"oClasses\": {},\n\t\n\t\n\t\t/**\n\t\t * All strings that DataTables uses in the user interface that it creates\n\t\t * are defined in this object, allowing you to modified them individually or\n\t\t * completely replace them all as required.\n\t\t *  @namespace\n\t\t *  @name DataTable.defaults.language\n\t\t */\n\t\t\"oLanguage\": {\n\t\t\t/**\n\t\t\t * Strings that are used for WAI-ARIA labels and controls only (these are not\n\t\t\t * actually visible on the page, but will be read by screenreaders, and thus\n\t\t\t * must be internationalised as well).\n\t\t\t *  @namespace\n\t\t\t *  @name DataTable.defaults.language.aria\n\t\t\t */\n\t\t\t\"oAria\": {\n\t\t\t\t/**\n\t\t\t\t * ARIA label that is added to the table headers when the column may be\n\t\t\t\t * sorted ascending by activing the column (click or return when focused).\n\t\t\t\t * Note that the column header is prefixed to this string.\n\t\t\t\t *  @type string\n\t\t\t\t *  @default : activate to sort column ascending\n\t\t\t\t *\n\t\t\t\t *  @dtopt Language\n\t\t\t\t *  @name DataTable.defaults.language.aria.sortAscending\n\t\t\t\t *\n\t\t\t\t *  @example\n\t\t\t\t *    $(document).ready( function() {\n\t\t\t\t *      $('#example').dataTable( {\n\t\t\t\t *        \"language\": {\n\t\t\t\t *          \"aria\": {\n\t\t\t\t *            \"sortAscending\": \" - click/return to sort ascending\"\n\t\t\t\t *          }\n\t\t\t\t *        }\n\t\t\t\t *      } );\n\t\t\t\t *    } );\n\t\t\t\t */\n\t\t\t\t\"sSortAscending\": \": activate to sort column ascending\",\n\t\n\t\t\t\t/**\n\t\t\t\t * ARIA label that is added to the table headers when the column may be\n\t\t\t\t * sorted descending by activing the column (click or return when focused).\n\t\t\t\t * Note that the column header is prefixed to this string.\n\t\t\t\t *  @type string\n\t\t\t\t *  @default : activate to sort column ascending\n\t\t\t\t *\n\t\t\t\t *  @dtopt Language\n\t\t\t\t *  @name DataTable.defaults.language.aria.sortDescending\n\t\t\t\t *\n\t\t\t\t *  @example\n\t\t\t\t *    $(document).ready( function() {\n\t\t\t\t *      $('#example').dataTable( {\n\t\t\t\t *        \"language\": {\n\t\t\t\t *          \"aria\": {\n\t\t\t\t *            \"sortDescending\": \" - click/return to sort descending\"\n\t\t\t\t *          }\n\t\t\t\t *        }\n\t\t\t\t *      } );\n\t\t\t\t *    } );\n\t\t\t\t */\n\t\t\t\t\"sSortDescending\": \": activate to sort column descending\"\n\t\t\t},\n\t\n\t\t\t/**\n\t\t\t * Pagination string used by DataTables for the built-in pagination\n\t\t\t * control types.\n\t\t\t *  @namespace\n\t\t\t *  @name DataTable.defaults.language.paginate\n\t\t\t */\n\t\t\t\"oPaginate\": {\n\t\t\t\t/**\n\t\t\t\t * Text to use when using the 'full_numbers' type of pagination for the\n\t\t\t\t * button to take the user to the first page.\n\t\t\t\t *  @type string\n\t\t\t\t *  @default First\n\t\t\t\t *\n\t\t\t\t *  @dtopt Language\n\t\t\t\t *  @name DataTable.defaults.language.paginate.first\n\t\t\t\t *\n\t\t\t\t *  @example\n\t\t\t\t *    $(document).ready( function() {\n\t\t\t\t *      $('#example').dataTable( {\n\t\t\t\t *        \"language\": {\n\t\t\t\t *          \"paginate\": {\n\t\t\t\t *            \"first\": \"First page\"\n\t\t\t\t *          }\n\t\t\t\t *        }\n\t\t\t\t *      } );\n\t\t\t\t *    } );\n\t\t\t\t */\n\t\t\t\t\"sFirst\": \"First\",\n\t\n\t\n\t\t\t\t/**\n\t\t\t\t * Text to use when using the 'full_numbers' type of pagination for the\n\t\t\t\t * button to take the user to the last page.\n\t\t\t\t *  @type string\n\t\t\t\t *  @default Last\n\t\t\t\t *\n\t\t\t\t *  @dtopt Language\n\t\t\t\t *  @name DataTable.defaults.language.paginate.last\n\t\t\t\t *\n\t\t\t\t *  @example\n\t\t\t\t *    $(document).ready( function() {\n\t\t\t\t *      $('#example').dataTable( {\n\t\t\t\t *        \"language\": {\n\t\t\t\t *          \"paginate\": {\n\t\t\t\t *            \"last\": \"Last page\"\n\t\t\t\t *          }\n\t\t\t\t *        }\n\t\t\t\t *      } );\n\t\t\t\t *    } );\n\t\t\t\t */\n\t\t\t\t\"sLast\": \"Last\",\n\t\n\t\n\t\t\t\t/**\n\t\t\t\t * Text to use for the 'next' pagination button (to take the user to the\n\t\t\t\t * next page).\n\t\t\t\t *  @type string\n\t\t\t\t *  @default Next\n\t\t\t\t *\n\t\t\t\t *  @dtopt Language\n\t\t\t\t *  @name DataTable.defaults.language.paginate.next\n\t\t\t\t *\n\t\t\t\t *  @example\n\t\t\t\t *    $(document).ready( function() {\n\t\t\t\t *      $('#example').dataTable( {\n\t\t\t\t *        \"language\": {\n\t\t\t\t *          \"paginate\": {\n\t\t\t\t *            \"next\": \"Next page\"\n\t\t\t\t *          }\n\t\t\t\t *        }\n\t\t\t\t *      } );\n\t\t\t\t *    } );\n\t\t\t\t */\n\t\t\t\t\"sNext\": \"Next\",\n\t\n\t\n\t\t\t\t/**\n\t\t\t\t * Text to use for the 'previous' pagination button (to take the user to\n\t\t\t\t * the previous page).\n\t\t\t\t *  @type string\n\t\t\t\t *  @default Previous\n\t\t\t\t *\n\t\t\t\t *  @dtopt Language\n\t\t\t\t *  @name DataTable.defaults.language.paginate.previous\n\t\t\t\t *\n\t\t\t\t *  @example\n\t\t\t\t *    $(document).ready( function() {\n\t\t\t\t *      $('#example').dataTable( {\n\t\t\t\t *        \"language\": {\n\t\t\t\t *          \"paginate\": {\n\t\t\t\t *            \"previous\": \"Previous page\"\n\t\t\t\t *          }\n\t\t\t\t *        }\n\t\t\t\t *      } );\n\t\t\t\t *    } );\n\t\t\t\t */\n\t\t\t\t\"sPrevious\": \"Previous\"\n\t\t\t},\n\t\n\t\t\t/**\n\t\t\t * This string is shown in preference to `zeroRecords` when the table is\n\t\t\t * empty of data (regardless of filtering). Note that this is an optional\n\t\t\t * parameter - if it is not given, the value of `zeroRecords` will be used\n\t\t\t * instead (either the default or given value).\n\t\t\t *  @type string\n\t\t\t *  @default No data available in table\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.emptyTable\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"emptyTable\": \"No data available in table\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sEmptyTable\": \"No data available in table\",\n\t\n\t\n\t\t\t/**\n\t\t\t * This string gives information to the end user about the information\n\t\t\t * that is current on display on the page. The following tokens can be\n\t\t\t * used in the string and will be dynamically replaced as the table\n\t\t\t * display updates. This tokens can be placed anywhere in the string, or\n\t\t\t * removed as needed by the language requires:\n\t\t\t *\n\t\t\t * * `\\_START\\_` - Display index of the first record on the current page\n\t\t\t * * `\\_END\\_` - Display index of the last record on the current page\n\t\t\t * * `\\_TOTAL\\_` - Number of records in the table after filtering\n\t\t\t * * `\\_MAX\\_` - Number of records in the table without filtering\n\t\t\t * * `\\_PAGE\\_` - Current page number\n\t\t\t * * `\\_PAGES\\_` - Total number of pages of data in the table\n\t\t\t *\n\t\t\t *  @type string\n\t\t\t *  @default Showing _START_ to _END_ of _TOTAL_ entries\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.info\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"info\": \"Showing page _PAGE_ of _PAGES_\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sInfo\": \"Showing _START_ to _END_ of _TOTAL_ entries\",\n\t\n\t\n\t\t\t/**\n\t\t\t * Display information string for when the table is empty. Typically the\n\t\t\t * format of this string should match `info`.\n\t\t\t *  @type string\n\t\t\t *  @default Showing 0 to 0 of 0 entries\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.infoEmpty\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"infoEmpty\": \"No entries to show\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sInfoEmpty\": \"Showing 0 to 0 of 0 entries\",\n\t\n\t\n\t\t\t/**\n\t\t\t * When a user filters the information in a table, this string is appended\n\t\t\t * to the information (`info`) to give an idea of how strong the filtering\n\t\t\t * is. The variable _MAX_ is dynamically updated.\n\t\t\t *  @type string\n\t\t\t *  @default (filtered from _MAX_ total entries)\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.infoFiltered\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"infoFiltered\": \" - filtering from _MAX_ records\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sInfoFiltered\": \"(filtered from _MAX_ total entries)\",\n\t\n\t\n\t\t\t/**\n\t\t\t * If can be useful to append extra information to the info string at times,\n\t\t\t * and this variable does exactly that. This information will be appended to\n\t\t\t * the `info` (`infoEmpty` and `infoFiltered` in whatever combination they are\n\t\t\t * being used) at all times.\n\t\t\t *  @type string\n\t\t\t *  @default <i>Empty string</i>\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.infoPostFix\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"infoPostFix\": \"All records shown are derived from real information.\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sInfoPostFix\": \"\",\n\t\n\t\n\t\t\t/**\n\t\t\t * This decimal place operator is a little different from the other\n\t\t\t * language options since DataTables doesn't output floating point\n\t\t\t * numbers, so it won't ever use this for display of a number. Rather,\n\t\t\t * what this parameter does is modify the sort methods of the table so\n\t\t\t * that numbers which are in a format which has a character other than\n\t\t\t * a period (`.`) as a decimal place will be sorted numerically.\n\t\t\t *\n\t\t\t * Note that numbers with different decimal places cannot be shown in\n\t\t\t * the same table and still be sortable, the table must be consistent.\n\t\t\t * However, multiple different tables on the page can use different\n\t\t\t * decimal place characters.\n\t\t\t *  @type string\n\t\t\t *  @default \n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.decimal\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"decimal\": \",\"\n\t\t\t *          \"thousands\": \".\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sDecimal\": \"\",\n\t\n\t\n\t\t\t/**\n\t\t\t * DataTables has a build in number formatter (`formatNumber`) which is\n\t\t\t * used to format large numbers that are used in the table information.\n\t\t\t * By default a comma is used, but this can be trivially changed to any\n\t\t\t * character you wish with this parameter.\n\t\t\t *  @type string\n\t\t\t *  @default ,\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.thousands\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"thousands\": \"'\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sThousands\": \",\",\n\t\n\t\n\t\t\t/**\n\t\t\t * Detail the action that will be taken when the drop down menu for the\n\t\t\t * pagination length option is changed. The '_MENU_' variable is replaced\n\t\t\t * with a default select list of 10, 25, 50 and 100, and can be replaced\n\t\t\t * with a custom select box if required.\n\t\t\t *  @type string\n\t\t\t *  @default Show _MENU_ entries\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.lengthMenu\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    // Language change only\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"lengthMenu\": \"Display _MENU_ records\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    // Language and options change\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"lengthMenu\": 'Display <select>'+\n\t\t\t *            '<option value=\"10\">10</option>'+\n\t\t\t *            '<option value=\"20\">20</option>'+\n\t\t\t *            '<option value=\"30\">30</option>'+\n\t\t\t *            '<option value=\"40\">40</option>'+\n\t\t\t *            '<option value=\"50\">50</option>'+\n\t\t\t *            '<option value=\"-1\">All</option>'+\n\t\t\t *            '</select> records'\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sLengthMenu\": \"Show _MENU_ entries\",\n\t\n\t\n\t\t\t/**\n\t\t\t * When using Ajax sourced data and during the first draw when DataTables is\n\t\t\t * gathering the data, this message is shown in an empty row in the table to\n\t\t\t * indicate to the end user the the data is being loaded. Note that this\n\t\t\t * parameter is not used when loading data by server-side processing, just\n\t\t\t * Ajax sourced data with client-side processing.\n\t\t\t *  @type string\n\t\t\t *  @default Loading...\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.loadingRecords\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"loadingRecords\": \"Please wait - loading...\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sLoadingRecords\": \"Loading...\",\n\t\n\t\n\t\t\t/**\n\t\t\t * Text which is displayed when the table is processing a user action\n\t\t\t * (usually a sort command or similar).\n\t\t\t *  @type string\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.processing\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"processing\": \"DataTables is currently busy\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sProcessing\": \"\",\n\t\n\t\n\t\t\t/**\n\t\t\t * Details the actions that will be taken when the user types into the\n\t\t\t * filtering input text box. The variable \"_INPUT_\", if used in the string,\n\t\t\t * is replaced with the HTML text box for the filtering input allowing\n\t\t\t * control over where it appears in the string. If \"_INPUT_\" is not given\n\t\t\t * then the input box is appended to the string automatically.\n\t\t\t *  @type string\n\t\t\t *  @default Search:\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.search\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    // Input text box will be appended at the end automatically\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"search\": \"Filter records:\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    // Specify where the filter should appear\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"search\": \"Apply filter _INPUT_ to table\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sSearch\": \"Search:\",\n\t\n\t\n\t\t\t/**\n\t\t\t * Assign a `placeholder` attribute to the search `input` element\n\t\t\t *  @type string\n\t\t\t *  @default \n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.searchPlaceholder\n\t\t\t */\n\t\t\t\"sSearchPlaceholder\": \"\",\n\t\n\t\n\t\t\t/**\n\t\t\t * All of the language information can be stored in a file on the\n\t\t\t * server-side, which DataTables will look up if this parameter is passed.\n\t\t\t * It must store the URL of the language file, which is in a JSON format,\n\t\t\t * and the object has the same properties as the oLanguage object in the\n\t\t\t * initialiser object (i.e. the above parameters). Please refer to one of\n\t\t\t * the example language files to see how this works in action.\n\t\t\t *  @type string\n\t\t\t *  @default <i>Empty string - i.e. disabled</i>\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.url\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"url\": \"http://www.sprymedia.co.uk/dataTables/lang.txt\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sUrl\": \"\",\n\t\n\t\n\t\t\t/**\n\t\t\t * Text shown inside the table records when the is no information to be\n\t\t\t * displayed after filtering. `emptyTable` is shown when there is simply no\n\t\t\t * information in the table at all (regardless of filtering).\n\t\t\t *  @type string\n\t\t\t *  @default No matching records found\n\t\t\t *\n\t\t\t *  @dtopt Language\n\t\t\t *  @name DataTable.defaults.language.zeroRecords\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $(document).ready( function() {\n\t\t\t *      $('#example').dataTable( {\n\t\t\t *        \"language\": {\n\t\t\t *          \"zeroRecords\": \"No records to display\"\n\t\t\t *        }\n\t\t\t *      } );\n\t\t\t *    } );\n\t\t\t */\n\t\t\t\"sZeroRecords\": \"No matching records found\"\n\t\t},\n\t\n\t\n\t\t/**\n\t\t * This parameter allows you to have define the global filtering state at\n\t\t * initialisation time. As an object the `search` parameter must be\n\t\t * defined, but all other parameters are optional. When `regex` is true,\n\t\t * the search string will be treated as a regular expression, when false\n\t\t * (default) it will be treated as a straight string. When `smart`\n\t\t * DataTables will use it's smart filtering methods (to word match at\n\t\t * any point in the data), when false this will not be done.\n\t\t *  @namespace\n\t\t *  @extends DataTable.models.oSearch\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.search\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"search\": {\"search\": \"Initial search\"}\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"oSearch\": $.extend( {}, DataTable.models.oSearch ),\n\t\n\t\n\t\t/**\n\t\t * __Deprecated__ The functionality provided by this parameter has now been\n\t\t * superseded by that provided through `ajax`, which should be used instead.\n\t\t *\n\t\t * By default DataTables will look for the property `data` (or `aaData` for\n\t\t * compatibility with DataTables 1.9-) when obtaining data from an Ajax\n\t\t * source or for server-side processing - this parameter allows that\n\t\t * property to be changed. You can use Javascript dotted object notation to\n\t\t * get a data source for multiple levels of nesting.\n\t\t *  @type string\n\t\t *  @default data\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @dtopt Server-side\n\t\t *  @name DataTable.defaults.ajaxDataProp\n\t\t *\n\t\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t\t */\n\t\t\"sAjaxDataProp\": \"data\",\n\t\n\t\n\t\t/**\n\t\t * __Deprecated__ The functionality provided by this parameter has now been\n\t\t * superseded by that provided through `ajax`, which should be used instead.\n\t\t *\n\t\t * You can instruct DataTables to load data from an external\n\t\t * source using this parameter (use aData if you want to pass data in you\n\t\t * already have). Simply provide a url a JSON object can be obtained from.\n\t\t *  @type string\n\t\t *  @default null\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @dtopt Server-side\n\t\t *  @name DataTable.defaults.ajaxSource\n\t\t *\n\t\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t\t */\n\t\t\"sAjaxSource\": null,\n\t\n\t\n\t\t/**\n\t\t * This initialisation variable allows you to specify exactly where in the\n\t\t * DOM you want DataTables to inject the various controls it adds to the page\n\t\t * (for example you might want the pagination controls at the top of the\n\t\t * table). DIV elements (with or without a custom class) can also be added to\n\t\t * aid styling. The follow syntax is used:\n\t\t *   <ul>\n\t\t *     <li>The following options are allowed:\n\t\t *       <ul>\n\t\t *         <li>'l' - Length changing</li>\n\t\t *         <li>'f' - Filtering input</li>\n\t\t *         <li>'t' - The table!</li>\n\t\t *         <li>'i' - Information</li>\n\t\t *         <li>'p' - Pagination</li>\n\t\t *         <li>'r' - pRocessing</li>\n\t\t *       </ul>\n\t\t *     </li>\n\t\t *     <li>The following constants are allowed:\n\t\t *       <ul>\n\t\t *         <li>'H' - jQueryUI theme \"header\" classes ('fg-toolbar ui-widget-header ui-corner-tl ui-corner-tr ui-helper-clearfix')</li>\n\t\t *         <li>'F' - jQueryUI theme \"footer\" classes ('fg-toolbar ui-widget-header ui-corner-bl ui-corner-br ui-helper-clearfix')</li>\n\t\t *       </ul>\n\t\t *     </li>\n\t\t *     <li>The following syntax is expected:\n\t\t *       <ul>\n\t\t *         <li>'&lt;' and '&gt;' - div elements</li>\n\t\t *         <li>'&lt;\"class\" and '&gt;' - div with a class</li>\n\t\t *         <li>'&lt;\"#id\" and '&gt;' - div with an ID</li>\n\t\t *       </ul>\n\t\t *     </li>\n\t\t *     <li>Examples:\n\t\t *       <ul>\n\t\t *         <li>'&lt;\"wrapper\"flipt&gt;'</li>\n\t\t *         <li>'&lt;lf&lt;t&gt;ip&gt;'</li>\n\t\t *       </ul>\n\t\t *     </li>\n\t\t *   </ul>\n\t\t *  @type string\n\t\t *  @default lfrtip <i>(when `jQueryUI` is false)</i> <b>or</b>\n\t\t *    <\"H\"lfr>t<\"F\"ip> <i>(when `jQueryUI` is true)</i>\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.dom\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"dom\": '&lt;\"top\"i&gt;rt&lt;\"bottom\"flp&gt;&lt;\"clear\"&gt;'\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sDom\": \"lfrtip\",\n\t\n\t\n\t\t/**\n\t\t * Search delay option. This will throttle full table searches that use the\n\t\t * DataTables provided search input element (it does not effect calls to\n\t\t * `dt-api search()`, providing a delay before the search is made.\n\t\t *  @type integer\n\t\t *  @default 0\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.searchDelay\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"searchDelay\": 200\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"searchDelay\": null,\n\t\n\t\n\t\t/**\n\t\t * DataTables features six different built-in options for the buttons to\n\t\t * display for pagination control:\n\t\t *\n\t\t * * `numbers` - Page number buttons only\n\t\t * * `simple` - 'Previous' and 'Next' buttons only\n\t\t * * 'simple_numbers` - 'Previous' and 'Next' buttons, plus page numbers\n\t\t * * `full` - 'First', 'Previous', 'Next' and 'Last' buttons\n\t\t * * `full_numbers` - 'First', 'Previous', 'Next' and 'Last' buttons, plus page numbers\n\t\t * * `first_last_numbers` - 'First' and 'Last' buttons, plus page numbers\n\t\t *  \n\t\t * Further methods can be added using {@link DataTable.ext.oPagination}.\n\t\t *  @type string\n\t\t *  @default simple_numbers\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.pagingType\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"pagingType\": \"full_numbers\"\n\t\t *      } );\n\t\t *    } )\n\t\t */\n\t\t\"sPaginationType\": \"simple_numbers\",\n\t\n\t\n\t\t/**\n\t\t * Enable horizontal scrolling. When a table is too wide to fit into a\n\t\t * certain layout, or you have a large number of columns in the table, you\n\t\t * can enable x-scrolling to show the table in a viewport, which can be\n\t\t * scrolled. This property can be `true` which will allow the table to\n\t\t * scroll horizontally when needed, or any CSS unit, or a number (in which\n\t\t * case it will be treated as a pixel measurement). Setting as simply `true`\n\t\t * is recommended.\n\t\t *  @type boolean|string\n\t\t *  @default <i>blank string - i.e. disabled</i>\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.scrollX\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"scrollX\": true,\n\t\t *        \"scrollCollapse\": true\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sScrollX\": \"\",\n\t\n\t\n\t\t/**\n\t\t * This property can be used to force a DataTable to use more width than it\n\t\t * might otherwise do when x-scrolling is enabled. For example if you have a\n\t\t * table which requires to be well spaced, this parameter is useful for\n\t\t * \"over-sizing\" the table, and thus forcing scrolling. This property can by\n\t\t * any CSS unit, or a number (in which case it will be treated as a pixel\n\t\t * measurement).\n\t\t *  @type string\n\t\t *  @default <i>blank string - i.e. disabled</i>\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @name DataTable.defaults.scrollXInner\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"scrollX\": \"100%\",\n\t\t *        \"scrollXInner\": \"110%\"\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sScrollXInner\": \"\",\n\t\n\t\n\t\t/**\n\t\t * Enable vertical scrolling. Vertical scrolling will constrain the DataTable\n\t\t * to the given height, and enable scrolling for any data which overflows the\n\t\t * current viewport. This can be used as an alternative to paging to display\n\t\t * a lot of data in a small area (although paging and scrolling can both be\n\t\t * enabled at the same time). This property can be any CSS unit, or a number\n\t\t * (in which case it will be treated as a pixel measurement).\n\t\t *  @type string\n\t\t *  @default <i>blank string - i.e. disabled</i>\n\t\t *\n\t\t *  @dtopt Features\n\t\t *  @name DataTable.defaults.scrollY\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"scrollY\": \"200px\",\n\t\t *        \"paginate\": false\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sScrollY\": \"\",\n\t\n\t\n\t\t/**\n\t\t * __Deprecated__ The functionality provided by this parameter has now been\n\t\t * superseded by that provided through `ajax`, which should be used instead.\n\t\t *\n\t\t * Set the HTTP method that is used to make the Ajax call for server-side\n\t\t * processing or Ajax sourced data.\n\t\t *  @type string\n\t\t *  @default GET\n\t\t *\n\t\t *  @dtopt Options\n\t\t *  @dtopt Server-side\n\t\t *  @name DataTable.defaults.serverMethod\n\t\t *\n\t\t *  @deprecated 1.10. Please use `ajax` for this functionality now.\n\t\t */\n\t\t\"sServerMethod\": \"GET\",\n\t\n\t\n\t\t/**\n\t\t * DataTables makes use of renderers when displaying HTML elements for\n\t\t * a table. These renderers can be added or modified by plug-ins to\n\t\t * generate suitable mark-up for a site. For example the Bootstrap\n\t\t * integration plug-in for DataTables uses a paging button renderer to\n\t\t * display pagination buttons in the mark-up required by Bootstrap.\n\t\t *\n\t\t * For further information about the renderers available see\n\t\t * DataTable.ext.renderer\n\t\t *  @type string|object\n\t\t *  @default null\n\t\t *\n\t\t *  @name DataTable.defaults.renderer\n\t\t *\n\t\t */\n\t\t\"renderer\": null,\n\t\n\t\n\t\t/**\n\t\t * Set the data property name that DataTables should use to get a row's id\n\t\t * to set as the `id` property in the node.\n\t\t *  @type string\n\t\t *  @default DT_RowId\n\t\t *\n\t\t *  @name DataTable.defaults.rowId\n\t\t */\n\t\t\"rowId\": \"DT_RowId\"\n\t};\n\t\n\t_fnHungarianMap( DataTable.defaults );\n\t\n\t\n\t\n\t/*\n\t * Developer note - See note in model.defaults.js about the use of Hungarian\n\t * notation and camel case.\n\t */\n\t\n\t/**\n\t * Column options that can be given to DataTables at initialisation time.\n\t *  @namespace\n\t */\n\tDataTable.defaults.column = {\n\t\t/**\n\t\t * Define which column(s) an order will occur on for this column. This\n\t\t * allows a column's ordering to take multiple columns into account when\n\t\t * doing a sort or use the data from a different column. For example first\n\t\t * name / last name columns make sense to do a multi-column sort over the\n\t\t * two columns.\n\t\t *  @type array|int\n\t\t *  @default null <i>Takes the value of the column index automatically</i>\n\t\t *\n\t\t *  @name DataTable.defaults.column.orderData\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"orderData\": [ 0, 1 ], \"targets\": [ 0 ] },\n\t\t *          { \"orderData\": [ 1, 0 ], \"targets\": [ 1 ] },\n\t\t *          { \"orderData\": 2, \"targets\": [ 2 ] }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          { \"orderData\": [ 0, 1 ] },\n\t\t *          { \"orderData\": [ 1, 0 ] },\n\t\t *          { \"orderData\": 2 },\n\t\t *          null,\n\t\t *          null\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"aDataSort\": null,\n\t\t\"iDataSort\": -1,\n\t\n\t\n\t\t/**\n\t\t * You can control the default ordering direction, and even alter the\n\t\t * behaviour of the sort handler (i.e. only allow ascending ordering etc)\n\t\t * using this parameter.\n\t\t *  @type array\n\t\t *  @default [ 'asc', 'desc' ]\n\t\t *\n\t\t *  @name DataTable.defaults.column.orderSequence\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"orderSequence\": [ \"asc\" ], \"targets\": [ 1 ] },\n\t\t *          { \"orderSequence\": [ \"desc\", \"asc\", \"asc\" ], \"targets\": [ 2 ] },\n\t\t *          { \"orderSequence\": [ \"desc\" ], \"targets\": [ 3 ] }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          null,\n\t\t *          { \"orderSequence\": [ \"asc\" ] },\n\t\t *          { \"orderSequence\": [ \"desc\", \"asc\", \"asc\" ] },\n\t\t *          { \"orderSequence\": [ \"desc\" ] },\n\t\t *          null\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"asSorting\": [ 'asc', 'desc' ],\n\t\n\t\n\t\t/**\n\t\t * Enable or disable filtering on the data in this column.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @name DataTable.defaults.column.searchable\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"searchable\": false, \"targets\": [ 0 ] }\n\t\t *        ] } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          { \"searchable\": false },\n\t\t *          null,\n\t\t *          null,\n\t\t *          null,\n\t\t *          null\n\t\t *        ] } );\n\t\t *    } );\n\t\t */\n\t\t\"bSearchable\": true,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable ordering on this column.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @name DataTable.defaults.column.orderable\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"orderable\": false, \"targets\": [ 0 ] }\n\t\t *        ] } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          { \"orderable\": false },\n\t\t *          null,\n\t\t *          null,\n\t\t *          null,\n\t\t *          null\n\t\t *        ] } );\n\t\t *    } );\n\t\t */\n\t\t\"bSortable\": true,\n\t\n\t\n\t\t/**\n\t\t * Enable or disable the display of this column.\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t *\n\t\t *  @name DataTable.defaults.column.visible\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"visible\": false, \"targets\": [ 0 ] }\n\t\t *        ] } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          { \"visible\": false },\n\t\t *          null,\n\t\t *          null,\n\t\t *          null,\n\t\t *          null\n\t\t *        ] } );\n\t\t *    } );\n\t\t */\n\t\t\"bVisible\": true,\n\t\n\t\n\t\t/**\n\t\t * Developer definable function that is called whenever a cell is created (Ajax source,\n\t\t * etc) or processed for input (DOM source). This can be used as a compliment to mRender\n\t\t * allowing you to modify the DOM element (add background colour for example) when the\n\t\t * element is available.\n\t\t *  @type function\n\t\t *  @param {element} td The TD node that has been created\n\t\t *  @param {*} cellData The Data for the cell\n\t\t *  @param {array|object} rowData The data for the whole row\n\t\t *  @param {int} row The row index for the aoData data store\n\t\t *  @param {int} col The column index for aoColumns\n\t\t *\n\t\t *  @name DataTable.defaults.column.createdCell\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [ {\n\t\t *          \"targets\": [3],\n\t\t *          \"createdCell\": function (td, cellData, rowData, row, col) {\n\t\t *            if ( cellData == \"1.7\" ) {\n\t\t *              $(td).css('color', 'blue')\n\t\t *            }\n\t\t *          }\n\t\t *        } ]\n\t\t *      });\n\t\t *    } );\n\t\t */\n\t\t\"fnCreatedCell\": null,\n\t\n\t\n\t\t/**\n\t\t * This parameter has been replaced by `data` in DataTables to ensure naming\n\t\t * consistency. `dataProp` can still be used, as there is backwards\n\t\t * compatibility in DataTables for this option, but it is strongly\n\t\t * recommended that you use `data` in preference to `dataProp`.\n\t\t *  @name DataTable.defaults.column.dataProp\n\t\t */\n\t\n\t\n\t\t/**\n\t\t * This property can be used to read data from any data source property,\n\t\t * including deeply nested objects / properties. `data` can be given in a\n\t\t * number of different ways which effect its behaviour:\n\t\t *\n\t\t * * `integer` - treated as an array index for the data source. This is the\n\t\t *   default that DataTables uses (incrementally increased for each column).\n\t\t * * `string` - read an object property from the data source. There are\n\t\t *   three 'special' options that can be used in the string to alter how\n\t\t *   DataTables reads the data from the source object:\n\t\t *    * `.` - Dotted Javascript notation. Just as you use a `.` in\n\t\t *      Javascript to read from nested objects, so to can the options\n\t\t *      specified in `data`. For example: `browser.version` or\n\t\t *      `browser.name`. If your object parameter name contains a period, use\n\t\t *      `\\\\` to escape it - i.e. `first\\\\.name`.\n\t\t *    * `[]` - Array notation. DataTables can automatically combine data\n\t\t *      from and array source, joining the data with the characters provided\n\t\t *      between the two brackets. For example: `name[, ]` would provide a\n\t\t *      comma-space separated list from the source array. If no characters\n\t\t *      are provided between the brackets, the original array source is\n\t\t *      returned.\n\t\t *    * `()` - Function notation. Adding `()` to the end of a parameter will\n\t\t *      execute a function of the name given. For example: `browser()` for a\n\t\t *      simple function on the data source, `browser.version()` for a\n\t\t *      function in a nested property or even `browser().version` to get an\n\t\t *      object property if the function called returns an object. Note that\n\t\t *      function notation is recommended for use in `render` rather than\n\t\t *      `data` as it is much simpler to use as a renderer.\n\t\t * * `null` - use the original data source for the row rather than plucking\n\t\t *   data directly from it. This action has effects on two other\n\t\t *   initialisation options:\n\t\t *    * `defaultContent` - When null is given as the `data` option and\n\t\t *      `defaultContent` is specified for the column, the value defined by\n\t\t *      `defaultContent` will be used for the cell.\n\t\t *    * `render` - When null is used for the `data` option and the `render`\n\t\t *      option is specified for the column, the whole data source for the\n\t\t *      row is used for the renderer.\n\t\t * * `function` - the function given will be executed whenever DataTables\n\t\t *   needs to set or get the data for a cell in the column. The function\n\t\t *   takes three parameters:\n\t\t *    * Parameters:\n\t\t *      * `{array|object}` The data source for the row\n\t\t *      * `{string}` The type call data requested - this will be 'set' when\n\t\t *        setting data or 'filter', 'display', 'type', 'sort' or undefined\n\t\t *        when gathering data. Note that when `undefined` is given for the\n\t\t *        type DataTables expects to get the raw data for the object back<\n\t\t *      * `{*}` Data to set when the second parameter is 'set'.\n\t\t *    * Return:\n\t\t *      * The return value from the function is not required when 'set' is\n\t\t *        the type of call, but otherwise the return is what will be used\n\t\t *        for the data requested.\n\t\t *\n\t\t * Note that `data` is a getter and setter option. If you just require\n\t\t * formatting of data for output, you will likely want to use `render` which\n\t\t * is simply a getter and thus simpler to use.\n\t\t *\n\t\t * Note that prior to DataTables 1.9.2 `data` was called `mDataProp`. The\n\t\t * name change reflects the flexibility of this property and is consistent\n\t\t * with the naming of mRender. If 'mDataProp' is given, then it will still\n\t\t * be used by DataTables, as it automatically maps the old name to the new\n\t\t * if required.\n\t\t *\n\t\t *  @type string|int|function|null\n\t\t *  @default null <i>Use automatically calculated column index</i>\n\t\t *\n\t\t *  @name DataTable.defaults.column.data\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Read table data from objects\n\t\t *    // JSON structure for each row:\n\t\t *    //   {\n\t\t *    //      \"engine\": {value},\n\t\t *    //      \"browser\": {value},\n\t\t *    //      \"platform\": {value},\n\t\t *    //      \"version\": {value},\n\t\t *    //      \"grade\": {value}\n\t\t *    //   }\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"ajaxSource\": \"sources/objects.txt\",\n\t\t *        \"columns\": [\n\t\t *          { \"data\": \"engine\" },\n\t\t *          { \"data\": \"browser\" },\n\t\t *          { \"data\": \"platform\" },\n\t\t *          { \"data\": \"version\" },\n\t\t *          { \"data\": \"grade\" }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Read information from deeply nested objects\n\t\t *    // JSON structure for each row:\n\t\t *    //   {\n\t\t *    //      \"engine\": {value},\n\t\t *    //      \"browser\": {value},\n\t\t *    //      \"platform\": {\n\t\t *    //         \"inner\": {value}\n\t\t *    //      },\n\t\t *    //      \"details\": [\n\t\t *    //         {value}, {value}\n\t\t *    //      ]\n\t\t *    //   }\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"ajaxSource\": \"sources/deep.txt\",\n\t\t *        \"columns\": [\n\t\t *          { \"data\": \"engine\" },\n\t\t *          { \"data\": \"browser\" },\n\t\t *          { \"data\": \"platform.inner\" },\n\t\t *          { \"data\": \"details.0\" },\n\t\t *          { \"data\": \"details.1\" }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `data` as a function to provide different information for\n\t\t *    // sorting, filtering and display. In this case, currency (price)\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [ {\n\t\t *          \"targets\": [ 0 ],\n\t\t *          \"data\": function ( source, type, val ) {\n\t\t *            if (type === 'set') {\n\t\t *              source.price = val;\n\t\t *              // Store the computed display and filter values for efficiency\n\t\t *              source.price_display = val==\"\" ? \"\" : \"$\"+numberFormat(val);\n\t\t *              source.price_filter  = val==\"\" ? \"\" : \"$\"+numberFormat(val)+\" \"+val;\n\t\t *              return;\n\t\t *            }\n\t\t *            else if (type === 'display') {\n\t\t *              return source.price_display;\n\t\t *            }\n\t\t *            else if (type === 'filter') {\n\t\t *              return source.price_filter;\n\t\t *            }\n\t\t *            // 'sort', 'type' and undefined all just use the integer\n\t\t *            return source.price;\n\t\t *          }\n\t\t *        } ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using default content\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [ {\n\t\t *          \"targets\": [ 0 ],\n\t\t *          \"data\": null,\n\t\t *          \"defaultContent\": \"Click to edit\"\n\t\t *        } ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using array notation - outputting a list from an array\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [ {\n\t\t *          \"targets\": [ 0 ],\n\t\t *          \"data\": \"name[, ]\"\n\t\t *        } ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t */\n\t\t\"mData\": null,\n\t\n\t\n\t\t/**\n\t\t * This property is the rendering partner to `data` and it is suggested that\n\t\t * when you want to manipulate data for display (including filtering,\n\t\t * sorting etc) without altering the underlying data for the table, use this\n\t\t * property. `render` can be considered to be the the read only companion to\n\t\t * `data` which is read / write (then as such more complex). Like `data`\n\t\t * this option can be given in a number of different ways to effect its\n\t\t * behaviour:\n\t\t *\n\t\t * * `integer` - treated as an array index for the data source. This is the\n\t\t *   default that DataTables uses (incrementally increased for each column).\n\t\t * * `string` - read an object property from the data source. There are\n\t\t *   three 'special' options that can be used in the string to alter how\n\t\t *   DataTables reads the data from the source object:\n\t\t *    * `.` - Dotted Javascript notation. Just as you use a `.` in\n\t\t *      Javascript to read from nested objects, so to can the options\n\t\t *      specified in `data`. For example: `browser.version` or\n\t\t *      `browser.name`. If your object parameter name contains a period, use\n\t\t *      `\\\\` to escape it - i.e. `first\\\\.name`.\n\t\t *    * `[]` - Array notation. DataTables can automatically combine data\n\t\t *      from and array source, joining the data with the characters provided\n\t\t *      between the two brackets. For example: `name[, ]` would provide a\n\t\t *      comma-space separated list from the source array. If no characters\n\t\t *      are provided between the brackets, the original array source is\n\t\t *      returned.\n\t\t *    * `()` - Function notation. Adding `()` to the end of a parameter will\n\t\t *      execute a function of the name given. For example: `browser()` for a\n\t\t *      simple function on the data source, `browser.version()` for a\n\t\t *      function in a nested property or even `browser().version` to get an\n\t\t *      object property if the function called returns an object.\n\t\t * * `object` - use different data for the different data types requested by\n\t\t *   DataTables ('filter', 'display', 'type' or 'sort'). The property names\n\t\t *   of the object is the data type the property refers to and the value can\n\t\t *   defined using an integer, string or function using the same rules as\n\t\t *   `render` normally does. Note that an `_` option _must_ be specified.\n\t\t *   This is the default value to use if you haven't specified a value for\n\t\t *   the data type requested by DataTables.\n\t\t * * `function` - the function given will be executed whenever DataTables\n\t\t *   needs to set or get the data for a cell in the column. The function\n\t\t *   takes three parameters:\n\t\t *    * Parameters:\n\t\t *      * {array|object} The data source for the row (based on `data`)\n\t\t *      * {string} The type call data requested - this will be 'filter',\n\t\t *        'display', 'type' or 'sort'.\n\t\t *      * {array|object} The full data source for the row (not based on\n\t\t *        `data`)\n\t\t *    * Return:\n\t\t *      * The return value from the function is what will be used for the\n\t\t *        data requested.\n\t\t *\n\t\t *  @type string|int|function|object|null\n\t\t *  @default null Use the data source value.\n\t\t *\n\t\t *  @name DataTable.defaults.column.render\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Create a comma separated list from an array of objects\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"ajaxSource\": \"sources/deep.txt\",\n\t\t *        \"columns\": [\n\t\t *          { \"data\": \"engine\" },\n\t\t *          { \"data\": \"browser\" },\n\t\t *          {\n\t\t *            \"data\": \"platform\",\n\t\t *            \"render\": \"[, ].name\"\n\t\t *          }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Execute a function to obtain data\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [ {\n\t\t *          \"targets\": [ 0 ],\n\t\t *          \"data\": null, // Use the full data source object for the renderer's source\n\t\t *          \"render\": \"browserName()\"\n\t\t *        } ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // As an object, extracting different data for the different types\n\t\t *    // This would be used with a data source such as:\n\t\t *    //   { \"phone\": 5552368, \"phone_filter\": \"5552368 555-2368\", \"phone_display\": \"555-2368\" }\n\t\t *    // Here the `phone` integer is used for sorting and type detection, while `phone_filter`\n\t\t *    // (which has both forms) is used for filtering for if a user inputs either format, while\n\t\t *    // the formatted phone number is the one that is shown in the table.\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [ {\n\t\t *          \"targets\": [ 0 ],\n\t\t *          \"data\": null, // Use the full data source object for the renderer's source\n\t\t *          \"render\": {\n\t\t *            \"_\": \"phone\",\n\t\t *            \"filter\": \"phone_filter\",\n\t\t *            \"display\": \"phone_display\"\n\t\t *          }\n\t\t *        } ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Use as a function to create a link from the data source\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [ {\n\t\t *          \"targets\": [ 0 ],\n\t\t *          \"data\": \"download_link\",\n\t\t *          \"render\": function ( data, type, full ) {\n\t\t *            return '<a href=\"'+data+'\">Download</a>';\n\t\t *          }\n\t\t *        } ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"mRender\": null,\n\t\n\t\n\t\t/**\n\t\t * Change the cell type created for the column - either TD cells or TH cells. This\n\t\t * can be useful as TH cells have semantic meaning in the table body, allowing them\n\t\t * to act as a header for a row (you may wish to add scope='row' to the TH elements).\n\t\t *  @type string\n\t\t *  @default td\n\t\t *\n\t\t *  @name DataTable.defaults.column.cellType\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Make the first column use TH cells\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [ {\n\t\t *          \"targets\": [ 0 ],\n\t\t *          \"cellType\": \"th\"\n\t\t *        } ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sCellType\": \"td\",\n\t\n\t\n\t\t/**\n\t\t * Class to give to each cell in this column.\n\t\t *  @type string\n\t\t *  @default <i>Empty string</i>\n\t\t *\n\t\t *  @name DataTable.defaults.column.class\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"class\": \"my_class\", \"targets\": [ 0 ] }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          { \"class\": \"my_class\" },\n\t\t *          null,\n\t\t *          null,\n\t\t *          null,\n\t\t *          null\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sClass\": \"\",\n\t\n\t\t/**\n\t\t * When DataTables calculates the column widths to assign to each column,\n\t\t * it finds the longest string in each column and then constructs a\n\t\t * temporary table and reads the widths from that. The problem with this\n\t\t * is that \"mmm\" is much wider then \"iiii\", but the latter is a longer\n\t\t * string - thus the calculation can go wrong (doing it properly and putting\n\t\t * it into an DOM object and measuring that is horribly(!) slow). Thus as\n\t\t * a \"work around\" we provide this option. It will append its value to the\n\t\t * text that is found to be the longest string for the column - i.e. padding.\n\t\t * Generally you shouldn't need this!\n\t\t *  @type string\n\t\t *  @default <i>Empty string<i>\n\t\t *\n\t\t *  @name DataTable.defaults.column.contentPadding\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          null,\n\t\t *          null,\n\t\t *          null,\n\t\t *          {\n\t\t *            \"contentPadding\": \"mmm\"\n\t\t *          }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sContentPadding\": \"\",\n\t\n\t\n\t\t/**\n\t\t * Allows a default value to be given for a column's data, and will be used\n\t\t * whenever a null data source is encountered (this can be because `data`\n\t\t * is set to null, or because the data source itself is null).\n\t\t *  @type string\n\t\t *  @default null\n\t\t *\n\t\t *  @name DataTable.defaults.column.defaultContent\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          {\n\t\t *            \"data\": null,\n\t\t *            \"defaultContent\": \"Edit\",\n\t\t *            \"targets\": [ -1 ]\n\t\t *          }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          null,\n\t\t *          null,\n\t\t *          null,\n\t\t *          {\n\t\t *            \"data\": null,\n\t\t *            \"defaultContent\": \"Edit\"\n\t\t *          }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sDefaultContent\": null,\n\t\n\t\n\t\t/**\n\t\t * This parameter is only used in DataTables' server-side processing. It can\n\t\t * be exceptionally useful to know what columns are being displayed on the\n\t\t * client side, and to map these to database fields. When defined, the names\n\t\t * also allow DataTables to reorder information from the server if it comes\n\t\t * back in an unexpected order (i.e. if you switch your columns around on the\n\t\t * client-side, your server-side code does not also need updating).\n\t\t *  @type string\n\t\t *  @default <i>Empty string</i>\n\t\t *\n\t\t *  @name DataTable.defaults.column.name\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"name\": \"engine\", \"targets\": [ 0 ] },\n\t\t *          { \"name\": \"browser\", \"targets\": [ 1 ] },\n\t\t *          { \"name\": \"platform\", \"targets\": [ 2 ] },\n\t\t *          { \"name\": \"version\", \"targets\": [ 3 ] },\n\t\t *          { \"name\": \"grade\", \"targets\": [ 4 ] }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          { \"name\": \"engine\" },\n\t\t *          { \"name\": \"browser\" },\n\t\t *          { \"name\": \"platform\" },\n\t\t *          { \"name\": \"version\" },\n\t\t *          { \"name\": \"grade\" }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sName\": \"\",\n\t\n\t\n\t\t/**\n\t\t * Defines a data source type for the ordering which can be used to read\n\t\t * real-time information from the table (updating the internally cached\n\t\t * version) prior to ordering. This allows ordering to occur on user\n\t\t * editable elements such as form inputs.\n\t\t *  @type string\n\t\t *  @default std\n\t\t *\n\t\t *  @name DataTable.defaults.column.orderDataType\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"orderDataType\": \"dom-text\", \"targets\": [ 2, 3 ] },\n\t\t *          { \"type\": \"numeric\", \"targets\": [ 3 ] },\n\t\t *          { \"orderDataType\": \"dom-select\", \"targets\": [ 4 ] },\n\t\t *          { \"orderDataType\": \"dom-checkbox\", \"targets\": [ 5 ] }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          null,\n\t\t *          null,\n\t\t *          { \"orderDataType\": \"dom-text\" },\n\t\t *          { \"orderDataType\": \"dom-text\", \"type\": \"numeric\" },\n\t\t *          { \"orderDataType\": \"dom-select\" },\n\t\t *          { \"orderDataType\": \"dom-checkbox\" }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sSortDataType\": \"std\",\n\t\n\t\n\t\t/**\n\t\t * The title of this column.\n\t\t *  @type string\n\t\t *  @default null <i>Derived from the 'TH' value for this column in the\n\t\t *    original HTML table.</i>\n\t\t *\n\t\t *  @name DataTable.defaults.column.title\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"title\": \"My column title\", \"targets\": [ 0 ] }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          { \"title\": \"My column title\" },\n\t\t *          null,\n\t\t *          null,\n\t\t *          null,\n\t\t *          null\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sTitle\": null,\n\t\n\t\n\t\t/**\n\t\t * The type allows you to specify how the data for this column will be\n\t\t * ordered. Four types (string, numeric, date and html (which will strip\n\t\t * HTML tags before ordering)) are currently available. Note that only date\n\t\t * formats understood by Javascript's Date() object will be accepted as type\n\t\t * date. For example: \"Mar 26, 2008 5:03 PM\". May take the values: 'string',\n\t\t * 'numeric', 'date' or 'html' (by default). Further types can be adding\n\t\t * through plug-ins.\n\t\t *  @type string\n\t\t *  @default null <i>Auto-detected from raw data</i>\n\t\t *\n\t\t *  @name DataTable.defaults.column.type\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"type\": \"html\", \"targets\": [ 0 ] }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          { \"type\": \"html\" },\n\t\t *          null,\n\t\t *          null,\n\t\t *          null,\n\t\t *          null\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sType\": null,\n\t\n\t\n\t\t/**\n\t\t * Defining the width of the column, this parameter may take any CSS value\n\t\t * (3em, 20px etc). DataTables applies 'smart' widths to columns which have not\n\t\t * been given a specific width through this interface ensuring that the table\n\t\t * remains readable.\n\t\t *  @type string\n\t\t *  @default null <i>Automatic</i>\n\t\t *\n\t\t *  @name DataTable.defaults.column.width\n\t\t *  @dtopt Columns\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columnDefs`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columnDefs\": [\n\t\t *          { \"width\": \"20%\", \"targets\": [ 0 ] }\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t *\n\t\t *  @example\n\t\t *    // Using `columns`\n\t\t *    $(document).ready( function() {\n\t\t *      $('#example').dataTable( {\n\t\t *        \"columns\": [\n\t\t *          { \"width\": \"20%\" },\n\t\t *          null,\n\t\t *          null,\n\t\t *          null,\n\t\t *          null\n\t\t *        ]\n\t\t *      } );\n\t\t *    } );\n\t\t */\n\t\t\"sWidth\": null\n\t};\n\t\n\t_fnHungarianMap( DataTable.defaults.column );\n\t\n\t\n\t\n\t/**\n\t * DataTables settings object - this holds all the information needed for a\n\t * given table, including configuration, data and current application of the\n\t * table options. DataTables does not have a single instance for each DataTable\n\t * with the settings attached to that instance, but rather instances of the\n\t * DataTable \"class\" are created on-the-fly as needed (typically by a\n\t * $().dataTable() call) and the settings object is then applied to that\n\t * instance.\n\t *\n\t * Note that this object is related to {@link DataTable.defaults} but this\n\t * one is the internal data store for DataTables's cache of columns. It should\n\t * NOT be manipulated outside of DataTables. Any configuration should be done\n\t * through the initialisation options.\n\t *  @namespace\n\t *  @todo Really should attach the settings object to individual instances so we\n\t *    don't need to create new instances on each $().dataTable() call (if the\n\t *    table already exists). It would also save passing oSettings around and\n\t *    into every single function. However, this is a very significant\n\t *    architecture change for DataTables and will almost certainly break\n\t *    backwards compatibility with older installations. This is something that\n\t *    will be done in 2.0.\n\t */\n\tDataTable.models.oSettings = {\n\t\t/**\n\t\t * Primary features of DataTables and their enablement state.\n\t\t *  @namespace\n\t\t */\n\t\t\"oFeatures\": {\n\t\n\t\t\t/**\n\t\t\t * Flag to say if DataTables should automatically try to calculate the\n\t\t\t * optimum table and columns widths (true) or not (false).\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bAutoWidth\": null,\n\t\n\t\t\t/**\n\t\t\t * Delay the creation of TR and TD elements until they are actually\n\t\t\t * needed by a driven page draw. This can give a significant speed\n\t\t\t * increase for Ajax source and Javascript source data, but makes no\n\t\t\t * difference at all for DOM and server-side processing tables.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bDeferRender\": null,\n\t\n\t\t\t/**\n\t\t\t * Enable filtering on the table or not. Note that if this is disabled\n\t\t\t * then there is no filtering at all on the table, including fnFilter.\n\t\t\t * To just remove the filtering input use sDom and remove the 'f' option.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bFilter\": null,\n\t\n\t\t\t/**\n\t\t\t * Table information element (the 'Showing x of y records' div) enable\n\t\t\t * flag.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bInfo\": null,\n\t\n\t\t\t/**\n\t\t\t * Present a user control allowing the end user to change the page size\n\t\t\t * when pagination is enabled.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bLengthChange\": null,\n\t\n\t\t\t/**\n\t\t\t * Pagination enabled or not. Note that if this is disabled then length\n\t\t\t * changing must also be disabled.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bPaginate\": null,\n\t\n\t\t\t/**\n\t\t\t * Processing indicator enable flag whenever DataTables is enacting a\n\t\t\t * user request - typically an Ajax request for server-side processing.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bProcessing\": null,\n\t\n\t\t\t/**\n\t\t\t * Server-side processing enabled flag - when enabled DataTables will\n\t\t\t * get all data from the server for every draw - there is no filtering,\n\t\t\t * sorting or paging done on the client-side.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bServerSide\": null,\n\t\n\t\t\t/**\n\t\t\t * Sorting enablement flag.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bSort\": null,\n\t\n\t\t\t/**\n\t\t\t * Multi-column sorting\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bSortMulti\": null,\n\t\n\t\t\t/**\n\t\t\t * Apply a class to the columns which are being sorted to provide a\n\t\t\t * visual highlight or not. This can slow things down when enabled since\n\t\t\t * there is a lot of DOM interaction.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bSortClasses\": null,\n\t\n\t\t\t/**\n\t\t\t * State saving enablement flag.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bStateSave\": null\n\t\t},\n\t\n\t\n\t\t/**\n\t\t * Scrolling settings for a table.\n\t\t *  @namespace\n\t\t */\n\t\t\"oScroll\": {\n\t\t\t/**\n\t\t\t * When the table is shorter in height than sScrollY, collapse the\n\t\t\t * table container down to the height of the table (when true).\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type boolean\n\t\t\t */\n\t\t\t\"bCollapse\": null,\n\t\n\t\t\t/**\n\t\t\t * Width of the scrollbar for the web-browser's platform. Calculated\n\t\t\t * during table initialisation.\n\t\t\t *  @type int\n\t\t\t *  @default 0\n\t\t\t */\n\t\t\t\"iBarWidth\": 0,\n\t\n\t\t\t/**\n\t\t\t * Viewport width for horizontal scrolling. Horizontal scrolling is\n\t\t\t * disabled if an empty string.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type string\n\t\t\t */\n\t\t\t\"sX\": null,\n\t\n\t\t\t/**\n\t\t\t * Width to expand the table to when using x-scrolling. Typically you\n\t\t\t * should not need to use this.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type string\n\t\t\t *  @deprecated\n\t\t\t */\n\t\t\t\"sXInner\": null,\n\t\n\t\t\t/**\n\t\t\t * Viewport height for vertical scrolling. Vertical scrolling is disabled\n\t\t\t * if an empty string.\n\t\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t\t * set a default use {@link DataTable.defaults}.\n\t\t\t *  @type string\n\t\t\t */\n\t\t\t\"sY\": null\n\t\t},\n\t\n\t\t/**\n\t\t * Language information for the table.\n\t\t *  @namespace\n\t\t *  @extends DataTable.defaults.oLanguage\n\t\t */\n\t\t\"oLanguage\": {\n\t\t\t/**\n\t\t\t * Information callback function. See\n\t\t\t * {@link DataTable.defaults.fnInfoCallback}\n\t\t\t *  @type function\n\t\t\t *  @default null\n\t\t\t */\n\t\t\t\"fnInfoCallback\": null\n\t\t},\n\t\n\t\t/**\n\t\t * Browser support parameters\n\t\t *  @namespace\n\t\t */\n\t\t\"oBrowser\": {\n\t\t\t/**\n\t\t\t * Indicate if the browser incorrectly calculates width:100% inside a\n\t\t\t * scrolling element (IE6/7)\n\t\t\t *  @type boolean\n\t\t\t *  @default false\n\t\t\t */\n\t\t\t\"bScrollOversize\": false,\n\t\n\t\t\t/**\n\t\t\t * Determine if the vertical scrollbar is on the right or left of the\n\t\t\t * scrolling container - needed for rtl language layout, although not\n\t\t\t * all browsers move the scrollbar (Safari).\n\t\t\t *  @type boolean\n\t\t\t *  @default false\n\t\t\t */\n\t\t\t\"bScrollbarLeft\": false,\n\t\n\t\t\t/**\n\t\t\t * Flag for if `getBoundingClientRect` is fully supported or not\n\t\t\t *  @type boolean\n\t\t\t *  @default false\n\t\t\t */\n\t\t\t\"bBounding\": false,\n\t\n\t\t\t/**\n\t\t\t * Browser scrollbar width\n\t\t\t *  @type integer\n\t\t\t *  @default 0\n\t\t\t */\n\t\t\t\"barWidth\": 0\n\t\t},\n\t\n\t\n\t\t\"ajax\": null,\n\t\n\t\n\t\t/**\n\t\t * Array referencing the nodes which are used for the features. The\n\t\t * parameters of this object match what is allowed by sDom - i.e.\n\t\t *   <ul>\n\t\t *     <li>'l' - Length changing</li>\n\t\t *     <li>'f' - Filtering input</li>\n\t\t *     <li>'t' - The table!</li>\n\t\t *     <li>'i' - Information</li>\n\t\t *     <li>'p' - Pagination</li>\n\t\t *     <li>'r' - pRocessing</li>\n\t\t *   </ul>\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aanFeatures\": [],\n\t\n\t\t/**\n\t\t * Store data information - see {@link DataTable.models.oRow} for detailed\n\t\t * information.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoData\": [],\n\t\n\t\t/**\n\t\t * Array of indexes which are in the current display (after filtering etc)\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aiDisplay\": [],\n\t\n\t\t/**\n\t\t * Array of indexes for display - no filtering\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aiDisplayMaster\": [],\n\t\n\t\t/**\n\t\t * Map of row ids to data indexes\n\t\t *  @type object\n\t\t *  @default {}\n\t\t */\n\t\t\"aIds\": {},\n\t\n\t\t/**\n\t\t * Store information about each column that is in use\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoColumns\": [],\n\t\n\t\t/**\n\t\t * Store information about the table's header\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoHeader\": [],\n\t\n\t\t/**\n\t\t * Store information about the table's footer\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoFooter\": [],\n\t\n\t\t/**\n\t\t * Store the applied global search information in case we want to force a\n\t\t * research or compare the old search to a new one.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @namespace\n\t\t *  @extends DataTable.models.oSearch\n\t\t */\n\t\t\"oPreviousSearch\": {},\n\t\n\t\t/**\n\t\t * Store the applied search for each column - see\n\t\t * {@link DataTable.models.oSearch} for the format that is used for the\n\t\t * filtering information for each column.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoPreSearchCols\": [],\n\t\n\t\t/**\n\t\t * Sorting that is applied to the table. Note that the inner arrays are\n\t\t * used in the following manner:\n\t\t * <ul>\n\t\t *   <li>Index 0 - column number</li>\n\t\t *   <li>Index 1 - current sorting direction</li>\n\t\t * </ul>\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type array\n\t\t *  @todo These inner arrays should really be objects\n\t\t */\n\t\t\"aaSorting\": null,\n\t\n\t\t/**\n\t\t * Sorting that is always applied to the table (i.e. prefixed in front of\n\t\t * aaSorting).\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aaSortingFixed\": [],\n\t\n\t\t/**\n\t\t * Classes to use for the striping of a table.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"asStripeClasses\": null,\n\t\n\t\t/**\n\t\t * If restoring a table - we should restore its striping classes as well\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"asDestroyStripes\": [],\n\t\n\t\t/**\n\t\t * If restoring a table - we should restore its width\n\t\t *  @type int\n\t\t *  @default 0\n\t\t */\n\t\t\"sDestroyWidth\": 0,\n\t\n\t\t/**\n\t\t * Callback functions array for every time a row is inserted (i.e. on a draw).\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoRowCallback\": [],\n\t\n\t\t/**\n\t\t * Callback functions for the header on each draw.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoHeaderCallback\": [],\n\t\n\t\t/**\n\t\t * Callback function for the footer on each draw.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoFooterCallback\": [],\n\t\n\t\t/**\n\t\t * Array of callback functions for draw callback functions\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoDrawCallback\": [],\n\t\n\t\t/**\n\t\t * Array of callback functions for row created function\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoRowCreatedCallback\": [],\n\t\n\t\t/**\n\t\t * Callback functions for just before the table is redrawn. A return of\n\t\t * false will be used to cancel the draw.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoPreDrawCallback\": [],\n\t\n\t\t/**\n\t\t * Callback functions for when the table has been initialised.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoInitComplete\": [],\n\t\n\t\n\t\t/**\n\t\t * Callbacks for modifying the settings to be stored for state saving, prior to\n\t\t * saving state.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoStateSaveParams\": [],\n\t\n\t\t/**\n\t\t * Callbacks for modifying the settings that have been stored for state saving\n\t\t * prior to using the stored values to restore the state.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoStateLoadParams\": [],\n\t\n\t\t/**\n\t\t * Callbacks for operating on the settings object once the saved state has been\n\t\t * loaded\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoStateLoaded\": [],\n\t\n\t\t/**\n\t\t * Cache the table ID for quick access\n\t\t *  @type string\n\t\t *  @default <i>Empty string</i>\n\t\t */\n\t\t\"sTableId\": \"\",\n\t\n\t\t/**\n\t\t * The TABLE node for the main table\n\t\t *  @type node\n\t\t *  @default null\n\t\t */\n\t\t\"nTable\": null,\n\t\n\t\t/**\n\t\t * Permanent ref to the thead element\n\t\t *  @type node\n\t\t *  @default null\n\t\t */\n\t\t\"nTHead\": null,\n\t\n\t\t/**\n\t\t * Permanent ref to the tfoot element - if it exists\n\t\t *  @type node\n\t\t *  @default null\n\t\t */\n\t\t\"nTFoot\": null,\n\t\n\t\t/**\n\t\t * Permanent ref to the tbody element\n\t\t *  @type node\n\t\t *  @default null\n\t\t */\n\t\t\"nTBody\": null,\n\t\n\t\t/**\n\t\t * Cache the wrapper node (contains all DataTables controlled elements)\n\t\t *  @type node\n\t\t *  @default null\n\t\t */\n\t\t\"nTableWrapper\": null,\n\t\n\t\t/**\n\t\t * Indicate if when using server-side processing the loading of data\n\t\t * should be deferred until the second draw.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t */\n\t\t\"bDeferLoading\": false,\n\t\n\t\t/**\n\t\t * Indicate if all required information has been read in\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t */\n\t\t\"bInitialised\": false,\n\t\n\t\t/**\n\t\t * Information about open rows. Each object in the array has the parameters\n\t\t * 'nTr' and 'nParent'\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoOpenRows\": [],\n\t\n\t\t/**\n\t\t * Dictate the positioning of DataTables' control elements - see\n\t\t * {@link DataTable.model.oInit.sDom}.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sDom\": null,\n\t\n\t\t/**\n\t\t * Search delay (in mS)\n\t\t *  @type integer\n\t\t *  @default null\n\t\t */\n\t\t\"searchDelay\": null,\n\t\n\t\t/**\n\t\t * Which type of pagination should be used.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type string\n\t\t *  @default two_button\n\t\t */\n\t\t\"sPaginationType\": \"two_button\",\n\t\n\t\t/**\n\t\t * The state duration (for `stateSave`) in seconds.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type int\n\t\t *  @default 0\n\t\t */\n\t\t\"iStateDuration\": 0,\n\t\n\t\t/**\n\t\t * Array of callback functions for state saving. Each array element is an\n\t\t * object with the following parameters:\n\t\t *   <ul>\n\t\t *     <li>function:fn - function to call. Takes two parameters, oSettings\n\t\t *       and the JSON string to save that has been thus far created. Returns\n\t\t *       a JSON string to be inserted into a json object\n\t\t *       (i.e. '\"param\": [ 0, 1, 2]')</li>\n\t\t *     <li>string:sName - name of callback</li>\n\t\t *   </ul>\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoStateSave\": [],\n\t\n\t\t/**\n\t\t * Array of callback functions for state loading. Each array element is an\n\t\t * object with the following parameters:\n\t\t *   <ul>\n\t\t *     <li>function:fn - function to call. Takes two parameters, oSettings\n\t\t *       and the object stored. May return false to cancel state loading</li>\n\t\t *     <li>string:sName - name of callback</li>\n\t\t *   </ul>\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoStateLoad\": [],\n\t\n\t\t/**\n\t\t * State that was saved. Useful for back reference\n\t\t *  @type object\n\t\t *  @default null\n\t\t */\n\t\t\"oSavedState\": null,\n\t\n\t\t/**\n\t\t * State that was loaded. Useful for back reference\n\t\t *  @type object\n\t\t *  @default null\n\t\t */\n\t\t\"oLoadedState\": null,\n\t\n\t\t/**\n\t\t * Source url for AJAX data for the table.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sAjaxSource\": null,\n\t\n\t\t/**\n\t\t * Property from a given object from which to read the table data from. This\n\t\t * can be an empty string (when not server-side processing), in which case\n\t\t * it is  assumed an an array is given directly.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type string\n\t\t */\n\t\t\"sAjaxDataProp\": null,\n\t\n\t\t/**\n\t\t * The last jQuery XHR object that was used for server-side data gathering.\n\t\t * This can be used for working with the XHR information in one of the\n\t\t * callbacks\n\t\t *  @type object\n\t\t *  @default null\n\t\t */\n\t\t\"jqXHR\": null,\n\t\n\t\t/**\n\t\t * JSON returned from the server in the last Ajax request\n\t\t *  @type object\n\t\t *  @default undefined\n\t\t */\n\t\t\"json\": undefined,\n\t\n\t\t/**\n\t\t * Data submitted as part of the last Ajax request\n\t\t *  @type object\n\t\t *  @default undefined\n\t\t */\n\t\t\"oAjaxData\": undefined,\n\t\n\t\t/**\n\t\t * Function to get the server-side data.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type function\n\t\t */\n\t\t\"fnServerData\": null,\n\t\n\t\t/**\n\t\t * Functions which are called prior to sending an Ajax request so extra\n\t\t * parameters can easily be sent to the server\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoServerParams\": [],\n\t\n\t\t/**\n\t\t * Send the XHR HTTP method - GET or POST (could be PUT or DELETE if\n\t\t * required).\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type string\n\t\t */\n\t\t\"sServerMethod\": null,\n\t\n\t\t/**\n\t\t * Format numbers for display.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type function\n\t\t */\n\t\t\"fnFormatNumber\": null,\n\t\n\t\t/**\n\t\t * List of options that can be used for the user selectable length menu.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aLengthMenu\": null,\n\t\n\t\t/**\n\t\t * Counter for the draws that the table does. Also used as a tracker for\n\t\t * server-side processing\n\t\t *  @type int\n\t\t *  @default 0\n\t\t */\n\t\t\"iDraw\": 0,\n\t\n\t\t/**\n\t\t * Indicate if a redraw is being done - useful for Ajax\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t */\n\t\t\"bDrawing\": false,\n\t\n\t\t/**\n\t\t * Draw index (iDraw) of the last error when parsing the returned data\n\t\t *  @type int\n\t\t *  @default -1\n\t\t */\n\t\t\"iDrawError\": -1,\n\t\n\t\t/**\n\t\t * Paging display length\n\t\t *  @type int\n\t\t *  @default 10\n\t\t */\n\t\t\"_iDisplayLength\": 10,\n\t\n\t\t/**\n\t\t * Paging start point - aiDisplay index\n\t\t *  @type int\n\t\t *  @default 0\n\t\t */\n\t\t\"_iDisplayStart\": 0,\n\t\n\t\t/**\n\t\t * Server-side processing - number of records in the result set\n\t\t * (i.e. before filtering), Use fnRecordsTotal rather than\n\t\t * this property to get the value of the number of records, regardless of\n\t\t * the server-side processing setting.\n\t\t *  @type int\n\t\t *  @default 0\n\t\t *  @private\n\t\t */\n\t\t\"_iRecordsTotal\": 0,\n\t\n\t\t/**\n\t\t * Server-side processing - number of records in the current display set\n\t\t * (i.e. after filtering). Use fnRecordsDisplay rather than\n\t\t * this property to get the value of the number of records, regardless of\n\t\t * the server-side processing setting.\n\t\t *  @type boolean\n\t\t *  @default 0\n\t\t *  @private\n\t\t */\n\t\t\"_iRecordsDisplay\": 0,\n\t\n\t\t/**\n\t\t * The classes to use for the table\n\t\t *  @type object\n\t\t *  @default {}\n\t\t */\n\t\t\"oClasses\": {},\n\t\n\t\t/**\n\t\t * Flag attached to the settings object so you can check in the draw\n\t\t * callback if filtering has been done in the draw. Deprecated in favour of\n\t\t * events.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *  @deprecated\n\t\t */\n\t\t\"bFiltered\": false,\n\t\n\t\t/**\n\t\t * Flag attached to the settings object so you can check in the draw\n\t\t * callback if sorting has been done in the draw. Deprecated in favour of\n\t\t * events.\n\t\t *  @type boolean\n\t\t *  @default false\n\t\t *  @deprecated\n\t\t */\n\t\t\"bSorted\": false,\n\t\n\t\t/**\n\t\t * Indicate that if multiple rows are in the header and there is more than\n\t\t * one unique cell per column, if the top one (true) or bottom one (false)\n\t\t * should be used for sorting / title by DataTables.\n\t\t * Note that this parameter will be set by the initialisation routine. To\n\t\t * set a default use {@link DataTable.defaults}.\n\t\t *  @type boolean\n\t\t */\n\t\t\"bSortCellsTop\": null,\n\t\n\t\t/**\n\t\t * Initialisation object that is used for the table\n\t\t *  @type object\n\t\t *  @default null\n\t\t */\n\t\t\"oInit\": null,\n\t\n\t\t/**\n\t\t * Destroy callback functions - for plug-ins to attach themselves to the\n\t\t * destroy so they can clean up markup and events.\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aoDestroyCallback\": [],\n\t\n\t\n\t\t/**\n\t\t * Get the number of records in the current record set, before filtering\n\t\t *  @type function\n\t\t */\n\t\t\"fnRecordsTotal\": function ()\n\t\t{\n\t\t\treturn _fnDataSource( this ) == 'ssp' ?\n\t\t\t\tthis._iRecordsTotal * 1 :\n\t\t\t\tthis.aiDisplayMaster.length;\n\t\t},\n\t\n\t\t/**\n\t\t * Get the number of records in the current record set, after filtering\n\t\t *  @type function\n\t\t */\n\t\t\"fnRecordsDisplay\": function ()\n\t\t{\n\t\t\treturn _fnDataSource( this ) == 'ssp' ?\n\t\t\t\tthis._iRecordsDisplay * 1 :\n\t\t\t\tthis.aiDisplay.length;\n\t\t},\n\t\n\t\t/**\n\t\t * Get the display end point - aiDisplay index\n\t\t *  @type function\n\t\t */\n\t\t\"fnDisplayEnd\": function ()\n\t\t{\n\t\t\tvar\n\t\t\t\tlen      = this._iDisplayLength,\n\t\t\t\tstart    = this._iDisplayStart,\n\t\t\t\tcalc     = start + len,\n\t\t\t\trecords  = this.aiDisplay.length,\n\t\t\t\tfeatures = this.oFeatures,\n\t\t\t\tpaginate = features.bPaginate;\n\t\n\t\t\tif ( features.bServerSide ) {\n\t\t\t\treturn paginate === false || len === -1 ?\n\t\t\t\t\tstart + records :\n\t\t\t\t\tMath.min( start+len, this._iRecordsDisplay );\n\t\t\t}\n\t\t\telse {\n\t\t\t\treturn ! paginate || calc>records || len===-1 ?\n\t\t\t\t\trecords :\n\t\t\t\t\tcalc;\n\t\t\t}\n\t\t},\n\t\n\t\t/**\n\t\t * The DataTables object for this table\n\t\t *  @type object\n\t\t *  @default null\n\t\t */\n\t\t\"oInstance\": null,\n\t\n\t\t/**\n\t\t * Unique identifier for each instance of the DataTables object. If there\n\t\t * is an ID on the table node, then it takes that value, otherwise an\n\t\t * incrementing internal counter is used.\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"sInstance\": null,\n\t\n\t\t/**\n\t\t * tabindex attribute value that is added to DataTables control elements, allowing\n\t\t * keyboard navigation of the table and its controls.\n\t\t */\n\t\t\"iTabIndex\": 0,\n\t\n\t\t/**\n\t\t * DIV container for the footer scrolling table if scrolling\n\t\t */\n\t\t\"nScrollHead\": null,\n\t\n\t\t/**\n\t\t * DIV container for the footer scrolling table if scrolling\n\t\t */\n\t\t\"nScrollFoot\": null,\n\t\n\t\t/**\n\t\t * Last applied sort\n\t\t *  @type array\n\t\t *  @default []\n\t\t */\n\t\t\"aLastSort\": [],\n\t\n\t\t/**\n\t\t * Stored plug-in instances\n\t\t *  @type object\n\t\t *  @default {}\n\t\t */\n\t\t\"oPlugins\": {},\n\t\n\t\t/**\n\t\t * Function used to get a row's id from the row's data\n\t\t *  @type function\n\t\t *  @default null\n\t\t */\n\t\t\"rowIdFn\": null,\n\t\n\t\t/**\n\t\t * Data location where to store a row's id\n\t\t *  @type string\n\t\t *  @default null\n\t\t */\n\t\t\"rowId\": null\n\t};\n\t\n\t/**\n\t * Extension object for DataTables that is used to provide all extension\n\t * options.\n\t *\n\t * Note that the `DataTable.ext` object is available through\n\t * `jQuery.fn.dataTable.ext` where it may be accessed and manipulated. It is\n\t * also aliased to `jQuery.fn.dataTableExt` for historic reasons.\n\t *  @namespace\n\t *  @extends DataTable.models.ext\n\t */\n\t\n\t\n\t/**\n\t * DataTables extensions\n\t * \n\t * This namespace acts as a collection area for plug-ins that can be used to\n\t * extend DataTables capabilities. Indeed many of the build in methods\n\t * use this method to provide their own capabilities (sorting methods for\n\t * example).\n\t *\n\t * Note that this namespace is aliased to `jQuery.fn.dataTableExt` for legacy\n\t * reasons\n\t *\n\t *  @namespace\n\t */\n\tDataTable.ext = _ext = {\n\t\t/**\n\t\t * Buttons. For use with the Buttons extension for DataTables. This is\n\t\t * defined here so other extensions can define buttons regardless of load\n\t\t * order. It is _not_ used by DataTables core.\n\t\t *\n\t\t *  @type object\n\t\t *  @default {}\n\t\t */\n\t\tbuttons: {},\n\t\n\t\n\t\t/**\n\t\t * Element class names\n\t\t *\n\t\t *  @type object\n\t\t *  @default {}\n\t\t */\n\t\tclasses: {},\n\t\n\t\n\t\t/**\n\t\t * DataTables build type (expanded by the download builder)\n\t\t *\n\t\t *  @type string\n\t\t */\n\t\tbuilder: \"-source-\",\n\t\n\t\n\t\t/**\n\t\t * Error reporting.\n\t\t * \n\t\t * How should DataTables report an error. Can take the value 'alert',\n\t\t * 'throw', 'none' or a function.\n\t\t *\n\t\t *  @type string|function\n\t\t *  @default alert\n\t\t */\n\t\terrMode: \"alert\",\n\t\n\t\n\t\t/**\n\t\t * Feature plug-ins.\n\t\t * \n\t\t * This is an array of objects which describe the feature plug-ins that are\n\t\t * available to DataTables. These feature plug-ins are then available for\n\t\t * use through the `dom` initialisation option.\n\t\t * \n\t\t * Each feature plug-in is described by an object which must have the\n\t\t * following properties:\n\t\t * \n\t\t * * `fnInit` - function that is used to initialise the plug-in,\n\t\t * * `cFeature` - a character so the feature can be enabled by the `dom`\n\t\t *   instillation option. This is case sensitive.\n\t\t *\n\t\t * The `fnInit` function has the following input parameters:\n\t\t *\n\t\t * 1. `{object}` DataTables settings object: see\n\t\t *    {@link DataTable.models.oSettings}\n\t\t *\n\t\t * And the following return is expected:\n\t\t * \n\t\t * * {node|null} The element which contains your feature. Note that the\n\t\t *   return may also be void if your plug-in does not require to inject any\n\t\t *   DOM elements into DataTables control (`dom`) - for example this might\n\t\t *   be useful when developing a plug-in which allows table control via\n\t\t *   keyboard entry\n\t\t *\n\t\t *  @type array\n\t\t *\n\t\t *  @example\n\t\t *    $.fn.dataTable.ext.features.push( {\n\t\t *      \"fnInit\": function( oSettings ) {\n\t\t *        return new TableTools( { \"oDTSettings\": oSettings } );\n\t\t *      },\n\t\t *      \"cFeature\": \"T\"\n\t\t *    } );\n\t\t */\n\t\tfeature: [],\n\t\n\t\n\t\t/**\n\t\t * Row searching.\n\t\t * \n\t\t * This method of searching is complimentary to the default type based\n\t\t * searching, and a lot more comprehensive as it allows you complete control\n\t\t * over the searching logic. Each element in this array is a function\n\t\t * (parameters described below) that is called for every row in the table,\n\t\t * and your logic decides if it should be included in the searching data set\n\t\t * or not.\n\t\t *\n\t\t * Searching functions have the following input parameters:\n\t\t *\n\t\t * 1. `{object}` DataTables settings object: see\n\t\t *    {@link DataTable.models.oSettings}\n\t\t * 2. `{array|object}` Data for the row to be processed (same as the\n\t\t *    original format that was passed in as the data source, or an array\n\t\t *    from a DOM data source\n\t\t * 3. `{int}` Row index ({@link DataTable.models.oSettings.aoData}), which\n\t\t *    can be useful to retrieve the `TR` element if you need DOM interaction.\n\t\t *\n\t\t * And the following return is expected:\n\t\t *\n\t\t * * {boolean} Include the row in the searched result set (true) or not\n\t\t *   (false)\n\t\t *\n\t\t * Note that as with the main search ability in DataTables, technically this\n\t\t * is \"filtering\", since it is subtractive. However, for consistency in\n\t\t * naming we call it searching here.\n\t\t *\n\t\t *  @type array\n\t\t *  @default []\n\t\t *\n\t\t *  @example\n\t\t *    // The following example shows custom search being applied to the\n\t\t *    // fourth column (i.e. the data[3] index) based on two input values\n\t\t *    // from the end-user, matching the data in a certain range.\n\t\t *    $.fn.dataTable.ext.search.push(\n\t\t *      function( settings, data, dataIndex ) {\n\t\t *        var min = document.getElementById('min').value * 1;\n\t\t *        var max = document.getElementById('max').value * 1;\n\t\t *        var version = data[3] == \"-\" ? 0 : data[3]*1;\n\t\t *\n\t\t *        if ( min == \"\" && max == \"\" ) {\n\t\t *          return true;\n\t\t *        }\n\t\t *        else if ( min == \"\" && version < max ) {\n\t\t *          return true;\n\t\t *        }\n\t\t *        else if ( min < version && \"\" == max ) {\n\t\t *          return true;\n\t\t *        }\n\t\t *        else if ( min < version && version < max ) {\n\t\t *          return true;\n\t\t *        }\n\t\t *        return false;\n\t\t *      }\n\t\t *    );\n\t\t */\n\t\tsearch: [],\n\t\n\t\n\t\t/**\n\t\t * Selector extensions\n\t\t *\n\t\t * The `selector` option can be used to extend the options available for the\n\t\t * selector modifier options (`selector-modifier` object data type) that\n\t\t * each of the three built in selector types offer (row, column and cell +\n\t\t * their plural counterparts). For example the Select extension uses this\n\t\t * mechanism to provide an option to select only rows, columns and cells\n\t\t * that have been marked as selected by the end user (`{selected: true}`),\n\t\t * which can be used in conjunction with the existing built in selector\n\t\t * options.\n\t\t *\n\t\t * Each property is an array to which functions can be pushed. The functions\n\t\t * take three attributes:\n\t\t *\n\t\t * * Settings object for the host table\n\t\t * * Options object (`selector-modifier` object type)\n\t\t * * Array of selected item indexes\n\t\t *\n\t\t * The return is an array of the resulting item indexes after the custom\n\t\t * selector has been applied.\n\t\t *\n\t\t *  @type object\n\t\t */\n\t\tselector: {\n\t\t\tcell: [],\n\t\t\tcolumn: [],\n\t\t\trow: []\n\t\t},\n\t\n\t\n\t\t/**\n\t\t * Internal functions, exposed for used in plug-ins.\n\t\t * \n\t\t * Please note that you should not need to use the internal methods for\n\t\t * anything other than a plug-in (and even then, try to avoid if possible).\n\t\t * The internal function may change between releases.\n\t\t *\n\t\t *  @type object\n\t\t *  @default {}\n\t\t */\n\t\tinternal: {},\n\t\n\t\n\t\t/**\n\t\t * Legacy configuration options. Enable and disable legacy options that\n\t\t * are available in DataTables.\n\t\t *\n\t\t *  @type object\n\t\t */\n\t\tlegacy: {\n\t\t\t/**\n\t\t\t * Enable / disable DataTables 1.9 compatible server-side processing\n\t\t\t * requests\n\t\t\t *\n\t\t\t *  @type boolean\n\t\t\t *  @default null\n\t\t\t */\n\t\t\tajax: null\n\t\t},\n\t\n\t\n\t\t/**\n\t\t * Pagination plug-in methods.\n\t\t * \n\t\t * Each entry in this object is a function and defines which buttons should\n\t\t * be shown by the pagination rendering method that is used for the table:\n\t\t * {@link DataTable.ext.renderer.pageButton}. The renderer addresses how the\n\t\t * buttons are displayed in the document, while the functions here tell it\n\t\t * what buttons to display. This is done by returning an array of button\n\t\t * descriptions (what each button will do).\n\t\t *\n\t\t * Pagination types (the four built in options and any additional plug-in\n\t\t * options defined here) can be used through the `paginationType`\n\t\t * initialisation parameter.\n\t\t *\n\t\t * The functions defined take two parameters:\n\t\t *\n\t\t * 1. `{int} page` The current page index\n\t\t * 2. `{int} pages` The number of pages in the table\n\t\t *\n\t\t * Each function is expected to return an array where each element of the\n\t\t * array can be one of:\n\t\t *\n\t\t * * `first` - Jump to first page when activated\n\t\t * * `last` - Jump to last page when activated\n\t\t * * `previous` - Show previous page when activated\n\t\t * * `next` - Show next page when activated\n\t\t * * `{int}` - Show page of the index given\n\t\t * * `{array}` - A nested array containing the above elements to add a\n\t\t *   containing 'DIV' element (might be useful for styling).\n\t\t *\n\t\t * Note that DataTables v1.9- used this object slightly differently whereby\n\t\t * an object with two functions would be defined for each plug-in. That\n\t\t * ability is still supported by DataTables 1.10+ to provide backwards\n\t\t * compatibility, but this option of use is now decremented and no longer\n\t\t * documented in DataTables 1.10+.\n\t\t *\n\t\t *  @type object\n\t\t *  @default {}\n\t\t *\n\t\t *  @example\n\t\t *    // Show previous, next and current page buttons only\n\t\t *    $.fn.dataTableExt.oPagination.current = function ( page, pages ) {\n\t\t *      return [ 'previous', page, 'next' ];\n\t\t *    };\n\t\t */\n\t\tpager: {},\n\t\n\t\n\t\trenderer: {\n\t\t\tpageButton: {},\n\t\t\theader: {}\n\t\t},\n\t\n\t\n\t\t/**\n\t\t * Ordering plug-ins - custom data source\n\t\t * \n\t\t * The extension options for ordering of data available here is complimentary\n\t\t * to the default type based ordering that DataTables typically uses. It\n\t\t * allows much greater control over the the data that is being used to\n\t\t * order a column, but is necessarily therefore more complex.\n\t\t * \n\t\t * This type of ordering is useful if you want to do ordering based on data\n\t\t * live from the DOM (for example the contents of an 'input' element) rather\n\t\t * than just the static string that DataTables knows of.\n\t\t * \n\t\t * The way these plug-ins work is that you create an array of the values you\n\t\t * wish to be ordering for the column in question and then return that\n\t\t * array. The data in the array much be in the index order of the rows in\n\t\t * the table (not the currently ordering order!). Which order data gathering\n\t\t * function is run here depends on the `dt-init columns.orderDataType`\n\t\t * parameter that is used for the column (if any).\n\t\t *\n\t\t * The functions defined take two parameters:\n\t\t *\n\t\t * 1. `{object}` DataTables settings object: see\n\t\t *    {@link DataTable.models.oSettings}\n\t\t * 2. `{int}` Target column index\n\t\t *\n\t\t * Each function is expected to return an array:\n\t\t *\n\t\t * * `{array}` Data for the column to be ordering upon\n\t\t *\n\t\t *  @type array\n\t\t *\n\t\t *  @example\n\t\t *    // Ordering using `input` node values\n\t\t *    $.fn.dataTable.ext.order['dom-text'] = function  ( settings, col )\n\t\t *    {\n\t\t *      return this.api().column( col, {order:'index'} ).nodes().map( function ( td, i ) {\n\t\t *        return $('input', td).val();\n\t\t *      } );\n\t\t *    }\n\t\t */\n\t\torder: {},\n\t\n\t\n\t\t/**\n\t\t * Type based plug-ins.\n\t\t *\n\t\t * Each column in DataTables has a type assigned to it, either by automatic\n\t\t * detection or by direct assignment using the `type` option for the column.\n\t\t * The type of a column will effect how it is ordering and search (plug-ins\n\t\t * can also make use of the column type if required).\n\t\t *\n\t\t * @namespace\n\t\t */\n\t\ttype: {\n\t\t\t/**\n\t\t\t * Type detection functions.\n\t\t\t *\n\t\t\t * The functions defined in this object are used to automatically detect\n\t\t\t * a column's type, making initialisation of DataTables super easy, even\n\t\t\t * when complex data is in the table.\n\t\t\t *\n\t\t\t * The functions defined take two parameters:\n\t\t\t *\n\t\t     *  1. `{*}` Data from the column cell to be analysed\n\t\t     *  2. `{settings}` DataTables settings object. This can be used to\n\t\t     *     perform context specific type detection - for example detection\n\t\t     *     based on language settings such as using a comma for a decimal\n\t\t     *     place. Generally speaking the options from the settings will not\n\t\t     *     be required\n\t\t\t *\n\t\t\t * Each function is expected to return:\n\t\t\t *\n\t\t\t * * `{string|null}` Data type detected, or null if unknown (and thus\n\t\t\t *   pass it on to the other type detection functions.\n\t\t\t *\n\t\t\t *  @type array\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    // Currency type detection plug-in:\n\t\t\t *    $.fn.dataTable.ext.type.detect.push(\n\t\t\t *      function ( data, settings ) {\n\t\t\t *        // Check the numeric part\n\t\t\t *        if ( ! data.substring(1).match(/[0-9]/) ) {\n\t\t\t *          return null;\n\t\t\t *        }\n\t\t\t *\n\t\t\t *        // Check prefixed by currency\n\t\t\t *        if ( data.charAt(0) == '$' || data.charAt(0) == '&pound;' ) {\n\t\t\t *          return 'currency';\n\t\t\t *        }\n\t\t\t *        return null;\n\t\t\t *      }\n\t\t\t *    );\n\t\t\t */\n\t\t\tdetect: [],\n\t\n\t\n\t\t\t/**\n\t\t\t * Type based search formatting.\n\t\t\t *\n\t\t\t * The type based searching functions can be used to pre-format the\n\t\t\t * data to be search on. For example, it can be used to strip HTML\n\t\t\t * tags or to de-format telephone numbers for numeric only searching.\n\t\t\t *\n\t\t\t * Note that is a search is not defined for a column of a given type,\n\t\t\t * no search formatting will be performed.\n\t\t\t * \n\t\t\t * Pre-processing of searching data plug-ins - When you assign the sType\n\t\t\t * for a column (or have it automatically detected for you by DataTables\n\t\t\t * or a type detection plug-in), you will typically be using this for\n\t\t\t * custom sorting, but it can also be used to provide custom searching\n\t\t\t * by allowing you to pre-processing the data and returning the data in\n\t\t\t * the format that should be searched upon. This is done by adding\n\t\t\t * functions this object with a parameter name which matches the sType\n\t\t\t * for that target column. This is the corollary of <i>afnSortData</i>\n\t\t\t * for searching data.\n\t\t\t *\n\t\t\t * The functions defined take a single parameter:\n\t\t\t *\n\t\t     *  1. `{*}` Data from the column cell to be prepared for searching\n\t\t\t *\n\t\t\t * Each function is expected to return:\n\t\t\t *\n\t\t\t * * `{string|null}` Formatted string that will be used for the searching.\n\t\t\t *\n\t\t\t *  @type object\n\t\t\t *  @default {}\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    $.fn.dataTable.ext.type.search['title-numeric'] = function ( d ) {\n\t\t\t *      return d.replace(/\\n/g,\" \").replace( /<.*?>/g, \"\" );\n\t\t\t *    }\n\t\t\t */\n\t\t\tsearch: {},\n\t\n\t\n\t\t\t/**\n\t\t\t * Type based ordering.\n\t\t\t *\n\t\t\t * The column type tells DataTables what ordering to apply to the table\n\t\t\t * when a column is sorted upon. The order for each type that is defined,\n\t\t\t * is defined by the functions available in this object.\n\t\t\t *\n\t\t\t * Each ordering option can be described by three properties added to\n\t\t\t * this object:\n\t\t\t *\n\t\t\t * * `{type}-pre` - Pre-formatting function\n\t\t\t * * `{type}-asc` - Ascending order function\n\t\t\t * * `{type}-desc` - Descending order function\n\t\t\t *\n\t\t\t * All three can be used together, only `{type}-pre` or only\n\t\t\t * `{type}-asc` and `{type}-desc` together. It is generally recommended\n\t\t\t * that only `{type}-pre` is used, as this provides the optimal\n\t\t\t * implementation in terms of speed, although the others are provided\n\t\t\t * for compatibility with existing Javascript sort functions.\n\t\t\t *\n\t\t\t * `{type}-pre`: Functions defined take a single parameter:\n\t\t\t *\n\t\t     *  1. `{*}` Data from the column cell to be prepared for ordering\n\t\t\t *\n\t\t\t * And return:\n\t\t\t *\n\t\t\t * * `{*}` Data to be sorted upon\n\t\t\t *\n\t\t\t * `{type}-asc` and `{type}-desc`: Functions are typical Javascript sort\n\t\t\t * functions, taking two parameters:\n\t\t\t *\n\t\t     *  1. `{*}` Data to compare to the second parameter\n\t\t     *  2. `{*}` Data to compare to the first parameter\n\t\t\t *\n\t\t\t * And returning:\n\t\t\t *\n\t\t\t * * `{*}` Ordering match: <0 if first parameter should be sorted lower\n\t\t\t *   than the second parameter, ===0 if the two parameters are equal and\n\t\t\t *   >0 if the first parameter should be sorted height than the second\n\t\t\t *   parameter.\n\t\t\t * \n\t\t\t *  @type object\n\t\t\t *  @default {}\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    // Numeric ordering of formatted numbers with a pre-formatter\n\t\t\t *    $.extend( $.fn.dataTable.ext.type.order, {\n\t\t\t *      \"string-pre\": function(x) {\n\t\t\t *        a = (a === \"-\" || a === \"\") ? 0 : a.replace( /[^\\d\\-\\.]/g, \"\" );\n\t\t\t *        return parseFloat( a );\n\t\t\t *      }\n\t\t\t *    } );\n\t\t\t *\n\t\t\t *  @example\n\t\t\t *    // Case-sensitive string ordering, with no pre-formatting method\n\t\t\t *    $.extend( $.fn.dataTable.ext.order, {\n\t\t\t *      \"string-case-asc\": function(x,y) {\n\t\t\t *        return ((x < y) ? -1 : ((x > y) ? 1 : 0));\n\t\t\t *      },\n\t\t\t *      \"string-case-desc\": function(x,y) {\n\t\t\t *        return ((x < y) ? 1 : ((x > y) ? -1 : 0));\n\t\t\t *      }\n\t\t\t *    } );\n\t\t\t */\n\t\t\torder: {}\n\t\t},\n\t\n\t\t/**\n\t\t * Unique DataTables instance counter\n\t\t *\n\t\t * @type int\n\t\t * @private\n\t\t */\n\t\t_unique: 0,\n\t\n\t\n\t\t//\n\t\t// Depreciated\n\t\t// The following properties are retained for backwards compatibility only.\n\t\t// The should not be used in new projects and will be removed in a future\n\t\t// version\n\t\t//\n\t\n\t\t/**\n\t\t * Version check function.\n\t\t *  @type function\n\t\t *  @depreciated Since 1.10\n\t\t */\n\t\tfnVersionCheck: DataTable.fnVersionCheck,\n\t\n\t\n\t\t/**\n\t\t * Index for what 'this' index API functions should use\n\t\t *  @type int\n\t\t *  @deprecated Since v1.10\n\t\t */\n\t\tiApiIndex: 0,\n\t\n\t\n\t\t/**\n\t\t * jQuery UI class container\n\t\t *  @type object\n\t\t *  @deprecated Since v1.10\n\t\t */\n\t\toJUIClasses: {},\n\t\n\t\n\t\t/**\n\t\t * Software version\n\t\t *  @type string\n\t\t *  @deprecated Since v1.10\n\t\t */\n\t\tsVersion: DataTable.version\n\t};\n\t\n\t\n\t//\n\t// Backwards compatibility. Alias to pre 1.10 Hungarian notation counter parts\n\t//\n\t$.extend( _ext, {\n\t\tafnFiltering: _ext.search,\n\t\taTypes:       _ext.type.detect,\n\t\tofnSearch:    _ext.type.search,\n\t\toSort:        _ext.type.order,\n\t\tafnSortData:  _ext.order,\n\t\taoFeatures:   _ext.feature,\n\t\toApi:         _ext.internal,\n\t\toStdClasses:  _ext.classes,\n\t\toPagination:  _ext.pager\n\t} );\n\t\n\t\n\t$.extend( DataTable.ext.classes, {\n\t\t\"sTable\": \"dataTable\",\n\t\t\"sNoFooter\": \"no-footer\",\n\t\n\t\t/* Paging buttons */\n\t\t\"sPageButton\": \"paginate_button\",\n\t\t\"sPageButtonActive\": \"current\",\n\t\t\"sPageButtonDisabled\": \"disabled\",\n\t\n\t\t/* Striping classes */\n\t\t\"sStripeOdd\": \"odd\",\n\t\t\"sStripeEven\": \"even\",\n\t\n\t\t/* Empty row */\n\t\t\"sRowEmpty\": \"dataTables_empty\",\n\t\n\t\t/* Features */\n\t\t\"sWrapper\": \"dataTables_wrapper\",\n\t\t\"sFilter\": \"dataTables_filter\",\n\t\t\"sInfo\": \"dataTables_info\",\n\t\t\"sPaging\": \"dataTables_paginate paging_\", /* Note that the type is postfixed */\n\t\t\"sLength\": \"dataTables_length\",\n\t\t\"sProcessing\": \"dataTables_processing\",\n\t\n\t\t/* Sorting */\n\t\t\"sSortAsc\": \"sorting_asc\",\n\t\t\"sSortDesc\": \"sorting_desc\",\n\t\t\"sSortable\": \"sorting\", /* Sortable in both directions */\n\t\t\"sSortableAsc\": \"sorting_desc_disabled\",\n\t\t\"sSortableDesc\": \"sorting_asc_disabled\",\n\t\t\"sSortableNone\": \"sorting_disabled\",\n\t\t\"sSortColumn\": \"sorting_\", /* Note that an int is postfixed for the sorting order */\n\t\n\t\t/* Filtering */\n\t\t\"sFilterInput\": \"\",\n\t\n\t\t/* Page length */\n\t\t\"sLengthSelect\": \"\",\n\t\n\t\t/* Scrolling */\n\t\t\"sScrollWrapper\": \"dataTables_scroll\",\n\t\t\"sScrollHead\": \"dataTables_scrollHead\",\n\t\t\"sScrollHeadInner\": \"dataTables_scrollHeadInner\",\n\t\t\"sScrollBody\": \"dataTables_scrollBody\",\n\t\t\"sScrollFoot\": \"dataTables_scrollFoot\",\n\t\t\"sScrollFootInner\": \"dataTables_scrollFootInner\",\n\t\n\t\t/* Misc */\n\t\t\"sHeaderTH\": \"\",\n\t\t\"sFooterTH\": \"\",\n\t\n\t\t// Deprecated\n\t\t\"sSortJUIAsc\": \"\",\n\t\t\"sSortJUIDesc\": \"\",\n\t\t\"sSortJUI\": \"\",\n\t\t\"sSortJUIAscAllowed\": \"\",\n\t\t\"sSortJUIDescAllowed\": \"\",\n\t\t\"sSortJUIWrapper\": \"\",\n\t\t\"sSortIcon\": \"\",\n\t\t\"sJUIHeader\": \"\",\n\t\t\"sJUIFooter\": \"\"\n\t} );\n\t\n\t\n\tvar extPagination = DataTable.ext.pager;\n\t\n\tfunction _numbers ( page, pages ) {\n\t\tvar\n\t\t\tnumbers = [],\n\t\t\tbuttons = extPagination.numbers_length,\n\t\t\thalf = Math.floor( buttons / 2 ),\n\t\t\ti = 1;\n\t\n\t\tif ( pages <= buttons ) {\n\t\t\tnumbers = _range( 0, pages );\n\t\t}\n\t\telse if ( page <= half ) {\n\t\t\tnumbers = _range( 0, buttons-2 );\n\t\t\tnumbers.push( 'ellipsis' );\n\t\t\tnumbers.push( pages-1 );\n\t\t}\n\t\telse if ( page >= pages - 1 - half ) {\n\t\t\tnumbers = _range( pages-(buttons-2), pages );\n\t\t\tnumbers.splice( 0, 0, 'ellipsis' ); // no unshift in ie6\n\t\t\tnumbers.splice( 0, 0, 0 );\n\t\t}\n\t\telse {\n\t\t\tnumbers = _range( page-half+2, page+half-1 );\n\t\t\tnumbers.push( 'ellipsis' );\n\t\t\tnumbers.push( pages-1 );\n\t\t\tnumbers.splice( 0, 0, 'ellipsis' );\n\t\t\tnumbers.splice( 0, 0, 0 );\n\t\t}\n\t\n\t\tnumbers.DT_el = 'span';\n\t\treturn numbers;\n\t}\n\t\n\t\n\t$.extend( extPagination, {\n\t\tsimple: function ( page, pages ) {\n\t\t\treturn [ 'previous', 'next' ];\n\t\t},\n\t\n\t\tfull: function ( page, pages ) {\n\t\t\treturn [  'first', 'previous', 'next', 'last' ];\n\t\t},\n\t\n\t\tnumbers: function ( page, pages ) {\n\t\t\treturn [ _numbers(page, pages) ];\n\t\t},\n\t\n\t\tsimple_numbers: function ( page, pages ) {\n\t\t\treturn [ 'previous', _numbers(page, pages), 'next' ];\n\t\t},\n\t\n\t\tfull_numbers: function ( page, pages ) {\n\t\t\treturn [ 'first', 'previous', _numbers(page, pages), 'next', 'last' ];\n\t\t},\n\t\t\n\t\tfirst_last_numbers: function (page, pages) {\n\t \t\treturn ['first', _numbers(page, pages), 'last'];\n\t \t},\n\t\n\t\t// For testing and plug-ins to use\n\t\t_numbers: _numbers,\n\t\n\t\t// Number of number buttons (including ellipsis) to show. _Must be odd!_\n\t\tnumbers_length: 7\n\t} );\n\t\n\t\n\t$.extend( true, DataTable.ext.renderer, {\n\t\tpageButton: {\n\t\t\t_: function ( settings, host, idx, buttons, page, pages ) {\n\t\t\t\tvar classes = settings.oClasses;\n\t\t\t\tvar lang = settings.oLanguage.oPaginate;\n\t\t\t\tvar aria = settings.oLanguage.oAria.paginate || {};\n\t\t\t\tvar btnDisplay, btnClass, counter=0;\n\t\n\t\t\t\tvar attach = function( container, buttons ) {\n\t\t\t\t\tvar i, ien, node, button, tabIndex;\n\t\t\t\t\tvar disabledClass = classes.sPageButtonDisabled;\n\t\t\t\t\tvar clickHandler = function ( e ) {\n\t\t\t\t\t\t_fnPageChange( settings, e.data.action, true );\n\t\t\t\t\t};\n\t\n\t\t\t\t\tfor ( i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\t\t\t\tbutton = buttons[i];\n\t\n\t\t\t\t\t\tif ( Array.isArray( button ) ) {\n\t\t\t\t\t\t\tvar inner = $( '<'+(button.DT_el || 'div')+'/>' )\n\t\t\t\t\t\t\t\t.appendTo( container );\n\t\t\t\t\t\t\tattach( inner, button );\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tbtnDisplay = null;\n\t\t\t\t\t\t\tbtnClass = button;\n\t\t\t\t\t\t\ttabIndex = settings.iTabIndex;\n\t\n\t\t\t\t\t\t\tswitch ( button ) {\n\t\t\t\t\t\t\t\tcase 'ellipsis':\n\t\t\t\t\t\t\t\t\tcontainer.append('<span class=\"ellipsis\">&#x2026;</span>');\n\t\t\t\t\t\t\t\t\tbreak;\n\t\n\t\t\t\t\t\t\t\tcase 'first':\n\t\t\t\t\t\t\t\t\tbtnDisplay = lang.sFirst;\n\t\n\t\t\t\t\t\t\t\t\tif ( page === 0 ) {\n\t\t\t\t\t\t\t\t\t\ttabIndex = -1;\n\t\t\t\t\t\t\t\t\t\tbtnClass += ' ' + disabledClass;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\tbreak;\n\t\n\t\t\t\t\t\t\t\tcase 'previous':\n\t\t\t\t\t\t\t\t\tbtnDisplay = lang.sPrevious;\n\t\n\t\t\t\t\t\t\t\t\tif ( page === 0 ) {\n\t\t\t\t\t\t\t\t\t\ttabIndex = -1;\n\t\t\t\t\t\t\t\t\t\tbtnClass += ' ' + disabledClass;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\tbreak;\n\t\n\t\t\t\t\t\t\t\tcase 'next':\n\t\t\t\t\t\t\t\t\tbtnDisplay = lang.sNext;\n\t\n\t\t\t\t\t\t\t\t\tif ( pages === 0 || page === pages-1 ) {\n\t\t\t\t\t\t\t\t\t\ttabIndex = -1;\n\t\t\t\t\t\t\t\t\t\tbtnClass += ' ' + disabledClass;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\tbreak;\n\t\n\t\t\t\t\t\t\t\tcase 'last':\n\t\t\t\t\t\t\t\t\tbtnDisplay = lang.sLast;\n\t\n\t\t\t\t\t\t\t\t\tif ( pages === 0 || page === pages-1 ) {\n\t\t\t\t\t\t\t\t\t\ttabIndex = -1;\n\t\t\t\t\t\t\t\t\t\tbtnClass += ' ' + disabledClass;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\tbreak;\n\t\n\t\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t\t\tbtnDisplay = settings.fnFormatNumber( button + 1 );\n\t\t\t\t\t\t\t\t\tbtnClass = page === button ?\n\t\t\t\t\t\t\t\t\t\tclasses.sPageButtonActive : '';\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\t\tif ( btnDisplay !== null ) {\n\t\t\t\t\t\t\t\tnode = $('<a>', {\n\t\t\t\t\t\t\t\t\t\t'class': classes.sPageButton+' '+btnClass,\n\t\t\t\t\t\t\t\t\t\t'aria-controls': settings.sTableId,\n\t\t\t\t\t\t\t\t\t\t'aria-label': aria[ button ],\n\t\t\t\t\t\t\t\t\t\t'data-dt-idx': counter,\n\t\t\t\t\t\t\t\t\t\t'tabindex': tabIndex,\n\t\t\t\t\t\t\t\t\t\t'id': idx === 0 && typeof button === 'string' ?\n\t\t\t\t\t\t\t\t\t\t\tsettings.sTableId +'_'+ button :\n\t\t\t\t\t\t\t\t\t\t\tnull\n\t\t\t\t\t\t\t\t\t} )\n\t\t\t\t\t\t\t\t\t.html( btnDisplay )\n\t\t\t\t\t\t\t\t\t.appendTo( container );\n\t\n\t\t\t\t\t\t\t\t_fnBindAction(\n\t\t\t\t\t\t\t\t\tnode, {action: button}, clickHandler\n\t\t\t\t\t\t\t\t);\n\t\n\t\t\t\t\t\t\t\tcounter++;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\t\n\t\t\t\t// IE9 throws an 'unknown error' if document.activeElement is used\n\t\t\t\t// inside an iframe or frame. Try / catch the error. Not good for\n\t\t\t\t// accessibility, but neither are frames.\n\t\t\t\tvar activeEl;\n\t\n\t\t\t\ttry {\n\t\t\t\t\t// Because this approach is destroying and recreating the paging\n\t\t\t\t\t// elements, focus is lost on the select button which is bad for\n\t\t\t\t\t// accessibility. So we want to restore focus once the draw has\n\t\t\t\t\t// completed\n\t\t\t\t\tactiveEl = $(host).find(document.activeElement).data('dt-idx');\n\t\t\t\t}\n\t\t\t\tcatch (e) {}\n\t\n\t\t\t\tattach( $(host).empty(), buttons );\n\t\n\t\t\t\tif ( activeEl !== undefined ) {\n\t\t\t\t\t$(host).find( '[data-dt-idx='+activeEl+']' ).trigger('focus');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t} );\n\t\n\t\n\t\n\t// Built in type detection. See model.ext.aTypes for information about\n\t// what is required from this methods.\n\t$.extend( DataTable.ext.type.detect, [\n\t\t// Plain numbers - first since V8 detects some plain numbers as dates\n\t\t// e.g. Date.parse('55') (but not all, e.g. Date.parse('22')...).\n\t\tfunction ( d, settings )\n\t\t{\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _isNumber( d, decimal ) ? 'num'+decimal : null;\n\t\t},\n\t\n\t\t// Dates (only those recognised by the browser's Date.parse)\n\t\tfunction ( d, settings )\n\t\t{\n\t\t\t// V8 tries _very_ hard to make a string passed into `Date.parse()`\n\t\t\t// valid, so we need to use a regex to restrict date formats. Use a\n\t\t\t// plug-in for anything other than ISO8601 style strings\n\t\t\tif ( d && !(d instanceof Date) && ! _re_date.test(d) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\tvar parsed = Date.parse(d);\n\t\t\treturn (parsed !== null && !isNaN(parsed)) || _empty(d) ? 'date' : null;\n\t\t},\n\t\n\t\t// Formatted numbers\n\t\tfunction ( d, settings )\n\t\t{\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _isNumber( d, decimal, true ) ? 'num-fmt'+decimal : null;\n\t\t},\n\t\n\t\t// HTML numeric\n\t\tfunction ( d, settings )\n\t\t{\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _htmlNumeric( d, decimal ) ? 'html-num'+decimal : null;\n\t\t},\n\t\n\t\t// HTML numeric, formatted\n\t\tfunction ( d, settings )\n\t\t{\n\t\t\tvar decimal = settings.oLanguage.sDecimal;\n\t\t\treturn _htmlNumeric( d, decimal, true ) ? 'html-num-fmt'+decimal : null;\n\t\t},\n\t\n\t\t// HTML (this is strict checking - there must be html)\n\t\tfunction ( d, settings )\n\t\t{\n\t\t\treturn _empty( d ) || (typeof d === 'string' && d.indexOf('<') !== -1) ?\n\t\t\t\t'html' : null;\n\t\t}\n\t] );\n\t\n\t\n\t\n\t// Filter formatting functions. See model.ext.ofnSearch for information about\n\t// what is required from these methods.\n\t// \n\t// Note that additional search methods are added for the html numbers and\n\t// html formatted numbers by `_addNumericSort()` when we know what the decimal\n\t// place is\n\t\n\t\n\t$.extend( DataTable.ext.type.search, {\n\t\thtml: function ( data ) {\n\t\t\treturn _empty(data) ?\n\t\t\t\tdata :\n\t\t\t\ttypeof data === 'string' ?\n\t\t\t\t\tdata\n\t\t\t\t\t\t.replace( _re_new_lines, \" \" )\n\t\t\t\t\t\t.replace( _re_html, \"\" ) :\n\t\t\t\t\t'';\n\t\t},\n\t\n\t\tstring: function ( data ) {\n\t\t\treturn _empty(data) ?\n\t\t\t\tdata :\n\t\t\t\ttypeof data === 'string' ?\n\t\t\t\t\tdata.replace( _re_new_lines, \" \" ) :\n\t\t\t\t\tdata;\n\t\t}\n\t} );\n\t\n\t\n\t\n\tvar __numericReplace = function ( d, decimalPlace, re1, re2 ) {\n\t\tif ( d !== 0 && (!d || d === '-') ) {\n\t\t\treturn -Infinity;\n\t\t}\n\t\n\t\t// If a decimal place other than `.` is used, it needs to be given to the\n\t\t// function so we can detect it and replace with a `.` which is the only\n\t\t// decimal place Javascript recognises - it is not locale aware.\n\t\tif ( decimalPlace ) {\n\t\t\td = _numToDecimal( d, decimalPlace );\n\t\t}\n\t\n\t\tif ( d.replace ) {\n\t\t\tif ( re1 ) {\n\t\t\t\td = d.replace( re1, '' );\n\t\t\t}\n\t\n\t\t\tif ( re2 ) {\n\t\t\t\td = d.replace( re2, '' );\n\t\t\t}\n\t\t}\n\t\n\t\treturn d * 1;\n\t};\n\t\n\t\n\t// Add the numeric 'deformatting' functions for sorting and search. This is done\n\t// in a function to provide an easy ability for the language options to add\n\t// additional methods if a non-period decimal place is used.\n\tfunction _addNumericSort ( decimalPlace ) {\n\t\t$.each(\n\t\t\t{\n\t\t\t\t// Plain numbers\n\t\t\t\t\"num\": function ( d ) {\n\t\t\t\t\treturn __numericReplace( d, decimalPlace );\n\t\t\t\t},\n\t\n\t\t\t\t// Formatted numbers\n\t\t\t\t\"num-fmt\": function ( d ) {\n\t\t\t\t\treturn __numericReplace( d, decimalPlace, _re_formatted_numeric );\n\t\t\t\t},\n\t\n\t\t\t\t// HTML numeric\n\t\t\t\t\"html-num\": function ( d ) {\n\t\t\t\t\treturn __numericReplace( d, decimalPlace, _re_html );\n\t\t\t\t},\n\t\n\t\t\t\t// HTML numeric, formatted\n\t\t\t\t\"html-num-fmt\": function ( d ) {\n\t\t\t\t\treturn __numericReplace( d, decimalPlace, _re_html, _re_formatted_numeric );\n\t\t\t\t}\n\t\t\t},\n\t\t\tfunction ( key, fn ) {\n\t\t\t\t// Add the ordering method\n\t\t\t\t_ext.type.order[ key+decimalPlace+'-pre' ] = fn;\n\t\n\t\t\t\t// For HTML types add a search formatter that will strip the HTML\n\t\t\t\tif ( key.match(/^html\\-/) ) {\n\t\t\t\t\t_ext.type.search[ key+decimalPlace ] = _ext.type.search.html;\n\t\t\t\t}\n\t\t\t}\n\t\t);\n\t}\n\t\n\t\n\t// Default sort methods\n\t$.extend( _ext.type.order, {\n\t\t// Dates\n\t\t\"date-pre\": function ( d ) {\n\t\t\tvar ts = Date.parse( d );\n\t\t\treturn isNaN(ts) ? -Infinity : ts;\n\t\t},\n\t\n\t\t// html\n\t\t\"html-pre\": function ( a ) {\n\t\t\treturn _empty(a) ?\n\t\t\t\t'' :\n\t\t\t\ta.replace ?\n\t\t\t\t\ta.replace( /<.*?>/g, \"\" ).toLowerCase() :\n\t\t\t\t\ta+'';\n\t\t},\n\t\n\t\t// string\n\t\t\"string-pre\": function ( a ) {\n\t\t\t// This is a little complex, but faster than always calling toString,\n\t\t\t// http://jsperf.com/tostring-v-check\n\t\t\treturn _empty(a) ?\n\t\t\t\t'' :\n\t\t\t\ttypeof a === 'string' ?\n\t\t\t\t\ta.toLowerCase() :\n\t\t\t\t\t! a.toString ?\n\t\t\t\t\t\t'' :\n\t\t\t\t\t\ta.toString();\n\t\t},\n\t\n\t\t// string-asc and -desc are retained only for compatibility with the old\n\t\t// sort methods\n\t\t\"string-asc\": function ( x, y ) {\n\t\t\treturn ((x < y) ? -1 : ((x > y) ? 1 : 0));\n\t\t},\n\t\n\t\t\"string-desc\": function ( x, y ) {\n\t\t\treturn ((x < y) ? 1 : ((x > y) ? -1 : 0));\n\t\t}\n\t} );\n\t\n\t\n\t// Numeric sorting types - order doesn't matter here\n\t_addNumericSort( '' );\n\t\n\t\n\t$.extend( true, DataTable.ext.renderer, {\n\t\theader: {\n\t\t\t_: function ( settings, cell, column, classes ) {\n\t\t\t\t// No additional mark-up required\n\t\t\t\t// Attach a sort listener to update on sort - note that using the\n\t\t\t\t// `DT` namespace will allow the event to be removed automatically\n\t\t\t\t// on destroy, while the `dt` namespaced event is the one we are\n\t\t\t\t// listening for\n\t\t\t\t$(settings.nTable).on( 'order.dt.DT', function ( e, ctx, sorting, columns ) {\n\t\t\t\t\tif ( settings !== ctx ) { // need to check this this is the host\n\t\t\t\t\t\treturn;               // table, not a nested one\n\t\t\t\t\t}\n\t\n\t\t\t\t\tvar colIdx = column.idx;\n\t\n\t\t\t\t\tcell\n\t\t\t\t\t\t.removeClass(\n\t\t\t\t\t\t\tclasses.sSortAsc +' '+\n\t\t\t\t\t\t\tclasses.sSortDesc\n\t\t\t\t\t\t)\n\t\t\t\t\t\t.addClass( columns[ colIdx ] == 'asc' ?\n\t\t\t\t\t\t\tclasses.sSortAsc : columns[ colIdx ] == 'desc' ?\n\t\t\t\t\t\t\t\tclasses.sSortDesc :\n\t\t\t\t\t\t\t\tcolumn.sSortingClass\n\t\t\t\t\t\t);\n\t\t\t\t} );\n\t\t\t},\n\t\n\t\t\tjqueryui: function ( settings, cell, column, classes ) {\n\t\t\t\t$('<div/>')\n\t\t\t\t\t.addClass( classes.sSortJUIWrapper )\n\t\t\t\t\t.append( cell.contents() )\n\t\t\t\t\t.append( $('<span/>')\n\t\t\t\t\t\t.addClass( classes.sSortIcon+' '+column.sSortingClassJUI )\n\t\t\t\t\t)\n\t\t\t\t\t.appendTo( cell );\n\t\n\t\t\t\t// Attach a sort listener to update on sort\n\t\t\t\t$(settings.nTable).on( 'order.dt.DT', function ( e, ctx, sorting, columns ) {\n\t\t\t\t\tif ( settings !== ctx ) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\n\t\t\t\t\tvar colIdx = column.idx;\n\t\n\t\t\t\t\tcell\n\t\t\t\t\t\t.removeClass( classes.sSortAsc +\" \"+classes.sSortDesc )\n\t\t\t\t\t\t.addClass( columns[ colIdx ] == 'asc' ?\n\t\t\t\t\t\t\tclasses.sSortAsc : columns[ colIdx ] == 'desc' ?\n\t\t\t\t\t\t\t\tclasses.sSortDesc :\n\t\t\t\t\t\t\t\tcolumn.sSortingClass\n\t\t\t\t\t\t);\n\t\n\t\t\t\t\tcell\n\t\t\t\t\t\t.find( 'span.'+classes.sSortIcon )\n\t\t\t\t\t\t.removeClass(\n\t\t\t\t\t\t\tclasses.sSortJUIAsc +\" \"+\n\t\t\t\t\t\t\tclasses.sSortJUIDesc +\" \"+\n\t\t\t\t\t\t\tclasses.sSortJUI +\" \"+\n\t\t\t\t\t\t\tclasses.sSortJUIAscAllowed +\" \"+\n\t\t\t\t\t\t\tclasses.sSortJUIDescAllowed\n\t\t\t\t\t\t)\n\t\t\t\t\t\t.addClass( columns[ colIdx ] == 'asc' ?\n\t\t\t\t\t\t\tclasses.sSortJUIAsc : columns[ colIdx ] == 'desc' ?\n\t\t\t\t\t\t\t\tclasses.sSortJUIDesc :\n\t\t\t\t\t\t\t\tcolumn.sSortingClassJUI\n\t\t\t\t\t\t);\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t} );\n\t\n\t/*\n\t * Public helper functions. These aren't used internally by DataTables, or\n\t * called by any of the options passed into DataTables, but they can be used\n\t * externally by developers working with DataTables. They are helper functions\n\t * to make working with DataTables a little bit easier.\n\t */\n\t\n\tvar __htmlEscapeEntities = function ( d ) {\n\t\tif (Array.isArray(d)) {\n\t\t\td = d.join(',');\n\t\t}\n\t\n\t\treturn typeof d === 'string' ?\n\t\t\td\n\t\t\t\t.replace(/&/g, '&amp;')\n\t\t\t\t.replace(/</g, '&lt;')\n\t\t\t\t.replace(/>/g, '&gt;')\n\t\t\t\t.replace(/\"/g, '&quot;') :\n\t\t\td;\n\t};\n\t\n\t// Common logic for moment, luxon or a date action\n\tfunction __mld( dt, momentFn, luxonFn, dateFn, arg1 ) {\n\t\tif (window.moment) {\n\t\t\treturn dt[momentFn]( arg1 );\n\t\t}\n\t\telse if (window.luxon) {\n\t\t\treturn dt[luxonFn]( arg1 );\n\t\t}\n\t\t\n\t\treturn dateFn ? dt[dateFn]( arg1 ) : dt;\n\t}\n\t\n\t\n\tvar __mlWarning = false;\n\tfunction __mldObj (d, format, locale) {\n\t\tvar dt;\n\t\n\t\tif (window.moment) {\n\t\t\tdt = window.moment.utc( d, format, locale, true );\n\t\n\t\t\tif (! dt.isValid()) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\t}\n\t\telse if (window.luxon) {\n\t\t\tdt = format\n\t\t\t\t? window.luxon.DateTime.fromFormat( d, format )\n\t\t\t\t: window.luxon.DateTime.fromISO( d );\n\t\n\t\t\tif (! dt.isValid) {\n\t\t\t\treturn null;\n\t\t\t}\n\t\n\t\t\tdt.setLocale(locale);\n\t\t}\n\t\telse if (! format) {\n\t\t\t// No format given, must be ISO\n\t\t\tdt = new Date(d);\n\t\t}\n\t\telse {\n\t\t\tif (! __mlWarning) {\n\t\t\t\talert('DataTables warning: Formatted date without Moment.js or Luxon - https://datatables.net/tn/17');\n\t\t\t}\n\t\n\t\t\t__mlWarning = true;\n\t\t}\n\t\n\t\treturn dt;\n\t}\n\t\n\t// Wrapper for date, datetime and time which all operate the same way with the exception of\n\t// the output string for auto locale support\n\tfunction __mlHelper (localeString) {\n\t\treturn function ( from, to, locale, def ) {\n\t\t\t// Luxon and Moment support\n\t\t\t// Argument shifting\n\t\t\tif ( arguments.length === 0 ) {\n\t\t\t\tlocale = 'en';\n\t\t\t\tto = null; // means toLocaleString\n\t\t\t\tfrom = null; // means iso8601\n\t\t\t}\n\t\t\telse if ( arguments.length === 1 ) {\n\t\t\t\tlocale = 'en';\n\t\t\t\tto = from;\n\t\t\t\tfrom = null;\n\t\t\t}\n\t\t\telse if ( arguments.length === 2 ) {\n\t\t\t\tlocale = to;\n\t\t\t\tto = from;\n\t\t\t\tfrom = null;\n\t\t\t}\n\t\n\t\t\tvar typeName = 'datetime-' + to;\n\t\n\t\t\t// Add type detection and sorting specific to this date format - we need to be able to identify\n\t\t\t// date type columns as such, rather than as numbers in extensions. Hence the need for this.\n\t\t\tif (! DataTable.ext.type.order[typeName]) {\n\t\t\t\t// The renderer will give the value to type detect as the type!\n\t\t\t\tDataTable.ext.type.detect.unshift(function (d) {\n\t\t\t\t\treturn d === typeName ? typeName : false;\n\t\t\t\t});\n\t\n\t\t\t\t// The renderer gives us Moment, Luxon or Date obects for the sorting, all of which have a\n\t\t\t\t// `valueOf` which gives milliseconds epoch\n\t\t\t\tDataTable.ext.type.order[typeName + '-asc'] = function (a, b) {\n\t\t\t\t\tvar x = a.valueOf();\n\t\t\t\t\tvar y = b.valueOf();\n\t\n\t\t\t\t\treturn x === y\n\t\t\t\t\t\t? 0\n\t\t\t\t\t\t: x < y\n\t\t\t\t\t\t\t? -1\n\t\t\t\t\t\t\t: 1;\n\t\t\t\t}\n\t\n\t\t\t\tDataTable.ext.type.order[typeName + '-desc'] = function (a, b) {\n\t\t\t\t\tvar x = a.valueOf();\n\t\t\t\t\tvar y = b.valueOf();\n\t\n\t\t\t\t\treturn x === y\n\t\t\t\t\t\t? 0\n\t\t\t\t\t\t: x > y\n\t\t\t\t\t\t\t? -1\n\t\t\t\t\t\t\t: 1;\n\t\t\t\t}\n\t\t\t}\n\t\t\n\t\t\treturn function ( d, type ) {\n\t\t\t\t// Allow for a default value\n\t\t\t\tif (d === null || d === undefined) {\n\t\t\t\t\tif (def === '--now') {\n\t\t\t\t\t\t// We treat everything as UTC further down, so no changes are\n\t\t\t\t\t\t// made, as such need to get the local date / time as if it were\n\t\t\t\t\t\t// UTC\n\t\t\t\t\t\tvar local = new Date();\n\t\t\t\t\t\td = new Date( Date.UTC(\n\t\t\t\t\t\t\tlocal.getFullYear(), local.getMonth(), local.getDate(),\n\t\t\t\t\t\t\tlocal.getHours(), local.getMinutes(), local.getSeconds()\n\t\t\t\t\t\t) );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\td = '';\n\t\t\t\t\t}\n\t\t\t\t}\n\t\n\t\t\t\tif (type === 'type') {\n\t\t\t\t\t// Typing uses the type name for fast matching\n\t\t\t\t\treturn typeName;\n\t\t\t\t}\n\t\n\t\t\t\tif (d === '') {\n\t\t\t\t\treturn type !== 'sort'\n\t\t\t\t\t\t? ''\n\t\t\t\t\t\t: __mldObj('0000-01-01 00:00:00', null, locale);\n\t\t\t\t}\n\t\n\t\t\t\t// Shortcut. If `from` and `to` are the same, we are using the renderer to\n\t\t\t\t// format for ordering, not display - its already in the display format.\n\t\t\t\tif ( to !== null && from === to && type !== 'sort' && type !== 'type' && ! (d instanceof Date) ) {\n\t\t\t\t\treturn d;\n\t\t\t\t}\n\t\n\t\t\t\tvar dt = __mldObj(d, from, locale);\n\t\n\t\t\t\tif (dt === null) {\n\t\t\t\t\treturn d;\n\t\t\t\t}\n\t\n\t\t\t\tif (type === 'sort') {\n\t\t\t\t\treturn dt;\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tvar formatted = to === null\n\t\t\t\t\t? __mld(dt, 'toDate', 'toJSDate', '')[localeString]()\n\t\t\t\t\t: __mld(dt, 'format', 'toFormat', 'toISOString', to);\n\t\n\t\t\t\t// XSS protection\n\t\t\t\treturn type === 'display' ?\n\t\t\t\t\t__htmlEscapeEntities( formatted ) :\n\t\t\t\t\tformatted;\n\t\t\t};\n\t\t}\n\t}\n\t\n\t// Based on locale, determine standard number formatting\n\t// Fallback for legacy browsers is US English\n\tvar __thousands = ',';\n\tvar __decimal = '.';\n\t\n\tif (Intl) {\n\t\ttry {\n\t\t\tvar num = new Intl.NumberFormat().formatToParts(100000.1);\n\t\t\n\t\t\tfor (var i=0 ; i<num.length ; i++) {\n\t\t\t\tif (num[i].type === 'group') {\n\t\t\t\t\t__thousands = num[i].value;\n\t\t\t\t}\n\t\t\t\telse if (num[i].type === 'decimal') {\n\t\t\t\t\t__decimal = num[i].value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tcatch (e) {\n\t\t\t// noop\n\t\t}\n\t}\n\t\n\t// Formatted date time detection - use by declaring the formats you are going to use\n\tDataTable.datetime = function ( format, locale ) {\n\t\tvar typeName = 'datetime-detect-' + format;\n\t\n\t\tif (! locale) {\n\t\t\tlocale = 'en';\n\t\t}\n\t\n\t\tif (! DataTable.ext.type.order[typeName]) {\n\t\t\tDataTable.ext.type.detect.unshift(function (d) {\n\t\t\t\tvar dt = __mldObj(d, format, locale);\n\t\t\t\treturn d === '' || dt ? typeName : false;\n\t\t\t});\n\t\n\t\t\tDataTable.ext.type.order[typeName + '-pre'] = function (d) {\n\t\t\t\treturn __mldObj(d, format, locale) || 0;\n\t\t\t}\n\t\t}\n\t}\n\t\n\t/**\n\t * Helpers for `columns.render`.\n\t *\n\t * The options defined here can be used with the `columns.render` initialisation\n\t * option to provide a display renderer. The following functions are defined:\n\t *\n\t * * `number` - Will format numeric data (defined by `columns.data`) for\n\t *   display, retaining the original unformatted data for sorting and filtering.\n\t *   It takes 5 parameters:\n\t *   * `string` - Thousands grouping separator\n\t *   * `string` - Decimal point indicator\n\t *   * `integer` - Number of decimal points to show\n\t *   * `string` (optional) - Prefix.\n\t *   * `string` (optional) - Postfix (/suffix).\n\t * * `text` - Escape HTML to help prevent XSS attacks. It has no optional\n\t *   parameters.\n\t *\n\t * @example\n\t *   // Column definition using the number renderer\n\t *   {\n\t *     data: \"salary\",\n\t *     render: $.fn.dataTable.render.number( '\\'', '.', 0, '$' )\n\t *   }\n\t *\n\t * @namespace\n\t */\n\tDataTable.render = {\n\t\tdate: __mlHelper('toLocaleDateString'),\n\t\tdatetime: __mlHelper('toLocaleString'),\n\t\ttime: __mlHelper('toLocaleTimeString'),\n\t\tnumber: function ( thousands, decimal, precision, prefix, postfix ) {\n\t\t\t// Auto locale detection\n\t\t\tif (thousands === null || thousands === undefined) {\n\t\t\t\tthousands = __thousands;\n\t\t\t}\n\t\n\t\t\tif (decimal === null || decimal === undefined) {\n\t\t\t\tdecimal = __decimal;\n\t\t\t}\n\t\n\t\t\treturn {\n\t\t\t\tdisplay: function ( d ) {\n\t\t\t\t\tif ( typeof d !== 'number' && typeof d !== 'string' ) {\n\t\t\t\t\t\treturn d;\n\t\t\t\t\t}\n\t\n\t\t\t\t\tif (d === '' || d === null) {\n\t\t\t\t\t\treturn d;\n\t\t\t\t\t}\n\t\n\t\t\t\t\tvar negative = d < 0 ? '-' : '';\n\t\t\t\t\tvar flo = parseFloat( d );\n\t\n\t\t\t\t\t// If NaN then there isn't much formatting that we can do - just\n\t\t\t\t\t// return immediately, escaping any HTML (this was supposed to\n\t\t\t\t\t// be a number after all)\n\t\t\t\t\tif ( isNaN( flo ) ) {\n\t\t\t\t\t\treturn __htmlEscapeEntities( d );\n\t\t\t\t\t}\n\t\n\t\t\t\t\tflo = flo.toFixed( precision );\n\t\t\t\t\td = Math.abs( flo );\n\t\n\t\t\t\t\tvar intPart = parseInt( d, 10 );\n\t\t\t\t\tvar floatPart = precision ?\n\t\t\t\t\t\tdecimal+(d - intPart).toFixed( precision ).substring( 2 ):\n\t\t\t\t\t\t'';\n\t\n\t\t\t\t\t// If zero, then can't have a negative prefix\n\t\t\t\t\tif (intPart === 0 && parseFloat(floatPart) === 0) {\n\t\t\t\t\t\tnegative = '';\n\t\t\t\t\t}\n\t\n\t\t\t\t\treturn negative + (prefix||'') +\n\t\t\t\t\t\tintPart.toString().replace(\n\t\t\t\t\t\t\t/\\B(?=(\\d{3})+(?!\\d))/g, thousands\n\t\t\t\t\t\t) +\n\t\t\t\t\t\tfloatPart +\n\t\t\t\t\t\t(postfix||'');\n\t\t\t\t}\n\t\t\t};\n\t\t},\n\t\n\t\ttext: function () {\n\t\t\treturn {\n\t\t\t\tdisplay: __htmlEscapeEntities,\n\t\t\t\tfilter: __htmlEscapeEntities\n\t\t\t};\n\t\t}\n\t};\n\t\n\t\n\t/*\n\t * This is really a good bit rubbish this method of exposing the internal methods\n\t * publicly... - To be fixed in 2.0 using methods on the prototype\n\t */\n\t\n\t\n\t/**\n\t * Create a wrapper function for exporting an internal functions to an external API.\n\t *  @param {string} fn API function name\n\t *  @returns {function} wrapped function\n\t *  @memberof DataTable#internal\n\t */\n\tfunction _fnExternApiFunc (fn)\n\t{\n\t\treturn function() {\n\t\t\tvar args = [_fnSettingsFromNode( this[DataTable.ext.iApiIndex] )].concat(\n\t\t\t\tArray.prototype.slice.call(arguments)\n\t\t\t);\n\t\t\treturn DataTable.ext.internal[fn].apply( this, args );\n\t\t};\n\t}\n\t\n\t\n\t/**\n\t * Reference to internal functions for use by plug-in developers. Note that\n\t * these methods are references to internal functions and are considered to be\n\t * private. If you use these methods, be aware that they are liable to change\n\t * between versions.\n\t *  @namespace\n\t */\n\t$.extend( DataTable.ext.internal, {\n\t\t_fnExternApiFunc: _fnExternApiFunc,\n\t\t_fnBuildAjax: _fnBuildAjax,\n\t\t_fnAjaxUpdate: _fnAjaxUpdate,\n\t\t_fnAjaxParameters: _fnAjaxParameters,\n\t\t_fnAjaxUpdateDraw: _fnAjaxUpdateDraw,\n\t\t_fnAjaxDataSrc: _fnAjaxDataSrc,\n\t\t_fnAddColumn: _fnAddColumn,\n\t\t_fnColumnOptions: _fnColumnOptions,\n\t\t_fnAdjustColumnSizing: _fnAdjustColumnSizing,\n\t\t_fnVisibleToColumnIndex: _fnVisibleToColumnIndex,\n\t\t_fnColumnIndexToVisible: _fnColumnIndexToVisible,\n\t\t_fnVisbleColumns: _fnVisbleColumns,\n\t\t_fnGetColumns: _fnGetColumns,\n\t\t_fnColumnTypes: _fnColumnTypes,\n\t\t_fnApplyColumnDefs: _fnApplyColumnDefs,\n\t\t_fnHungarianMap: _fnHungarianMap,\n\t\t_fnCamelToHungarian: _fnCamelToHungarian,\n\t\t_fnLanguageCompat: _fnLanguageCompat,\n\t\t_fnBrowserDetect: _fnBrowserDetect,\n\t\t_fnAddData: _fnAddData,\n\t\t_fnAddTr: _fnAddTr,\n\t\t_fnNodeToDataIndex: _fnNodeToDataIndex,\n\t\t_fnNodeToColumnIndex: _fnNodeToColumnIndex,\n\t\t_fnGetCellData: _fnGetCellData,\n\t\t_fnSetCellData: _fnSetCellData,\n\t\t_fnSplitObjNotation: _fnSplitObjNotation,\n\t\t_fnGetObjectDataFn: _fnGetObjectDataFn,\n\t\t_fnSetObjectDataFn: _fnSetObjectDataFn,\n\t\t_fnGetDataMaster: _fnGetDataMaster,\n\t\t_fnClearTable: _fnClearTable,\n\t\t_fnDeleteIndex: _fnDeleteIndex,\n\t\t_fnInvalidate: _fnInvalidate,\n\t\t_fnGetRowElements: _fnGetRowElements,\n\t\t_fnCreateTr: _fnCreateTr,\n\t\t_fnBuildHead: _fnBuildHead,\n\t\t_fnDrawHead: _fnDrawHead,\n\t\t_fnDraw: _fnDraw,\n\t\t_fnReDraw: _fnReDraw,\n\t\t_fnAddOptionsHtml: _fnAddOptionsHtml,\n\t\t_fnDetectHeader: _fnDetectHeader,\n\t\t_fnGetUniqueThs: _fnGetUniqueThs,\n\t\t_fnFeatureHtmlFilter: _fnFeatureHtmlFilter,\n\t\t_fnFilterComplete: _fnFilterComplete,\n\t\t_fnFilterCustom: _fnFilterCustom,\n\t\t_fnFilterColumn: _fnFilterColumn,\n\t\t_fnFilter: _fnFilter,\n\t\t_fnFilterCreateSearch: _fnFilterCreateSearch,\n\t\t_fnEscapeRegex: _fnEscapeRegex,\n\t\t_fnFilterData: _fnFilterData,\n\t\t_fnFeatureHtmlInfo: _fnFeatureHtmlInfo,\n\t\t_fnUpdateInfo: _fnUpdateInfo,\n\t\t_fnInfoMacros: _fnInfoMacros,\n\t\t_fnInitialise: _fnInitialise,\n\t\t_fnInitComplete: _fnInitComplete,\n\t\t_fnLengthChange: _fnLengthChange,\n\t\t_fnFeatureHtmlLength: _fnFeatureHtmlLength,\n\t\t_fnFeatureHtmlPaginate: _fnFeatureHtmlPaginate,\n\t\t_fnPageChange: _fnPageChange,\n\t\t_fnFeatureHtmlProcessing: _fnFeatureHtmlProcessing,\n\t\t_fnProcessingDisplay: _fnProcessingDisplay,\n\t\t_fnFeatureHtmlTable: _fnFeatureHtmlTable,\n\t\t_fnScrollDraw: _fnScrollDraw,\n\t\t_fnApplyToChildren: _fnApplyToChildren,\n\t\t_fnCalculateColumnWidths: _fnCalculateColumnWidths,\n\t\t_fnThrottle: _fnThrottle,\n\t\t_fnConvertToWidth: _fnConvertToWidth,\n\t\t_fnGetWidestNode: _fnGetWidestNode,\n\t\t_fnGetMaxLenString: _fnGetMaxLenString,\n\t\t_fnStringToCss: _fnStringToCss,\n\t\t_fnSortFlatten: _fnSortFlatten,\n\t\t_fnSort: _fnSort,\n\t\t_fnSortAria: _fnSortAria,\n\t\t_fnSortListener: _fnSortListener,\n\t\t_fnSortAttachListener: _fnSortAttachListener,\n\t\t_fnSortingClasses: _fnSortingClasses,\n\t\t_fnSortData: _fnSortData,\n\t\t_fnSaveState: _fnSaveState,\n\t\t_fnLoadState: _fnLoadState,\n\t\t_fnImplementState: _fnImplementState,\n\t\t_fnSettingsFromNode: _fnSettingsFromNode,\n\t\t_fnLog: _fnLog,\n\t\t_fnMap: _fnMap,\n\t\t_fnBindAction: _fnBindAction,\n\t\t_fnCallbackReg: _fnCallbackReg,\n\t\t_fnCallbackFire: _fnCallbackFire,\n\t\t_fnLengthOverflow: _fnLengthOverflow,\n\t\t_fnRenderer: _fnRenderer,\n\t\t_fnDataSource: _fnDataSource,\n\t\t_fnRowAttributes: _fnRowAttributes,\n\t\t_fnExtend: _fnExtend,\n\t\t_fnCalculateEnd: function () {} // Used by a lot of plug-ins, but redundant\n\t\t                                // in 1.10, so this dead-end function is\n\t\t                                // added to prevent errors\n\t} );\n\t\n\t\n\t// jQuery access\n\t$.fn.dataTable = DataTable;\n\t\n\t// Provide access to the host jQuery object (circular reference)\n\tDataTable.$ = $;\n\t\n\t// Legacy aliases\n\t$.fn.dataTableSettings = DataTable.settings;\n\t$.fn.dataTableExt = DataTable.ext;\n\t\n\t// With a capital `D` we return a DataTables API instance rather than a\n\t// jQuery object\n\t$.fn.DataTable = function ( opts ) {\n\t\treturn $(this).dataTable( opts ).api();\n\t};\n\t\n\t// All properties that are available to $.fn.dataTable should also be\n\t// available on $.fn.DataTable\n\t$.each( DataTable, function ( prop, val ) {\n\t\t$.fn.DataTable[ prop ] = val;\n\t} );\n\t\n\treturn DataTable;\n}));\n"],"names":["factory","$","window","document","undefined","_ext","_Api","_api_register","_api_registerPlural","DataTable","selector","options","this","sSelector","oOpts","api","_","rows","data","traditional","_fnSettingsFromNode","iApiIndex","fnAddData","redraw","Array","isArray","isPlainObject","add","row","draw","flatten","toArray","fnAdjustColumnSizing","bRedraw","columns","adjust","settings","scroll","oScroll","sX","sY","_fnScrollDraw","fnClearTable","clear","fnClose","nTr","child","hide","fnDeleteRow","target","callback","aoData","remove","call","fnDestroy","destroy","fnDraw","complete","fnFilter","sInput","iColumn","bRegex","bSmart","bShowGlobal","bCaseInsensitive","search","column","fnGetData","src","col","type","nodeName","toLowerCase","cell","fnGetNodes","iRow","node","nodes","fnGetPosition","toUpperCase","index","columnVisible","fnIsOpen","isShown","fnOpen","mHtml","sClass","show","fnPageChange","mAction","page","fnSetColumnVis","iCol","bShow","visible","fnSettings","fnSort","aaSort","order","fnSortListener","nNode","fnCallback","listener","fnUpdate","mData","mRow","bAction","fnVersionCheck","_that","emptyInit","len","length","fn","oApi","internal","ext","_fnExternApiFunc","each","iLen","oInit","_fnExtend","i","sId","getAttribute","bInitHandedOff","defaults","$this","_fnCompatOpts","_fnCompatCols","_fnCamelToHungarian","extend","allSettings","s","nTable","nTHead","parentNode","nTFoot","bRetrieve","bDestroy","oInstance","_fnLog","sTableId","id","splice","_unique","oSettings","models","style","width","push","dataTable","_fnLanguageCompat","oLanguage","aLengthMenu","iDisplayLength","_fnMap","oFeatures","_fnCallbackReg","fnDrawCallback","fnServerParams","fnStateSaveParams","fnStateLoadParams","fnStateLoaded","fnRowCallback","fnCreatedRow","fnHeaderCallback","fnFooterCallback","fnInitComplete","fnPreDrawCallback","rowIdFn","_fnGetObjectDataFn","rowId","_fnBrowserDetect","oClasses","classes","addClass","sTable","iInitDisplayStart","iDisplayStart","_iDisplayStart","iDeferLoading","bDeferLoading","tmp","_iRecordsDisplay","_iRecordsTotal","sUrl","ajax","dataType","url","success","json","_fnCallbackFire","_fnInitialise","error","asStripeClasses","sStripeOdd","sStripeEven","stripeClasses","rowOne","children","find","eq","inArray","map","el","hasClass","removeClass","join","asDestroyStripes","slice","aoColumnsInit","anThs","nThead","getElementsByTagName","_fnDetectHeader","aoHeader","_fnGetUniqueThs","aoColumns","_fnAddColumn","_fnApplyColumnDefs","aoColumnDefs","oDef","_fnColumnOptions","a","name","sort","filter","features","loadedInit","aaSorting","sorting","asSorting","_fnSortingClasses","bSort","bSorted","aSort","_fnSortFlatten","sortedColumns","val","dir","_fnSortAria","_fnDataSource","bDeferRender","captions","_captionSide","css","thead","appendTo","tbody","insertAfter","nTBody","tfoot","sNoFooter","aoFooter","aaData","_fnAddData","_fnAddTr","aiDisplay","aiDisplayMaster","bInitialised","_fnSaveState","bStateSave","_fnLoadState","_re_dic","_re_new_lines","_re_html","_re_date","_re_escape_regex","RegExp","_re_formatted_numeric","_empty","d","_intVal","integer","parseInt","isNaN","isFinite","_numToDecimal","num","decimalPoint","_fnEscapeRegex","replace","_isNumber","formatted","strType","parseFloat","_htmlNumeric","_isHtml","_stripHtml","_pluck","prop","prop2","out","ien","_pluck_order","_range","start","end","_removeEmpty","sorted","last","_areAllUnique","j","k","again","_flatten","_includes","indexOf","_fnHungarianMap","o","match","newKey","key","_hungarianMap","user","force","hungarianKey","charAt","lang","defaultDecimal","sDecimal","_addNumericSort","zeroRecords","sZeroRecords","sEmptyTable","sLoadingRecords","sInfoThousands","sThousands","decimal","arg","Object","prototype","toString","includes","String","trim","util","throttle","freq","timer","frequency","that","now","Date","args","arguments","clearTimeout","setTimeout","apply","escapeRegex","set","source","meta","setData","b","arrayNotation","funcNotation","innerSrc","_fnSplitObjNotation","aLast","Error","__reArray","__reFn","jLen","get","t","fetchData","substring","_fnCompatMap","knew","old","init","sScrollX","scrollX","searchCols","aoSearchCols","oSearch","dataSort","aDataSort","__browser","browser","n","position","top","left","scrollLeft","height","overflow","append","outer","inner","barWidth","offsetWidth","clientWidth","bScrollOversize","bScrollbarLeft","Math","round","offset","bBounding","getBoundingClientRect","oBrowser","iBarWidth","_fnReduce","inc","value","isSet","hasOwnProperty","nTh","oDefaults","oCol","oColumn","createElement","sTitle","innerHTML","idx","aoPreSearchCols","oOptions","th","sWidthOrig","attr","mDataProp","sType","_sManualType","className","origClass","iDataSort","mDataSrc","mRender","attrTest","_bAttrSrc","_setter","rowData","innerData","fnSetData","_fnSetObjectDataFn","_rowReadObject","bSortable","sSortableNone","bAsc","bDesc","sSortingClass","sSortableAsc","sSortingClassJUI","sSortJUIAscAllowed","sSortableDesc","sSortJUIDescAllowed","sSortable","sSortJUI","_fnAdjustColumnSizing","bAutoWidth","_fnCalculateColumnWidths","sWidth","_fnVisibleToColumnIndex","iMatch","aiVis","_fnGetColumns","_fnColumnIndexToVisible","iPos","_fnVisbleColumns","vis","bVisible","sParam","_fnColumnTypes","jen","ken","detectedType","cache","types","detect","_fnGetCellData","aoColDefs","aoCols","kLen","def","aTargets","targets","aDataIn","anTds","oData","oRow","_aData","aIds","_fnCreateTr","trs","_fnGetRowElements","cells","rowIdx","colIdx","iDraw","defaultContent","sDefaultContent","cellData","iDrawError","fomatters","_fnSetCellData","str","_fnGetDataMaster","_fnClearTable","_fnDeleteIndex","iTarget","iTargetIndex","_fnInvalidate","cellWrite","childNodes","removeChild","firstChild","anCells","_aSortData","_aFilterData","cols","_fnRowAttributes","contents","tds","td","objectRead","setter","cellProcess","nextSibling","rowNode","nTrIn","nTd","create","_DT_RowIndex","sCellType","_DT_CellIndex","appendChild","fnCreatedCell","tr","DT_RowClass","split","__rowc","concat","DT_RowAttr","DT_RowData","_fnBuildHead","createHeader","iTabIndex","_fnSortAttachListener","html","_fnRenderer","sHeaderTH","sFooterTH","nTf","_fnDrawHead","aoSource","bIncludeHidden","nLocalTr","iRowspan","iColspan","aoLocal","aApplied","iColumns","_fnDraw","ajaxComplete","bServerSide","fnRecordsDisplay","_fnStart","aPreDraw","anRows","iRowCount","iStripes","oLang","iDisplayEnd","fnDisplayEnd","bDrawing","_fnProcessingDisplay","bDestroying","_fnAjaxUpdate","iStart","iEnd","iDataIndex","nRow","sStripe","_sRowStripe","sZero","fnRecordsTotal","sRowEmpty","body","detach","bFiltered","_fnReDraw","holdPosition","bFilter","_fnSort","_fnFilterComplete","oPreviousSearch","_drawHold","_fnAddOptionsHtml","table","holding","insertBefore","insert","sWrapper","nHolding","nTableWrapper","nTableReinsertBefore","featureNode","cOption","nNewNode","cNext","sAttr","aDom","sDom","sJUIHeader","sJUIFooter","aSplit","substr","parent","bPaginate","bLengthChange","_fnFeatureHtmlLength","_fnFeatureHtmlFilter","bProcessing","_fnFeatureHtmlProcessing","_fnFeatureHtmlTable","bInfo","_fnFeatureHtmlInfo","_fnFeatureHtmlPaginate","feature","aoFeatures","cFeature","fnInit","aanFeatures","replaceWith","aLayout","nCell","l","iColShifted","bUnique","nTrs","fnShiftCol","nHeader","aReturn","unique","bSortCellsTop","_fnBuildAjax","rbracket","ajaxData","instance","status","jqXHR","_fnAjaxDataSrc","sError","newData","baseAjax","sServerMethod","xhr","thrown","ret","readyState","oAjaxData","fnServerData","sAjaxSource","_fnAjaxParameters","_fnAjaxUpdateDraw","dataProp","columnSearch","columnCount","preSearch","preColSearch","displayStart","displayLength","_iDisplayLength","param","sSearch","regex","sName","searchable","bSearchable","orderable","legacy","compat","modern","recordsTotal","recordsFiltered","_bInitComplete","_fnInitComplete","write","dataSrc","sAjaxDataProp","tableId","language","previousSearch","input","sFilterInput","f","sFilter","searchFn","event","return","searchDelay","jqFilter","sSearchPlaceholder","on","_fnThrottle","e","keyCode","ev","activeElement","oInput","iForce","oPrevSearch","aoPrevSearch","fnSaveFilter","oFilter","fnRegex","bEscapeRegex","_fnFilter","_fnFilterColumn","_fnFilterCustom","filters","displayRows","merge","searchStr","smart","caseInsensitive","display","rpSearch","_fnFilterCreateSearch","test","invalidated","prevSearch","displayMaster","filtered","_fnFilterData","_sFilterRow","word","m","__filter_div","__filter_div_textContent","textContent","filterData","wasInvalidated","innerText","_fnSearchToCamel","obj","_fnSearchToHung","tid","sInfo","aoDrawCallback","_fnUpdateInfo","max","total","sInfoEmpty","sInfoFiltered","_fnInfoMacros","sInfoPostFix","fnInfoCallback","formatter","fnFormatNumber","all","ceil","iAjaxStart","deferLoading","_fnStringToCss","aData","_fnLengthChange","_fnLengthOverflow","menu","d2","lengths","select","sLengthSelect","Option","div","sLength","sLengthMenu","outerHTML","sPaginationType","plugin","pager","sPaging","p","visRecords","pages","buttons","_fnPageChange","action","records","floor","changed","r","sProcessing","scrollY","caption","captionSide","headerClone","cloneNode","footerClone","footer","_div","size","scroller","sScrollWrapper","sScrollHead","border","sScrollHeadInner","sXInner","removeAttr","sScrollBody","sScrollFoot","sScrollFootInner","scrollHead","scrollBody","scrollFoot","bCollapse","nScrollHead","nScrollBody","nScrollFoot","headerTrgEls","footerTrgEls","headerSrcEls","footerSrcEls","headerCopy","footerCopy","correction","sanityWidth","scrollXInner","divHeader","divHeaderStyle","divHeaderInner","divHeaderInnerStyle","divHeaderTable","divBodyEl","divBody","divBodyStyle","divFooterInner","divFooterTable","header","tableEl","tableStyle","ie67","headerWidths","footerWidths","headerContent","footerContent","zeroOut","nSizer","paddingTop","paddingBottom","borderTopWidth","borderBottomWidth","scrollBarVis","scrollHeight","clientHeight","clone","prependTo","_fnApplyToChildren","outerWidth","offsetHeight","getComputedStyle","nToSize","iOuterWidth","bScrolling","padding","trigger","scrollTop","an1","an2","nNode1","nNode2","nodeType","__re_html_remove","columnIdx","visibleColumns","headerCells","tableWidthAttr","tableContainer","userInputs","styleWidth","_fnConvertToWidth","tmpTable","margin","_fnGetWidestNode","sContentPadding","holder","right","bounding","_reszEvt","bindResize","sInstance","_fnGetMaxLenString","maxIdx","srcCol","fixed","aaSortingFixed","fixedObj","nestedSort","pre","post","_idx","sortCol","aiOrig","oExtSort","formatters","_fnSortData","x","y","dataA","dataB","label","nextSort","oAria","ariaTitle","removeAttribute","setAttribute","sSortAscending","sSortDescending","_fnSortListener","nextSortIdx","next","bSortMulti","sortIdx","attachTo","_fnBindAction","shiftKey","oldSort","aLastSort","sortClass","sSortColumn","bSortClasses","customData","customSort","sSortDataType","_bLoadingState","state","time","oSavedState","fnStateSaveCallback","fnStateLoadCallback","_fnImplementState","Api","abStateLoad","duration","iStateDuration","oLoadedState","level","msg","tn","console","log","sErrMode","errMode","alert","mappedName","extender","breakRefs","which","preventDefault","sStore","callbackArr","eventName","reverse","Event","result","renderer","host","__apiStruct","__arrayProto","context","ctxSettings","mixed","jq","tables","_toSettings","opts","any","count","ctx","iterator","alwaysNew","items","item","apiInst","_selector_row_indexes","apiSelector","lastIndexOf","pluck","pop","reduce","reduceRight","shift","to$","toJQuery","unshift","scope","__dt_wrapper","struct","methodScoping","struc","methodExt","propExt","register","method","heir","registerPlural","pluralName","singularName","__table_selector","paging","info","__reload","one","abort","resetPaging","_selector_run","selectFn","res","selectorType","_selector_opts","_selector_first","inst","displayFiltered","displayFilteredMap","sel","selInt","cellIdx","closest","rowObj","__row_selector","hash","thatIdx","loopRow","loopCells","newRows","modRows","idFn","ids","_detailsShow","childRows","loaded","every","__details_state","__details_remove","_details","__details_display","__details_events","namespace","drawEvent","colvisEvent","destroyEvent","off","_child_mth","_child_obj","klass","addRow","created","colSpan","__details_add","__re_column_selector","__columnData","r1","r2","names","visColumns","jqResult","__column_selector","calc","__setColumnVis","rowSelector","columnSelector","allCells","fnSelector","__cell_selector","internalOpts","cellsNoOpts","selected","caseInsen","versionCheck","version","iThis","iThat","aThis","aThat","isDataTable","fnIsDataTable","is","head","foot","fnTables","camelToHungarian","jqRows","jqTable","jqTbody","jqWrapper","orig","removedMethod","sDestroyWidth","arg1","arg2","arg3","arg4","token","plural","resolved","toFormat","JSON","parse","sessionStorage","localStorage","getItem","location","pathname","setItem","stringify","paginate","min","builder","pageButton","oJUIClasses","sVersion","afnFiltering","aTypes","ofnSearch","oSort","afnSortData","oStdClasses","oPagination","extPagination","_numbers","numbers","numbers_length","half","DT_el","simple","full","simple_numbers","full_numbers","first_last_numbers","btnDisplay","btnClass","activeEl","oPaginate","aria","counter","attach","container","button","tabIndex","disabledClass","sPageButtonDisabled","clickHandler","sFirst","sPrevious","sNext","sLast","sPageButtonActive","sPageButton","empty","parsed","string","__numericReplace","decimalPlace","re1","re2","ts","sSortAsc","sSortDesc","jqueryui","sSortJUIWrapper","sSortIcon","sSortJUIAsc","sSortJUIDesc","__htmlEscapeEntities","__mld","dt","momentFn","luxonFn","dateFn","moment","luxon","__mlWarning","__mldObj","format","locale","utc","isValid","DateTime","fromFormat","fromISO","setLocale","__mlHelper","localeString","from","to","typeName","valueOf","local","UTC","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","__thousands","__decimal","Intl","NumberFormat","formatToParts","datetime","render","date","number","thousands","precision","prefix","postfix","negative","flo","toFixed","abs","intPart","floatPart","text","_fnNodeToDataIndex","_fnNodeToColumnIndex","_fnCalculateEnd","dataTableSettings","dataTableExt"],"sourceRoot":""}