{"version":3,"file":"6448.907cad0ff213036036a9.js","mappings":"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","sources":["webpack://shipley-du-lib/./node_modules/datatables.net-bs/js/dataTables.bootstrap.js","webpack://shipley-du-lib/./node_modules/datatables.net-buttons-bs/js/buttons.bootstrap.js","webpack://shipley-du-lib/./node_modules/datatables.net-buttons/js/buttons.html5.js","webpack://shipley-du-lib/./node_modules/datatables.net-buttons/js/buttons.print.js","webpack://shipley-du-lib/./node_modules/datatables.net-buttons/js/dataTables.buttons.js","webpack://shipley-du-lib/./node_modules/datatables.net-responsive-bs/js/responsive.bootstrap.js","webpack://shipley-du-lib/./node_modules/datatables.net-responsive/js/dataTables.responsive.js","webpack://shipley-du-lib/./node_modules/datatables.net/js/jquery.dataTables.js"],"sourcesContent":["/*! DataTables Bootstrap 3 integration\n * ©2011-2015 SpryMedia Ltd - datatables.net/license\n */\n\n/**\n * DataTables integration for Bootstrap 3. This requires Bootstrap 3 and\n * DataTables 1.10 or newer.\n *\n * This file sets the defaults and adds options to DataTables to style its\n * controls using Bootstrap. See http://datatables.net/manual/styling/bootstrap\n * for further information.\n */\n(function( factory ){\n\tif ( typeof define === 'function' && define.amd ) {\n\t\t// AMD\n\t\tdefine( ['jquery', 'datatables.net'], 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\troot = window;\n\t\t\t}\n\n\t\t\tif ( ! $ || ! $.fn.dataTable ) {\n\t\t\t\t// Require DataTables, which attaches to jQuery, including\n\t\t\t\t// jQuery if needed and have a $ property so we can access the\n\t\t\t\t// jQuery object that is used\n\t\t\t\t$ = require('datatables.net')(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\tfactory( jQuery, window, document );\n\t}\n}(function( $, window, document, undefined ) {\n'use strict';\nvar DataTable = $.fn.dataTable;\n\n\n/* Set the defaults for DataTables initialisation */\n$.extend( true, DataTable.defaults, {\n\tdom:\n\t\t\"<'row'<'col-sm-6'l><'col-sm-6'f>>\" +\n\t\t\"<'row'<'col-sm-12'tr>>\" +\n\t\t\"<'row'<'col-sm-5'i><'col-sm-7'p>>\",\n\trenderer: 'bootstrap'\n} );\n\n\n/* Default class modification */\n$.extend( DataTable.ext.classes, {\n\tsWrapper:      \"dataTables_wrapper form-inline dt-bootstrap\",\n\tsFilterInput:  \"form-control input-sm\",\n\tsLengthSelect: \"form-control input-sm\",\n\tsProcessing:   \"dataTables_processing panel panel-default\"\n} );\n\n\n/* Bootstrap paging button renderer */\nDataTable.ext.renderer.pageButton.bootstrap = function ( settings, host, idx, buttons, page, pages ) {\n\tvar api     = new DataTable.Api( settings );\n\tvar classes = settings.oClasses;\n\tvar lang    = settings.oLanguage.oPaginate;\n\tvar aria = settings.oLanguage.oAria.paginate || {};\n\tvar btnDisplay, btnClass, counter=0;\n\n\tvar attach = function( container, buttons ) {\n\t\tvar i, ien, node, button;\n\t\tvar clickHandler = function ( e ) {\n\t\t\te.preventDefault();\n\t\t\tif ( !$(e.currentTarget).hasClass('disabled') && api.page() != e.data.action ) {\n\t\t\t\tapi.page( e.data.action ).draw( 'page' );\n\t\t\t}\n\t\t};\n\n\t\tfor ( i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\tbutton = buttons[i];\n\n\t\t\tif ( $.isArray( button ) ) {\n\t\t\t\tattach( container, button );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tbtnDisplay = '';\n\t\t\t\tbtnClass = '';\n\n\t\t\t\tswitch ( button ) {\n\t\t\t\t\tcase 'ellipsis':\n\t\t\t\t\t\tbtnDisplay = '&#x2026;';\n\t\t\t\t\t\tbtnClass = 'disabled';\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'first':\n\t\t\t\t\t\tbtnDisplay = lang.sFirst;\n\t\t\t\t\t\tbtnClass = button + (page > 0 ?\n\t\t\t\t\t\t\t'' : ' disabled');\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'previous':\n\t\t\t\t\t\tbtnDisplay = lang.sPrevious;\n\t\t\t\t\t\tbtnClass = button + (page > 0 ?\n\t\t\t\t\t\t\t'' : ' disabled');\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'next':\n\t\t\t\t\t\tbtnDisplay = lang.sNext;\n\t\t\t\t\t\tbtnClass = button + (page < pages-1 ?\n\t\t\t\t\t\t\t'' : ' disabled');\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase 'last':\n\t\t\t\t\t\tbtnDisplay = lang.sLast;\n\t\t\t\t\t\tbtnClass = button + (page < pages-1 ?\n\t\t\t\t\t\t\t'' : ' disabled');\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tbtnDisplay = button + 1;\n\t\t\t\t\t\tbtnClass = page === button ?\n\t\t\t\t\t\t\t'active' : '';\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tif ( btnDisplay ) {\n\t\t\t\t\tnode = $('<li>', {\n\t\t\t\t\t\t\t'class': classes.sPageButton+' '+btnClass,\n\t\t\t\t\t\t\t'id': idx === 0 && typeof button === 'string' ?\n\t\t\t\t\t\t\t\tsettings.sTableId +'_'+ button :\n\t\t\t\t\t\t\t\tnull\n\t\t\t\t\t\t} )\n\t\t\t\t\t\t.append( $('<a>', {\n\t\t\t\t\t\t\t\t'href': '#',\n\t\t\t\t\t\t\t\t'aria-controls': settings.sTableId,\n\t\t\t\t\t\t\t\t'aria-label': aria[ button ],\n\t\t\t\t\t\t\t\t'data-dt-idx': counter,\n\t\t\t\t\t\t\t\t'tabindex': settings.iTabIndex\n\t\t\t\t\t\t\t} )\n\t\t\t\t\t\t\t.html( btnDisplay )\n\t\t\t\t\t\t)\n\t\t\t\t\t\t.appendTo( container );\n\n\t\t\t\t\tsettings.oApi._fnBindAction(\n\t\t\t\t\t\tnode, {action: button}, clickHandler\n\t\t\t\t\t);\n\n\t\t\t\t\tcounter++;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\t// IE9 throws an 'unknown error' if document.activeElement is used\n\t// inside an iframe or frame. \n\tvar activeEl;\n\n\ttry {\n\t\t// Because this approach is destroying and recreating the paging\n\t\t// elements, focus is lost on the select button which is bad for\n\t\t// accessibility. So we want to restore focus once the draw has\n\t\t// completed\n\t\tactiveEl = $(host).find(document.activeElement).data('dt-idx');\n\t}\n\tcatch (e) {}\n\n\tattach(\n\t\t$(host).empty().html('<ul class=\"pagination\"/>').children('ul'),\n\t\tbuttons\n\t);\n\n\tif ( activeEl !== undefined ) {\n\t\t$(host).find( '[data-dt-idx='+activeEl+']' ).focus();\n\t}\n};\n\n\nreturn DataTable;\n}));\n","/*! Bootstrap integration for DataTables' Buttons\n * ©2016 SpryMedia Ltd - datatables.net/license\n */\n\n(function( factory ){\n\tif ( typeof define === 'function' && define.amd ) {\n\t\t// AMD\n\t\tdefine( ['jquery', 'datatables.net-bs', 'datatables.net-buttons'], 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\troot = window;\n\t\t\t}\n\n\t\t\tif ( ! $ || ! $.fn.dataTable ) {\n\t\t\t\t$ = require('datatables.net-bs')(root, $).$;\n\t\t\t}\n\n\t\t\tif ( ! $.fn.dataTable.Buttons ) {\n\t\t\t\trequire('datatables.net-buttons')(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\tfactory( jQuery, window, document );\n\t}\n}(function( $, window, document, undefined ) {\n'use strict';\nvar DataTable = $.fn.dataTable;\n\n\n$.extend( true, DataTable.Buttons.defaults, {\n\tdom: {\n\t\tcontainer: {\n\t\t\tclassName: 'dt-buttons btn-group'\n\t\t},\n\t\tbutton: {\n\t\t\tclassName: 'btn btn-default'\n\t\t},\n\t\tcollection: {\n\t\t\ttag: 'ul',\n\t\t\tclassName: 'dt-button-collection dropdown-menu',\n\t\t\tbutton: {\n\t\t\t\ttag: 'li',\n\t\t\t\tclassName: 'dt-button',\n\t\t\t\tactive: 'active',\n\t\t\t\tdisabled: 'disabled'\n\t\t\t},\n\t\t\tbuttonLiner: {\n\t\t\t\ttag: 'a',\n\t\t\t\tclassName: ''\n\t\t\t}\n\t\t}\n\t}\n} );\n\nDataTable.ext.buttons.collection.text = function ( dt ) {\n\treturn dt.i18n('buttons.collection', 'Collection <span class=\"caret\"/>');\n};\n\n\nreturn DataTable.Buttons;\n}));\n","/*!\n * HTML5 export buttons for Buttons and DataTables.\n * 2016 SpryMedia Ltd - datatables.net/license\n *\n * FileSaver.js (1.3.3) - MIT license\n * Copyright © 2016 Eli Grey - http://eligrey.com\n */\n\n(function( factory ){\n\tif ( typeof define === 'function' && define.amd ) {\n\t\t// AMD\n\t\tdefine( ['jquery', 'datatables.net', 'datatables.net-buttons'], 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, $, jszip, pdfmake) {\n\t\t\tif ( ! root ) {\n\t\t\t\troot = window;\n\t\t\t}\n\n\t\t\tif ( ! $ || ! $.fn.dataTable ) {\n\t\t\t\t$ = require('datatables.net')(root, $).$;\n\t\t\t}\n\n\t\t\tif ( ! $.fn.dataTable.Buttons ) {\n\t\t\t\trequire('datatables.net-buttons')(root, $);\n\t\t\t}\n\n\t\t\treturn factory( $, root, root.document, jszip, pdfmake );\n\t\t};\n\t}\n\telse {\n\t\t// Browser\n\t\tfactory( jQuery, window, document );\n\t}\n}(function( $, window, document, jszip, pdfmake, undefined ) {\n'use strict';\nvar DataTable = $.fn.dataTable;\n\n// Allow the constructor to pass in JSZip and PDFMake from external requires.\n// Otherwise, use globally defined variables, if they are available.\nfunction _jsZip () {\n\treturn jszip || window.JSZip;\n}\nfunction _pdfMake () {\n\treturn pdfmake || window.pdfMake;\n}\n\n\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * FileSaver.js dependency\n */\n\n/*jslint bitwise: true, indent: 4, laxbreak: true, laxcomma: true, smarttabs: true, plusplus: true */\n\nvar _saveAs = (function(view) {\n\t\"use strict\";\n\t// IE <10 is explicitly unsupported\n\tif (typeof view === \"undefined\" || typeof navigator !== \"undefined\" && /MSIE [1-9]\\./.test(navigator.userAgent)) {\n\t\treturn;\n\t}\n\tvar\n\t\t  doc = view.document\n\t\t  // only get URL when necessary in case Blob.js hasn't overridden it yet\n\t\t, get_URL = function() {\n\t\t\treturn view.URL || view.webkitURL || view;\n\t\t}\n\t\t, save_link = doc.createElementNS(\"http://www.w3.org/1999/xhtml\", \"a\")\n\t\t, can_use_save_link = \"download\" in save_link\n\t\t, click = function(node) {\n\t\t\tvar event = new MouseEvent(\"click\");\n\t\t\tnode.dispatchEvent(event);\n\t\t}\n\t\t, is_safari = /constructor/i.test(view.HTMLElement) || view.safari\n\t\t, is_chrome_ios =/CriOS\\/[\\d]+/.test(navigator.userAgent)\n\t\t, throw_outside = function(ex) {\n\t\t\t(view.setImmediate || view.setTimeout)(function() {\n\t\t\t\tthrow ex;\n\t\t\t}, 0);\n\t\t}\n\t\t, force_saveable_type = \"application/octet-stream\"\n\t\t// the Blob API is fundamentally broken as there is no \"downloadfinished\" event to subscribe to\n\t\t, arbitrary_revoke_timeout = 1000 * 40 // in ms\n\t\t, revoke = function(file) {\n\t\t\tvar revoker = function() {\n\t\t\t\tif (typeof file === \"string\") { // file is an object URL\n\t\t\t\t\tget_URL().revokeObjectURL(file);\n\t\t\t\t} else { // file is a File\n\t\t\t\t\tfile.remove();\n\t\t\t\t}\n\t\t\t};\n\t\t\tsetTimeout(revoker, arbitrary_revoke_timeout);\n\t\t}\n\t\t, dispatch = function(filesaver, event_types, event) {\n\t\t\tevent_types = [].concat(event_types);\n\t\t\tvar i = event_types.length;\n\t\t\twhile (i--) {\n\t\t\t\tvar listener = filesaver[\"on\" + event_types[i]];\n\t\t\t\tif (typeof listener === \"function\") {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tlistener.call(filesaver, event || filesaver);\n\t\t\t\t\t} catch (ex) {\n\t\t\t\t\t\tthrow_outside(ex);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t, auto_bom = function(blob) {\n\t\t\t// prepend BOM for UTF-8 XML and text/* types (including HTML)\n\t\t\t// note: your browser will automatically convert UTF-16 U+FEFF to EF BB BF\n\t\t\tif (/^\\s*(?:text\\/\\S*|application\\/xml|\\S*\\/\\S*\\+xml)\\s*;.*charset\\s*=\\s*utf-8/i.test(blob.type)) {\n\t\t\t\treturn new Blob([String.fromCharCode(0xFEFF), blob], {type: blob.type});\n\t\t\t}\n\t\t\treturn blob;\n\t\t}\n\t\t, FileSaver = function(blob, name, no_auto_bom) {\n\t\t\tif (!no_auto_bom) {\n\t\t\t\tblob = auto_bom(blob);\n\t\t\t}\n\t\t\t// First try a.download, then web filesystem, then object URLs\n\t\t\tvar\n\t\t\t\t  filesaver = this\n\t\t\t\t, type = blob.type\n\t\t\t\t, force = type === force_saveable_type\n\t\t\t\t, object_url\n\t\t\t\t, dispatch_all = function() {\n\t\t\t\t\tdispatch(filesaver, \"writestart progress write writeend\".split(\" \"));\n\t\t\t\t}\n\t\t\t\t// on any filesys errors revert to saving with object URLs\n\t\t\t\t, fs_error = function() {\n\t\t\t\t\tif ((is_chrome_ios || (force && is_safari)) && view.FileReader) {\n\t\t\t\t\t\t// Safari doesn't allow downloading of blob urls\n\t\t\t\t\t\tvar reader = new FileReader();\n\t\t\t\t\t\treader.onloadend = function() {\n\t\t\t\t\t\t\tvar url = is_chrome_ios ? reader.result : reader.result.replace(/^data:[^;]*;/, 'data:attachment/file;');\n\t\t\t\t\t\t\tvar popup = view.open(url, '_blank');\n\t\t\t\t\t\t\tif(!popup) view.location.href = url;\n\t\t\t\t\t\t\turl=undefined; // release reference before dispatching\n\t\t\t\t\t\t\tfilesaver.readyState = filesaver.DONE;\n\t\t\t\t\t\t\tdispatch_all();\n\t\t\t\t\t\t};\n\t\t\t\t\t\treader.readAsDataURL(blob);\n\t\t\t\t\t\tfilesaver.readyState = filesaver.INIT;\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\t// don't create more object URLs than needed\n\t\t\t\t\tif (!object_url) {\n\t\t\t\t\t\tobject_url = get_URL().createObjectURL(blob);\n\t\t\t\t\t}\n\t\t\t\t\tif (force) {\n\t\t\t\t\t\tview.location.href = object_url;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tvar opened = view.open(object_url, \"_blank\");\n\t\t\t\t\t\tif (!opened) {\n\t\t\t\t\t\t\t// Apple does not allow window.open, see https://developer.apple.com/library/safari/documentation/Tools/Conceptual/SafariExtensionGuide/WorkingwithWindowsandTabs/WorkingwithWindowsandTabs.html\n\t\t\t\t\t\t\tview.location.href = object_url;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tfilesaver.readyState = filesaver.DONE;\n\t\t\t\t\tdispatch_all();\n\t\t\t\t\trevoke(object_url);\n\t\t\t\t}\n\t\t\t;\n\t\t\tfilesaver.readyState = filesaver.INIT;\n\n\t\t\tif (can_use_save_link) {\n\t\t\t\tobject_url = get_URL().createObjectURL(blob);\n\t\t\t\tsetTimeout(function() {\n\t\t\t\t\tsave_link.href = object_url;\n\t\t\t\t\tsave_link.download = name;\n\t\t\t\t\tclick(save_link);\n\t\t\t\t\tdispatch_all();\n\t\t\t\t\trevoke(object_url);\n\t\t\t\t\tfilesaver.readyState = filesaver.DONE;\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tfs_error();\n\t\t}\n\t\t, FS_proto = FileSaver.prototype\n\t\t, saveAs = function(blob, name, no_auto_bom) {\n\t\t\treturn new FileSaver(blob, name || blob.name || \"download\", no_auto_bom);\n\t\t}\n\t;\n\t// IE 10+ (native saveAs)\n\tif (typeof navigator !== \"undefined\" && navigator.msSaveOrOpenBlob) {\n\t\treturn function(blob, name, no_auto_bom) {\n\t\t\tname = name || blob.name || \"download\";\n\n\t\t\tif (!no_auto_bom) {\n\t\t\t\tblob = auto_bom(blob);\n\t\t\t}\n\t\t\treturn navigator.msSaveOrOpenBlob(blob, name);\n\t\t};\n\t}\n\n\tFS_proto.abort = function(){};\n\tFS_proto.readyState = FS_proto.INIT = 0;\n\tFS_proto.WRITING = 1;\n\tFS_proto.DONE = 2;\n\n\tFS_proto.error =\n\tFS_proto.onwritestart =\n\tFS_proto.onprogress =\n\tFS_proto.onwrite =\n\tFS_proto.onabort =\n\tFS_proto.onerror =\n\tFS_proto.onwriteend =\n\t\tnull;\n\n\treturn saveAs;\n}(\n\t   typeof self !== \"undefined\" && self\n\t|| typeof window !== \"undefined\" && window\n\t|| this.content\n));\n\n\n// Expose file saver on the DataTables API. Can't attach to `DataTables.Buttons`\n// since this file can be loaded before Button's core!\nDataTable.fileSave = _saveAs;\n\n\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * Local (private) functions\n */\n\n/**\n * Get the sheet name for Excel exports.\n *\n * @param {object}\tconfig Button configuration\n */\nvar _sheetname = function ( config )\n{\n\tvar sheetName = 'Sheet1';\n\n\tif ( config.sheetName ) {\n\t\tsheetName = config.sheetName.replace(/[\\[\\]\\*\\/\\\\\\?\\:]/g, '');\n\t}\n\n\treturn sheetName;\n};\n\n/**\n * Get the newline character(s)\n *\n * @param {object}\tconfig Button configuration\n * @return {string}\t\t\t\tNewline character\n */\nvar _newLine = function ( config )\n{\n\treturn config.newline ?\n\t\tconfig.newline :\n\t\tnavigator.userAgent.match(/Windows/) ?\n\t\t\t'\\r\\n' :\n\t\t\t'\\n';\n};\n\n/**\n * Combine the data from the `buttons.exportData` method into a string that\n * will be used in the export file.\n *\n * @param\t{DataTable.Api} dt\t\t DataTables API instance\n * @param\t{object}\t\t\t\tconfig Button configuration\n * @return {object}\t\t\t\t\t\t\t The data to export\n */\nvar _exportData = function ( dt, config )\n{\n\tvar newLine = _newLine( config );\n\tvar data = dt.buttons.exportData( config.exportOptions );\n\tvar boundary = config.fieldBoundary;\n\tvar separator = config.fieldSeparator;\n\tvar reBoundary = new RegExp( boundary, 'g' );\n\tvar escapeChar = config.escapeChar !== undefined ?\n\t\tconfig.escapeChar :\n\t\t'\\\\';\n\tvar join = function ( a ) {\n\t\tvar s = '';\n\n\t\t// If there is a field boundary, then we might need to escape it in\n\t\t// the source data\n\t\tfor ( var i=0, ien=a.length ; i<ien ; i++ ) {\n\t\t\tif ( i > 0 ) {\n\t\t\t\ts += separator;\n\t\t\t}\n\n\t\t\ts += boundary ?\n\t\t\t\tboundary + ('' + a[i]).replace( reBoundary, escapeChar+boundary ) + boundary :\n\t\t\t\ta[i];\n\t\t}\n\n\t\treturn s;\n\t};\n\n\tvar header = config.header ? join( data.header )+newLine : '';\n\tvar footer = config.footer && data.footer ? newLine+join( data.footer ) : '';\n\tvar body = [];\n\n\tfor ( var i=0, ien=data.body.length ; i<ien ; i++ ) {\n\t\tbody.push( join( data.body[i] ) );\n\t}\n\n\treturn {\n\t\tstr: header + body.join( newLine ) + footer,\n\t\trows: body.length\n\t};\n};\n\n/**\n * Older versions of Safari (prior to tech preview 18) don't support the\n * download option required.\n *\n * @return {Boolean} `true` if old Safari\n */\nvar _isDuffSafari = function ()\n{\n\tvar safari = navigator.userAgent.indexOf('Safari') !== -1 &&\n\t\tnavigator.userAgent.indexOf('Chrome') === -1 &&\n\t\tnavigator.userAgent.indexOf('Opera') === -1;\n\n\tif ( ! safari ) {\n\t\treturn false;\n\t}\n\n\tvar version = navigator.userAgent.match( /AppleWebKit\\/(\\d+\\.\\d+)/ );\n\tif ( version && version.length > 1 && version[1]*1 < 603.1 ) {\n\t\treturn true;\n\t}\n\n\treturn false;\n};\n\n/**\n * Convert from numeric position to letter for column names in Excel\n * @param  {int} n Column number\n * @return {string} Column letter(s) name\n */\nfunction createCellPos( n ){\n\tvar ordA = 'A'.charCodeAt(0);\n\tvar ordZ = 'Z'.charCodeAt(0);\n\tvar len = ordZ - ordA + 1;\n\tvar s = \"\";\n\n\twhile( n >= 0 ) {\n\t\ts = String.fromCharCode(n % len + ordA) + s;\n\t\tn = Math.floor(n / len) - 1;\n\t}\n\n\treturn s;\n}\n\ntry {\n\tvar _serialiser = new XMLSerializer();\n\tvar _ieExcel;\n}\ncatch (t) {}\n\n/**\n * Recursively add XML files from an object's structure to a ZIP file. This\n * allows the XSLX file to be easily defined with an object's structure matching\n * the files structure.\n *\n * @param {JSZip} zip ZIP package\n * @param {object} obj Object to add (recursive)\n */\nfunction _addToZip( zip, obj ) {\n\tif ( _ieExcel === undefined ) {\n\t\t// Detect if we are dealing with IE's _awful_ serialiser by seeing if it\n\t\t// drop attributes\n\t\t_ieExcel = _serialiser\n\t\t\t.serializeToString(\n\t\t\t\t$.parseXML( excelStrings['xl/worksheets/sheet1.xml'] )\n\t\t\t)\n\t\t\t.indexOf( 'xmlns:r' ) === -1;\n\t}\n\n\t$.each( obj, function ( name, val ) {\n\t\tif ( $.isPlainObject( val ) ) {\n\t\t\tvar newDir = zip.folder( name );\n\t\t\t_addToZip( newDir, val );\n\t\t}\n\t\telse {\n\t\t\tif ( _ieExcel ) {\n\t\t\t\t// IE's XML serialiser will drop some name space attributes from\n\t\t\t\t// from the root node, so we need to save them. Do this by\n\t\t\t\t// replacing the namespace nodes with a regular attribute that\n\t\t\t\t// we convert back when serialised. Edge does not have this\n\t\t\t\t// issue\n\t\t\t\tvar worksheet = val.childNodes[0];\n\t\t\t\tvar i, ien;\n\t\t\t\tvar attrs = [];\n\n\t\t\t\tfor ( i=worksheet.attributes.length-1 ; i>=0 ; i-- ) {\n\t\t\t\t\tvar attrName = worksheet.attributes[i].nodeName;\n\t\t\t\t\tvar attrValue = worksheet.attributes[i].nodeValue;\n\n\t\t\t\t\tif ( attrName.indexOf( ':' ) !== -1 ) {\n\t\t\t\t\t\tattrs.push( { name: attrName, value: attrValue } );\n\n\t\t\t\t\t\tworksheet.removeAttribute( attrName );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tfor ( i=0, ien=attrs.length ; i<ien ; i++ ) {\n\t\t\t\t\tvar attr = val.createAttribute( attrs[i].name.replace( ':', '_dt_b_namespace_token_' ) );\n\t\t\t\t\tattr.value = attrs[i].value;\n\t\t\t\t\tworksheet.setAttributeNode( attr );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar str = _serialiser.serializeToString(val);\n\n\t\t\t// Fix IE's XML\n\t\t\tif ( _ieExcel ) {\n\t\t\t\t// IE doesn't include the XML declaration\n\t\t\t\tif ( str.indexOf( '<?xml' ) === -1 ) {\n\t\t\t\t\tstr = '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>'+str;\n\t\t\t\t}\n\n\t\t\t\t// Return namespace attributes to being as such\n\t\t\t\tstr = str.replace( /_dt_b_namespace_token_/g, ':' );\n\t\t\t}\n\n\t\t\t// Safari, IE and Edge will put empty name space attributes onto\n\t\t\t// various elements making them useless. This strips them out\n\t\t\tstr = str.replace( /<([^<>]*?) xmlns=\"\"([^<>]*?)>/g, '<$1 $2>' );\n\n\t\t\tzip.file( name, str );\n\t\t}\n\t} );\n}\n\n/**\n * Create an XML node and add any children, attributes, etc without needing to\n * be verbose in the DOM.\n *\n * @param  {object} doc      XML document\n * @param  {string} nodeName Node name\n * @param  {object} opts     Options - can be `attr` (attributes), `children`\n *   (child nodes) and `text` (text content)\n * @return {node}            Created node\n */\nfunction _createNode( doc, nodeName, opts ) {\n\tvar tempNode = doc.createElement( nodeName );\n\n\tif ( opts ) {\n\t\tif ( opts.attr ) {\n\t\t\t$(tempNode).attr( opts.attr );\n\t\t}\n\n\t\tif ( opts.children ) {\n\t\t\t$.each( opts.children, function ( key, value ) {\n\t\t\t\ttempNode.appendChild( value );\n\t\t\t} );\n\t\t}\n\n\t\tif ( opts.text !== null && opts.text !== undefined ) {\n\t\t\ttempNode.appendChild( doc.createTextNode( opts.text ) );\n\t\t}\n\t}\n\n\treturn tempNode;\n}\n\n/**\n * Get the width for an Excel column based on the contents of that column\n * @param  {object} data Data for export\n * @param  {int}    col  Column index\n * @return {int}         Column width\n */\nfunction _excelColWidth( data, col ) {\n\tvar max = data.header[col].length;\n\tvar len, lineSplit, str;\n\n\tif ( data.footer && data.footer[col].length > max ) {\n\t\tmax = data.footer[col].length;\n\t}\n\n\tfor ( var i=0, ien=data.body.length ; i<ien ; i++ ) {\n\t\tvar point = data.body[i][col];\n\t\tstr = point !== null && point !== undefined ?\n\t\t\tpoint.toString() :\n\t\t\t'';\n\n\t\t// If there is a newline character, workout the width of the column\n\t\t// based on the longest line in the string\n\t\tif ( str.indexOf('\\n') !== -1 ) {\n\t\t\tlineSplit = str.split('\\n');\n\t\t\tlineSplit.sort( function (a, b) {\n\t\t\t\treturn b.length - a.length;\n\t\t\t} );\n\n\t\t\tlen = lineSplit[0].length;\n\t\t}\n\t\telse {\n\t\t\tlen = str.length;\n\t\t}\n\n\t\tif ( len > max ) {\n\t\t\tmax = len;\n\t\t}\n\n\t\t// Max width rather than having potentially massive column widths\n\t\tif ( max > 40 ) {\n\t\t\treturn 52; // 40 * 1.3\n\t\t}\n\t}\n\n\tmax *= 1.3;\n\n\t// And a min width\n\treturn max > 6 ? max : 6;\n}\n\n// Excel - Pre-defined strings to build a basic XLSX file\nvar excelStrings = {\n\t\"_rels/.rels\":\n\t\t'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>'+\n\t\t'<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">'+\n\t\t\t'<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"xl/workbook.xml\"/>'+\n\t\t'</Relationships>',\n\n\t\"xl/_rels/workbook.xml.rels\":\n\t\t'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>'+\n\t\t'<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">'+\n\t\t\t'<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet1.xml\"/>'+\n\t\t\t'<Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles\" Target=\"styles.xml\"/>'+\n\t\t'</Relationships>',\n\n\t\"[Content_Types].xml\":\n\t\t'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>'+\n\t\t'<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">'+\n\t\t\t'<Default Extension=\"xml\" ContentType=\"application/xml\" />'+\n\t\t\t'<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\" />'+\n\t\t\t'<Default Extension=\"jpeg\" ContentType=\"image/jpeg\" />'+\n\t\t\t'<Override PartName=\"/xl/workbook.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml\" />'+\n\t\t\t'<Override PartName=\"/xl/worksheets/sheet1.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml\" />'+\n\t\t\t'<Override PartName=\"/xl/styles.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml\" />'+\n\t\t'</Types>',\n\n\t\"xl/workbook.xml\":\n\t\t'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>'+\n\t\t'<workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">'+\n\t\t\t'<fileVersion appName=\"xl\" lastEdited=\"5\" lowestEdited=\"5\" rupBuild=\"24816\"/>'+\n\t\t\t'<workbookPr showInkAnnotation=\"0\" autoCompressPictures=\"0\"/>'+\n\t\t\t'<bookViews>'+\n\t\t\t\t'<workbookView xWindow=\"0\" yWindow=\"0\" windowWidth=\"25600\" windowHeight=\"19020\" tabRatio=\"500\"/>'+\n\t\t\t'</bookViews>'+\n\t\t\t'<sheets>'+\n\t\t\t\t'<sheet name=\"\" sheetId=\"1\" r:id=\"rId1\"/>'+\n\t\t\t'</sheets>'+\n\t\t'</workbook>',\n\n\t\"xl/worksheets/sheet1.xml\":\n\t\t'<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>'+\n\t\t'<worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" mc:Ignorable=\"x14ac\" xmlns:x14ac=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac\">'+\n\t\t\t'<sheetData/>'+\n\t\t\t'<mergeCells count=\"0\"/>'+\n\t\t'</worksheet>',\n\n\t\"xl/styles.xml\":\n\t\t'<?xml version=\"1.0\" encoding=\"UTF-8\"?>'+\n\t\t'<styleSheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" mc:Ignorable=\"x14ac\" xmlns:x14ac=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac\">'+\n\t\t\t'<numFmts count=\"6\">'+\n\t\t\t\t'<numFmt numFmtId=\"164\" formatCode=\"#,##0.00_-\\ [$$-45C]\"/>'+\n\t\t\t\t'<numFmt numFmtId=\"165\" formatCode=\"&quot;£&quot;#,##0.00\"/>'+\n\t\t\t\t'<numFmt numFmtId=\"166\" formatCode=\"[$€-2]\\ #,##0.00\"/>'+\n\t\t\t\t'<numFmt numFmtId=\"167\" formatCode=\"0.0%\"/>'+\n\t\t\t\t'<numFmt numFmtId=\"168\" formatCode=\"#,##0;(#,##0)\"/>'+\n\t\t\t\t'<numFmt numFmtId=\"169\" formatCode=\"#,##0.00;(#,##0.00)\"/>'+\n\t\t\t'</numFmts>'+\n\t\t\t'<fonts count=\"5\" x14ac:knownFonts=\"1\">'+\n\t\t\t\t'<font>'+\n\t\t\t\t\t'<sz val=\"11\" />'+\n\t\t\t\t\t'<name val=\"Calibri\" />'+\n\t\t\t\t'</font>'+\n\t\t\t\t'<font>'+\n\t\t\t\t\t'<sz val=\"11\" />'+\n\t\t\t\t\t'<name val=\"Calibri\" />'+\n\t\t\t\t\t'<color rgb=\"FFFFFFFF\" />'+\n\t\t\t\t'</font>'+\n\t\t\t\t'<font>'+\n\t\t\t\t\t'<sz val=\"11\" />'+\n\t\t\t\t\t'<name val=\"Calibri\" />'+\n\t\t\t\t\t'<b />'+\n\t\t\t\t'</font>'+\n\t\t\t\t'<font>'+\n\t\t\t\t\t'<sz val=\"11\" />'+\n\t\t\t\t\t'<name val=\"Calibri\" />'+\n\t\t\t\t\t'<i />'+\n\t\t\t\t'</font>'+\n\t\t\t\t'<font>'+\n\t\t\t\t\t'<sz val=\"11\" />'+\n\t\t\t\t\t'<name val=\"Calibri\" />'+\n\t\t\t\t\t'<u />'+\n\t\t\t\t'</font>'+\n\t\t\t'</fonts>'+\n\t\t\t'<fills count=\"6\">'+\n\t\t\t\t'<fill>'+\n\t\t\t\t\t'<patternFill patternType=\"none\" />'+\n\t\t\t\t'</fill>'+\n\t\t\t\t'<fill>'+ // Excel appears to use this as a dotted background regardless of values but\n\t\t\t\t\t'<patternFill patternType=\"none\" />'+ // to be valid to the schema, use a patternFill\n\t\t\t\t'</fill>'+\n\t\t\t\t'<fill>'+\n\t\t\t\t\t'<patternFill patternType=\"solid\">'+\n\t\t\t\t\t\t'<fgColor rgb=\"FFD9D9D9\" />'+\n\t\t\t\t\t\t'<bgColor indexed=\"64\" />'+\n\t\t\t\t\t'</patternFill>'+\n\t\t\t\t'</fill>'+\n\t\t\t\t'<fill>'+\n\t\t\t\t\t'<patternFill patternType=\"solid\">'+\n\t\t\t\t\t\t'<fgColor rgb=\"FFD99795\" />'+\n\t\t\t\t\t\t'<bgColor indexed=\"64\" />'+\n\t\t\t\t\t'</patternFill>'+\n\t\t\t\t'</fill>'+\n\t\t\t\t'<fill>'+\n\t\t\t\t\t'<patternFill patternType=\"solid\">'+\n\t\t\t\t\t\t'<fgColor rgb=\"ffc6efce\" />'+\n\t\t\t\t\t\t'<bgColor indexed=\"64\" />'+\n\t\t\t\t\t'</patternFill>'+\n\t\t\t\t'</fill>'+\n\t\t\t\t'<fill>'+\n\t\t\t\t\t'<patternFill patternType=\"solid\">'+\n\t\t\t\t\t\t'<fgColor rgb=\"ffc6cfef\" />'+\n\t\t\t\t\t\t'<bgColor indexed=\"64\" />'+\n\t\t\t\t\t'</patternFill>'+\n\t\t\t\t'</fill>'+\n\t\t\t'</fills>'+\n\t\t\t'<borders count=\"2\">'+\n\t\t\t\t'<border>'+\n\t\t\t\t\t'<left />'+\n\t\t\t\t\t'<right />'+\n\t\t\t\t\t'<top />'+\n\t\t\t\t\t'<bottom />'+\n\t\t\t\t\t'<diagonal />'+\n\t\t\t\t'</border>'+\n\t\t\t\t'<border diagonalUp=\"false\" diagonalDown=\"false\">'+\n\t\t\t\t\t'<left style=\"thin\">'+\n\t\t\t\t\t\t'<color auto=\"1\" />'+\n\t\t\t\t\t'</left>'+\n\t\t\t\t\t'<right style=\"thin\">'+\n\t\t\t\t\t\t'<color auto=\"1\" />'+\n\t\t\t\t\t'</right>'+\n\t\t\t\t\t'<top style=\"thin\">'+\n\t\t\t\t\t\t'<color auto=\"1\" />'+\n\t\t\t\t\t'</top>'+\n\t\t\t\t\t'<bottom style=\"thin\">'+\n\t\t\t\t\t\t'<color auto=\"1\" />'+\n\t\t\t\t\t'</bottom>'+\n\t\t\t\t\t'<diagonal />'+\n\t\t\t\t'</border>'+\n\t\t\t'</borders>'+\n\t\t\t'<cellStyleXfs count=\"1\">'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" />'+\n\t\t\t'</cellStyleXfs>'+\n\t\t\t'<cellXfs count=\"67\">'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"2\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"3\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"4\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"5\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"0\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"2\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"3\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"4\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"1\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"2\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"3\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"4\" fillId=\"5\" borderId=\"1\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\">'+\n\t\t\t\t\t'<alignment horizontal=\"left\"/>'+\n\t\t\t\t'</xf>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\">'+\n\t\t\t\t\t'<alignment horizontal=\"center\"/>'+\n\t\t\t\t'</xf>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\">'+\n\t\t\t\t\t'<alignment horizontal=\"right\"/>'+\n\t\t\t\t'</xf>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\">'+\n\t\t\t\t\t'<alignment horizontal=\"fill\"/>'+\n\t\t\t\t'</xf>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\">'+\n\t\t\t\t\t'<alignment textRotation=\"90\"/>'+\n\t\t\t\t'</xf>'+\n\t\t\t\t'<xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyAlignment=\"1\">'+\n\t\t\t\t\t'<alignment wrapText=\"1\"/>'+\n\t\t\t\t'</xf>'+\n\t\t\t\t'<xf numFmtId=\"9\"   fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"164\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"165\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"166\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"167\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"168\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"169\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"3\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"4\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"1\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t\t'<xf numFmtId=\"2\" fontId=\"0\" fillId=\"0\" borderId=\"0\" applyFont=\"1\" applyFill=\"1\" applyBorder=\"1\" xfId=\"0\" applyNumberFormat=\"1\"/>'+\n\t\t\t'</cellXfs>'+\n\t\t\t'<cellStyles count=\"1\">'+\n\t\t\t\t'<cellStyle name=\"Normal\" xfId=\"0\" builtinId=\"0\" />'+\n\t\t\t'</cellStyles>'+\n\t\t\t'<dxfs count=\"0\" />'+\n\t\t\t'<tableStyles count=\"0\" defaultTableStyle=\"TableStyleMedium9\" defaultPivotStyle=\"PivotStyleMedium4\" />'+\n\t\t'</styleSheet>'\n};\n// Note we could use 3 `for` loops for the styles, but when gzipped there is\n// virtually no difference in size, since the above can be easily compressed\n\n// Pattern matching for special number formats. Perhaps this should be exposed\n// via an API in future?\n// Ref: section 3.8.30 - built in formatters in open spreadsheet\n//   https://www.ecma-international.org/news/TC45_current_work/Office%20Open%20XML%20Part%204%20-%20Markup%20Language%20Reference.pdf\nvar _excelSpecials = [\n\t{ match: /^\\-?\\d+\\.\\d%$/,       style: 60, fmt: function (d) { return d/100; } }, // Precent with d.p.\n\t{ match: /^\\-?\\d+\\.?\\d*%$/,     style: 56, fmt: function (d) { return d/100; } }, // Percent\n\t{ match: /^\\-?\\$[\\d,]+.?\\d*$/,  style: 57 }, // Dollars\n\t{ match: /^\\-?£[\\d,]+.?\\d*$/,   style: 58 }, // Pounds\n\t{ match: /^\\-?€[\\d,]+.?\\d*$/,   style: 59 }, // Euros\n\t{ match: /^\\-?\\d+$/,            style: 65 }, // Numbers without thousand separators\n\t{ match: /^\\-?\\d+\\.\\d{2}$/,     style: 66 }, // Numbers 2 d.p. without thousands separators\n\t{ match: /^\\([\\d,]+\\)$/,        style: 61, fmt: function (d) { return -1 * d.replace(/[\\(\\)]/g, ''); } },  // Negative numbers indicated by brackets\n\t{ match: /^\\([\\d,]+\\.\\d{2}\\)$/, style: 62, fmt: function (d) { return -1 * d.replace(/[\\(\\)]/g, ''); } },  // Negative numbers indicated by brackets - 2d.p.\n\t{ match: /^\\-?[\\d,]+$/,         style: 63 }, // Numbers with thousand separators\n\t{ match: /^\\-?[\\d,]+\\.\\d{2}$/,  style: 64 }  // Numbers with 2 d.p. and thousands separators\n];\n\n\n\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * Buttons\n */\n\n//\n// Copy to clipboard\n//\nDataTable.ext.buttons.copyHtml5 = {\n\tclassName: 'buttons-copy buttons-html5',\n\n\ttext: function ( dt ) {\n\t\treturn dt.i18n( 'buttons.copy', 'Copy' );\n\t},\n\n\taction: function ( e, dt, button, config ) {\n\t\tthis.processing( true );\n\n\t\tvar that = this;\n\t\tvar exportData = _exportData( dt, config );\n\t\tvar info = dt.buttons.exportInfo( config );\n\t\tvar newline = _newLine(config);\n\t\tvar output = exportData.str;\n\t\tvar hiddenDiv = $('<div/>')\n\t\t\t.css( {\n\t\t\t\theight: 1,\n\t\t\t\twidth: 1,\n\t\t\t\toverflow: 'hidden',\n\t\t\t\tposition: 'fixed',\n\t\t\t\ttop: 0,\n\t\t\t\tleft: 0\n\t\t\t} );\n\n\t\tif ( info.title ) {\n\t\t\toutput = info.title + newline + newline + output;\n\t\t}\n\n\t\tif ( info.messageTop ) {\n\t\t\toutput = info.messageTop + newline + newline + output;\n\t\t}\n\n\t\tif ( info.messageBottom ) {\n\t\t\toutput = output + newline + newline + info.messageBottom;\n\t\t}\n\n\t\tif ( config.customize ) {\n\t\t\toutput = config.customize( output, config );\n\t\t}\n\n\t\tvar textarea = $('<textarea readonly/>')\n\t\t\t.val( output )\n\t\t\t.appendTo( hiddenDiv );\n\n\t\t// For browsers that support the copy execCommand, try to use it\n\t\tif ( document.queryCommandSupported('copy') ) {\n\t\t\thiddenDiv.appendTo( dt.table().container() );\n\t\t\ttextarea[0].focus();\n\t\t\ttextarea[0].select();\n\n\t\t\ttry {\n\t\t\t\tvar successful = document.execCommand( 'copy' );\n\t\t\t\thiddenDiv.remove();\n\n\t\t\t\tif (successful) {\n\t\t\t\t\tdt.buttons.info(\n\t\t\t\t\t\tdt.i18n( 'buttons.copyTitle', 'Copy to clipboard' ),\n\t\t\t\t\t\tdt.i18n( 'buttons.copySuccess', {\n\t\t\t\t\t\t\t1: 'Copied one row to clipboard',\n\t\t\t\t\t\t\t_: 'Copied %d rows to clipboard'\n\t\t\t\t\t\t}, exportData.rows ),\n\t\t\t\t\t\t2000\n\t\t\t\t\t);\n\n\t\t\t\t\tthis.processing( false );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\t\t\tcatch (t) {}\n\t\t}\n\n\t\t// Otherwise we show the text box and instruct the user to use it\n\t\tvar message = $('<span>'+dt.i18n( 'buttons.copyKeys',\n\t\t\t\t'Press <i>ctrl</i> or <i>\\u2318</i> + <i>C</i> to copy the table data<br>to your system clipboard.<br><br>'+\n\t\t\t\t'To cancel, click this message or press escape.' )+'</span>'\n\t\t\t)\n\t\t\t.append( hiddenDiv );\n\n\t\tdt.buttons.info( dt.i18n( 'buttons.copyTitle', 'Copy to clipboard' ), message, 0 );\n\n\t\t// Select the text so when the user activates their system clipboard\n\t\t// it will copy that text\n\t\ttextarea[0].focus();\n\t\ttextarea[0].select();\n\n\t\t// Event to hide the message when the user is done\n\t\tvar container = $(message).closest('.dt-button-info');\n\t\tvar close = function () {\n\t\t\tcontainer.off( 'click.buttons-copy' );\n\t\t\t$(document).off( '.buttons-copy' );\n\t\t\tdt.buttons.info( false );\n\t\t};\n\n\t\tcontainer.on( 'click.buttons-copy', close );\n\t\t$(document)\n\t\t\t.on( 'keydown.buttons-copy', function (e) {\n\t\t\t\tif ( e.keyCode === 27 ) { // esc\n\t\t\t\t\tclose();\n\t\t\t\t\tthat.processing( false );\n\t\t\t\t}\n\t\t\t} )\n\t\t\t.on( 'copy.buttons-copy cut.buttons-copy', function () {\n\t\t\t\tclose();\n\t\t\t\tthat.processing( false );\n\t\t\t} );\n\t},\n\n\texportOptions: {},\n\n\tfieldSeparator: '\\t',\n\n\tfieldBoundary: '',\n\n\theader: true,\n\n\tfooter: false,\n\n\ttitle: '*',\n\n\tmessageTop: '*',\n\n\tmessageBottom: '*'\n};\n\n//\n// CSV export\n//\nDataTable.ext.buttons.csvHtml5 = {\n\tbom: false,\n\n\tclassName: 'buttons-csv buttons-html5',\n\n\tavailable: function () {\n\t\treturn window.FileReader !== undefined && window.Blob;\n\t},\n\n\ttext: function ( dt ) {\n\t\treturn dt.i18n( 'buttons.csv', 'CSV' );\n\t},\n\n\taction: function ( e, dt, button, config ) {\n\t\tthis.processing( true );\n\n\t\t// Set the text\n\t\tvar output = _exportData( dt, config ).str;\n\t\tvar info = dt.buttons.exportInfo(config);\n\t\tvar charset = config.charset;\n\n\t\tif ( config.customize ) {\n\t\t\toutput = config.customize( output, config );\n\t\t}\n\n\t\tif ( charset !== false ) {\n\t\t\tif ( ! charset ) {\n\t\t\t\tcharset = document.characterSet || document.charset;\n\t\t\t}\n\n\t\t\tif ( charset ) {\n\t\t\t\tcharset = ';charset='+charset;\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tcharset = '';\n\t\t}\n\n\t\tif ( config.bom ) {\n\t\t\toutput = '\\ufeff' + output;\n\t\t}\n\n\t\t_saveAs(\n\t\t\tnew Blob( [output], {type: 'text/csv'+charset} ),\n\t\t\tinfo.filename,\n\t\t\ttrue\n\t\t);\n\n\t\tthis.processing( false );\n\t},\n\n\tfilename: '*',\n\n\textension: '.csv',\n\n\texportOptions: {},\n\n\tfieldSeparator: ',',\n\n\tfieldBoundary: '\"',\n\n\tescapeChar: '\"',\n\n\tcharset: null,\n\n\theader: true,\n\n\tfooter: false\n};\n\n//\n// Excel (xlsx) export\n//\nDataTable.ext.buttons.excelHtml5 = {\n\tclassName: 'buttons-excel buttons-html5',\n\n\tavailable: function () {\n\t\treturn window.FileReader !== undefined && _jsZip() !== undefined && ! _isDuffSafari() && _serialiser;\n\t},\n\n\ttext: function ( dt ) {\n\t\treturn dt.i18n( 'buttons.excel', 'Excel' );\n\t},\n\n\taction: function ( e, dt, button, config ) {\n\t\tthis.processing( true );\n\n\t\tvar that = this;\n\t\tvar rowPos = 0;\n\t\tvar getXml = function ( type ) {\n\t\t\tvar str = excelStrings[ type ];\n\n\t\t\t//str = str.replace( /xmlns:/g, 'xmlns_' ).replace( /mc:/g, 'mc_' );\n\n\t\t\treturn $.parseXML( str );\n\t\t};\n\t\tvar rels = getXml('xl/worksheets/sheet1.xml');\n\t\tvar relsGet = rels.getElementsByTagName( \"sheetData\" )[0];\n\n\t\tvar xlsx = {\n\t\t\t_rels: {\n\t\t\t\t\".rels\": getXml('_rels/.rels')\n\t\t\t},\n\t\t\txl: {\n\t\t\t\t_rels: {\n\t\t\t\t\t\"workbook.xml.rels\": getXml('xl/_rels/workbook.xml.rels')\n\t\t\t\t},\n\t\t\t\t\"workbook.xml\": getXml('xl/workbook.xml'),\n\t\t\t\t\"styles.xml\": getXml('xl/styles.xml'),\n\t\t\t\t\"worksheets\": {\n\t\t\t\t\t\"sheet1.xml\": rels\n\t\t\t\t}\n\n\t\t\t},\n\t\t\t\"[Content_Types].xml\": getXml('[Content_Types].xml')\n\t\t};\n\n\t\tvar data = dt.buttons.exportData( config.exportOptions );\n\t\tvar currentRow, rowNode;\n\t\tvar addRow = function ( row ) {\n\t\t\tcurrentRow = rowPos+1;\n\t\t\trowNode = _createNode( rels, \"row\", { attr: {r:currentRow} } );\n\n\t\t\tfor ( var i=0, ien=row.length ; i<ien ; i++ ) {\n\t\t\t\t// Concat both the Cell Columns as a letter and the Row of the cell.\n\t\t\t\tvar cellId = createCellPos(i) + '' + currentRow;\n\t\t\t\tvar cell = null;\n\n\t\t\t\t// For null, undefined of blank cell, continue so it doesn't create the _createNode\n\t\t\t\tif ( row[i] === null || row[i] === undefined || row[i] === '' ) {\n\t\t\t\t\tif ( config.createEmptyCells === true ) {\n\t\t\t\t\t\trow[i] = '';\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\trow[i] = $.trim( row[i] );\n\n\t\t\t\t// Special number formatting options\n\t\t\t\tfor ( var j=0, jen=_excelSpecials.length ; j<jen ; j++ ) {\n\t\t\t\t\tvar special = _excelSpecials[j];\n\n\t\t\t\t\t// TODO Need to provide the ability for the specials to say\n\t\t\t\t\t// if they are returning a string, since at the moment it is\n\t\t\t\t\t// assumed to be a number\n\t\t\t\t\tif ( row[i].match && ! row[i].match(/^0\\d+/) && row[i].match( special.match ) ) {\n\t\t\t\t\t\tvar val = row[i].replace(/[^\\d\\.\\-]/g, '');\n\n\t\t\t\t\t\tif ( special.fmt ) {\n\t\t\t\t\t\t\tval = special.fmt( val );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tcell = _createNode( rels, 'c', {\n\t\t\t\t\t\t\tattr: {\n\t\t\t\t\t\t\t\tr: cellId,\n\t\t\t\t\t\t\t\ts: special.style\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tchildren: [\n\t\t\t\t\t\t\t\t_createNode( rels, 'v', { text: val } )\n\t\t\t\t\t\t\t]\n\t\t\t\t\t\t} );\n\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tif ( ! cell ) {\n\t\t\t\t\tif ( typeof row[i] === 'number' || (\n\t\t\t\t\t\trow[i].match &&\n\t\t\t\t\t\trow[i].match(/^-?\\d+(\\.\\d+)?$/) &&\n\t\t\t\t\t\t! row[i].match(/^0\\d+/) )\n\t\t\t\t\t) {\n\t\t\t\t\t\t// Detect numbers - don't match numbers with leading zeros\n\t\t\t\t\t\t// or a negative anywhere but the start\n\t\t\t\t\t\tcell = _createNode( rels, 'c', {\n\t\t\t\t\t\t\tattr: {\n\t\t\t\t\t\t\t\tt: 'n',\n\t\t\t\t\t\t\t\tr: cellId\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tchildren: [\n\t\t\t\t\t\t\t\t_createNode( rels, 'v', { text: row[i] } )\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\t// String output - replace non standard characters for text output\n\t\t\t\t\t\tvar text = ! row[i].replace ?\n\t\t\t\t\t\t\trow[i] :\n\t\t\t\t\t\t\trow[i].replace(/[\\x00-\\x09\\x0B\\x0C\\x0E-\\x1F\\x7F-\\x9F]/g, '');\n\n\t\t\t\t\t\tcell = _createNode( rels, 'c', {\n\t\t\t\t\t\t\tattr: {\n\t\t\t\t\t\t\t\tt: 'inlineStr',\n\t\t\t\t\t\t\t\tr: cellId\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tchildren:{\n\t\t\t\t\t\t\t\trow: _createNode( rels, 'is', {\n\t\t\t\t\t\t\t\t\tchildren: {\n\t\t\t\t\t\t\t\t\t\trow: _createNode( rels, 't', {\n\t\t\t\t\t\t\t\t\t\t\ttext: text\n\t\t\t\t\t\t\t\t\t\t} )\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t} )\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\n\t\t\t\trowNode.appendChild( cell );\n\t\t\t}\n\n\t\t\trelsGet.appendChild(rowNode);\n\t\t\trowPos++;\n\t\t};\n\n\t\t$( 'sheets sheet', xlsx.xl['workbook.xml'] ).attr( 'name', _sheetname( config ) );\n\n\t\tif ( config.customizeData ) {\n\t\t\tconfig.customizeData( data );\n\t\t}\n\n\t\tvar mergeCells = function ( row, colspan ) {\n\t\t\tvar mergeCells = $('mergeCells', rels);\n\n\t\t\tmergeCells[0].appendChild( _createNode( rels, 'mergeCell', {\n\t\t\t\tattr: {\n\t\t\t\t\tref: 'A'+row+':'+createCellPos(colspan)+row\n\t\t\t\t}\n\t\t\t} ) );\n\t\t\tmergeCells.attr( 'count', parseFloat(mergeCells.attr( 'count' ))+1 );\n\t\t\t$('row:eq('+(row-1)+') c', rels).attr( 's', '51' ); // centre\n\t\t};\n\n\t\t// Title and top messages\n\t\tvar exportInfo = dt.buttons.exportInfo( config );\n\t\tif ( exportInfo.title ) {\n\t\t\taddRow( [exportInfo.title], rowPos );\n\t\t\tmergeCells( rowPos, data.header.length-1 );\n\t\t}\n\n\t\tif ( exportInfo.messageTop ) {\n\t\t\taddRow( [exportInfo.messageTop], rowPos );\n\t\t\tmergeCells( rowPos, data.header.length-1 );\n\t\t}\n\n\t\t// Table itself\n\t\tif ( config.header ) {\n\t\t\taddRow( data.header, rowPos );\n\t\t\t$('row:last c', rels).attr( 's', '2' ); // bold\n\t\t}\n\n\t\tfor ( var n=0, ie=data.body.length ; n<ie ; n++ ) {\n\t\t\taddRow( data.body[n], rowPos );\n\t\t}\n\n\t\tif ( config.footer && data.footer ) {\n\t\t\taddRow( data.footer, rowPos);\n\t\t\t$('row:last c', rels).attr( 's', '2' ); // bold\n\t\t}\n\n\t\t// Below the table\n\t\tif ( exportInfo.messageBottom ) {\n\t\t\taddRow( [exportInfo.messageBottom], rowPos );\n\t\t\tmergeCells( rowPos, data.header.length-1 );\n\t\t}\n\n\t\t// Set column widths\n\t\tvar cols = _createNode( rels, 'cols' );\n\t\t$('worksheet', rels).prepend( cols );\n\n\t\tfor ( var i=0, ien=data.header.length ; i<ien ; i++ ) {\n\t\t\tcols.appendChild( _createNode( rels, 'col', {\n\t\t\t\tattr: {\n\t\t\t\t\tmin: i+1,\n\t\t\t\t\tmax: i+1,\n\t\t\t\t\twidth: _excelColWidth( data, i ),\n\t\t\t\t\tcustomWidth: 1\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\t// Let the developer customise the document if they want to\n\t\tif ( config.customize ) {\n\t\t\tconfig.customize( xlsx );\n\t\t}\n\n\t\t// Excel doesn't like an empty mergeCells tag\n\t\tif ( $('mergeCells', rels).children().length === 0 ) {\n\t\t\t$('mergeCells', rels).remove();\n\t\t}\n\n\t\tvar jszip = _jsZip();\n\t\tvar zip = new jszip();\n\t\tvar zipConfig = {\n\t\t\ttype: 'blob',\n\t\t\tmimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'\n\t\t};\n\n\t\t_addToZip( zip, xlsx );\n\n\t\tif ( zip.generateAsync ) {\n\t\t\t// JSZip 3+\n\t\t\tzip\n\t\t\t\t.generateAsync( zipConfig )\n\t\t\t\t.then( function ( blob ) {\n\t\t\t\t\t_saveAs( blob, exportInfo.filename );\n\t\t\t\t\tthat.processing( false );\n\t\t\t\t} );\n\t\t}\n\t\telse {\n\t\t\t// JSZip 2.5\n\t\t\t_saveAs(\n\t\t\t\tzip.generate( zipConfig ),\n\t\t\t\texportInfo.filename\n\t\t\t);\n\t\t\tthis.processing( false );\n\t\t}\n\t},\n\n\tfilename: '*',\n\n\textension: '.xlsx',\n\n\texportOptions: {},\n\n\theader: true,\n\n\tfooter: false,\n\n\ttitle: '*',\n\n\tmessageTop: '*',\n\n\tmessageBottom: '*',\n\n\tcreateEmptyCells: false\n};\n\n//\n// PDF export - using pdfMake - http://pdfmake.org\n//\nDataTable.ext.buttons.pdfHtml5 = {\n\tclassName: 'buttons-pdf buttons-html5',\n\n\tavailable: function () {\n\t\treturn window.FileReader !== undefined && _pdfMake();\n\t},\n\n\ttext: function ( dt ) {\n\t\treturn dt.i18n( 'buttons.pdf', 'PDF' );\n\t},\n\n\taction: function ( e, dt, button, config ) {\n\t\tthis.processing( true );\n\n\t\tvar that = this;\n\t\tvar data = dt.buttons.exportData( config.exportOptions );\n\t\tvar info = dt.buttons.exportInfo( config );\n\t\tvar rows = [];\n\n\t\tif ( config.header ) {\n\t\t\trows.push( $.map( data.header, function ( d ) {\n\t\t\t\treturn {\n\t\t\t\t\ttext: typeof d === 'string' ? d : d+'',\n\t\t\t\t\tstyle: 'tableHeader'\n\t\t\t\t};\n\t\t\t} ) );\n\t\t}\n\n\t\tfor ( var i=0, ien=data.body.length ; i<ien ; i++ ) {\n\t\t\trows.push( $.map( data.body[i], function ( d ) {\n\t\t\t\treturn {\n\t\t\t\t\ttext: typeof d === 'string' ? d : d+'',\n\t\t\t\t\tstyle: i % 2 ? 'tableBodyEven' : 'tableBodyOdd'\n\t\t\t\t};\n\t\t\t} ) );\n\t\t}\n\n\t\tif ( config.footer && data.footer) {\n\t\t\trows.push( $.map( data.footer, function ( d ) {\n\t\t\t\treturn {\n\t\t\t\t\ttext: typeof d === 'string' ? d : d+'',\n\t\t\t\t\tstyle: 'tableFooter'\n\t\t\t\t};\n\t\t\t} ) );\n\t\t}\n\n\t\tvar doc = {\n\t\t\tpageSize: config.pageSize,\n\t\t\tpageOrientation: config.orientation,\n\t\t\tcontent: [\n\t\t\t\t{\n\t\t\t\t\ttable: {\n\t\t\t\t\t\theaderRows: 1,\n\t\t\t\t\t\tbody: rows\n\t\t\t\t\t},\n\t\t\t\t\tlayout: 'noBorders'\n\t\t\t\t}\n\t\t\t],\n\t\t\tstyles: {\n\t\t\t\ttableHeader: {\n\t\t\t\t\tbold: true,\n\t\t\t\t\tfontSize: 11,\n\t\t\t\t\tcolor: 'white',\n\t\t\t\t\tfillColor: '#2d4154',\n\t\t\t\t\talignment: 'center'\n\t\t\t\t},\n\t\t\t\ttableBodyEven: {},\n\t\t\t\ttableBodyOdd: {\n\t\t\t\t\tfillColor: '#f3f3f3'\n\t\t\t\t},\n\t\t\t\ttableFooter: {\n\t\t\t\t\tbold: true,\n\t\t\t\t\tfontSize: 11,\n\t\t\t\t\tcolor: 'white',\n\t\t\t\t\tfillColor: '#2d4154'\n\t\t\t\t},\n\t\t\t\ttitle: {\n\t\t\t\t\talignment: 'center',\n\t\t\t\t\tfontSize: 15\n\t\t\t\t},\n\t\t\t\tmessage: {}\n\t\t\t},\n\t\t\tdefaultStyle: {\n\t\t\t\tfontSize: 10\n\t\t\t}\n\t\t};\n\n\t\tif ( info.messageTop ) {\n\t\t\tdoc.content.unshift( {\n\t\t\t\ttext: info.messageTop,\n\t\t\t\tstyle: 'message',\n\t\t\t\tmargin: [ 0, 0, 0, 12 ]\n\t\t\t} );\n\t\t}\n\n\t\tif ( info.messageBottom ) {\n\t\t\tdoc.content.push( {\n\t\t\t\ttext: info.messageBottom,\n\t\t\t\tstyle: 'message',\n\t\t\t\tmargin: [ 0, 0, 0, 12 ]\n\t\t\t} );\n\t\t}\n\n\t\tif ( info.title ) {\n\t\t\tdoc.content.unshift( {\n\t\t\t\ttext: info.title,\n\t\t\t\tstyle: 'title',\n\t\t\t\tmargin: [ 0, 0, 0, 12 ]\n\t\t\t} );\n\t\t}\n\n\t\tif ( config.customize ) {\n\t\t\tconfig.customize( doc, config );\n\t\t}\n\n\t\tvar pdf = _pdfMake().createPdf( doc );\n\n\t\tif ( config.download === 'open' && ! _isDuffSafari() ) {\n\t\t\tpdf.open();\n\t\t}\n\t\telse {\n\t\t\tpdf.download( info.filename );\n\t\t}\n\n\t\tthis.processing( false );\n\t},\n\n\ttitle: '*',\n\n\tfilename: '*',\n\n\textension: '.pdf',\n\n\texportOptions: {},\n\n\torientation: 'portrait',\n\n\tpageSize: 'A4',\n\n\theader: true,\n\n\tfooter: false,\n\n\tmessageTop: '*',\n\n\tmessageBottom: '*',\n\n\tcustomize: null,\n\n\tdownload: 'download'\n};\n\n\nreturn DataTable.Buttons;\n}));\n","/*!\n * Print button for Buttons and DataTables.\n * 2016 SpryMedia Ltd - datatables.net/license\n */\n\n(function( factory ){\n\tif ( typeof define === 'function' && define.amd ) {\n\t\t// AMD\n\t\tdefine( ['jquery', 'datatables.net', 'datatables.net-buttons'], 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\troot = window;\n\t\t\t}\n\n\t\t\tif ( ! $ || ! $.fn.dataTable ) {\n\t\t\t\t$ = require('datatables.net')(root, $).$;\n\t\t\t}\n\n\t\t\tif ( ! $.fn.dataTable.Buttons ) {\n\t\t\t\trequire('datatables.net-buttons')(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\tfactory( jQuery, window, document );\n\t}\n}(function( $, window, document, undefined ) {\n'use strict';\nvar DataTable = $.fn.dataTable;\n\n\nvar _link = document.createElement( 'a' );\n\n/**\n * Clone link and style tags, taking into account the need to change the source\n * path.\n *\n * @param  {node}     el Element to convert\n */\nvar _styleToAbs = function( el ) {\n\tvar url;\n\tvar clone = $(el).clone()[0];\n\tvar linkHost;\n\n\tif ( clone.nodeName.toLowerCase() === 'link' ) {\n\t\tclone.href = _relToAbs( clone.href );\n\t}\n\n\treturn clone.outerHTML;\n};\n\n/**\n * Convert a URL from a relative to an absolute address so it will work\n * correctly in the popup window which has no base URL.\n *\n * @param  {string} href URL\n */\nvar _relToAbs = function( href ) {\n\t// Assign to a link on the original page so the browser will do all the\n\t// hard work of figuring out where the file actually is\n\t_link.href = href;\n\tvar linkHost = _link.host;\n\n\t// IE doesn't have a trailing slash on the host\n\t// Chrome has it on the pathname\n\tif ( linkHost.indexOf('/') === -1 && _link.pathname.indexOf('/') !== 0) {\n\t\tlinkHost += '/';\n\t}\n\n\treturn _link.protocol+\"//\"+linkHost+_link.pathname+_link.search;\n};\n\n\nDataTable.ext.buttons.print = {\n\tclassName: 'buttons-print',\n\n\ttext: function ( dt ) {\n\t\treturn dt.i18n( 'buttons.print', 'Print' );\n\t},\n\n\taction: function ( e, dt, button, config ) {\n\t\tvar data = dt.buttons.exportData(\n\t\t\t$.extend( {decodeEntities: false}, config.exportOptions ) // XSS protection\n\t\t);\n\t\tvar exportInfo = dt.buttons.exportInfo( config );\n\n\t\tvar addRow = function ( d, tag ) {\n\t\t\tvar str = '<tr>';\n\n\t\t\tfor ( var i=0, ien=d.length ; i<ien ; i++ ) {\n\t\t\t\tstr += '<'+tag+'>'+d[i]+'</'+tag+'>';\n\t\t\t}\n\n\t\t\treturn str + '</tr>';\n\t\t};\n\n\t\t// Construct a table for printing\n\t\tvar html = '<table class=\"'+dt.table().node().className+'\">';\n\n\t\tif ( config.header ) {\n\t\t\thtml += '<thead>'+ addRow( data.header, 'th' ) +'</thead>';\n\t\t}\n\n\t\thtml += '<tbody>';\n\t\tfor ( var i=0, ien=data.body.length ; i<ien ; i++ ) {\n\t\t\thtml += addRow( data.body[i], 'td' );\n\t\t}\n\t\thtml += '</tbody>';\n\n\t\tif ( config.footer && data.footer ) {\n\t\t\thtml += '<tfoot>'+ addRow( data.footer, 'th' ) +'</tfoot>';\n\t\t}\n\t\thtml += '</table>';\n\n\t\t// Open a new window for the printable table\n\t\tvar win = window.open( '', '' );\n\t\twin.document.close();\n\n\t\t// Inject the title and also a copy of the style and link tags from this\n\t\t// document so the table can retain its base styling. Note that we have\n\t\t// to use string manipulation as IE won't allow elements to be created\n\t\t// in the host document and then appended to the new window.\n\t\tvar head = '<title>'+exportInfo.title+'</title>';\n\t\t$('style, link').each( function () {\n\t\t\thead += _styleToAbs( this );\n\t\t} );\n\n\t\ttry {\n\t\t\twin.document.head.innerHTML = head; // Work around for Edge\n\t\t}\n\t\tcatch (e) {\n\t\t\t$(win.document.head).html( head ); // Old IE\n\t\t}\n\n\t\t// Inject the table and other surrounding information\n\t\twin.document.body.innerHTML =\n\t\t\t'<h1>'+exportInfo.title+'</h1>'+\n\t\t\t'<div>'+(exportInfo.messageTop || '')+'</div>'+\n\t\t\thtml+\n\t\t\t'<div>'+(exportInfo.messageBottom || '')+'</div>';\n\n\t\t$(win.document.body).addClass('dt-print-view');\n\n\t\t$('img', win.document.body).each( function ( i, img ) {\n\t\t\timg.setAttribute( 'src', _relToAbs( img.getAttribute('src') ) );\n\t\t} );\n\n\t\tif ( config.customize ) {\n\t\t\tconfig.customize( win );\n\t\t}\n\n\t\t// Allow stylesheets time to load\n\t\tsetTimeout( function () {\n\t\t\tif ( config.autoPrint ) {\n\t\t\t\twin.print(); // blocking - so close will not\n\t\t\t\twin.close(); // execute until this is done\n\t\t\t}\n\t\t}, 1000 );\n\t},\n\n\ttitle: '*',\n\n\tmessageTop: '*',\n\n\tmessageBottom: '*',\n\n\texportOptions: {},\n\n\theader: true,\n\n\tfooter: false,\n\n\tautoPrint: true,\n\n\tcustomize: null\n};\n\n\nreturn DataTable.Buttons;\n}));\n","/*! Buttons for DataTables 1.5.1\n * ©2016-2017 SpryMedia Ltd - datatables.net/license\n */\n\n(function( factory ){\n\tif ( typeof define === 'function' && define.amd ) {\n\t\t// AMD\n\t\tdefine( ['jquery', 'datatables.net'], 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\troot = window;\n\t\t\t}\n\n\t\t\tif ( ! $ || ! $.fn.dataTable ) {\n\t\t\t\t$ = require('datatables.net')(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\tfactory( jQuery, window, document );\n\t}\n}(function( $, window, document, undefined ) {\n'use strict';\nvar DataTable = $.fn.dataTable;\n\n\n// Used for namespacing events added to the document by each instance, so they\n// can be removed on destroy\nvar _instCounter = 0;\n\n// Button namespacing counter for namespacing events on individual buttons\nvar _buttonCounter = 0;\n\nvar _dtButtons = DataTable.ext.buttons;\n\n/**\n * [Buttons description]\n * @param {[type]}\n * @param {[type]}\n */\nvar Buttons = function( dt, config )\n{\n\t// If there is no config set it to an empty object\n\tif ( typeof( config ) === 'undefined' ) {\n\t\tconfig = {};\t\n\t}\n\t\n\t// Allow a boolean true for defaults\n\tif ( config === true ) {\n\t\tconfig = {};\n\t}\n\n\t// For easy configuration of buttons an array can be given\n\tif ( $.isArray( config ) ) {\n\t\tconfig = { buttons: config };\n\t}\n\n\tthis.c = $.extend( true, {}, Buttons.defaults, config );\n\n\t// Don't want a deep copy for the buttons\n\tif ( config.buttons ) {\n\t\tthis.c.buttons = config.buttons;\n\t}\n\n\tthis.s = {\n\t\tdt: new DataTable.Api( dt ),\n\t\tbuttons: [],\n\t\tlistenKeys: '',\n\t\tnamespace: 'dtb'+(_instCounter++)\n\t};\n\n\tthis.dom = {\n\t\tcontainer: $('<'+this.c.dom.container.tag+'/>')\n\t\t\t.addClass( this.c.dom.container.className )\n\t};\n\n\tthis._constructor();\n};\n\n\n$.extend( Buttons.prototype, {\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Public methods\n\t */\n\n\t/**\n\t * Get the action of a button\n\t * @param  {int|string} Button index\n\t * @return {function}\n\t *//**\n\t * Set the action of a button\n\t * @param  {node} node Button element\n\t * @param  {function} action Function to set\n\t * @return {Buttons} Self for chaining\n\t */\n\taction: function ( node, action )\n\t{\n\t\tvar button = this._nodeToButton( node );\n\n\t\tif ( action === undefined ) {\n\t\t\treturn button.conf.action;\n\t\t}\n\n\t\tbutton.conf.action = action;\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Add an active class to the button to make to look active or get current\n\t * active state.\n\t * @param  {node} node Button element\n\t * @param  {boolean} [flag] Enable / disable flag\n\t * @return {Buttons} Self for chaining or boolean for getter\n\t */\n\tactive: function ( node, flag ) {\n\t\tvar button = this._nodeToButton( node );\n\t\tvar klass = this.c.dom.button.active;\n\t\tvar jqNode = $(button.node);\n\n\t\tif ( flag === undefined ) {\n\t\t\treturn jqNode.hasClass( klass );\n\t\t}\n\n\t\tjqNode.toggleClass( klass, flag === undefined ? true : flag );\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Add a new button\n\t * @param {object} config Button configuration object, base string name or function\n\t * @param {int|string} [idx] Button index for where to insert the button\n\t * @return {Buttons} Self for chaining\n\t */\n\tadd: function ( config, idx )\n\t{\n\t\tvar buttons = this.s.buttons;\n\n\t\tif ( typeof idx === 'string' ) {\n\t\t\tvar split = idx.split('-');\n\t\t\tvar base = this.s;\n\n\t\t\tfor ( var i=0, ien=split.length-1 ; i<ien ; i++ ) {\n\t\t\t\tbase = base.buttons[ split[i]*1 ];\n\t\t\t}\n\n\t\t\tbuttons = base.buttons;\n\t\t\tidx = split[ split.length-1 ]*1;\n\t\t}\n\n\t\tthis._expandButton( buttons, config, false, idx );\n\t\tthis._draw();\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Get the container node for the buttons\n\t * @return {jQuery} Buttons node\n\t */\n\tcontainer: function ()\n\t{\n\t\treturn this.dom.container;\n\t},\n\n\t/**\n\t * Disable a button\n\t * @param  {node} node Button node\n\t * @return {Buttons} Self for chaining\n\t */\n\tdisable: function ( node ) {\n\t\tvar button = this._nodeToButton( node );\n\n\t\t$(button.node).addClass( this.c.dom.button.disabled );\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Destroy the instance, cleaning up event handlers and removing DOM\n\t * elements\n\t * @return {Buttons} Self for chaining\n\t */\n\tdestroy: function ()\n\t{\n\t\t// Key event listener\n\t\t$('body').off( 'keyup.'+this.s.namespace );\n\n\t\t// Individual button destroy (so they can remove their own events if\n\t\t// needed). Take a copy as the array is modified by `remove`\n\t\tvar buttons = this.s.buttons.slice();\n\t\tvar i, ien;\n\t\t\n\t\tfor ( i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\tthis.remove( buttons[i].node );\n\t\t}\n\n\t\t// Container\n\t\tthis.dom.container.remove();\n\n\t\t// Remove from the settings object collection\n\t\tvar buttonInsts = this.s.dt.settings()[0];\n\n\t\tfor ( i=0, ien=buttonInsts.length ; i<ien ; i++ ) {\n\t\t\tif ( buttonInsts.inst === this ) {\n\t\t\t\tbuttonInsts.splice( i, 1 );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Enable / disable a button\n\t * @param  {node} node Button node\n\t * @param  {boolean} [flag=true] Enable / disable flag\n\t * @return {Buttons} Self for chaining\n\t */\n\tenable: function ( node, flag )\n\t{\n\t\tif ( flag === false ) {\n\t\t\treturn this.disable( node );\n\t\t}\n\n\t\tvar button = this._nodeToButton( node );\n\t\t$(button.node).removeClass( this.c.dom.button.disabled );\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Get the instance name for the button set selector\n\t * @return {string} Instance name\n\t */\n\tname: function ()\n\t{\n\t\treturn this.c.name;\n\t},\n\n\t/**\n\t * Get a button's node\n\t * @param  {node} node Button node\n\t * @return {jQuery} Button element\n\t */\n\tnode: function ( node )\n\t{\n\t\tvar button = this._nodeToButton( node );\n\t\treturn $(button.node);\n\t},\n\n\t/**\n\t * Set / get a processing class on the selected button\n\t * @param  {boolean} flag true to add, false to remove, undefined to get\n\t * @return {boolean|Buttons} Getter value or this if a setter.\n\t */\n\tprocessing: function ( node, flag )\n\t{\n\t\tvar button = this._nodeToButton( node );\n\n\t\tif ( flag === undefined ) {\n\t\t\treturn $(button.node).hasClass( 'processing' );\n\t\t}\n\n\t\t$(button.node).toggleClass( 'processing', flag );\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Remove a button.\n\t * @param  {node} node Button node\n\t * @return {Buttons} Self for chaining\n\t */\n\tremove: function ( node )\n\t{\n\t\tvar button = this._nodeToButton( node );\n\t\tvar host = this._nodeToHost( node );\n\t\tvar dt = this.s.dt;\n\n\t\t// Remove any child buttons first\n\t\tif ( button.buttons.length ) {\n\t\t\tfor ( var i=button.buttons.length-1 ; i>=0 ; i-- ) {\n\t\t\t\tthis.remove( button.buttons[i].node );\n\t\t\t}\n\t\t}\n\n\t\t// Allow the button to remove event handlers, etc\n\t\tif ( button.conf.destroy ) {\n\t\t\tbutton.conf.destroy.call( dt.button(node), dt, $(node), button.conf );\n\t\t}\n\n\t\tthis._removeKey( button.conf );\n\n\t\t$(button.node).remove();\n\n\t\tvar idx = $.inArray( button, host );\n\t\thost.splice( idx, 1 );\n\n\t\treturn this;\n\t},\n\n\t/**\n\t * Get the text for a button\n\t * @param  {int|string} node Button index\n\t * @return {string} Button text\n\t *//**\n\t * Set the text for a button\n\t * @param  {int|string|function} node Button index\n\t * @param  {string} label Text\n\t * @return {Buttons} Self for chaining\n\t */\n\ttext: function ( node, label )\n\t{\n\t\tvar button = this._nodeToButton( node );\n\t\tvar buttonLiner = this.c.dom.collection.buttonLiner;\n\t\tvar linerTag = button.inCollection && buttonLiner && buttonLiner.tag ?\n\t\t\tbuttonLiner.tag :\n\t\t\tthis.c.dom.buttonLiner.tag;\n\t\tvar dt = this.s.dt;\n\t\tvar jqNode = $(button.node);\n\t\tvar text = function ( opt ) {\n\t\t\treturn typeof opt === 'function' ?\n\t\t\t\topt( dt, jqNode, button.conf ) :\n\t\t\t\topt;\n\t\t};\n\n\t\tif ( label === undefined ) {\n\t\t\treturn text( button.conf.text );\n\t\t}\n\n\t\tbutton.conf.text = label;\n\n\t\tif ( linerTag ) {\n\t\t\tjqNode.children( linerTag ).html( text(label) );\n\t\t}\n\t\telse {\n\t\t\tjqNode.html( text(label) );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Constructor\n\t */\n\n\t/**\n\t * Buttons constructor\n\t * @private\n\t */\n\t_constructor: function ()\n\t{\n\t\tvar that = this;\n\t\tvar dt = this.s.dt;\n\t\tvar dtSettings = dt.settings()[0];\n\t\tvar buttons =  this.c.buttons;\n\n\t\tif ( ! dtSettings._buttons ) {\n\t\t\tdtSettings._buttons = [];\n\t\t}\n\n\t\tdtSettings._buttons.push( {\n\t\t\tinst: this,\n\t\t\tname: this.c.name\n\t\t} );\n\n\t\tfor ( var i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\tthis.add( buttons[i] );\n\t\t}\n\n\t\tdt.on( 'destroy', function () {\n\t\t\tthat.destroy();\n\t\t} );\n\n\t\t// Global key event binding to listen for button keys\n\t\t$('body').on( 'keyup.'+this.s.namespace, function ( e ) {\n\t\t\tif ( ! document.activeElement || document.activeElement === document.body ) {\n\t\t\t\t// SUse a string of characters for fast lookup of if we need to\n\t\t\t\t// handle this\n\t\t\t\tvar character = String.fromCharCode(e.keyCode).toLowerCase();\n\n\t\t\t\tif ( that.s.listenKeys.toLowerCase().indexOf( character ) !== -1 ) {\n\t\t\t\t\tthat._keypress( character, e );\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Private methods\n\t */\n\n\t/**\n\t * Add a new button to the key press listener\n\t * @param {object} conf Resolved button configuration object\n\t * @private\n\t */\n\t_addKey: function ( conf )\n\t{\n\t\tif ( conf.key ) {\n\t\t\tthis.s.listenKeys += $.isPlainObject( conf.key ) ?\n\t\t\t\tconf.key.key :\n\t\t\t\tconf.key;\n\t\t}\n\t},\n\n\t/**\n\t * Insert the buttons into the container. Call without parameters!\n\t * @param  {node} [container] Recursive only - Insert point\n\t * @param  {array} [buttons] Recursive only - Buttons array\n\t * @private\n\t */\n\t_draw: function ( container, buttons )\n\t{\n\t\tif ( ! container ) {\n\t\t\tcontainer = this.dom.container;\n\t\t\tbuttons = this.s.buttons;\n\t\t}\n\n\t\tcontainer.children().detach();\n\n\t\tfor ( var i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\tcontainer.append( buttons[i].inserter );\n\t\t\tcontainer.append( ' ' );\n\n\t\t\tif ( buttons[i].buttons && buttons[i].buttons.length ) {\n\t\t\t\tthis._draw( buttons[i].collection, buttons[i].buttons );\n\t\t\t}\n\t\t}\n\t},\n\n\t/**\n\t * Create buttons from an array of buttons\n\t * @param  {array} attachTo Buttons array to attach to\n\t * @param  {object} button Button definition\n\t * @param  {boolean} inCollection true if the button is in a collection\n\t * @private\n\t */\n\t_expandButton: function ( attachTo, button, inCollection, attachPoint )\n\t{\n\t\tvar dt = this.s.dt;\n\t\tvar buttonCounter = 0;\n\t\tvar buttons = ! $.isArray( button ) ?\n\t\t\t[ button ] :\n\t\t\tbutton;\n\n\t\tfor ( var i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\tvar conf = this._resolveExtends( buttons[i] );\n\n\t\t\tif ( ! conf ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If the configuration is an array, then expand the buttons at this\n\t\t\t// point\n\t\t\tif ( $.isArray( conf ) ) {\n\t\t\t\tthis._expandButton( attachTo, conf, inCollection, attachPoint );\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tvar built = this._buildButton( conf, inCollection );\n\t\t\tif ( ! built ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif ( attachPoint !== undefined ) {\n\t\t\t\tattachTo.splice( attachPoint, 0, built );\n\t\t\t\tattachPoint++;\n\t\t\t}\n\t\t\telse {\n\t\t\t\tattachTo.push( built );\n\t\t\t}\n\n\t\t\tif ( built.conf.buttons ) {\n\t\t\t\tvar collectionDom = this.c.dom.collection;\n\t\t\t\tbuilt.collection = $('<'+collectionDom.tag+'/>')\n\t\t\t\t\t.addClass( collectionDom.className )\n\t\t\t\t\t.attr( 'role', 'menu') ;\n\t\t\t\tbuilt.conf._collection = built.collection;\n\n\t\t\t\tthis._expandButton( built.buttons, built.conf.buttons, true, attachPoint );\n\t\t\t}\n\n\t\t\t// init call is made here, rather than buildButton as it needs to\n\t\t\t// be selectable, and for that it needs to be in the buttons array\n\t\t\tif ( conf.init ) {\n\t\t\t\tconf.init.call( dt.button( built.node ), dt, $(built.node), conf );\n\t\t\t}\n\n\t\t\tbuttonCounter++;\n\t\t}\n\t},\n\n\t/**\n\t * Create an individual button\n\t * @param  {object} config            Resolved button configuration\n\t * @param  {boolean} inCollection `true` if a collection button\n\t * @return {jQuery} Created button node (jQuery)\n\t * @private\n\t */\n\t_buildButton: function ( config, inCollection )\n\t{\n\t\tvar buttonDom = this.c.dom.button;\n\t\tvar linerDom = this.c.dom.buttonLiner;\n\t\tvar collectionDom = this.c.dom.collection;\n\t\tvar dt = this.s.dt;\n\t\tvar text = function ( opt ) {\n\t\t\treturn typeof opt === 'function' ?\n\t\t\t\topt( dt, button, config ) :\n\t\t\t\topt;\n\t\t};\n\n\t\tif ( inCollection && collectionDom.button ) {\n\t\t\tbuttonDom = collectionDom.button;\n\t\t}\n\n\t\tif ( inCollection && collectionDom.buttonLiner ) {\n\t\t\tlinerDom = collectionDom.buttonLiner;\n\t\t}\n\n\t\t// Make sure that the button is available based on whatever requirements\n\t\t// it has. For example, Flash buttons require Flash\n\t\tif ( config.available && ! config.available( dt, config ) ) {\n\t\t\treturn false;\n\t\t}\n\n\t\tvar action = function ( e, dt, button, config ) {\n\t\t\tconfig.action.call( dt.button( button ), e, dt, button, config );\n\n\t\t\t$(dt.table().node()).triggerHandler( 'buttons-action.dt', [\n\t\t\t\tdt.button( button ), dt, button, config \n\t\t\t] );\n\t\t};\n\n\t\tvar button = $('<'+buttonDom.tag+'/>')\n\t\t\t.addClass( buttonDom.className )\n\t\t\t.attr( 'tabindex', this.s.dt.settings()[0].iTabIndex )\n\t\t\t.attr( 'aria-controls', this.s.dt.table().node().id )\n\t\t\t.on( 'click.dtb', function (e) {\n\t\t\t\te.preventDefault();\n\n\t\t\t\tif ( ! button.hasClass( buttonDom.disabled ) && config.action ) {\n\t\t\t\t\taction( e, dt, button, config );\n\t\t\t\t}\n\n\t\t\t\tbutton.blur();\n\t\t\t} )\n\t\t\t.on( 'keyup.dtb', function (e) {\n\t\t\t\tif ( e.keyCode === 13 ) {\n\t\t\t\t\tif ( ! button.hasClass( buttonDom.disabled ) && config.action ) {\n\t\t\t\t\t\taction( e, dt, button, config );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\n\t\t// Make `a` tags act like a link\n\t\tif ( buttonDom.tag.toLowerCase() === 'a' ) {\n\t\t\tbutton.attr( 'href', '#' );\n\t\t}\n\n\t\tif ( linerDom.tag ) {\n\t\t\tvar liner = $('<'+linerDom.tag+'/>')\n\t\t\t\t.html( text( config.text ) )\n\t\t\t\t.addClass( linerDom.className );\n\n\t\t\tif ( linerDom.tag.toLowerCase() === 'a' ) {\n\t\t\t\tliner.attr( 'href', '#' );\n\t\t\t}\n\n\t\t\tbutton.append( liner );\n\t\t}\n\t\telse {\n\t\t\tbutton.html( text( config.text ) );\n\t\t}\n\n\t\tif ( config.enabled === false ) {\n\t\t\tbutton.addClass( buttonDom.disabled );\n\t\t}\n\n\t\tif ( config.className ) {\n\t\t\tbutton.addClass( config.className );\n\t\t}\n\n\t\tif ( config.titleAttr ) {\n\t\t\tbutton.attr( 'title', text( config.titleAttr ) );\n\t\t}\n\n\t\tif ( config.attr ) {\n\t\t\tbutton.attr( config.attr );\n\t\t}\n\n\t\tif ( ! config.namespace ) {\n\t\t\tconfig.namespace = '.dt-button-'+(_buttonCounter++);\n\t\t}\n\n\t\tvar buttonContainer = this.c.dom.buttonContainer;\n\t\tvar inserter;\n\t\tif ( buttonContainer && buttonContainer.tag ) {\n\t\t\tinserter = $('<'+buttonContainer.tag+'/>')\n\t\t\t\t.addClass( buttonContainer.className )\n\t\t\t\t.append( button );\n\t\t}\n\t\telse {\n\t\t\tinserter = button;\n\t\t}\n\n\t\tthis._addKey( config );\n\n\t\treturn {\n\t\t\tconf:         config,\n\t\t\tnode:         button.get(0),\n\t\t\tinserter:     inserter,\n\t\t\tbuttons:      [],\n\t\t\tinCollection: inCollection,\n\t\t\tcollection:   null\n\t\t};\n\t},\n\n\t/**\n\t * Get the button object from a node (recursive)\n\t * @param  {node} node Button node\n\t * @param  {array} [buttons] Button array, uses base if not defined\n\t * @return {object} Button object\n\t * @private\n\t */\n\t_nodeToButton: function ( node, buttons )\n\t{\n\t\tif ( ! buttons ) {\n\t\t\tbuttons = this.s.buttons;\n\t\t}\n\n\t\tfor ( var i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\tif ( buttons[i].node === node ) {\n\t\t\t\treturn buttons[i];\n\t\t\t}\n\n\t\t\tif ( buttons[i].buttons.length ) {\n\t\t\t\tvar ret = this._nodeToButton( node, buttons[i].buttons );\n\n\t\t\t\tif ( ret ) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t/**\n\t * Get container array for a button from a button node (recursive)\n\t * @param  {node} node Button node\n\t * @param  {array} [buttons] Button array, uses base if not defined\n\t * @return {array} Button's host array\n\t * @private\n\t */\n\t_nodeToHost: function ( node, buttons )\n\t{\n\t\tif ( ! buttons ) {\n\t\t\tbuttons = this.s.buttons;\n\t\t}\n\n\t\tfor ( var i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\tif ( buttons[i].node === node ) {\n\t\t\t\treturn buttons;\n\t\t\t}\n\n\t\t\tif ( buttons[i].buttons.length ) {\n\t\t\t\tvar ret = this._nodeToHost( node, buttons[i].buttons );\n\n\t\t\t\tif ( ret ) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t/**\n\t * Handle a key press - determine if any button's key configured matches\n\t * what was typed and trigger the action if so.\n\t * @param  {string} character The character pressed\n\t * @param  {object} e Key event that triggered this call\n\t * @private\n\t */\n\t_keypress: function ( character, e )\n\t{\n\t\t// Check if this button press already activated on another instance of Buttons\n\t\tif ( e._buttonsHandled ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar run = function ( conf, node ) {\n\t\t\tif ( ! conf.key ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( conf.key === character ) {\n\t\t\t\te._buttonsHandled = true;\n\t\t\t\t$(node).click();\n\t\t\t}\n\t\t\telse if ( $.isPlainObject( conf.key ) ) {\n\t\t\t\tif ( conf.key.key !== character ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( conf.key.shiftKey && ! e.shiftKey ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( conf.key.altKey && ! e.altKey ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( conf.key.ctrlKey && ! e.ctrlKey ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( conf.key.metaKey && ! e.metaKey ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// Made it this far - it is good\n\t\t\t\te._buttonsHandled = true;\n\t\t\t\t$(node).click();\n\t\t\t}\n\t\t};\n\n\t\tvar recurse = function ( a ) {\n\t\t\tfor ( var i=0, ien=a.length ; i<ien ; i++ ) {\n\t\t\t\trun( a[i].conf, a[i].node );\n\n\t\t\t\tif ( a[i].buttons.length ) {\n\t\t\t\t\trecurse( a[i].buttons );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\trecurse( this.s.buttons );\n\t},\n\n\t/**\n\t * Remove a key from the key listener for this instance (to be used when a\n\t * button is removed)\n\t * @param  {object} conf Button configuration\n\t * @private\n\t */\n\t_removeKey: function ( conf )\n\t{\n\t\tif ( conf.key ) {\n\t\t\tvar character = $.isPlainObject( conf.key ) ?\n\t\t\t\tconf.key.key :\n\t\t\t\tconf.key;\n\n\t\t\t// Remove only one character, as multiple buttons could have the\n\t\t\t// same listening key\n\t\t\tvar a = this.s.listenKeys.split('');\n\t\t\tvar idx = $.inArray( character, a );\n\t\t\ta.splice( idx, 1 );\n\t\t\tthis.s.listenKeys = a.join('');\n\t\t}\n\t},\n\n\t/**\n\t * Resolve a button configuration\n\t * @param  {string|function|object} conf Button config to resolve\n\t * @return {object} Button configuration\n\t * @private\n\t */\n\t_resolveExtends: function ( conf )\n\t{\n\t\tvar dt = this.s.dt;\n\t\tvar i, ien;\n\t\tvar toConfObject = function ( base ) {\n\t\t\tvar loop = 0;\n\n\t\t\t// Loop until we have resolved to a button configuration, or an\n\t\t\t// array of button configurations (which will be iterated\n\t\t\t// separately)\n\t\t\twhile ( ! $.isPlainObject(base) && ! $.isArray(base) ) {\n\t\t\t\tif ( base === undefined ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif ( typeof base === 'function' ) {\n\t\t\t\t\tbase = base( dt, conf );\n\n\t\t\t\t\tif ( ! base ) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if ( typeof base === 'string' ) {\n\t\t\t\t\tif ( ! _dtButtons[ base ] ) {\n\t\t\t\t\t\tthrow 'Unknown button type: '+base;\n\t\t\t\t\t}\n\n\t\t\t\t\tbase = _dtButtons[ base ];\n\t\t\t\t}\n\n\t\t\t\tloop++;\n\t\t\t\tif ( loop > 30 ) {\n\t\t\t\t\t// Protect against misconfiguration killing the browser\n\t\t\t\t\tthrow 'Buttons: Too many iterations';\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn $.isArray( base ) ?\n\t\t\t\tbase :\n\t\t\t\t$.extend( {}, base );\n\t\t};\n\n\t\tconf = toConfObject( conf );\n\n\t\twhile ( conf && conf.extend ) {\n\t\t\t// Use `toConfObject` in case the button definition being extended\n\t\t\t// is itself a string or a function\n\t\t\tif ( ! _dtButtons[ conf.extend ] ) {\n\t\t\t\tthrow 'Cannot extend unknown button type: '+conf.extend;\n\t\t\t}\n\n\t\t\tvar objArray = toConfObject( _dtButtons[ conf.extend ] );\n\t\t\tif ( $.isArray( objArray ) ) {\n\t\t\t\treturn objArray;\n\t\t\t}\n\t\t\telse if ( ! objArray ) {\n\t\t\t\t// This is a little brutal as it might be possible to have a\n\t\t\t\t// valid button without the extend, but if there is no extend\n\t\t\t\t// then the host button would be acting in an undefined state\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// Stash the current class name\n\t\t\tvar originalClassName = objArray.className;\n\n\t\t\tconf = $.extend( {}, objArray, conf );\n\n\t\t\t// The extend will have overwritten the original class name if the\n\t\t\t// `conf` object also assigned a class, but we want to concatenate\n\t\t\t// them so they are list that is combined from all extended buttons\n\t\t\tif ( originalClassName && conf.className !== originalClassName ) {\n\t\t\t\tconf.className = originalClassName+' '+conf.className;\n\t\t\t}\n\n\t\t\t// Buttons to be added to a collection  -gives the ability to define\n\t\t\t// if buttons should be added to the start or end of a collection\n\t\t\tvar postfixButtons = conf.postfixButtons;\n\t\t\tif ( postfixButtons ) {\n\t\t\t\tif ( ! conf.buttons ) {\n\t\t\t\t\tconf.buttons = [];\n\t\t\t\t}\n\n\t\t\t\tfor ( i=0, ien=postfixButtons.length ; i<ien ; i++ ) {\n\t\t\t\t\tconf.buttons.push( postfixButtons[i] );\n\t\t\t\t}\n\n\t\t\t\tconf.postfixButtons = null;\n\t\t\t}\n\n\t\t\tvar prefixButtons = conf.prefixButtons;\n\t\t\tif ( prefixButtons ) {\n\t\t\t\tif ( ! conf.buttons ) {\n\t\t\t\t\tconf.buttons = [];\n\t\t\t\t}\n\n\t\t\t\tfor ( i=0, ien=prefixButtons.length ; i<ien ; i++ ) {\n\t\t\t\t\tconf.buttons.splice( i, 0, prefixButtons[i] );\n\t\t\t\t}\n\n\t\t\t\tconf.prefixButtons = null;\n\t\t\t}\n\n\t\t\t// Although we want the `conf` object to overwrite almost all of\n\t\t\t// the properties of the object being extended, the `extend`\n\t\t\t// property should come from the object being extended\n\t\t\tconf.extend = objArray.extend;\n\t\t}\n\n\t\treturn conf;\n\t}\n} );\n\n\n\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * Statics\n */\n\n/**\n * Show / hide a background layer behind a collection\n * @param  {boolean} Flag to indicate if the background should be shown or\n *   hidden \n * @param  {string} Class to assign to the background\n * @static\n */\nButtons.background = function ( show, className, fade ) {\n\tif ( fade === undefined ) {\n\t\tfade = 400;\n\t}\n\n\tif ( show ) {\n\t\t$('<div/>')\n\t\t\t.addClass( className )\n\t\t\t.css( 'display', 'none' )\n\t\t\t.appendTo( 'body' )\n\t\t\t.fadeIn( fade );\n\t}\n\telse {\n\t\t$('body > div.'+className)\n\t\t\t.fadeOut( fade, function () {\n\t\t\t\t$(this)\n\t\t\t\t\t.removeClass( className )\n\t\t\t\t\t.remove();\n\t\t\t} );\n\t}\n};\n\n/**\n * Instance selector - select Buttons instances based on an instance selector\n * value from the buttons assigned to a DataTable. This is only useful if\n * multiple instances are attached to a DataTable.\n * @param  {string|int|array} Instance selector - see `instance-selector`\n *   documentation on the DataTables site\n * @param  {array} Button instance array that was attached to the DataTables\n *   settings object\n * @return {array} Buttons instances\n * @static\n */\nButtons.instanceSelector = function ( group, buttons )\n{\n\tif ( ! group ) {\n\t\treturn $.map( buttons, function ( v ) {\n\t\t\treturn v.inst;\n\t\t} );\n\t}\n\n\tvar ret = [];\n\tvar names = $.map( buttons, function ( v ) {\n\t\treturn v.name;\n\t} );\n\n\t// Flatten the group selector into an array of single options\n\tvar process = function ( input ) {\n\t\tif ( $.isArray( input ) ) {\n\t\t\tfor ( var i=0, ien=input.length ; i<ien ; i++ ) {\n\t\t\t\tprocess( input[i] );\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\tif ( typeof input === 'string' ) {\n\t\t\tif ( input.indexOf( ',' ) !== -1 ) {\n\t\t\t\t// String selector, list of names\n\t\t\t\tprocess( input.split(',') );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// String selector individual name\n\t\t\t\tvar idx = $.inArray( $.trim(input), names );\n\n\t\t\t\tif ( idx !== -1 ) {\n\t\t\t\t\tret.push( buttons[ idx ].inst );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse if ( typeof input === 'number' ) {\n\t\t\t// Index selector\n\t\t\tret.push( buttons[ input ].inst );\n\t\t}\n\t};\n\t\n\tprocess( group );\n\n\treturn ret;\n};\n\n/**\n * Button selector - select one or more buttons from a selector input so some\n * operation can be performed on them.\n * @param  {array} Button instances array that the selector should operate on\n * @param  {string|int|node|jQuery|array} Button selector - see\n *   `button-selector` documentation on the DataTables site\n * @return {array} Array of objects containing `inst` and `idx` properties of\n *   the selected buttons so you know which instance each button belongs to.\n * @static\n */\nButtons.buttonSelector = function ( insts, selector )\n{\n\tvar ret = [];\n\tvar nodeBuilder = function ( a, buttons, baseIdx ) {\n\t\tvar button;\n\t\tvar idx;\n\n\t\tfor ( var i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\tbutton = buttons[i];\n\n\t\t\tif ( button ) {\n\t\t\t\tidx = baseIdx !== undefined ?\n\t\t\t\t\tbaseIdx+i :\n\t\t\t\t\ti+'';\n\n\t\t\t\ta.push( {\n\t\t\t\t\tnode: button.node,\n\t\t\t\t\tname: button.conf.name,\n\t\t\t\t\tidx:  idx\n\t\t\t\t} );\n\n\t\t\t\tif ( button.buttons ) {\n\t\t\t\t\tnodeBuilder( a, button.buttons, idx+'-' );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\tvar run = function ( selector, inst ) {\n\t\tvar i, ien;\n\t\tvar buttons = [];\n\t\tnodeBuilder( buttons, inst.s.buttons );\n\n\t\tvar nodes = $.map( buttons, function (v) {\n\t\t\treturn v.node;\n\t\t} );\n\n\t\tif ( $.isArray( selector ) || selector instanceof $ ) {\n\t\t\tfor ( i=0, ien=selector.length ; i<ien ; i++ ) {\n\t\t\t\trun( selector[i], inst );\n\t\t\t}\n\t\t\treturn;\n\t\t}\n\n\t\tif ( selector === null || selector === undefined || selector === '*' ) {\n\t\t\t// Select all\n\t\t\tfor ( i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\t\tret.push( {\n\t\t\t\t\tinst: inst,\n\t\t\t\t\tnode: buttons[i].node\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t\telse if ( typeof selector === 'number' ) {\n\t\t\t// Main button index selector\n\t\t\tret.push( {\n\t\t\t\tinst: inst,\n\t\t\t\tnode: inst.s.buttons[ selector ].node\n\t\t\t} );\n\t\t}\n\t\telse if ( typeof selector === 'string' ) {\n\t\t\tif ( selector.indexOf( ',' ) !== -1 ) {\n\t\t\t\t// Split\n\t\t\t\tvar a = selector.split(',');\n\n\t\t\t\tfor ( i=0, ien=a.length ; i<ien ; i++ ) {\n\t\t\t\t\trun( $.trim(a[i]), inst );\n\t\t\t\t}\n\t\t\t}\n\t\t\telse if ( selector.match( /^\\d+(\\-\\d+)*$/ ) ) {\n\t\t\t\t// Sub-button index selector\n\t\t\t\tvar indexes = $.map( buttons, function (v) {\n\t\t\t\t\treturn v.idx;\n\t\t\t\t} );\n\n\t\t\t\tret.push( {\n\t\t\t\t\tinst: inst,\n\t\t\t\t\tnode: buttons[ $.inArray( selector, indexes ) ].node\n\t\t\t\t} );\n\t\t\t}\n\t\t\telse if ( selector.indexOf( ':name' ) !== -1 ) {\n\t\t\t\t// Button name selector\n\t\t\t\tvar name = selector.replace( ':name', '' );\n\n\t\t\t\tfor ( i=0, ien=buttons.length ; i<ien ; i++ ) {\n\t\t\t\t\tif ( buttons[i].name === name ) {\n\t\t\t\t\t\tret.push( {\n\t\t\t\t\t\t\tinst: inst,\n\t\t\t\t\t\t\tnode: buttons[i].node\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\telse {\n\t\t\t\t// jQuery selector on the nodes\n\t\t\t\t$( nodes ).filter( selector ).each( function () {\n\t\t\t\t\tret.push( {\n\t\t\t\t\t\tinst: inst,\n\t\t\t\t\t\tnode: this\n\t\t\t\t\t} );\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t\telse if ( typeof selector === 'object' && selector.nodeName ) {\n\t\t\t// Node selector\n\t\t\tvar idx = $.inArray( selector, nodes );\n\n\t\t\tif ( idx !== -1 ) {\n\t\t\t\tret.push( {\n\t\t\t\t\tinst: inst,\n\t\t\t\t\tnode: nodes[ idx ]\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t};\n\n\n\tfor ( var i=0, ien=insts.length ; i<ien ; i++ ) {\n\t\tvar inst = insts[i];\n\n\t\trun( selector, inst );\n\t}\n\n\treturn ret;\n};\n\n\n/**\n * Buttons defaults. For full documentation, please refer to the docs/option\n * directory or the DataTables site.\n * @type {Object}\n * @static\n */\nButtons.defaults = {\n\tbuttons: [ 'copy', 'excel', 'csv', 'pdf', 'print' ],\n\tname: 'main',\n\ttabIndex: 0,\n\tdom: {\n\t\tcontainer: {\n\t\t\ttag: 'div',\n\t\t\tclassName: 'dt-buttons'\n\t\t},\n\t\tcollection: {\n\t\t\ttag: 'div',\n\t\t\tclassName: 'dt-button-collection'\n\t\t},\n\t\tbutton: {\n\t\t\ttag: 'button',\n\t\t\tclassName: 'dt-button',\n\t\t\tactive: 'active',\n\t\t\tdisabled: 'disabled'\n\t\t},\n\t\tbuttonLiner: {\n\t\t\ttag: 'span',\n\t\t\tclassName: ''\n\t\t}\n\t}\n};\n\n/**\n * Version information\n * @type {string}\n * @static\n */\nButtons.version = '1.5.1';\n\n\n$.extend( _dtButtons, {\n\tcollection: {\n\t\ttext: function ( dt ) {\n\t\t\treturn dt.i18n( 'buttons.collection', 'Collection' );\n\t\t},\n\t\tclassName: 'buttons-collection',\n\t\taction: function ( e, dt, button, config ) {\n\t\t\tvar host = button;\n\t\t\tvar collectionParent = $(button).parents('div.dt-button-collection');\n\t\t\tvar hostPosition = host.position();\n\t\t\tvar tableContainer = $( dt.table().container() );\n\t\t\tvar multiLevel = false;\n\t\t\tvar insertPoint = host;\n\n\t\t\t// Remove any old collection\n\t\t\tif ( collectionParent.length ) {\n\t\t\t\tmultiLevel = $('.dt-button-collection').position();\n\t\t\t\tinsertPoint = collectionParent;\n\t\t\t\t$('body').trigger( 'click.dtb-collection' );\n\t\t\t}\n\n\t\t\tconfig._collection\n\t\t\t\t.addClass( config.collectionLayout )\n\t\t\t\t.css( 'display', 'none' )\n\t\t\t\t.insertAfter( insertPoint )\n\t\t\t\t.fadeIn( config.fade );\n\t\t\t\n\n\t\t\tvar position = config._collection.css( 'position' );\n\n\t\t\tif ( multiLevel && position === 'absolute' ) {\n\t\t\t\tconfig._collection.css( {\n\t\t\t\t\ttop: multiLevel.top,\n\t\t\t\t\tleft: multiLevel.left\n\t\t\t\t} );\n\t\t\t}\n\t\t\telse if ( position === 'absolute' ) {\n\t\t\t\tconfig._collection.css( {\n\t\t\t\t\ttop: hostPosition.top + host.outerHeight(),\n\t\t\t\t\tleft: hostPosition.left\n\t\t\t\t} );\n\n\t\t\t\t// calculate overflow when positioned beneath\n\t\t\t\tvar tableBottom = tableContainer.offset().top + tableContainer.height();\n\t\t\t\tvar listBottom = hostPosition.top + host.outerHeight() + config._collection.outerHeight();\n\t\t\t\tvar bottomOverflow = listBottom - tableBottom;\n\t\t\t\t\n\t\t\t\t// calculate overflow when positioned above\n\t\t\t\tvar listTop = hostPosition.top - config._collection.outerHeight();\n\t\t\t\tvar tableTop = tableContainer.offset().top;\n\t\t\t\tvar topOverflow = tableTop - listTop;\n\t\t\t\t\n\t\t\t\t// if bottom overflow is larger, move to the top because it fits better\n\t\t\t\tif (bottomOverflow > topOverflow) {\n\t\t\t\t\tconfig._collection.css( 'top', hostPosition.top - config._collection.outerHeight() - 5);\n\t\t\t\t}\n\n\t\t\t\tvar listRight = hostPosition.left + config._collection.outerWidth();\n\t\t\t\tvar tableRight = tableContainer.offset().left + tableContainer.width();\n\t\t\t\tif ( listRight > tableRight ) {\n\t\t\t\t\tconfig._collection.css( 'left', hostPosition.left - ( listRight - tableRight ) );\n\t\t\t\t}\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// Fix position - centre on screen\n\t\t\t\tvar top = config._collection.height() / 2;\n\t\t\t\tif ( top > $(window).height() / 2 ) {\n\t\t\t\t\ttop = $(window).height() / 2;\n\t\t\t\t}\n\n\t\t\t\tconfig._collection.css( 'marginTop', top*-1 );\n\t\t\t}\n\n\t\t\tif ( config.background ) {\n\t\t\t\tButtons.background( true, config.backgroundClassName, config.fade );\n\t\t\t}\n\n\t\t\t// Need to break the 'thread' for the collection button being\n\t\t\t// activated by a click - it would also trigger this event\n\t\t\tsetTimeout( function () {\n\t\t\t\t// This is bonkers, but if we don't have a click listener on the\n\t\t\t\t// background element, iOS Safari will ignore the body click\n\t\t\t\t// listener below. An empty function here is all that is\n\t\t\t\t// required to make it work...\n\t\t\t\t$('div.dt-button-background').on( 'click.dtb-collection', function () {} );\n\n\t\t\t\t$('body').on( 'click.dtb-collection', function (e) {\n\t\t\t\t\t// andSelf is deprecated in jQ1.8, but we want 1.7 compat\n\t\t\t\t\tvar back = $.fn.addBack ? 'addBack' : 'andSelf';\n\n\t\t\t\t\tif ( ! $(e.target).parents()[back]().filter( config._collection ).length ) {\n\t\t\t\t\t\tconfig._collection\n\t\t\t\t\t\t\t.fadeOut( config.fade, function () {\n\t\t\t\t\t\t\t\tconfig._collection.detach();\n\t\t\t\t\t\t\t} );\n\n\t\t\t\t\t\t$('div.dt-button-background').off( 'click.dtb-collection' );\n\t\t\t\t\t\tButtons.background( false, config.backgroundClassName, config.fade );\n\n\t\t\t\t\t\t$('body').off( 'click.dtb-collection' );\n\t\t\t\t\t\tdt.off( 'buttons-action.b-internal' );\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t}, 10 );\n\n\t\t\tif ( config.autoClose ) {\n\t\t\t\tdt.on( 'buttons-action.b-internal', function () {\n\t\t\t\t\t$('div.dt-button-background').click();\n\t\t\t\t} );\n\t\t\t}\n\t\t},\n\t\tbackground: true,\n\t\tcollectionLayout: '',\n\t\tbackgroundClassName: 'dt-button-background',\n\t\tautoClose: false,\n\t\tfade: 400,\n\t\tattr: {\n\t\t\t'aria-haspopup': true\n\t\t}\n\t},\n\tcopy: function ( dt, conf ) {\n\t\tif ( _dtButtons.copyHtml5 ) {\n\t\t\treturn 'copyHtml5';\n\t\t}\n\t\tif ( _dtButtons.copyFlash && _dtButtons.copyFlash.available( dt, conf ) ) {\n\t\t\treturn 'copyFlash';\n\t\t}\n\t},\n\tcsv: function ( dt, conf ) {\n\t\t// Common option that will use the HTML5 or Flash export buttons\n\t\tif ( _dtButtons.csvHtml5 && _dtButtons.csvHtml5.available( dt, conf ) ) {\n\t\t\treturn 'csvHtml5';\n\t\t}\n\t\tif ( _dtButtons.csvFlash && _dtButtons.csvFlash.available( dt, conf ) ) {\n\t\t\treturn 'csvFlash';\n\t\t}\n\t},\n\texcel: function ( dt, conf ) {\n\t\t// Common option that will use the HTML5 or Flash export buttons\n\t\tif ( _dtButtons.excelHtml5 && _dtButtons.excelHtml5.available( dt, conf ) ) {\n\t\t\treturn 'excelHtml5';\n\t\t}\n\t\tif ( _dtButtons.excelFlash && _dtButtons.excelFlash.available( dt, conf ) ) {\n\t\t\treturn 'excelFlash';\n\t\t}\n\t},\n\tpdf: function ( dt, conf ) {\n\t\t// Common option that will use the HTML5 or Flash export buttons\n\t\tif ( _dtButtons.pdfHtml5 && _dtButtons.pdfHtml5.available( dt, conf ) ) {\n\t\t\treturn 'pdfHtml5';\n\t\t}\n\t\tif ( _dtButtons.pdfFlash && _dtButtons.pdfFlash.available( dt, conf ) ) {\n\t\t\treturn 'pdfFlash';\n\t\t}\n\t},\n\tpageLength: function ( dt ) {\n\t\tvar lengthMenu = dt.settings()[0].aLengthMenu;\n\t\tvar vals = $.isArray( lengthMenu[0] ) ? lengthMenu[0] : lengthMenu;\n\t\tvar lang = $.isArray( lengthMenu[0] ) ? lengthMenu[1] : lengthMenu;\n\t\tvar text = function ( dt ) {\n\t\t\treturn dt.i18n( 'buttons.pageLength', {\n\t\t\t\t\"-1\": 'Show all rows',\n\t\t\t\t_:    'Show %d rows'\n\t\t\t}, dt.page.len() );\n\t\t};\n\n\t\treturn {\n\t\t\textend: 'collection',\n\t\t\ttext: text,\n\t\t\tclassName: 'buttons-page-length',\n\t\t\tautoClose: true,\n\t\t\tbuttons: $.map( vals, function ( val, i ) {\n\t\t\t\treturn {\n\t\t\t\t\ttext: lang[i],\n\t\t\t\t\tclassName: 'button-page-length',\n\t\t\t\t\taction: function ( e, dt ) {\n\t\t\t\t\t\tdt.page.len( val ).draw();\n\t\t\t\t\t},\n\t\t\t\t\tinit: function ( dt, node, conf ) {\n\t\t\t\t\t\tvar that = this;\n\t\t\t\t\t\tvar fn = function () {\n\t\t\t\t\t\t\tthat.active( dt.page.len() === val );\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\tdt.on( 'length.dt'+conf.namespace, fn );\n\t\t\t\t\t\tfn();\n\t\t\t\t\t},\n\t\t\t\t\tdestroy: function ( dt, node, conf ) {\n\t\t\t\t\t\tdt.off( 'length.dt'+conf.namespace );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t} ),\n\t\t\tinit: function ( dt, node, conf ) {\n\t\t\t\tvar that = this;\n\t\t\t\tdt.on( 'length.dt'+conf.namespace, function () {\n\t\t\t\t\tthat.text( text( dt ) );\n\t\t\t\t} );\n\t\t\t},\n\t\t\tdestroy: function ( dt, node, conf ) {\n\t\t\t\tdt.off( 'length.dt'+conf.namespace );\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * DataTables API\n *\n * For complete documentation, please refer to the docs/api directory or the\n * DataTables site\n */\n\n// Buttons group and individual button selector\nDataTable.Api.register( 'buttons()', function ( group, selector ) {\n\t// Argument shifting\n\tif ( selector === undefined ) {\n\t\tselector = group;\n\t\tgroup = undefined;\n\t}\n\n\tthis.selector.buttonGroup = group;\n\n\tvar res = this.iterator( true, 'table', function ( ctx ) {\n\t\tif ( ctx._buttons ) {\n\t\t\treturn Buttons.buttonSelector(\n\t\t\t\tButtons.instanceSelector( group, ctx._buttons ),\n\t\t\t\tselector\n\t\t\t);\n\t\t}\n\t}, true );\n\n\tres._groupSelector = group;\n\treturn res;\n} );\n\n// Individual button selector\nDataTable.Api.register( 'button()', function ( group, selector ) {\n\t// just run buttons() and truncate\n\tvar buttons = this.buttons( group, selector );\n\n\tif ( buttons.length > 1 ) {\n\t\tbuttons.splice( 1, buttons.length );\n\t}\n\n\treturn buttons;\n} );\n\n// Active buttons\nDataTable.Api.registerPlural( 'buttons().active()', 'button().active()', function ( flag ) {\n\tif ( flag === undefined ) {\n\t\treturn this.map( function ( set ) {\n\t\t\treturn set.inst.active( set.node );\n\t\t} );\n\t}\n\n\treturn this.each( function ( set ) {\n\t\tset.inst.active( set.node, flag );\n\t} );\n} );\n\n// Get / set button action\nDataTable.Api.registerPlural( 'buttons().action()', 'button().action()', function ( action ) {\n\tif ( action === undefined ) {\n\t\treturn this.map( function ( set ) {\n\t\t\treturn set.inst.action( set.node );\n\t\t} );\n\t}\n\n\treturn this.each( function ( set ) {\n\t\tset.inst.action( set.node, action );\n\t} );\n} );\n\n// Enable / disable buttons\nDataTable.Api.register( ['buttons().enable()', 'button().enable()'], function ( flag ) {\n\treturn this.each( function ( set ) {\n\t\tset.inst.enable( set.node, flag );\n\t} );\n} );\n\n// Disable buttons\nDataTable.Api.register( ['buttons().disable()', 'button().disable()'], function () {\n\treturn this.each( function ( set ) {\n\t\tset.inst.disable( set.node );\n\t} );\n} );\n\n// Get button nodes\nDataTable.Api.registerPlural( 'buttons().nodes()', 'button().node()', function () {\n\tvar jq = $();\n\n\t// jQuery will automatically reduce duplicates to a single entry\n\t$( this.each( function ( set ) {\n\t\tjq = jq.add( set.inst.node( set.node ) );\n\t} ) );\n\n\treturn jq;\n} );\n\n// Get / set button processing state\nDataTable.Api.registerPlural( 'buttons().processing()', 'button().processing()', function ( flag ) {\n\tif ( flag === undefined ) {\n\t\treturn this.map( function ( set ) {\n\t\t\treturn set.inst.processing( set.node );\n\t\t} );\n\t}\n\n\treturn this.each( function ( set ) {\n\t\tset.inst.processing( set.node, flag );\n\t} );\n} );\n\n// Get / set button text (i.e. the button labels)\nDataTable.Api.registerPlural( 'buttons().text()', 'button().text()', function ( label ) {\n\tif ( label === undefined ) {\n\t\treturn this.map( function ( set ) {\n\t\t\treturn set.inst.text( set.node );\n\t\t} );\n\t}\n\n\treturn this.each( function ( set ) {\n\t\tset.inst.text( set.node, label );\n\t} );\n} );\n\n// Trigger a button's action\nDataTable.Api.registerPlural( 'buttons().trigger()', 'button().trigger()', function () {\n\treturn this.each( function ( set ) {\n\t\tset.inst.node( set.node ).trigger( 'click' );\n\t} );\n} );\n\n// Get the container elements\nDataTable.Api.registerPlural( 'buttons().containers()', 'buttons().container()', function () {\n\tvar jq = $();\n\tvar groupSelector = this._groupSelector;\n\n\t// We need to use the group selector directly, since if there are no buttons\n\t// the result set will be empty\n\tthis.iterator( true, 'table', function ( ctx ) {\n\t\tif ( ctx._buttons ) {\n\t\t\tvar insts = Buttons.instanceSelector( groupSelector, ctx._buttons );\n\n\t\t\tfor ( var i=0, ien=insts.length ; i<ien ; i++ ) {\n\t\t\t\tjq = jq.add( insts[i].container() );\n\t\t\t}\n\t\t}\n\t} );\n\n\treturn jq;\n} );\n\n// Add a new button\nDataTable.Api.register( 'button().add()', function ( idx, conf ) {\n\tvar ctx = this.context;\n\n\t// Don't use `this` as it could be empty - select the instances directly\n\tif ( ctx.length ) {\n\t\tvar inst = Buttons.instanceSelector( this._groupSelector, ctx[0]._buttons );\n\n\t\tif ( inst.length ) {\n\t\t\tinst[0].add( conf, idx );\n\t\t}\n\t}\n\n\treturn this.button( this._groupSelector, idx );\n} );\n\n// Destroy the button sets selected\nDataTable.Api.register( 'buttons().destroy()', function () {\n\tthis.pluck( 'inst' ).unique().each( function ( inst ) {\n\t\tinst.destroy();\n\t} );\n\n\treturn this;\n} );\n\n// Remove a button\nDataTable.Api.registerPlural( 'buttons().remove()', 'buttons().remove()', function () {\n\tthis.each( function ( set ) {\n\t\tset.inst.remove( set.node );\n\t} );\n\n\treturn this;\n} );\n\n// Information box that can be used by buttons\nvar _infoTimer;\nDataTable.Api.register( 'buttons.info()', function ( title, message, time ) {\n\tvar that = this;\n\n\tif ( title === false ) {\n\t\t$('#datatables_buttons_info').fadeOut( function () {\n\t\t\t$(this).remove();\n\t\t} );\n\t\tclearTimeout( _infoTimer );\n\t\t_infoTimer = null;\n\n\t\treturn this;\n\t}\n\n\tif ( _infoTimer ) {\n\t\tclearTimeout( _infoTimer );\n\t}\n\n\tif ( $('#datatables_buttons_info').length ) {\n\t\t$('#datatables_buttons_info').remove();\n\t}\n\n\ttitle = title ? '<h2>'+title+'</h2>' : '';\n\n\t$('<div id=\"datatables_buttons_info\" class=\"dt-button-info\"/>')\n\t\t.html( title )\n\t\t.append( $('<div/>')[ typeof message === 'string' ? 'html' : 'append' ]( message ) )\n\t\t.css( 'display', 'none' )\n\t\t.appendTo( 'body' )\n\t\t.fadeIn();\n\n\tif ( time !== undefined && time !== 0 ) {\n\t\t_infoTimer = setTimeout( function () {\n\t\t\tthat.buttons.info( false );\n\t\t}, time );\n\t}\n\n\treturn this;\n} );\n\n// Get data from the table for export - this is common to a number of plug-in\n// buttons so it is included in the Buttons core library\nDataTable.Api.register( 'buttons.exportData()', function ( options ) {\n\tif ( this.context.length ) {\n\t\treturn _exportData( new DataTable.Api( this.context[0] ), options );\n\t}\n} );\n\n// Get information about the export that is common to many of the export data\n// types (DRY)\nDataTable.Api.register( 'buttons.exportInfo()', function ( conf ) {\n\tif ( ! conf ) {\n\t\tconf = {};\n\t}\n\n\treturn {\n\t\tfilename: _filename( conf ),\n\t\ttitle: _title( conf ),\n\t\tmessageTop: _message(this, conf.message || conf.messageTop, 'top'),\n\t\tmessageBottom: _message(this, conf.messageBottom, 'bottom')\n\t};\n} );\n\n\n\n/**\n * Get the file name for an exported file.\n *\n * @param {object}\tconfig Button configuration\n * @param {boolean} incExtension Include the file name extension\n */\nvar _filename = function ( config )\n{\n\t// Backwards compatibility\n\tvar filename = config.filename === '*' && config.title !== '*' && config.title !== undefined && config.title !== null && config.title !== '' ?\n\t\tconfig.title :\n\t\tconfig.filename;\n\n\tif ( typeof filename === 'function' ) {\n\t\tfilename = filename();\n\t}\n\n\tif ( filename === undefined || filename === null ) {\n\t\treturn null;\n\t}\n\n\tif ( filename.indexOf( '*' ) !== -1 ) {\n\t\tfilename = $.trim( filename.replace( '*', $('head > title').text() ) );\n\t}\n\n\t// Strip characters which the OS will object to\n\tfilename = filename.replace(/[^a-zA-Z0-9_\\u00A1-\\uFFFF\\.,\\-_ !\\(\\)]/g, \"\");\n\n\tvar extension = _stringOrFunction( config.extension );\n\tif ( ! extension ) {\n\t\textension = '';\n\t}\n\n\treturn filename + extension;\n};\n\n/**\n * Simply utility method to allow parameters to be given as a function\n *\n * @param {undefined|string|function} option Option\n * @return {null|string} Resolved value\n */\nvar _stringOrFunction = function ( option )\n{\n\tif ( option === null || option === undefined ) {\n\t\treturn null;\n\t}\n\telse if ( typeof option === 'function' ) {\n\t\treturn option();\n\t}\n\treturn option;\n};\n\n/**\n * Get the title for an exported file.\n *\n * @param {object} config\tButton configuration\n */\nvar _title = function ( config )\n{\n\tvar title = _stringOrFunction( config.title );\n\n\treturn title === null ?\n\t\tnull : title.indexOf( '*' ) !== -1 ?\n\t\t\ttitle.replace( '*', $('head > title').text() || 'Exported data' ) :\n\t\t\ttitle;\n};\n\nvar _message = function ( dt, option, position )\n{\n\tvar message = _stringOrFunction( option );\n\tif ( message === null ) {\n\t\treturn null;\n\t}\n\n\tvar caption = $('caption', dt.table().container()).eq(0);\n\tif ( message === '*' ) {\n\t\tvar side = caption.css( 'caption-side' );\n\t\tif ( side !== position ) {\n\t\t\treturn null;\n\t\t}\n\n\t\treturn caption.length ?\n\t\t\tcaption.text() :\n\t\t\t'';\n\t}\n\n\treturn message;\n};\n\n\n\n\n\n\n\nvar _exportTextarea = $('<textarea/>')[0];\nvar _exportData = function ( dt, inOpts )\n{\n\tvar config = $.extend( true, {}, {\n\t\trows:           null,\n\t\tcolumns:        '',\n\t\tmodifier:       {\n\t\t\tsearch: 'applied',\n\t\t\torder:  'applied'\n\t\t},\n\t\torthogonal:     'display',\n\t\tstripHtml:      true,\n\t\tstripNewlines:  true,\n\t\tdecodeEntities: true,\n\t\ttrim:           true,\n\t\tformat:         {\n\t\t\theader: function ( d ) {\n\t\t\t\treturn strip( d );\n\t\t\t},\n\t\t\tfooter: function ( d ) {\n\t\t\t\treturn strip( d );\n\t\t\t},\n\t\t\tbody: function ( d ) {\n\t\t\t\treturn strip( d );\n\t\t\t}\n\t\t}\n\t}, inOpts );\n\n\tvar strip = function ( str ) {\n\t\tif ( typeof str !== 'string' ) {\n\t\t\treturn str;\n\t\t}\n\n\t\t// Always remove script tags\n\t\tstr = str.replace( /<script\\b[^<]*(?:(?!<\\/script>)<[^<]*)*<\\/script>/gi, '' );\n\n\t\tif ( config.stripHtml ) {\n\t\t\tstr = str.replace( /<[^>]*>/g, '' );\n\t\t}\n\n\t\tif ( config.trim ) {\n\t\t\tstr = str.replace( /^\\s+|\\s+$/g, '' );\n\t\t}\n\n\t\tif ( config.stripNewlines ) {\n\t\t\tstr = str.replace( /\\n/g, ' ' );\n\t\t}\n\n\t\tif ( config.decodeEntities ) {\n\t\t\t_exportTextarea.innerHTML = str;\n\t\t\tstr = _exportTextarea.value;\n\t\t}\n\n\t\treturn str;\n\t};\n\n\n\tvar header = dt.columns( config.columns ).indexes().map( function (idx) {\n\t\tvar el = dt.column( idx ).header();\n\t\treturn config.format.header( el.innerHTML, idx, el );\n\t} ).toArray();\n\n\tvar footer = dt.table().footer() ?\n\t\tdt.columns( config.columns ).indexes().map( function (idx) {\n\t\t\tvar el = dt.column( idx ).footer();\n\t\t\treturn config.format.footer( el ? el.innerHTML : '', idx, el );\n\t\t} ).toArray() :\n\t\tnull;\n\t\n\t// If Select is available on this table, and any rows are selected, limit the export\n\t// to the selected rows. If no rows are selected, all rows will be exported. Specify\n\t// a `selected` modifier to control directly.\n\tvar modifier = $.extend( {}, config.modifier );\n\tif ( dt.select && typeof dt.select.info === 'function' && modifier.selected === undefined ) {\n\t\tif ( dt.rows( config.rows, $.extend( { selected: true }, modifier ) ).any() ) {\n\t\t\t$.extend( modifier, { selected: true } )\n\t\t}\n\t}\n\n\tvar rowIndexes = dt.rows( config.rows, modifier ).indexes().toArray();\n\tvar selectedCells = dt.cells( rowIndexes, config.columns );\n\tvar cells = selectedCells\n\t\t.render( config.orthogonal )\n\t\t.toArray();\n\tvar cellNodes = selectedCells\n\t\t.nodes()\n\t\t.toArray();\n\n\tvar columns = header.length;\n\tvar rows = columns > 0 ? cells.length / columns : 0;\n\tvar body = [ rows ];\n\tvar cellCounter = 0;\n\n\tfor ( var i=0, ien=rows ; i<ien ; i++ ) {\n\t\tvar row = [ columns ];\n\n\t\tfor ( var j=0 ; j<columns ; j++ ) {\n\t\t\trow[j] = config.format.body( cells[ cellCounter ], i, j, cellNodes[ cellCounter ] );\n\t\t\tcellCounter++;\n\t\t}\n\n\t\tbody[i] = row;\n\t}\n\n\treturn {\n\t\theader: header,\n\t\tfooter: footer,\n\t\tbody:   body\n\t};\n};\n\n\n/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n * DataTables interface\n */\n\n// Attach to DataTables objects for global access\n$.fn.dataTable.Buttons = Buttons;\n$.fn.DataTable.Buttons = Buttons;\n\n\n\n// DataTables creation - check if the buttons have been defined for this table,\n// they will have been if the `B` option was used in `dom`, otherwise we should\n// create the buttons instance here so they can be inserted into the document\n// using the API. Listen for `init` for compatibility with pre 1.10.10, but to\n// be removed in future.\n$(document).on( 'init.dt plugin-init.dt', function (e, settings) {\n\tif ( e.namespace !== 'dt' ) {\n\t\treturn;\n\t}\n\n\tvar opts = settings.oInit.buttons || DataTable.defaults.buttons;\n\n\tif ( opts && ! settings._buttons ) {\n\t\tnew Buttons( settings, opts ).container();\n\t}\n} );\n\n// DataTables `dom` feature option\nDataTable.ext.feature.push( {\n\tfnInit: function( settings ) {\n\t\tvar api = new DataTable.Api( settings );\n\t\tvar opts = api.init().buttons || DataTable.defaults.buttons;\n\n\t\treturn new Buttons( api, opts ).container();\n\t},\n\tcFeature: \"B\"\n} );\n\n\nreturn Buttons;\n}));\n","/*! Bootstrap integration for DataTables' Responsive\n * ©2015-2016 SpryMedia Ltd - datatables.net/license\n */\n\n(function( factory ){\n\tif ( typeof define === 'function' && define.amd ) {\n\t\t// AMD\n\t\tdefine( ['jquery', 'datatables.net-bs', 'datatables.net-responsive'], 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\troot = window;\n\t\t\t}\n\n\t\t\tif ( ! $ || ! $.fn.dataTable ) {\n\t\t\t\t$ = require('datatables.net-bs')(root, $).$;\n\t\t\t}\n\n\t\t\tif ( ! $.fn.dataTable.Responsive ) {\n\t\t\t\trequire('datatables.net-responsive')(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\tfactory( jQuery, window, document );\n\t}\n}(function( $, window, document, undefined ) {\n'use strict';\nvar DataTable = $.fn.dataTable;\n\n\nvar _display = DataTable.Responsive.display;\nvar _original = _display.modal;\nvar _modal = $(\n\t'<div class=\"modal fade dtr-bs-modal\" role=\"dialog\">'+\n\t\t'<div class=\"modal-dialog\" role=\"document\">'+\n\t\t\t'<div class=\"modal-content\">'+\n\t\t\t\t'<div class=\"modal-header\">'+\n\t\t\t\t\t'<button type=\"button\" class=\"close\" data-dismiss=\"modal\" aria-label=\"Close\"><span aria-hidden=\"true\">&times;</span></button>'+\n\t\t\t\t'</div>'+\n\t\t\t\t'<div class=\"modal-body\"/>'+\n\t\t\t'</div>'+\n\t\t'</div>'+\n\t'</div>'\n);\n\n_display.modal = function ( options ) {\n\treturn function ( row, update, render ) {\n\t\tif ( ! $.fn.modal ) {\n\t\t\t_original( row, update, render );\n\t\t}\n\t\telse {\n\t\t\tif ( ! update ) {\n\t\t\t\tif ( options && options.header ) {\n\t\t\t\t\tvar header = _modal.find('div.modal-header');\n\t\t\t\t\tvar button = header.find('button').detach();\n\t\t\t\t\t\n\t\t\t\t\theader\n\t\t\t\t\t\t.empty()\n\t\t\t\t\t\t.append( '<h4 class=\"modal-title\">'+options.header( row )+'</h4>' )\n\t\t\t\t\t\t.prepend( button );\n\t\t\t\t}\n\n\t\t\t\t_modal.find( 'div.modal-body' )\n\t\t\t\t\t.empty()\n\t\t\t\t\t.append( render() );\n\n\t\t\t\t_modal\n\t\t\t\t\t.appendTo( 'body' )\n\t\t\t\t\t.modal();\n\t\t\t}\n\t\t}\n\t};\n};\n\n\nreturn DataTable.Responsive;\n}));\n","/*! Responsive 2.2.7\n * 2014-2021 SpryMedia Ltd - datatables.net/license\n */\n\n/**\n * @summary     Responsive\n * @description Responsive tables plug-in for DataTables\n * @version     2.2.7\n * @file        dataTables.responsive.js\n * @author      SpryMedia Ltd (www.sprymedia.co.uk)\n * @contact     www.sprymedia.co.uk/contact\n * @copyright   Copyright 2014-2021 SpryMedia Ltd.\n *\n * This source file is free software, available under the following license:\n *   MIT license - http://datatables.net/license/mit\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(function( factory ){\n\tif ( typeof define === 'function' && define.amd ) {\n\t\t// AMD\n\t\tdefine( ['jquery', 'datatables.net'], 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\troot = window;\n\t\t\t}\n\n\t\t\tif ( ! $ || ! $.fn.dataTable ) {\n\t\t\t\t$ = require('datatables.net')(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\tfactory( jQuery, window, document );\n\t}\n}(function( $, window, document, undefined ) {\n'use strict';\nvar DataTable = $.fn.dataTable;\n\n\n/**\n * Responsive is a plug-in for the DataTables library that makes use of\n * DataTables' ability to change the visibility of columns, changing the\n * visibility of columns so the displayed columns fit into the table container.\n * The end result is that complex tables will be dynamically adjusted to fit\n * into the viewport, be it on a desktop, tablet or mobile browser.\n *\n * Responsive for DataTables has two modes of operation, which can used\n * individually or combined:\n *\n * * Class name based control - columns assigned class names that match the\n *   breakpoint logic can be shown / hidden as required for each breakpoint.\n * * Automatic control - columns are automatically hidden when there is no\n *   room left to display them. Columns removed from the right.\n *\n * In additional to column visibility control, Responsive also has built into\n * options to use DataTables' child row display to show / hide the information\n * from the table that has been hidden. There are also two modes of operation\n * for this child row display:\n *\n * * Inline - when the control element that the user can use to show / hide\n *   child rows is displayed inside the first column of the table.\n * * Column - where a whole column is dedicated to be the show / hide control.\n *\n * Initialisation of Responsive is performed by:\n *\n * * Adding the class `responsive` or `dt-responsive` to the table. In this case\n *   Responsive will automatically be initialised with the default configuration\n *   options when the DataTable is created.\n * * Using the `responsive` option in the DataTables configuration options. This\n *   can also be used to specify the configuration options, or simply set to\n *   `true` to use the defaults.\n *\n *  @class\n *  @param {object} settings DataTables settings object for the host table\n *  @param {object} [opts] Configuration options\n *  @requires jQuery 1.7+\n *  @requires DataTables 1.10.3+\n *\n *  @example\n *      $('#example').DataTable( {\n *        responsive: true\n *      } );\n *    } );\n */\nvar Responsive = function ( settings, opts ) {\n\t// Sanity check that we are using DataTables 1.10 or newer\n\tif ( ! DataTable.versionCheck || ! DataTable.versionCheck( '1.10.10' ) ) {\n\t\tthrow 'DataTables Responsive requires DataTables 1.10.10 or newer';\n\t}\n\n\tthis.s = {\n\t\tdt: new DataTable.Api( settings ),\n\t\tcolumns: [],\n\t\tcurrent: []\n\t};\n\n\t// Check if responsive has already been initialised on this table\n\tif ( this.s.dt.settings()[0].responsive ) {\n\t\treturn;\n\t}\n\n\t// details is an object, but for simplicity the user can give it as a string\n\t// or a boolean\n\tif ( opts && typeof opts.details === 'string' ) {\n\t\topts.details = { type: opts.details };\n\t}\n\telse if ( opts && opts.details === false ) {\n\t\topts.details = { type: false };\n\t}\n\telse if ( opts && opts.details === true ) {\n\t\topts.details = { type: 'inline' };\n\t}\n\n\tthis.c = $.extend( true, {}, Responsive.defaults, DataTable.defaults.responsive, opts );\n\tsettings.responsive = this;\n\tthis._constructor();\n};\n\n$.extend( Responsive.prototype, {\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Constructor\n\t */\n\n\t/**\n\t * Initialise the Responsive instance\n\t *\n\t * @private\n\t */\n\t_constructor: function ()\n\t{\n\t\tvar that = this;\n\t\tvar dt = this.s.dt;\n\t\tvar dtPrivateSettings = dt.settings()[0];\n\t\tvar oldWindowWidth = $(window).innerWidth();\n\n\t\tdt.settings()[0]._responsive = this;\n\n\t\t// Use DataTables' throttle function to avoid processor thrashing on\n\t\t// resize\n\t\t$(window).on( 'resize.dtr orientationchange.dtr', DataTable.util.throttle( function () {\n\t\t\t// iOS has a bug whereby resize can fire when only scrolling\n\t\t\t// See: http://stackoverflow.com/questions/8898412\n\t\t\tvar width = $(window).innerWidth();\n\n\t\t\tif ( width !== oldWindowWidth ) {\n\t\t\t\tthat._resize();\n\t\t\t\toldWindowWidth = width;\n\t\t\t}\n\t\t} ) );\n\n\t\t// DataTables doesn't currently trigger an event when a row is added, so\n\t\t// we need to hook into its private API to enforce the hidden rows when\n\t\t// new data is added\n\t\tdtPrivateSettings.oApi._fnCallbackReg( dtPrivateSettings, 'aoRowCreatedCallback', function (tr, data, idx) {\n\t\t\tif ( $.inArray( false, that.s.current ) !== -1 ) {\n\t\t\t\t$('>td, >th', tr).each( function ( i ) {\n\t\t\t\t\tvar idx = dt.column.index( 'toData', i );\n\n\t\t\t\t\tif ( that.s.current[idx] === false ) {\n\t\t\t\t\t\t$(this).css('display', 'none');\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t}\n\t\t} );\n\n\t\t// Destroy event handler\n\t\tdt.on( 'destroy.dtr', function () {\n\t\t\tdt.off( '.dtr' );\n\t\t\t$( dt.table().body() ).off( '.dtr' );\n\t\t\t$(window).off( 'resize.dtr orientationchange.dtr' );\n\t\t\tdt.cells('.dtr-control').nodes().to$().removeClass('dtr-control');\n\n\t\t\t// Restore the columns that we've hidden\n\t\t\t$.each( that.s.current, function ( i, val ) {\n\t\t\t\tif ( val === false ) {\n\t\t\t\t\tthat._setColumnVis( i, true );\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\n\t\t// Reorder the breakpoints array here in case they have been added out\n\t\t// of order\n\t\tthis.c.breakpoints.sort( function (a, b) {\n\t\t\treturn a.width < b.width ? 1 :\n\t\t\t\ta.width > b.width ? -1 : 0;\n\t\t} );\n\n\t\tthis._classLogic();\n\t\tthis._resizeAuto();\n\n\t\t// Details handler\n\t\tvar details = this.c.details;\n\n\t\tif ( details.type !== false ) {\n\t\t\tthat._detailsInit();\n\n\t\t\t// DataTables will trigger this event on every column it shows and\n\t\t\t// hides individually\n\t\t\tdt.on( 'column-visibility.dtr', function () {\n\t\t\t\t// Use a small debounce to allow multiple columns to be set together\n\t\t\t\tif ( that._timer ) {\n\t\t\t\t\tclearTimeout( that._timer );\n\t\t\t\t}\n\n\t\t\t\tthat._timer = setTimeout( function () {\n\t\t\t\t\tthat._timer = null;\n\n\t\t\t\t\tthat._classLogic();\n\t\t\t\t\tthat._resizeAuto();\n\t\t\t\t\tthat._resize(true);\n\n\t\t\t\t\tthat._redrawChildren();\n\t\t\t\t}, 100 );\n\t\t\t} );\n\n\t\t\t// Redraw the details box on each draw which will happen if the data\n\t\t\t// has changed. This is used until DataTables implements a native\n\t\t\t// `updated` event for rows\n\t\t\tdt.on( 'draw.dtr', function () {\n\t\t\t\tthat._redrawChildren();\n\t\t\t} );\n\n\t\t\t$(dt.table().node()).addClass( 'dtr-'+details.type );\n\t\t}\n\n\t\tdt.on( 'column-reorder.dtr', function (e, settings, details) {\n\t\t\tthat._classLogic();\n\t\t\tthat._resizeAuto();\n\t\t\tthat._resize(true);\n\t\t} );\n\n\t\t// Change in column sizes means we need to calc\n\t\tdt.on( 'column-sizing.dtr', function () {\n\t\t\tthat._resizeAuto();\n\t\t\tthat._resize();\n\t\t});\n\n\t\t// On Ajax reload we want to reopen any child rows which are displayed\n\t\t// by responsive\n\t\tdt.on( 'preXhr.dtr', function () {\n\t\t\tvar rowIds = [];\n\t\t\tdt.rows().every( function () {\n\t\t\t\tif ( this.child.isShown() ) {\n\t\t\t\t\trowIds.push( this.id(true) );\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\tdt.one( 'draw.dtr', function () {\n\t\t\t\tthat._resizeAuto();\n\t\t\t\tthat._resize();\n\n\t\t\t\tdt.rows( rowIds ).every( function () {\n\t\t\t\t\tthat._detailsDisplay( this, false );\n\t\t\t\t} );\n\t\t\t} );\n\t\t});\n\n\t\tdt\n\t\t\t.on( 'draw.dtr', function () {\n\t\t\t\tthat._controlClass();\n\t\t\t})\n\t\t\t.on( 'init.dtr', function (e, settings, details) {\n\t\t\t\tif ( e.namespace !== 'dt' ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tthat._resizeAuto();\n\t\t\t\tthat._resize();\n\n\t\t\t\t// If columns were hidden, then DataTables needs to adjust the\n\t\t\t\t// column sizing\n\t\t\t\tif ( $.inArray( false, that.s.current ) ) {\n\t\t\t\t\tdt.columns.adjust();\n\t\t\t\t}\n\t\t\t} );\n\n\t\t// First pass - draw the table for the current viewport size\n\t\tthis._resize();\n\t},\n\n\n\t/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n\t * Private methods\n\t */\n\n\t/**\n\t * Calculate the visibility for the columns in a table for a given\n\t * breakpoint. The result is pre-determined based on the class logic if\n\t * class names are used to control all columns, but the width of the table\n\t * is also used if there are columns which are to be automatically shown\n\t * and hidden.\n\t *\n\t * @param  {string} breakpoint Breakpoint name to use for the calculation\n\t * @return {array} Array of boolean values initiating the visibility of each\n\t *   column.\n\t *  @private\n\t */\n\t_columnsVisiblity: function ( breakpoint )\n\t{\n\t\tvar dt = this.s.dt;\n\t\tvar columns = this.s.columns;\n\t\tvar i, ien;\n\n\t\t// Create an array that defines the column ordering based first on the\n\t\t// column's priority, and secondly the column index. This allows the\n\t\t// columns to be removed from the right if the priority matches\n\t\tvar order = columns\n\t\t\t.map( function ( col, idx ) {\n\t\t\t\treturn {\n\t\t\t\t\tcolumnIdx: idx,\n\t\t\t\t\tpriority: col.priority\n\t\t\t\t};\n\t\t\t} )\n\t\t\t.sort( function ( a, b ) {\n\t\t\t\tif ( a.priority !== b.priority ) {\n\t\t\t\t\treturn a.priority - b.priority;\n\t\t\t\t}\n\t\t\t\treturn a.columnIdx - b.columnIdx;\n\t\t\t} );\n\n\t\t// Class logic - determine which columns are in this breakpoint based\n\t\t// on the classes. If no class control (i.e. `auto`) then `-` is used\n\t\t// to indicate this to the rest of the function\n\t\tvar display = $.map( columns, function ( col, i ) {\n\t\t\tif ( dt.column(i).visible() === false ) {\n\t\t\t\treturn 'not-visible';\n\t\t\t}\n\t\t\treturn col.auto && col.minWidth === null ?\n\t\t\t\tfalse :\n\t\t\t\tcol.auto === true ?\n\t\t\t\t\t'-' :\n\t\t\t\t\t$.inArray( breakpoint, col.includeIn ) !== -1;\n\t\t} );\n\n\t\t// Auto column control - first pass: how much width is taken by the\n\t\t// ones that must be included from the non-auto columns\n\t\tvar requiredWidth = 0;\n\t\tfor ( i=0, ien=display.length ; i<ien ; i++ ) {\n\t\t\tif ( display[i] === true ) {\n\t\t\t\trequiredWidth += columns[i].minWidth;\n\t\t\t}\n\t\t}\n\n\t\t// Second pass, use up any remaining width for other columns. For\n\t\t// scrolling tables we need to subtract the width of the scrollbar. It\n\t\t// may not be requires which makes this sub-optimal, but it would\n\t\t// require another full redraw to make complete use of those extra few\n\t\t// pixels\n\t\tvar scrolling = dt.settings()[0].oScroll;\n\t\tvar bar = scrolling.sY || scrolling.sX ? scrolling.iBarWidth : 0;\n\t\tvar widthAvailable = dt.table().container().offsetWidth - bar;\n\t\tvar usedWidth = widthAvailable - requiredWidth;\n\n\t\t// Control column needs to always be included. This makes it sub-\n\t\t// optimal in terms of using the available with, but to stop layout\n\t\t// thrashing or overflow. Also we need to account for the control column\n\t\t// width first so we know how much width is available for the other\n\t\t// columns, since the control column might not be the first one shown\n\t\tfor ( i=0, ien=display.length ; i<ien ; i++ ) {\n\t\t\tif ( columns[i].control ) {\n\t\t\t\tusedWidth -= columns[i].minWidth;\n\t\t\t}\n\t\t}\n\n\t\t// Allow columns to be shown (counting by priority and then right to\n\t\t// left) until we run out of room\n\t\tvar empty = false;\n\t\tfor ( i=0, ien=order.length ; i<ien ; i++ ) {\n\t\t\tvar colIdx = order[i].columnIdx;\n\n\t\t\tif ( display[colIdx] === '-' && ! columns[colIdx].control && columns[colIdx].minWidth ) {\n\t\t\t\t// Once we've found a column that won't fit we don't let any\n\t\t\t\t// others display either, or columns might disappear in the\n\t\t\t\t// middle of the table\n\t\t\t\tif ( empty || usedWidth - columns[colIdx].minWidth < 0 ) {\n\t\t\t\t\tempty = true;\n\t\t\t\t\tdisplay[colIdx] = false;\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tdisplay[colIdx] = true;\n\t\t\t\t}\n\n\t\t\t\tusedWidth -= columns[colIdx].minWidth;\n\t\t\t}\n\t\t}\n\n\t\t// Determine if the 'control' column should be shown (if there is one).\n\t\t// This is the case when there is a hidden column (that is not the\n\t\t// control column). The two loops look inefficient here, but they are\n\t\t// trivial and will fly through. We need to know the outcome from the\n\t\t// first , before the action in the second can be taken\n\t\tvar showControl = false;\n\n\t\tfor ( i=0, ien=columns.length ; i<ien ; i++ ) {\n\t\t\tif ( ! columns[i].control && ! columns[i].never && display[i] === false ) {\n\t\t\t\tshowControl = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tfor ( i=0, ien=columns.length ; i<ien ; i++ ) {\n\t\t\tif ( columns[i].control ) {\n\t\t\t\tdisplay[i] = showControl;\n\t\t\t}\n\n\t\t\t// Replace not visible string with false from the control column detection above\n\t\t\tif ( display[i] === 'not-visible' ) {\n\t\t\t\tdisplay[i] = false;\n\t\t\t}\n\t\t}\n\n\t\t// Finally we need to make sure that there is at least one column that\n\t\t// is visible\n\t\tif ( $.inArray( true, display ) === -1 ) {\n\t\t\tdisplay[0] = true;\n\t\t}\n\n\t\treturn display;\n\t},\n\n\n\t/**\n\t * Create the internal `columns` array with information about the columns\n\t * for the table. This includes determining which breakpoints the column\n\t * will appear in, based upon class names in the column, which makes up the\n\t * vast majority of this method.\n\t *\n\t * @private\n\t */\n\t_classLogic: function ()\n\t{\n\t\tvar that = this;\n\t\tvar calc = {};\n\t\tvar breakpoints = this.c.breakpoints;\n\t\tvar dt = this.s.dt;\n\t\tvar columns = dt.columns().eq(0).map( function (i) {\n\t\t\tvar column = this.column(i);\n\t\t\tvar className = column.header().className;\n\t\t\tvar priority = dt.settings()[0].aoColumns[i].responsivePriority;\n\t\t\tvar dataPriority = column.header().getAttribute('data-priority');\n\n\t\t\tif ( priority === undefined ) {\n\t\t\t\tpriority = dataPriority === undefined || dataPriority === null?\n\t\t\t\t\t10000 :\n\t\t\t\t\tdataPriority * 1;\n\t\t\t}\n\n\t\t\treturn {\n\t\t\t\tclassName: className,\n\t\t\t\tincludeIn: [],\n\t\t\t\tauto:      false,\n\t\t\t\tcontrol:   false,\n\t\t\t\tnever:     className.match(/\\bnever\\b/) ? true : false,\n\t\t\t\tpriority:  priority\n\t\t\t};\n\t\t} );\n\n\t\t// Simply add a breakpoint to `includeIn` array, ensuring that there are\n\t\t// no duplicates\n\t\tvar add = function ( colIdx, name ) {\n\t\t\tvar includeIn = columns[ colIdx ].includeIn;\n\n\t\t\tif ( $.inArray( name, includeIn ) === -1 ) {\n\t\t\t\tincludeIn.push( name );\n\t\t\t}\n\t\t};\n\n\t\tvar column = function ( colIdx, name, operator, matched ) {\n\t\t\tvar size, i, ien;\n\n\t\t\tif ( ! operator ) {\n\t\t\t\tcolumns[ colIdx ].includeIn.push( name );\n\t\t\t}\n\t\t\telse if ( operator === 'max-' ) {\n\t\t\t\t// Add this breakpoint and all smaller\n\t\t\t\tsize = that._find( name ).width;\n\n\t\t\t\tfor ( i=0, ien=breakpoints.length ; i<ien ; i++ ) {\n\t\t\t\t\tif ( breakpoints[i].width <= size ) {\n\t\t\t\t\t\tadd( colIdx, breakpoints[i].name );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\telse if ( operator === 'min-' ) {\n\t\t\t\t// Add this breakpoint and all larger\n\t\t\t\tsize = that._find( name ).width;\n\n\t\t\t\tfor ( i=0, ien=breakpoints.length ; i<ien ; i++ ) {\n\t\t\t\t\tif ( breakpoints[i].width >= size ) {\n\t\t\t\t\t\tadd( colIdx, breakpoints[i].name );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\telse if ( operator === 'not-' ) {\n\t\t\t\t// Add all but this breakpoint\n\t\t\t\tfor ( i=0, ien=breakpoints.length ; i<ien ; i++ ) {\n\t\t\t\t\tif ( breakpoints[i].name.indexOf( matched ) === -1 ) {\n\t\t\t\t\t\tadd( colIdx, breakpoints[i].name );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\n\t\t// Loop over each column and determine if it has a responsive control\n\t\t// class\n\t\tcolumns.each( function ( col, i ) {\n\t\t\tvar classNames = col.className.split(' ');\n\t\t\tvar hasClass = false;\n\n\t\t\t// Split the class name up so multiple rules can be applied if needed\n\t\t\tfor ( var k=0, ken=classNames.length ; k<ken ; k++ ) {\n\t\t\t\tvar className = classNames[k].trim();\n\n\t\t\t\tif ( className === 'all' ) {\n\t\t\t\t\t// Include in all\n\t\t\t\t\thasClass = true;\n\t\t\t\t\tcol.includeIn = $.map( breakpoints, function (a) {\n\t\t\t\t\t\treturn a.name;\n\t\t\t\t\t} );\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\telse if ( className === 'none' || col.never ) {\n\t\t\t\t\t// Include in none (default) and no auto\n\t\t\t\t\thasClass = true;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\telse if ( className === 'control' || className === 'dtr-control' ) {\n\t\t\t\t\t// Special column that is only visible, when one of the other\n\t\t\t\t\t// columns is hidden. This is used for the details control\n\t\t\t\t\thasClass = true;\n\t\t\t\t\tcol.control = true;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t$.each( breakpoints, function ( j, breakpoint ) {\n\t\t\t\t\t// Does this column have a class that matches this breakpoint?\n\t\t\t\t\tvar brokenPoint = breakpoint.name.split('-');\n\t\t\t\t\tvar re = new RegExp( '(min\\\\-|max\\\\-|not\\\\-)?('+brokenPoint[0]+')(\\\\-[_a-zA-Z0-9])?' );\n\t\t\t\t\tvar match = className.match( re );\n\n\t\t\t\t\tif ( match ) {\n\t\t\t\t\t\thasClass = true;\n\n\t\t\t\t\t\tif ( match[2] === brokenPoint[0] && match[3] === '-'+brokenPoint[1] ) {\n\t\t\t\t\t\t\t// Class name matches breakpoint name fully\n\t\t\t\t\t\t\tcolumn( i, breakpoint.name, match[1], match[2]+match[3] );\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if ( match[2] === brokenPoint[0] && ! match[3] ) {\n\t\t\t\t\t\t\t// Class name matched primary breakpoint name with no qualifier\n\t\t\t\t\t\t\tcolumn( i, breakpoint.name, match[1], match[2] );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\t// If there was no control class, then automatic sizing is used\n\t\t\tif ( ! hasClass ) {\n\t\t\t\tcol.auto = true;\n\t\t\t}\n\t\t} );\n\n\t\tthis.s.columns = columns;\n\t},\n\n\t/**\n\t * Update the cells to show the correct control class / button\n\t * @private\n\t */\n\t_controlClass: function ()\n\t{\n\t\tif ( this.c.details.type === 'inline' ) {\n\t\t\tvar dt = this.s.dt;\n\t\t\tvar columnsVis = this.s.current;\n\t\t\tvar firstVisible = $.inArray(true, columnsVis);\n\n\t\t\t// Remove from any cells which shouldn't have it\n\t\t\tdt.cells(\n\t\t\t\tnull,\n\t\t\t\tfunction(idx) {\n\t\t\t\t\treturn idx !== firstVisible;\n\t\t\t\t},\n\t\t\t\t{page: 'current'}\n\t\t\t)\n\t\t\t\t.nodes()\n\t\t\t\t.to$()\n\t\t\t\t.filter('.dtr-control')\n\t\t\t\t.removeClass('dtr-control');\n\n\t\t\tdt.cells(null, firstVisible, {page: 'current'})\n\t\t\t\t.nodes()\n\t\t\t\t.to$()\n\t\t\t\t.addClass('dtr-control');\n\t\t}\n\t},\n\n\t/**\n\t * Show the details for the child row\n\t *\n\t * @param  {DataTables.Api} row    API instance for the row\n\t * @param  {boolean}        update Update flag\n\t * @private\n\t */\n\t_detailsDisplay: function ( row, update )\n\t{\n\t\tvar that = this;\n\t\tvar dt = this.s.dt;\n\t\tvar details = this.c.details;\n\n\t\tif ( details && details.type !== false ) {\n\t\t\tvar res = details.display( row, update, function () {\n\t\t\t\treturn details.renderer(\n\t\t\t\t\tdt, row[0], that._detailsObj(row[0])\n\t\t\t\t);\n\t\t\t} );\n\n\t\t\tif ( res === true || res === false ) {\n\t\t\t\t$(dt.table().node()).triggerHandler( 'responsive-display.dt', [dt, row, res, update] );\n\t\t\t}\n\t\t}\n\t},\n\n\n\t/**\n\t * Initialisation for the details handler\n\t *\n\t * @private\n\t */\n\t_detailsInit: function ()\n\t{\n\t\tvar that    = this;\n\t\tvar dt      = this.s.dt;\n\t\tvar details = this.c.details;\n\n\t\t// The inline type always uses the first child as the target\n\t\tif ( details.type === 'inline' ) {\n\t\t\tdetails.target = 'td.dtr-control, th.dtr-control';\n\t\t}\n\n\t\t// Keyboard accessibility\n\t\tdt.on( 'draw.dtr', function () {\n\t\t\tthat._tabIndexes();\n\t\t} );\n\t\tthat._tabIndexes(); // Initial draw has already happened\n\n\t\t$( dt.table().body() ).on( 'keyup.dtr', 'td, th', function (e) {\n\t\t\tif ( e.keyCode === 13 && $(this).data('dtr-keyboard') ) {\n\t\t\t\t$(this).click();\n\t\t\t}\n\t\t} );\n\n\t\t// type.target can be a string jQuery selector or a column index\n\t\tvar target   = details.target;\n\t\tvar selector = typeof target === 'string' ? target : 'td, th';\n\n\t\tif ( target !== undefined || target !== null ) {\n\t\t\t// Click handler to show / hide the details rows when they are available\n\t\t\t$( dt.table().body() )\n\t\t\t\t.on( 'click.dtr mousedown.dtr mouseup.dtr', selector, function (e) {\n\t\t\t\t\t// If the table is not collapsed (i.e. there is no hidden columns)\n\t\t\t\t\t// then take no action\n\t\t\t\t\tif ( ! $(dt.table().node()).hasClass('collapsed' ) ) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Check that the row is actually a DataTable's controlled node\n\t\t\t\t\tif ( $.inArray( $(this).closest('tr').get(0), dt.rows().nodes().toArray() ) === -1 ) {\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\n\t\t\t\t\t// For column index, we determine if we should act or not in the\n\t\t\t\t\t// handler - otherwise it is already okay\n\t\t\t\t\tif ( typeof target === 'number' ) {\n\t\t\t\t\t\tvar targetIdx = target < 0 ?\n\t\t\t\t\t\t\tdt.columns().eq(0).length + target :\n\t\t\t\t\t\t\ttarget;\n\n\t\t\t\t\t\tif ( dt.cell( this ).index().column !== targetIdx ) {\n\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// $().closest() includes itself in its check\n\t\t\t\t\tvar row = dt.row( $(this).closest('tr') );\n\n\t\t\t\t\t// Check event type to do an action\n\t\t\t\t\tif ( e.type === 'click' ) {\n\t\t\t\t\t\t// The renderer is given as a function so the caller can execute it\n\t\t\t\t\t\t// only when they need (i.e. if hiding there is no point is running\n\t\t\t\t\t\t// the renderer)\n\t\t\t\t\t\tthat._detailsDisplay( row, false );\n\t\t\t\t\t}\n\t\t\t\t\telse if ( e.type === 'mousedown' ) {\n\t\t\t\t\t\t// For mouse users, prevent the focus ring from showing\n\t\t\t\t\t\t$(this).css('outline', 'none');\n\t\t\t\t\t}\n\t\t\t\t\telse if ( e.type === 'mouseup' ) {\n\t\t\t\t\t\t// And then re-allow at the end of the click\n\t\t\t\t\t\t$(this).trigger('blur').css('outline', '');\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}\n\t},\n\n\n\t/**\n\t * Get the details to pass to a renderer for a row\n\t * @param  {int} rowIdx Row index\n\t * @private\n\t */\n\t_detailsObj: function ( rowIdx )\n\t{\n\t\tvar that = this;\n\t\tvar dt = this.s.dt;\n\n\t\treturn $.map( this.s.columns, function( col, i ) {\n\t\t\t// Never and control columns should not be passed to the renderer\n\t\t\tif ( col.never || col.control ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tvar dtCol = dt.settings()[0].aoColumns[ i ];\n\n\t\t\treturn {\n\t\t\t\tclassName:   dtCol.sClass,\n\t\t\t\tcolumnIndex: i,\n\t\t\t\tdata:        dt.cell( rowIdx, i ).render( that.c.orthogonal ),\n\t\t\t\thidden:      dt.column( i ).visible() && !that.s.current[ i ],\n\t\t\t\trowIndex:    rowIdx,\n\t\t\t\ttitle:       dtCol.sTitle !== null ?\n\t\t\t\t\tdtCol.sTitle :\n\t\t\t\t\t$(dt.column(i).header()).text()\n\t\t\t};\n\t\t} );\n\t},\n\n\n\t/**\n\t * Find a breakpoint object from a name\n\t *\n\t * @param  {string} name Breakpoint name to find\n\t * @return {object}      Breakpoint description object\n\t * @private\n\t */\n\t_find: function ( name )\n\t{\n\t\tvar breakpoints = this.c.breakpoints;\n\n\t\tfor ( var i=0, ien=breakpoints.length ; i<ien ; i++ ) {\n\t\t\tif ( breakpoints[i].name === name ) {\n\t\t\t\treturn breakpoints[i];\n\t\t\t}\n\t\t}\n\t},\n\n\n\t/**\n\t * Re-create the contents of the child rows as the display has changed in\n\t * some way.\n\t *\n\t * @private\n\t */\n\t_redrawChildren: function ()\n\t{\n\t\tvar that = this;\n\t\tvar dt = this.s.dt;\n\n\t\tdt.rows( {page: 'current'} ).iterator( 'row', function ( settings, idx ) {\n\t\t\tvar row = dt.row( idx );\n\n\t\t\tthat._detailsDisplay( dt.row( idx ), true );\n\t\t} );\n\t},\n\n\n\t/**\n\t * Alter the table display for a resized viewport. This involves first\n\t * determining what breakpoint the window currently is in, getting the\n\t * column visibilities to apply and then setting them.\n\t *\n\t * @param  {boolean} forceRedraw Force a redraw\n\t * @private\n\t */\n\t_resize: function (forceRedraw)\n\t{\n\t\tvar that = this;\n\t\tvar dt = this.s.dt;\n\t\tvar width = $(window).innerWidth();\n\t\tvar breakpoints = this.c.breakpoints;\n\t\tvar breakpoint = breakpoints[0].name;\n\t\tvar columns = this.s.columns;\n\t\tvar i, ien;\n\t\tvar oldVis = this.s.current.slice();\n\n\t\t// Determine what breakpoint we are currently at\n\t\tfor ( i=breakpoints.length-1 ; i>=0 ; i-- ) {\n\t\t\tif ( width <= breakpoints[i].width ) {\n\t\t\t\tbreakpoint = breakpoints[i].name;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\t\n\t\t// Show the columns for that break point\n\t\tvar columnsVis = this._columnsVisiblity( breakpoint );\n\t\tthis.s.current = columnsVis;\n\n\t\t// Set the class before the column visibility is changed so event\n\t\t// listeners know what the state is. Need to determine if there are\n\t\t// any columns that are not visible but can be shown\n\t\tvar collapsedClass = false;\n\t\n\t\tfor ( i=0, ien=columns.length ; i<ien ; i++ ) {\n\t\t\tif ( columnsVis[i] === false && ! columns[i].never && ! columns[i].control && ! dt.column(i).visible() === false ) {\n\t\t\t\tcollapsedClass = true;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\t$( dt.table().node() ).toggleClass( 'collapsed', collapsedClass );\n\n\t\tvar changed = false;\n\t\tvar visible = 0;\n\n\t\tdt.columns().eq(0).each( function ( colIdx, i ) {\n\t\t\tif ( columnsVis[i] === true ) {\n\t\t\t\tvisible++;\n\t\t\t}\n\n\t\t\tif ( forceRedraw || columnsVis[i] !== oldVis[i] ) {\n\t\t\t\tchanged = true;\n\t\t\t\tthat._setColumnVis( colIdx, columnsVis[i] );\n\t\t\t}\n\t\t} );\n\n\t\tif ( changed ) {\n\t\t\tthis._redrawChildren();\n\n\t\t\t// Inform listeners of the change\n\t\t\t$(dt.table().node()).trigger( 'responsive-resize.dt', [dt, this.s.current] );\n\n\t\t\t// If no records, update the \"No records\" display element\n\t\t\tif ( dt.page.info().recordsDisplay === 0 ) {\n\t\t\t\t$('td', dt.table().body()).eq(0).attr('colspan', visible);\n\t\t\t}\n\t\t}\n\n\t\tthat._controlClass();\n\t},\n\n\n\t/**\n\t * Determine the width of each column in the table so the auto column hiding\n\t * has that information to work with. This method is never going to be 100%\n\t * perfect since column widths can change slightly per page, but without\n\t * seriously compromising performance this is quite effective.\n\t *\n\t * @private\n\t */\n\t_resizeAuto: function ()\n\t{\n\t\tvar dt = this.s.dt;\n\t\tvar columns = this.s.columns;\n\n\t\t// Are we allowed to do auto sizing?\n\t\tif ( ! this.c.auto ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Are there any columns that actually need auto-sizing, or do they all\n\t\t// have classes defined\n\t\tif ( $.inArray( true, $.map( columns, function (c) { return c.auto; } ) ) === -1 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Need to restore all children. They will be reinstated by a re-render\n\t\tif ( ! $.isEmptyObject( _childNodeStore ) ) {\n\t\t\t$.each( _childNodeStore, function ( key ) {\n\t\t\t\tvar idx = key.split('-');\n\n\t\t\t\t_childNodesRestore( dt, idx[0]*1, idx[1]*1 );\n\t\t\t} );\n\t\t}\n\n\t\t// Clone the table with the current data in it\n\t\tvar tableWidth   = dt.table().node().offsetWidth;\n\t\tvar columnWidths = dt.columns;\n\t\tvar clonedTable  = dt.table().node().cloneNode( false );\n\t\tvar clonedHeader = $( dt.table().header().cloneNode( false ) ).appendTo( clonedTable );\n\t\tvar clonedBody   = $( dt.table().body() ).clone( false, false ).empty().appendTo( clonedTable ); // use jQuery because of IE8\n\n\t\tclonedTable.style.width = 'auto';\n\n\t\t// Header\n\t\tvar headerCells = dt.columns()\n\t\t\t.header()\n\t\t\t.filter( function (idx) {\n\t\t\t\treturn dt.column(idx).visible();\n\t\t\t} )\n\t\t\t.to$()\n\t\t\t.clone( false )\n\t\t\t.css( 'display', 'table-cell' )\n\t\t\t.css( 'width', 'auto' )\n\t\t\t.css( 'min-width', 0 );\n\n\t\t// Body rows - we don't need to take account of DataTables' column\n\t\t// visibility since we implement our own here (hence the `display` set)\n\t\t$(clonedBody)\n\t\t\t.append( $(dt.rows( { page: 'current' } ).nodes()).clone( false ) )\n\t\t\t.find( 'th, td' ).css( 'display', '' );\n\n\t\t// Footer\n\t\tvar footer = dt.table().footer();\n\t\tif ( footer ) {\n\t\t\tvar clonedFooter = $( footer.cloneNode( false ) ).appendTo( clonedTable );\n\t\t\tvar footerCells = dt.columns()\n\t\t\t\t.footer()\n\t\t\t\t.filter( function (idx) {\n\t\t\t\t\treturn dt.column(idx).visible();\n\t\t\t\t} )\n\t\t\t\t.to$()\n\t\t\t\t.clone( false )\n\t\t\t\t.css( 'display', 'table-cell' );\n\n\t\t\t$('<tr/>')\n\t\t\t\t.append( footerCells )\n\t\t\t\t.appendTo( clonedFooter );\n\t\t}\n\n\t\t$('<tr/>')\n\t\t\t.append( headerCells )\n\t\t\t.appendTo( clonedHeader );\n\n\t\t// In the inline case extra padding is applied to the first column to\n\t\t// give space for the show / hide icon. We need to use this in the\n\t\t// calculation\n\t\tif ( this.c.details.type === 'inline' ) {\n\t\t\t$(clonedTable).addClass( 'dtr-inline collapsed' );\n\t\t}\n\t\t\n\t\t// It is unsafe to insert elements with the same name into the DOM\n\t\t// multiple times. For example, cloning and inserting a checked radio\n\t\t// clears the chcecked state of the original radio.\n\t\t$( clonedTable ).find( '[name]' ).removeAttr( 'name' );\n\n\t\t// A position absolute table would take the table out of the flow of\n\t\t// our container element, bypassing the height and width (Scroller)\n\t\t$( clonedTable ).css( 'position', 'relative' )\n\t\t\n\t\tvar inserted = $('<div/>')\n\t\t\t.css( {\n\t\t\t\twidth: 1,\n\t\t\t\theight: 1,\n\t\t\t\toverflow: 'hidden',\n\t\t\t\tclear: 'both'\n\t\t\t} )\n\t\t\t.append( clonedTable );\n\n\t\tinserted.insertBefore( dt.table().node() );\n\n\t\t// The cloned header now contains the smallest that each column can be\n\t\theaderCells.each( function (i) {\n\t\t\tvar idx = dt.column.index( 'fromVisible', i );\n\t\t\tcolumns[ idx ].minWidth =  this.offsetWidth || 0;\n\t\t} );\n\n\t\tinserted.remove();\n\t},\n\n\t/**\n\t * Get the state of the current hidden columns - controlled by Responsive only\n\t */\n\t_responsiveOnlyHidden: function ()\n\t{\n\t\tvar dt = this.s.dt;\n\n\t\treturn $.map( this.s.current, function (v, i) {\n\t\t\t// If the column is hidden by DataTables then it can't be hidden by\n\t\t\t// Responsive!\n\t\t\tif ( dt.column(i).visible() === false ) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\treturn v;\n\t\t} );\n\t},\n\n\t/**\n\t * Set a column's visibility.\n\t *\n\t * We don't use DataTables' column visibility controls in order to ensure\n\t * that column visibility can Responsive can no-exist. Since only IE8+ is\n\t * supported (and all evergreen browsers of course) the control of the\n\t * display attribute works well.\n\t *\n\t * @param {integer} col      Column index\n\t * @param {boolean} showHide Show or hide (true or false)\n\t * @private\n\t */\n\t_setColumnVis: function ( col, showHide )\n\t{\n\t\tvar dt = this.s.dt;\n\t\tvar display = showHide ? '' : 'none'; // empty string will remove the attr\n\n\t\t$( dt.column( col ).header() ).css( 'display', display );\n\t\t$( dt.column( col ).footer() ).css( 'display', display );\n\t\tdt.column( col ).nodes().to$().css( 'display', display );\n\n\t\t// If the are child nodes stored, we might need to reinsert them\n\t\tif ( ! $.isEmptyObject( _childNodeStore ) ) {\n\t\t\tdt.cells( null, col ).indexes().each( function (idx) {\n\t\t\t\t_childNodesRestore( dt, idx.row, idx.column );\n\t\t\t} );\n\t\t}\n\t},\n\n\n\t/**\n\t * Update the cell tab indexes for keyboard accessibility. This is called on\n\t * every table draw - that is potentially inefficient, but also the least\n\t * complex option given that column visibility can change on the fly. Its a\n\t * shame user-focus was removed from CSS 3 UI, as it would have solved this\n\t * issue with a single CSS statement.\n\t *\n\t * @private\n\t */\n\t_tabIndexes: function ()\n\t{\n\t\tvar dt = this.s.dt;\n\t\tvar cells = dt.cells( { page: 'current' } ).nodes().to$();\n\t\tvar ctx = dt.settings()[0];\n\t\tvar target = this.c.details.target;\n\n\t\tcells.filter( '[data-dtr-keyboard]' ).removeData( '[data-dtr-keyboard]' );\n\n\t\tif ( typeof target === 'number' ) {\n\t\t\tdt.cells( null, target, { page: 'current' } ).nodes().to$()\n\t\t\t\t.attr( 'tabIndex', ctx.iTabIndex )\n\t\t\t\t.data( 'dtr-keyboard', 1 );\n\t\t}\n\t\telse {\n\t\t\t// This is a bit of a hack - we need to limit the selected nodes to just\n\t\t\t// those of this table\n\t\t\tif ( target === 'td:first-child, th:first-child' ) {\n\t\t\t\ttarget = '>td:first-child, >th:first-child';\n\t\t\t}\n\n\t\t\t$( target, dt.rows( { page: 'current' } ).nodes() )\n\t\t\t\t.attr( 'tabIndex', ctx.iTabIndex )\n\t\t\t\t.data( 'dtr-keyboard', 1 );\n\t\t}\n\t}\n} );\n\n\n/**\n * List of default breakpoints. Each item in the array is an object with two\n * properties:\n *\n * * `name` - the breakpoint name.\n * * `width` - the breakpoint width\n *\n * @name Responsive.breakpoints\n * @static\n */\nResponsive.breakpoints = [\n\t{ name: 'desktop',  width: Infinity },\n\t{ name: 'tablet-l', width: 1024 },\n\t{ name: 'tablet-p', width: 768 },\n\t{ name: 'mobile-l', width: 480 },\n\t{ name: 'mobile-p', width: 320 }\n];\n\n\n/**\n * Display methods - functions which define how the hidden data should be shown\n * in the table.\n *\n * @namespace\n * @name Responsive.defaults\n * @static\n */\nResponsive.display = {\n\tchildRow: function ( row, update, render ) {\n\t\tif ( update ) {\n\t\t\tif ( $(row.node()).hasClass('parent') ) {\n\t\t\t\trow.child( render(), 'child' ).show();\n\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tif ( ! row.child.isShown()  ) {\n\t\t\t\trow.child( render(), 'child' ).show();\n\t\t\t\t$( row.node() ).addClass( 'parent' );\n\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\telse {\n\t\t\t\trow.child( false );\n\t\t\t\t$( row.node() ).removeClass( 'parent' );\n\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t},\n\n\tchildRowImmediate: function ( row, update, render ) {\n\t\tif ( (! update && row.child.isShown()) || ! row.responsive.hasHidden() ) {\n\t\t\t// User interaction and the row is show, or nothing to show\n\t\t\trow.child( false );\n\t\t\t$( row.node() ).removeClass( 'parent' );\n\n\t\t\treturn false;\n\t\t}\n\t\telse {\n\t\t\t// Display\n\t\t\trow.child( render(), 'child' ).show();\n\t\t\t$( row.node() ).addClass( 'parent' );\n\n\t\t\treturn true;\n\t\t}\n\t},\n\n\t// This is a wrapper so the modal options for Bootstrap and jQuery UI can\n\t// have options passed into them. This specific one doesn't need to be a\n\t// function but it is for consistency in the `modal` name\n\tmodal: function ( options ) {\n\t\treturn function ( row, update, render ) {\n\t\t\tif ( ! update ) {\n\t\t\t\t// Show a modal\n\t\t\t\tvar close = function () {\n\t\t\t\t\tmodal.remove(); // will tidy events for us\n\t\t\t\t\t$(document).off( 'keypress.dtr' );\n\t\t\t\t};\n\n\t\t\t\tvar modal = $('<div class=\"dtr-modal\"/>')\n\t\t\t\t\t.append( $('<div class=\"dtr-modal-display\"/>')\n\t\t\t\t\t\t.append( $('<div class=\"dtr-modal-content\"/>')\n\t\t\t\t\t\t\t.append( render() )\n\t\t\t\t\t\t)\n\t\t\t\t\t\t.append( $('<div class=\"dtr-modal-close\">&times;</div>' )\n\t\t\t\t\t\t\t.click( function () {\n\t\t\t\t\t\t\t\tclose();\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\t.append( $('<div class=\"dtr-modal-background\"/>')\n\t\t\t\t\t\t.click( function () {\n\t\t\t\t\t\t\tclose();\n\t\t\t\t\t\t} )\n\t\t\t\t\t)\n\t\t\t\t\t.appendTo( 'body' );\n\n\t\t\t\t$(document).on( 'keyup.dtr', function (e) {\n\t\t\t\t\tif ( e.keyCode === 27 ) {\n\t\t\t\t\t\te.stopPropagation();\n\n\t\t\t\t\t\tclose();\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t}\n\t\t\telse {\n\t\t\t\t$('div.dtr-modal-content')\n\t\t\t\t\t.empty()\n\t\t\t\t\t.append( render() );\n\t\t\t}\n\n\t\t\tif ( options && options.header ) {\n\t\t\t\t$('div.dtr-modal-content').prepend(\n\t\t\t\t\t'<h2>'+options.header( row )+'</h2>'\n\t\t\t\t);\n\t\t\t}\n\t\t};\n\t}\n};\n\n\nvar _childNodeStore = {};\n\nfunction _childNodes( dt, row, col ) {\n\tvar name = row+'-'+col;\n\n\tif ( _childNodeStore[ name ] ) {\n\t\treturn _childNodeStore[ name ];\n\t}\n\n\t// https://jsperf.com/childnodes-array-slice-vs-loop\n\tvar nodes = [];\n\tvar children = dt.cell( row, col ).node().childNodes;\n\tfor ( var i=0, ien=children.length ; i<ien ; i++ ) {\n\t\tnodes.push( children[i] );\n\t}\n\n\t_childNodeStore[ name ] = nodes;\n\n\treturn nodes;\n}\n\nfunction _childNodesRestore( dt, row, col ) {\n\tvar name = row+'-'+col;\n\n\tif ( ! _childNodeStore[ name ] ) {\n\t\treturn;\n\t}\n\n\tvar node = dt.cell( row, col ).node();\n\tvar store = _childNodeStore[ name ];\n\tvar parent = store[0].parentNode;\n\tvar parentChildren = parent.childNodes;\n\tvar a = [];\n\n\tfor ( var i=0, ien=parentChildren.length ; i<ien ; i++ ) {\n\t\ta.push( parentChildren[i] );\n\t}\n\n\tfor ( var j=0, jen=a.length ; j<jen ; j++ ) {\n\t\tnode.appendChild( a[j] );\n\t}\n\n\t_childNodeStore[ name ] = undefined;\n}\n\n\n/**\n * Display methods - functions which define how the hidden data should be shown\n * in the table.\n *\n * @namespace\n * @name Responsive.defaults\n * @static\n */\nResponsive.renderer = {\n\tlistHiddenNodes: function () {\n\t\treturn function ( api, rowIdx, columns ) {\n\t\t\tvar ul = $('<ul data-dtr-index=\"'+rowIdx+'\" class=\"dtr-details\"/>');\n\t\t\tvar found = false;\n\n\t\t\tvar data = $.each( columns, function ( i, col ) {\n\t\t\t\tif ( col.hidden ) {\n\t\t\t\t\tvar klass = col.className ?\n\t\t\t\t\t\t'class=\"'+ col.className +'\"' :\n\t\t\t\t\t\t'';\n\t\n\t\t\t\t\t$(\n\t\t\t\t\t\t'<li '+klass+' data-dtr-index=\"'+col.columnIndex+'\" data-dt-row=\"'+col.rowIndex+'\" data-dt-column=\"'+col.columnIndex+'\">'+\n\t\t\t\t\t\t\t'<span class=\"dtr-title\">'+\n\t\t\t\t\t\t\t\tcol.title+\n\t\t\t\t\t\t\t'</span> '+\n\t\t\t\t\t\t'</li>'\n\t\t\t\t\t)\n\t\t\t\t\t\t.append( $('<span class=\"dtr-data\"/>').append( _childNodes( api, col.rowIndex, col.columnIndex ) ) )// api.cell( col.rowIndex, col.columnIndex ).node().childNodes ) )\n\t\t\t\t\t\t.appendTo( ul );\n\n\t\t\t\t\tfound = true;\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\treturn found ?\n\t\t\t\tul :\n\t\t\t\tfalse;\n\t\t};\n\t},\n\n\tlistHidden: function () {\n\t\treturn function ( api, rowIdx, columns ) {\n\t\t\tvar data = $.map( columns, function ( col ) {\n\t\t\t\tvar klass = col.className ?\n\t\t\t\t\t'class=\"'+ col.className +'\"' :\n\t\t\t\t\t'';\n\n\t\t\t\treturn col.hidden ?\n\t\t\t\t\t'<li '+klass+' data-dtr-index=\"'+col.columnIndex+'\" data-dt-row=\"'+col.rowIndex+'\" data-dt-column=\"'+col.columnIndex+'\">'+\n\t\t\t\t\t\t'<span class=\"dtr-title\">'+\n\t\t\t\t\t\t\tcol.title+\n\t\t\t\t\t\t'</span> '+\n\t\t\t\t\t\t'<span class=\"dtr-data\">'+\n\t\t\t\t\t\t\tcol.data+\n\t\t\t\t\t\t'</span>'+\n\t\t\t\t\t'</li>' :\n\t\t\t\t\t'';\n\t\t\t} ).join('');\n\n\t\t\treturn data ?\n\t\t\t\t$('<ul data-dtr-index=\"'+rowIdx+'\" class=\"dtr-details\"/>').append( data ) :\n\t\t\t\tfalse;\n\t\t}\n\t},\n\n\ttableAll: function ( options ) {\n\t\toptions = $.extend( {\n\t\t\ttableClass: ''\n\t\t}, options );\n\n\t\treturn function ( api, rowIdx, columns ) {\n\t\t\tvar data = $.map( columns, function ( col ) {\n\t\t\t\tvar klass = col.className ?\n\t\t\t\t\t'class=\"'+ col.className +'\"' :\n\t\t\t\t\t'';\n\n\t\t\t\treturn '<tr '+klass+' data-dt-row=\"'+col.rowIndex+'\" data-dt-column=\"'+col.columnIndex+'\">'+\n\t\t\t\t\t\t'<td>'+col.title+':'+'</td> '+\n\t\t\t\t\t\t'<td>'+col.data+'</td>'+\n\t\t\t\t\t'</tr>';\n\t\t\t} ).join('');\n\n\t\t\treturn $('<table class=\"'+options.tableClass+' dtr-details\" width=\"100%\"/>').append( data );\n\t\t}\n\t}\n};\n\n/**\n * Responsive default settings for initialisation\n *\n * @namespace\n * @name Responsive.defaults\n * @static\n */\nResponsive.defaults = {\n\t/**\n\t * List of breakpoints for the instance. Note that this means that each\n\t * instance can have its own breakpoints. Additionally, the breakpoints\n\t * cannot be changed once an instance has been creased.\n\t *\n\t * @type {Array}\n\t * @default Takes the value of `Responsive.breakpoints`\n\t */\n\tbreakpoints: Responsive.breakpoints,\n\n\t/**\n\t * Enable / disable auto hiding calculations. It can help to increase\n\t * performance slightly if you disable this option, but all columns would\n\t * need to have breakpoint classes assigned to them\n\t *\n\t * @type {Boolean}\n\t * @default  `true`\n\t */\n\tauto: true,\n\n\t/**\n\t * Details control. If given as a string value, the `type` property of the\n\t * default object is set to that value, and the defaults used for the rest\n\t * of the object - this is for ease of implementation.\n\t *\n\t * The object consists of the following properties:\n\t *\n\t * * `display` - A function that is used to show and hide the hidden details\n\t * * `renderer` - function that is called for display of the child row data.\n\t *   The default function will show the data from the hidden columns\n\t * * `target` - Used as the selector for what objects to attach the child\n\t *   open / close to\n\t * * `type` - `false` to disable the details display, `inline` or `column`\n\t *   for the two control types\n\t *\n\t * @type {Object|string}\n\t */\n\tdetails: {\n\t\tdisplay: Responsive.display.childRow,\n\n\t\trenderer: Responsive.renderer.listHidden(),\n\n\t\ttarget: 0,\n\n\t\ttype: 'inline'\n\t},\n\n\t/**\n\t * Orthogonal data request option. This is used to define the data type\n\t * requested when Responsive gets the data to show in the child row.\n\t *\n\t * @type {String}\n\t */\n\torthogonal: 'display'\n};\n\n\n/*\n * API\n */\nvar Api = $.fn.dataTable.Api;\n\n// Doesn't do anything - work around for a bug in DT... Not documented\nApi.register( 'responsive()', function () {\n\treturn this;\n} );\n\nApi.register( 'responsive.index()', function ( li ) {\n\tli = $(li);\n\n\treturn {\n\t\tcolumn: li.data('dtr-index'),\n\t\trow:    li.parent().data('dtr-index')\n\t};\n} );\n\nApi.register( 'responsive.rebuild()', function () {\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\tif ( ctx._responsive ) {\n\t\t\tctx._responsive._classLogic();\n\t\t}\n\t} );\n} );\n\nApi.register( 'responsive.recalc()', function () {\n\treturn this.iterator( 'table', function ( ctx ) {\n\t\tif ( ctx._responsive ) {\n\t\t\tctx._responsive._resizeAuto();\n\t\t\tctx._responsive._resize();\n\t\t}\n\t} );\n} );\n\nApi.register( 'responsive.hasHidden()', function () {\n\tvar ctx = this.context[0];\n\n\treturn ctx._responsive ?\n\t\t$.inArray( false, ctx._responsive._responsiveOnlyHidden() ) !== -1 :\n\t\tfalse;\n} );\n\nApi.registerPlural( 'columns().responsiveHidden()', 'column().responsiveHidden()', function () {\n\treturn this.iterator( 'column', function ( settings, column ) {\n\t\treturn settings._responsive ?\n\t\t\tsettings._responsive._responsiveOnlyHidden()[ column ] :\n\t\t\tfalse;\n\t}, 1 );\n} );\n\n\n/**\n * Version information\n *\n * @name Responsive.version\n * @static\n */\nResponsive.version = '2.2.7';\n\n\n$.fn.dataTable.Responsive = Responsive;\n$.fn.DataTable.Responsive = Responsive;\n\n// Attach a listener to the document which listens for DataTables initialisation\n// events so we can automatically initialise\n$(document).on( 'preInit.dt.dtr', function (e, settings, json) {\n\tif ( e.namespace !== 'dt' ) {\n\t\treturn;\n\t}\n\n\tif ( $(settings.nTable).hasClass( 'responsive' ) ||\n\t\t $(settings.nTable).hasClass( 'dt-responsive' ) ||\n\t\t settings.oInit.responsive ||\n\t\t DataTable.defaults.responsive\n\t) {\n\t\tvar init = settings.oInit.responsive;\n\n\t\tif ( init !== false ) {\n\t\t\tnew Responsive( settings, $.isPlainObject( init ) ? init : {}  );\n\t\t}\n\t}\n} );\n\n\nreturn Responsive;\n}));\n","/*! DataTables 1.10.19\n * ©2008-2018 SpryMedia Ltd - datatables.net/license\n */\n\n/**\n * @summary     DataTables\n * @description Paginate, search and order HTML tables\n * @version     1.10.19\n * @file        jquery.dataTables.js\n * @author      SpryMedia Ltd\n * @contact     www.datatables.net\n * @copyright   Copyright 2008-2018 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\tfactory( jQuery, window, document );\n\t}\n}\n(function( $, window, document, undefined ) {\n\t\"use strict\";\n\n\t/**\n\t * DataTables is a plug-in for the jQuery Javascript library. It is a highly\n\t * flexible tool, based upon the foundations of progressive enhancement,\n\t * which will add advanced interaction controls to any HTML table. For a\n\t * full list of features please refer to\n\t * [DataTables.net](href=\"http://datatables.net).\n\t *\n\t * Note that the `DataTable` object is not a global variable but is aliased\n\t * to `jQuery.fn.DataTable` and `jQuery.fn.dataTable` through which it may\n\t * be  accessed.\n\t *\n\t *  @class\n\t *  @param {object} [init={}] Configuration object for DataTables. Options\n\t *    are defined by {@link DataTable.defaults}\n\t *  @requires jQuery 1.7+\n\t *\n\t *  @example\n\t *    // Basic initialisation\n\t *    $(document).ready( function {\n\t *      $('#example').dataTable();\n\t *    } );\n\t *\n\t *  @example\n\t *    // Initialisation with configuration options - in this case, disable\n\t *    // pagination and sorting.\n\t *    $(document).ready( function {\n\t *      $('#example').dataTable( {\n\t *        \"paginate\": false,\n\t *        \"sort\": false\n\t *      } );\n\t *    } );\n\t */\n\tvar DataTable = function ( options )\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 = $.isArray(data) && ( $.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\n\t\tvar _that = this;\n\t\tvar emptyInit = options === undefined;\n\t\tvar len = this.length;\n\n\t\tif ( emptyInit ) {\n\t\t\toptions = {};\n\t\t}\n\n\t\tthis.oApi = this.internal = _ext.internal;\n\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\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\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() ) );\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 = $.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 = $.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_fnLanguageCompat( json );\n\t\t\t\t\t\t_fnCamelToHungarian( defaults.oLanguage, json );\n\t\t\t\t\t\t$.extend( true, oLanguage, json );\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\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/>').appendTo($this);\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\tif ( oInit.bStateSave )\n\t\t\t{\n\t\t\t\tfeatures.bStateSave = true;\n\t\t\t\t_fnCallbackReg( oSettings, 'aoDrawCallback', _fnSaveState, 'state_save' );\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\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]/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 = /[',$£€¥%\\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\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\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' && ! $.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 );\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\t$.extend( oCol, oOptions );\n\t\t\t_fnMap( oCol, oOptions, \"sWidth\", \"sWidthOrig\" );\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 * Covert 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 * Covert 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\n\t\t\t\t\t\tif ( detectedType === 'html' ) {\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.targets !== undefined ?\n\t\t\t\t\tdef.targets :\n\t\t\t\t\tdef.aTargets;\n\t\n\t\t\t\tif ( ! $.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' 'sort')\n\t *  @returns {*} Cell data\n\t *  @memberof DataTable#oApi\n\t */\n\tfunction _fnGetCellData( settings, rowIdx, colIdx, type )\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\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\tfunction _fnGetObjectDataFn( mSource )\n\t{\n\t\tif ( $.isPlainObject( mSource ) )\n\t\t{\n\t\t\t/* Build an object of get functions, and wrap them in a single call */\n\t\t\tvar o = {};\n\t\t\t$.each( mSource, function (key, val) {\n\t\t\t\tif ( val ) {\n\t\t\t\t\to[key] = _fnGetObjectDataFn( val );\n\t\t\t\t}\n\t\t\t} );\n\t\n\t\t\treturn function (data, type, row, meta) {\n\t\t\t\tvar t = o[type] || o._;\n\t\t\t\treturn t !== undefined ?\n\t\t\t\t\tt(data, type, row, meta) :\n\t\t\t\t\tdata;\n\t\t\t};\n\t\t}\n\t\telse if ( mSource === null )\n\t\t{\n\t\t\t/* Give an empty string for rendering / sorting etc */\n\t\t\treturn function (data) { // type, row and meta also passed, but not used\n\t\t\t\treturn data;\n\t\t\t};\n\t\t}\n\t\telse if ( typeof mSource === 'function' )\n\t\t{\n\t\t\treturn function (data, type, row, meta) {\n\t\t\t\treturn mSource( data, type, row, meta );\n\t\t\t};\n\t\t}\n\t\telse if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||\n\t\t\t      mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )\n\t\t{\n\t\t\t/* If there is a . in the source string then the data source is in a\n\t\t\t * nested object so we loop over the data for each level to get the next\n\t\t\t * level down. On each loop we test for undefined, and if found immediately\n\t\t\t * return. This allows entire objects to be missing and sDefaultContent to\n\t\t\t * be used if defined, rather than throwing an error\n\t\t\t */\n\t\t\tvar fetchData = function (data, type, src) {\n\t\t\t\tvar arrayNotation, funcNotation, out, innerSrc;\n\t\n\t\t\t\tif ( src !== \"\" )\n\t\t\t\t{\n\t\t\t\t\tvar a = _fnSplitObjNotation( src );\n\t\n\t\t\t\t\tfor ( var i=0, iLen=a.length ; i<iLen ; i++ )\n\t\t\t\t\t{\n\t\t\t\t\t\t// Check if we are dealing with special notation\n\t\t\t\t\t\tarrayNotation = a[i].match(__reArray);\n\t\t\t\t\t\tfuncNotation = a[i].match(__reFn);\n\t\n\t\t\t\t\t\tif ( arrayNotation )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t// Array notation\n\t\t\t\t\t\t\ta[i] = a[i].replace(__reArray, '');\n\t\n\t\t\t\t\t\t\t// Condition allows simply [] to be passed in\n\t\t\t\t\t\t\tif ( a[i] !== \"\" ) {\n\t\t\t\t\t\t\t\tdata = data[ a[i] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tout = [];\n\t\n\t\t\t\t\t\t\t// Get the remainder of the nested object to get\n\t\t\t\t\t\t\ta.splice( 0, i+1 );\n\t\t\t\t\t\t\tinnerSrc = a.join('.');\n\t\n\t\t\t\t\t\t\t// Traverse each entry in the array getting the properties requested\n\t\t\t\t\t\t\tif ( $.isArray( data ) ) {\n\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\tout.push( fetchData( data[j], type, innerSrc ) );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\n\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// is used to join the strings together, otherwise an array is returned\n\t\t\t\t\t\t\tvar join = arrayNotation[0].substring(1, arrayNotation[0].length-1);\n\t\t\t\t\t\t\tdata = (join===\"\") ? out : out.join(join);\n\t\n\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// of the source requested, so we exit from the loop\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if ( funcNotation )\n\t\t\t\t\t\t{\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] ]();\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\tif ( data === null || data[ a[i] ] === undefined )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\treturn undefined;\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\t\t}\n\t\n\t\t\t\treturn data;\n\t\t\t};\n\t\n\t\t\treturn function (data, type) { // row and meta also passed, but not used\n\t\t\t\treturn fetchData( data, type, mSource );\n\t\t\t};\n\t\t}\n\t\telse\n\t\t{\n\t\t\t/* Array or flat object mapping */\n\t\t\treturn function (data, type) { // row and meta also passed, but not used\n\t\t\t\treturn data[mSource];\n\t\t\t};\n\t\t}\n\t}\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\tfunction _fnSetObjectDataFn( mSource )\n\t{\n\t\tif ( $.isPlainObject( mSource ) )\n\t\t{\n\t\t\t/* Unlike get, only the underscore (global) option is used for for\n\t\t\t * setting data since we don't know the type here. This is why an object\n\t\t\t * option is not documented for `mData` (which is read/write), but it is\n\t\t\t * for `mRender` which is read only.\n\t\t\t */\n\t\t\treturn _fnSetObjectDataFn( mSource._ );\n\t\t}\n\t\telse if ( mSource === null )\n\t\t{\n\t\t\t/* Nothing to do when the data source is null */\n\t\t\treturn function () {};\n\t\t}\n\t\telse if ( typeof mSource === 'function' )\n\t\t{\n\t\t\treturn function (data, val, meta) {\n\t\t\t\tmSource( data, 'set', val, meta );\n\t\t\t};\n\t\t}\n\t\telse if ( typeof mSource === 'string' && (mSource.indexOf('.') !== -1 ||\n\t\t\t      mSource.indexOf('[') !== -1 || mSource.indexOf('(') !== -1) )\n\t\t{\n\t\t\t/* Like the get, we need to get data from a nested object */\n\t\t\tvar setData = function (data, val, src) {\n\t\t\t\tvar a = _fnSplitObjNotation( src ), b;\n\t\t\t\tvar aLast = a[a.length-1];\n\t\t\t\tvar arrayNotation, funcNotation, o, innerSrc;\n\t\n\t\t\t\tfor ( var i=0, iLen=a.length-1 ; i<iLen ; i++ )\n\t\t\t\t{\n\t\t\t\t\t// Check if we are dealing with an array notation request\n\t\t\t\t\tarrayNotation = a[i].match(__reArray);\n\t\t\t\t\tfuncNotation = a[i].match(__reFn);\n\t\n\t\t\t\t\tif ( arrayNotation )\n\t\t\t\t\t{\n\t\t\t\t\t\ta[i] = a[i].replace(__reArray, '');\n\t\t\t\t\t\tdata[ a[i] ] = [];\n\t\n\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\tb = a.slice();\n\t\t\t\t\t\tb.splice( 0, i+1 );\n\t\t\t\t\t\tinnerSrc = b.join('.');\n\t\n\t\t\t\t\t\t// Traverse each entry in the array setting the properties requested\n\t\t\t\t\t\tif ( $.isArray( val ) )\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfor ( var j=0, jLen=val.length ; j<jLen ; j++ )\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\to = {};\n\t\t\t\t\t\t\t\tsetData( o, val[j], innerSrc );\n\t\t\t\t\t\t\t\tdata[ a[i] ].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{\n\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// isn't array data to be saved. Best that can be done\n\t\t\t\t\t\t\t// is to just save the value.\n\t\t\t\t\t\t\tdata[ a[i] ] = val;\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\t// The inner call to setData has already traversed through the remainder\n\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\treturn;\n\t\t\t\t\t}\n\t\t\t\t\telse if ( funcNotation )\n\t\t\t\t\t{\n\t\t\t\t\t\t// Function call\n\t\t\t\t\t\ta[i] = a[i].replace(__reFn, '');\n\t\t\t\t\t\tdata = data[ a[i] ]( val );\n\t\t\t\t\t}\n\t\n\t\t\t\t\t// If the nested object doesn't currently exist - since we are\n\t\t\t\t\t// trying to set the value - create it\n\t\t\t\t\tif ( data[ a[i] ] === null || data[ a[i] ] === undefined )\n\t\t\t\t\t{\n\t\t\t\t\t\tdata[ a[i] ] = {};\n\t\t\t\t\t}\n\t\t\t\t\tdata = data[ a[i] ];\n\t\t\t\t}\n\t\n\t\t\t\t// Last item in the input - i.e, the actual set\n\t\t\t\tif ( aLast.match(__reFn ) )\n\t\t\t\t{\n\t\t\t\t\t// Function call\n\t\t\t\t\tdata = data[ aLast.replace(__reFn, '') ]( val );\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\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// and assign the value. If it isn't used, then we get the result we want anyway\n\t\t\t\t\tdata[ aLast.replace(__reArray, '') ] = val;\n\t\t\t\t}\n\t\t\t};\n\t\n\t\t\treturn function (data, val) { // meta is also passed in, but not used\n\t\t\t\treturn setData( data, val, mSource );\n\t\t\t};\n\t\t}\n\t\telse\n\t\t{\n\t\t\t/* Array or flat object mapping */\n\t\t\treturn function (data, val) { // meta is also passed in, but not used\n\t\t\t\tdata[mSource] = val;\n\t\t\t};\n\t\t}\n\t}\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 = $.trim(cell.innerHTML);\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;\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\n\t\t\t\tnTd = nTrIn ? anTds[i] : document.createElement( oCol.sCellType );\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 ( (!nTrIn || 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\t// Remove once webkit bug 131819 and Chromium bug 365619 have been resolved\n\t\t// and deployed\n\t\trow.nTr.setAttribute( 'role', 'row' );\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\t\n\t\t/* ARIA role for the rows */\n\t \t$(thead).find('>tr').attr('role', 'row');\n\t\n\t\t/* Deal with the footer - add classes if required */\n\t\t$(thead).find('>tr>th, >tr>td').addClass( classes.sHeaderTH );\n\t\t$(tfoot).find('>tr>th, >tr>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 *  @memberof DataTable#oApi\n\t */\n\tfunction _fnDraw( 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 i, iLen, n;\n\t\tvar anRows = [];\n\t\tvar iRowCount = 0;\n\t\tvar asStripeClasses = oSettings.asStripeClasses;\n\t\tvar iStripes = asStripeClasses.length;\n\t\tvar iOpenRows = oSettings.aoOpenRows.length;\n\t\tvar oLang = oSettings.oLanguage;\n\t\tvar iInitDisplayStart = oSettings.iInitDisplayStart;\n\t\tvar bServerSide = _fnDataSource( oSettings ) == 'ssp';\n\t\tvar aiDisplay = oSettings.aiDisplay;\n\t\n\t\toSettings.bDrawing = true;\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\tvar iDisplayStart = oSettings._iDisplayStart;\n\t\tvar iDisplayEnd = oSettings.fnDisplayEnd();\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 && !_fnAjaxUpdate( oSettings ) )\n\t\t{\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 * 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 && $.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\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\": function (json) {\n\t\t\t\tvar error = json.error || json.sError;\n\t\t\t\tif ( error ) {\n\t\t\t\t\t_fnLog( oSettings, 0, error );\n\t\t\t\t}\n\t\n\t\t\t\toSettings.json = json;\n\t\t\t\tcallback( json );\n\t\t\t},\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\tif ( settings.bAjaxDataGet ) {\n\t\t\tsettings.iDraw++;\n\t\t\t_fnProcessingDisplay( settings, true );\n\t\n\t\t\t_fnBuildAjax(\n\t\t\t\tsettings,\n\t\t\t\t_fnAjaxParameters( settings ),\n\t\t\t\tfunction(json) {\n\t\t\t\t\t_fnAjaxUpdateDraw( settings, json );\n\t\t\t\t}\n\t\t\t);\n\t\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\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 ) {\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_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\tsettings.bAjaxDataGet = false;\n\t\t_fnDraw( settings );\n\t\n\t\tif ( ! settings._bInitComplete ) {\n\t\t\t_fnInitComplete( settings, json );\n\t\t}\n\t\n\t\tsettings.bAjaxDataGet = true;\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\tfunction _fnAjaxDataSrc ( oSettings, json )\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\t// Compatibility with 1.9-. In order to read from aaData, check if the\n\t\t// default has been changed, if not, check for aaData\n\t\tif ( dataSrc === 'data' ) {\n\t\t\treturn json.aaData || json[dataSrc];\n\t\t}\n\t\n\t\treturn dataSrc !== \"\" ?\n\t\t\t_fnGetObjectDataFn( dataSrc )( json ) :\n\t\t\tjson;\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() {\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\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} );\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( '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};\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 );\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 insenstive 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 insenstive 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 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 fomatters = DataTable.ext.type.search;\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\tif ( fomatters[ column.sType ] ) {\n\t\t\t\t\t\t\tcellData = fomatters[ column.sType ]( cellData );\n\t\t\t\t\t\t}\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]/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       = $.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.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// Add the ARIA grid role to the table\n\t\ttable.attr( 'role', 'grid' );\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(\n\t\t\tscrollY && scroll.bCollapse ? 'max-height' : 'height', \n\t\t\tscrollY\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}\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\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\theaderContent.push( nSizer.innerHTML );\n\t\t\theaderWidths.push( _fnStringToCss( $(nSizer).css('width') ) );\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\t// Only apply widths to the DataTables detected header cells - this\n\t\t\t// prevents complex headers from having contradictory sizes applied\n\t\t\tif ( $.inArray( nToSize, dtHeaderCells ) !== -1 ) {\n\t\t\t\tnToSize.style.width = headerWidths[i];\n\t\t\t}\n\t\t}, headerTrgEls );\n\t\n\t\t$(headerSrcEls).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 ( table.outerWidth() < 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.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 && ! $.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 ( $.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.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.oFeatures.bStateSave || settings.bDestroying )\n\t\t{\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\t_fnCallbackFire( settings, \"aoStateSaveParams\", 'stateSaveParams', [settings, state] );\n\t\n\t\tsettings.oSavedState = state;\n\t\tsettings.fnStateSaveCallback.call( settings.oInstance, settings, state );\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\tvar i, ien;\n\t\tvar columns = settings.aoColumns;\n\t\tvar loaded = function ( s ) {\n\t\t\tif ( ! s || ! s.time ) {\n\t\t\t\tcallback();\n\t\t\t\treturn;\n\t\t\t}\n\t\n\t\t\t// Allow custom and plug-in manipulation functions to alter the saved data set and\n\t\t\t// cancelling of loading by returning false\n\t\t\tvar abStateLoad = _fnCallbackFire( settings, 'aoStateLoadParams', 'stateLoadParams', [settings, s] );\n\t\t\tif ( $.inArray( false, abStateLoad ) !== -1 ) {\n\t\t\t\tcallback();\n\t\t\t\treturn;\n\t\t\t}\n\t\n\t\t\t// Reject old data\n\t\t\tvar duration = settings.iStateDuration;\n\t\t\tif ( duration > 0 && s.time < +new Date() - (duration*1000) ) {\n\t\t\t\tcallback();\n\t\t\t\treturn;\n\t\t\t}\n\t\n\t\t\t// Number of columns have changed - all bets are off, no restore of settings\n\t\t\tif ( s.columns && columns.length !== s.columns.length ) {\n\t\t\t\tcallback();\n\t\t\t\treturn;\n\t\t\t}\n\t\n\t\t\t// Store the saved state so it might be accessed at any time\n\t\t\tsettings.oLoadedState = $.extend( true, {}, s );\n\t\n\t\t\t// Restore key features - todo - for 1.11 this needs to be done by\n\t\t\t// subscribed events\n\t\t\tif ( s.start !== undefined ) {\n\t\t\t\tsettings._iDisplayStart    = s.start;\n\t\t\t\tsettings.iInitDisplayStart = s.start;\n\t\t\t}\n\t\t\tif ( s.length !== undefined ) {\n\t\t\t\tsettings._iDisplayLength   = s.length;\n\t\t\t}\n\t\n\t\t\t// Order\n\t\t\tif ( s.order !== undefined ) {\n\t\t\t\tsettings.aaSorting = [];\n\t\t\t\t$.each( s.order, function ( i, col ) {\n\t\t\t\t\tsettings.aaSorting.push( col[0] >= columns.length ?\n\t\t\t\t\t\t[ 0, col[1] ] :\n\t\t\t\t\t\tcol\n\t\t\t\t\t);\n\t\t\t\t} );\n\t\t\t}\n\t\n\t\t\t// Search\n\t\t\tif ( s.search !== undefined ) {\n\t\t\t\t$.extend( settings.oPreviousSearch, _fnSearchToHung( s.search ) );\n\t\t\t}\n\t\n\t\t\t// Columns\n\t\t\t//\n\t\t\tif ( s.columns ) {\n\t\t\t\tfor ( i=0, ien=s.columns.length ; i<ien ; i++ ) {\n\t\t\t\t\tvar col = s.columns[i];\n\t\n\t\t\t\t\t// Visibility\n\t\t\t\t\tif ( col.visible !== undefined ) {\n\t\t\t\t\t\tcolumns[i].bVisible = col.visible;\n\t\t\t\t\t}\n\t\n\t\t\t\t\t// Search\n\t\t\t\t\tif ( col.search !== undefined ) {\n\t\t\t\t\t\t$.extend( settings.aoPreSearchCols[i], _fnSearchToHung( col.search ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\n\t\t\t_fnCallbackFire( settings, 'aoStateLoaded', 'stateLoaded', [settings, s] );\n\t\t\tcallback();\n\t\t}\n\t\n\t\tif ( ! settings.oFeatures.bStateSave ) {\n\t\t\tcallback();\n\t\t\treturn;\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\tloaded( state );\n\t\t}\n\t\t// otherwise, wait for the loaded callback to be executed\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 ( $.isArray( name ) ) {\n\t\t\t$.each( name, function (i, val) {\n\t\t\t\tif ( $.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' && $.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).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\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 = settings.concat( a );\n\t\t\t}\n\t\t};\n\t\n\t\tif ( $.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\treturn this.map( function ( el ) {\n\t\t\t\treturn el[ prop ];\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\tj, jen,\n\t\t\tstruct, inner,\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 ] = typeof struct.val === 'function' ?\n\t\t\t\tmethodScoping( scope, struct.val, struct ) :\n\t\t\t\t$.isPlainObject( struct.val ) ?\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 ( $.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};\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}\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\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\t$.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\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 ?\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' ? $.trim(a[j]) : 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 fitler=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 ?\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 ( $.isArray( data ) && 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\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 ( $.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/></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\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}\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}\n\t\t\t\telse {\n\t\t\t\t\trow._details.detach();\n\t\t\t\t}\n\t\n\t\t\t\t__details_events( ctx[0] );\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-visibility'+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\t_fnDrawHead( settings, settings.aoHeader );\n\t\t_fnDrawHead( settings, settings.aoFooter );\n\t\n\t\t// Update colspan for no records display. Child rows and extensions will use their own\n\t\t// listeners to do this - only need to update the empty table item here\n\t\tif ( ! settings.aiDisplay.length ) {\n\t\t\t$(settings.nTBody).find('td[colspan]').attr('colspan', _fnVisbleColumns(settings));\n\t\t}\n\t\n\t\t_fnSaveState( settings );\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 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\t// Second loop once the first is done for events\n\t\t\tthis.iterator( 'column', function ( settings, column ) {\n\t\t\t\t_fnCallbackFire( settings, null, 'column-visibility', [settings, column, vis, calc] );\n\t\t\t} );\n\t\n\t\t\tif ( calc === undefined || calc ) {\n\t\t\t\tthis.columns.adjust();\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\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 = $( [].concat.apply([], 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// Row + column selector\n\t\tvar columns = this.columns( columnSelector );\n\t\tvar rows = this.rows( rowSelector );\n\t\tvar a, i, ien, j, jen;\n\t\n\t\tthis.iterator( 'table', function ( settings, idx ) {\n\t\t\ta = [];\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\t}, 1 );\n\t\n\t    // Now pass through the cell selector for options\n\t    var cells = this.cells( a, opts );\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 && ! $.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 $.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 orig      = settings.nTableWrapper.parentNode;\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\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} );\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.10.19\";\n\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\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\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 at 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},\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 *  @default Processing...\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\": \"Processing...\",\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 dislay 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 fro 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 * Note if draw should be blocked while getting data\n\t\t *  @type boolean\n\t\t *  @default true\n\t\t */\n\t\t\"bAjaxDataGet\": true,\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\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 compatiblity 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_asc_disabled\",\n\t\t\"sSortableDesc\": \"sorting_desc_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;\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 ( $.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 = '';\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\t\t\t\t\t\t\t\tbtnClass = button + (page > 0 ?\n\t\t\t\t\t\t\t\t\t\t'' : ' '+classes.sPageButtonDisabled);\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\t\t\t\t\t\t\t\tbtnClass = button + (page > 0 ?\n\t\t\t\t\t\t\t\t\t\t'' : ' '+classes.sPageButtonDisabled);\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\t\t\t\t\t\t\t\tbtnClass = button + (page < pages-1 ?\n\t\t\t\t\t\t\t\t\t\t'' : ' '+classes.sPageButtonDisabled);\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\t\t\t\t\t\t\t\tbtnClass = button + (page < pages-1 ?\n\t\t\t\t\t\t\t\t\t\t'' : ' '+classes.sPageButtonDisabled);\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 = 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': settings.iTabIndex,\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+']' ).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\tcolumn.sSortingClass +' '+\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\treturn typeof d === 'string' ?\n\t\t\td.replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\"/g, '&quot;') :\n\t\t\td;\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\tnumber: function ( thousands, decimal, precision, prefix, postfix ) {\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\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\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_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\n\t// jQuery access\n\t$.fn.dataTable = DataTable;\n\n\t// Provide access to the host jQuery object (circular reference)\n\tDataTable.$ = $;\n\n\t// Legacy aliases\n\t$.fn.dataTableSettings = DataTable.settings;\n\t$.fn.dataTableExt = DataTable.ext;\n\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\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\n\n\t// Information about events fired by DataTables - for documentation.\n\t/**\n\t * Draw event, fired whenever the table is redrawn on the page, at the same\n\t * point as fnDrawCallback. This may be useful for binding events or\n\t * performing calculations when the table is altered at all.\n\t *  @name DataTable#draw.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n\t */\n\n\t/**\n\t * Search event, fired when the searching applied to the table (using the\n\t * built-in global search, or column filters) is altered.\n\t *  @name DataTable#search.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n\t */\n\n\t/**\n\t * Page change event, fired when the paging of the table is altered.\n\t *  @name DataTable#page.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n\t */\n\n\t/**\n\t * Order event, fired when the ordering applied to the table is altered.\n\t *  @name DataTable#order.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n\t */\n\n\t/**\n\t * DataTables initialisation complete event, fired when the table is fully\n\t * drawn, including Ajax data loaded, if Ajax data is required.\n\t *  @name DataTable#init.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} oSettings DataTables settings object\n\t *  @param {object} json The JSON object request from the server - only\n\t *    present if client-side Ajax sourced data is used</li></ol>\n\t */\n\n\t/**\n\t * State save event, fired when the table has changed state a new state save\n\t * is required. This event allows modification of the state saving object\n\t * prior to actually doing the save, including addition or other state\n\t * properties (for plug-ins) or modification of a DataTables core property.\n\t *  @name DataTable#stateSaveParams.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} oSettings DataTables settings object\n\t *  @param {object} json The state information to be saved\n\t */\n\n\t/**\n\t * State load event, fired when the table is loading state from the stored\n\t * data, but prior to the settings object being modified by the saved state\n\t * - allowing modification of the saved state is required or loading of\n\t * state for a plug-in.\n\t *  @name DataTable#stateLoadParams.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} oSettings DataTables settings object\n\t *  @param {object} json The saved state information\n\t */\n\n\t/**\n\t * State loaded event, fired when state has been loaded from stored data and\n\t * the settings object has been modified by the loaded data.\n\t *  @name DataTable#stateLoaded.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} oSettings DataTables settings object\n\t *  @param {object} json The saved state information\n\t */\n\n\t/**\n\t * Processing event, fired when DataTables is doing some kind of processing\n\t * (be it, order, searcg or anything else). It can be used to indicate to\n\t * the end user that there is something happening, or that something has\n\t * finished.\n\t *  @name DataTable#processing.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} oSettings DataTables settings object\n\t *  @param {boolean} bShow Flag for if DataTables is doing processing or not\n\t */\n\n\t/**\n\t * Ajax (XHR) event, fired whenever an Ajax request is completed from a\n\t * request to made to the server for new data. This event is called before\n\t * DataTables processed the returned data, so it can also be used to pre-\n\t * process the data returned from the server, if needed.\n\t *\n\t * Note that this trigger is called in `fnServerData`, if you override\n\t * `fnServerData` and which to use this event, you need to trigger it in you\n\t * success function.\n\t *  @name DataTable#xhr.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n\t *  @param {object} json JSON returned from the server\n\t *\n\t *  @example\n\t *     // Use a custom property returned from the server in another DOM element\n\t *     $('#table').dataTable().on('xhr.dt', function (e, settings, json) {\n\t *       $('#status').html( json.status );\n\t *     } );\n\t *\n\t *  @example\n\t *     // Pre-process the data returned from the server\n\t *     $('#table').dataTable().on('xhr.dt', function (e, settings, json) {\n\t *       for ( var i=0, ien=json.aaData.length ; i<ien ; i++ ) {\n\t *         json.aaData[i].sum = json.aaData[i].one + json.aaData[i].two;\n\t *       }\n\t *       // Note no return - manipulate the data directly in the JSON object.\n\t *     } );\n\t */\n\n\t/**\n\t * Destroy event, fired when the DataTable is destroyed by calling fnDestroy\n\t * or passing the bDestroy:true parameter in the initialisation object. This\n\t * can be used to remove bound events, added DOM nodes, etc.\n\t *  @name DataTable#destroy.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n\t */\n\n\t/**\n\t * Page length change event, fired when number of records to show on each\n\t * page (the length) is changed.\n\t *  @name DataTable#length.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n\t *  @param {integer} len New length\n\t */\n\n\t/**\n\t * Column sizing has changed.\n\t *  @name DataTable#column-sizing.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n\t */\n\n\t/**\n\t * Column visibility has changed.\n\t *  @name DataTable#column-visibility.dt\n\t *  @event\n\t *  @param {event} e jQuery event object\n\t *  @param {object} o DataTables settings object {@link DataTable.models.oSettings}\n\t *  @param {int} column Column index\n\t *  @param {bool} vis `false` if column now hidden, or `true` if visible\n\t */\n\n\treturn $.fn.dataTable;\n}));\n"],"names":["$","window","document","undefined","DataTable","fn","dataTable","extend","defaults","dom","renderer","ext","classes","sWrapper","sFilterInput","sLengthSelect","sProcessing","pageButton","bootstrap","settings","host","idx","buttons","page","pages","btnDisplay","btnClass","activeEl","api","Api","oClasses","lang","oLanguage","oPaginate","aria","oAria","paginate","counter","attach","container","i","ien","node","button","clickHandler","e","preventDefault","currentTarget","hasClass","data","action","draw","length","isArray","sFirst","sPrevious","sNext","sLast","sPageButton","sTableId","append","iTabIndex","html","appendTo","oApi","_fnBindAction","find","activeElement","empty","children","factory","focus","Buttons","className","collection","tag","active","disabled","buttonLiner","text","dt","i18n","jszip","pdfmake","_jsZip","JSZip","_pdfMake","pdfMake","_saveAs","view","navigator","test","userAgent","doc","get_URL","URL","webkitURL","save_link","createElementNS","can_use_save_link","is_safari","HTMLElement","safari","is_chrome_ios","throw_outside","ex","setImmediate","setTimeout","revoke","file","revokeObjectURL","remove","auto_bom","blob","type","Blob","String","fromCharCode","FileSaver","name","no_auto_bom","object_url","filesaver","this","force","dispatch_all","event_types","event","concat","listener","call","dispatch","split","readyState","INIT","createObjectURL","href","download","MouseEvent","dispatchEvent","DONE","FileReader","reader","onloadend","url","result","replace","open","location","readAsDataURL","fs_error","FS_proto","prototype","msSaveOrOpenBlob","abort","WRITING","error","onwritestart","onprogress","onwrite","onabort","onerror","onwriteend","self","content","fileSave","_newLine","config","newline","match","_exportData","newLine","exportData","exportOptions","boundary","fieldBoundary","separator","fieldSeparator","reBoundary","RegExp","escapeChar","join","a","s","header","footer","body","push","str","rows","_isDuffSafari","indexOf","version","createCellPos","n","ordA","charCodeAt","len","Math","floor","_ieExcel","_serialiser","XMLSerializer","t","_addToZip","zip","obj","serializeToString","parseXML","excelStrings","each","val","isPlainObject","folder","worksheet","childNodes","attrs","attributes","attrName","nodeName","attrValue","nodeValue","value","removeAttribute","attr","createAttribute","setAttributeNode","_createNode","opts","tempNode","createElement","key","appendChild","createTextNode","_excelColWidth","col","lineSplit","max","point","toString","sort","b","_excelSpecials","style","fmt","d","copyHtml5","processing","that","info","exportInfo","output","hiddenDiv","css","height","width","overflow","position","top","left","title","messageTop","messageBottom","customize","textarea","queryCommandSupported","table","select","successful","execCommand","_","message","closest","close","off","on","keyCode","csvHtml5","bom","available","charset","characterSet","filename","extension","excelHtml5","currentRow","rowNode","rowPos","getXml","rels","relsGet","getElementsByTagName","xlsx","_rels","xl","addRow","row","r","cellId","cell","createEmptyCells","trim","j","jen","special","sheetName","_sheetname","customizeData","mergeCells","colspan","ref","parseFloat","ie","cols","prepend","min","customWidth","zipConfig","mimeType","generateAsync","then","generate","pdfHtml5","map","pageSize","pageOrientation","orientation","headerRows","layout","styles","tableHeader","bold","fontSize","color","fillColor","alignment","tableBodyEven","tableBodyOdd","tableFooter","defaultStyle","unshift","margin","pdf","createPdf","_link","_relToAbs","linkHost","pathname","protocol","search","print","decodeEntities","win","head","clone","toLowerCase","outerHTML","innerHTML","addClass","img","setAttribute","getAttribute","autoPrint","_infoTimer","_instCounter","_buttonCounter","_dtButtons","c","listenKeys","namespace","_constructor","_nodeToButton","conf","flag","klass","jqNode","toggleClass","add","base","_expandButton","_draw","disable","destroy","slice","buttonInsts","inst","splice","enable","removeClass","_nodeToHost","_removeKey","inArray","label","linerTag","inCollection","opt","dtSettings","_buttons","character","_keypress","_addKey","detach","inserter","attachTo","attachPoint","_resolveExtends","built","_buildButton","collectionDom","_collection","init","buttonDom","linerDom","triggerHandler","id","blur","liner","enabled","titleAttr","buttonContainer","get","ret","_buttonsHandled","run","click","shiftKey","altKey","ctrlKey","metaKey","recurse","toConfObject","loop","objArray","originalClassName","postfixButtons","prefixButtons","background","show","fade","fadeIn","fadeOut","instanceSelector","group","v","names","process","input","buttonSelector","insts","selector","nodeBuilder","baseIdx","nodes","indexes","filter","tabIndex","collectionParent","parents","hostPosition","tableContainer","multiLevel","insertPoint","trigger","collectionLayout","insertAfter","outerHeight","tableBottom","offset","bottomOverflow","listTop","listRight","outerWidth","tableRight","backgroundClassName","back","addBack","target","autoClose","copy","copyFlash","csv","csvFlash","excel","excelFlash","pdfFlash","pageLength","lengthMenu","aLengthMenu","vals","register","buttonGroup","res","iterator","ctx","_groupSelector","registerPlural","set","jq","groupSelector","context","pluck","unique","time","clearTimeout","options","_filename","_title","_message","_stringOrFunction","option","caption","eq","_exportTextarea","inOpts","columns","modifier","order","orthogonal","stripHtml","stripNewlines","format","strip","el","column","toArray","selected","any","rowIndexes","selectedCells","cells","render","cellNodes","cellCounter","oInit","feature","fnInit","cFeature","_display","Responsive","display","_original","modal","_modal","update","versionCheck","current","responsive","details","dtPrivateSettings","oldWindowWidth","innerWidth","_responsive","util","throttle","_resize","_fnCallbackReg","tr","index","to$","_setColumnVis","breakpoints","_classLogic","_resizeAuto","_detailsInit","_timer","_redrawChildren","rowIds","every","child","isShown","one","_detailsDisplay","_controlClass","adjust","_columnsVisiblity","breakpoint","columnIdx","priority","visible","auto","minWidth","includeIn","requiredWidth","scrolling","oScroll","bar","sY","sX","iBarWidth","usedWidth","offsetWidth","control","colIdx","showControl","never","aoColumns","responsivePriority","dataPriority","operator","matched","size","_find","classNames","k","ken","brokenPoint","re","columnsVis","firstVisible","_detailsObj","_tabIndexes","targetIdx","rowIdx","dtCol","sClass","columnIndex","hidden","rowIndex","sTitle","forceRedraw","oldVis","collapsedClass","changed","recordsDisplay","isEmptyObject","_childNodeStore","_childNodesRestore","clonedTable","cloneNode","clonedHeader","clonedBody","headerCells","clonedFooter","footerCells","removeAttr","inserted","clear","insertBefore","_responsiveOnlyHidden","showHide","removeData","Infinity","childRow","childRowImmediate","hasHidden","stopPropagation","parentChildren","parentNode","listHiddenNodes","ul","found","_childNodes","listHidden","tableAll","tableClass","li","parent","json","nTable","_ext","_Api","_api_register","_api_registerPlural","sSelector","oOpts","traditional","_fnSettingsFromNode","iApiIndex","fnAddData","redraw","flatten","fnAdjustColumnSizing","bRedraw","scroll","_fnScrollDraw","fnClearTable","fnClose","nTr","hide","fnDeleteRow","callback","aoData","fnDestroy","fnDraw","complete","fnFilter","sInput","iColumn","bRegex","bSmart","bShowGlobal","bCaseInsensitive","fnGetData","src","fnGetNodes","iRow","fnGetPosition","toUpperCase","columnVisible","fnIsOpen","fnOpen","mHtml","fnPageChange","mAction","fnSetColumnVis","iCol","bShow","fnSettings","fnSort","aaSort","fnSortListener","nNode","fnCallback","fnUpdate","mData","mRow","bAction","fnVersionCheck","_that","emptyInit","internal","_fnExternApiFunc","iLen","_fnExtend","sId","bInitHandedOff","$this","_fnCompatOpts","_fnCompatCols","_fnCamelToHungarian","allSettings","nTHead","nTFoot","bRetrieve","bDestroy","oInstance","_fnLog","_unique","oSettings","models","_fnLanguageCompat","iDisplayLength","_fnMap","oFeatures","fnDrawCallback","fnServerParams","fnStateSaveParams","fnStateLoadParams","fnStateLoaded","fnRowCallback","fnCreatedRow","fnHeaderCallback","fnFooterCallback","fnInitComplete","fnPreDrawCallback","rowIdFn","_fnGetObjectDataFn","rowId","_fnBrowserDetect","sTable","iInitDisplayStart","iDisplayStart","_iDisplayStart","iDeferLoading","bDeferLoading","tmp","_iRecordsDisplay","_iRecordsTotal","sUrl","ajax","dataType","success","_fnInitialise","asStripeClasses","sStripeOdd","sStripeEven","stripeClasses","rowOne","asDestroyStripes","aoColumnsInit","anThs","nThead","_fnDetectHeader","aoHeader","_fnGetUniqueThs","_fnAddColumn","_fnApplyColumnDefs","aoColumnDefs","oDef","_fnColumnOptions","features","loadedInit","aaSorting","sorting","asSorting","_fnSortingClasses","bSort","bSorted","aSort","_fnSortFlatten","sortedColumns","dir","_fnCallbackFire","_fnSortAria","_fnDataSource","bDeferRender","captions","_captionSide","thead","tbody","nTBody","tfoot","sNoFooter","aoFooter","aaData","_fnAddData","_fnAddTr","aiDisplay","aiDisplayMaster","bInitialised","bStateSave","_fnSaveState","_fnLoadState","_re_dic","_re_new_lines","_re_html","_re_date","_re_escape_regex","_re_formatted_numeric","_empty","_intVal","integer","parseInt","isNaN","isFinite","_numToDecimal","num","decimalPoint","_fnEscapeRegex","_isNumber","formatted","strType","_htmlNumeric","_isHtml","_stripHtml","_pluck","prop","prop2","out","_pluck_order","_range","start","end","_removeEmpty","sorted","last","_areAllUnique","again","_fnHungarianMap","o","newKey","_hungarianMap","user","hungarianKey","charAt","defaultDecimal","sDecimal","_addNumericSort","zeroRecords","sZeroRecords","sEmptyTable","sLoadingRecords","sInfoThousands","sThousands","decimal","freq","timer","frequency","now","Date","args","arguments","apply","escapeRegex","_fnCompatMap","knew","old","sScrollX","scrollX","searchCols","aoSearchCols","oSearch","dataSort","aDataSort","__browser","browser","scrollLeft","outer","inner","barWidth","clientWidth","bScrollOversize","bScrollbarLeft","round","bBounding","getBoundingClientRect","oBrowser","_fnReduce","inc","isSet","hasOwnProperty","nTh","oDefaults","oCol","oColumn","aoPreSearchCols","oOptions","th","sWidthOrig","mDataProp","sType","_sManualType","iDataSort","mDataSrc","mRender","attrTest","_bAttrSrc","_setter","rowData","meta","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","detectedType","cache","types","detect","_fnGetCellData","aoColDefs","aoCols","jLen","kLen","def","aTargets","targets","aDataIn","anTds","oData","oRow","_aData","aIds","_fnCreateTr","trs","_fnGetRowElements","iDraw","defaultContent","sDefaultContent","cellData","iDrawError","_fnSetCellData","__reArray","__reFn","_fnSplitObjNotation","mSource","fetchData","arrayNotation","funcNotation","innerSrc","substring","setData","aLast","_fnGetDataMaster","_fnClearTable","_fnDeleteIndex","iTarget","iTargetIndex","_fnInvalidate","cellWrite","removeChild","firstChild","anCells","_aSortData","_aFilterData","_fnRowAttributes","contents","tds","td","objectRead","setter","cellProcess","nextSibling","nTrIn","nTd","_DT_RowIndex","sCellType","_DT_CellIndex","fnCreatedCell","DT_RowClass","__rowc","DT_RowAttr","DT_RowData","_fnBuildHead","createHeader","_fnSortAttachListener","_fnRenderer","sHeaderTH","sFooterTH","nTf","_fnDrawHead","aoSource","bIncludeHidden","nLocalTr","iRowspan","iColspan","aoLocal","aApplied","iColumns","_fnDraw","aPreDraw","anRows","iRowCount","iStripes","oLang","aoOpenRows","bServerSide","bDrawing","fnRecordsDisplay","iDisplayEnd","fnDisplayEnd","_fnProcessingDisplay","bDestroying","_fnAjaxUpdate","iStart","iEnd","iDataIndex","nRow","sStripe","_sRowStripe","sZero","fnRecordsTotal","sRowEmpty","bFiltered","_fnReDraw","holdPosition","bFilter","_fnSort","_fnFilterComplete","oPreviousSearch","_drawHold","_fnAddOptionsHtml","holding","insert","nHolding","nTableWrapper","nTableReinsertBefore","featureNode","cOption","nNewNode","cNext","sAttr","aDom","sDom","sJUIHeader","sJUIFooter","aSplit","substr","bPaginate","bLengthChange","_fnFeatureHtmlLength","_fnFeatureHtmlFilter","bProcessing","_fnFeatureHtmlProcessing","_fnFeatureHtmlTable","bInfo","_fnFeatureHtmlInfo","_fnFeatureHtmlPaginate","aoFeatures","aanFeatures","replaceWith","aLayout","nCell","l","iColShifted","bUnique","nTrs","fnShiftCol","nHeader","aReturn","bSortCellsTop","_fnBuildAjax","rbracket","ajaxData","instance","jqXHR","newData","baseAjax","sError","sServerMethod","xhr","thrown","oAjaxData","fnServerData","sAjaxSource","bAjaxDataGet","_fnAjaxParameters","_fnAjaxUpdateDraw","dataProp","columnSearch","columnCount","preSearch","preColSearch","displayStart","displayLength","_iDisplayLength","param","sSearch","regex","sName","searchable","bSearchable","orderable","legacy","compat","modern","_fnAjaxDataSrc","recordsTotal","recordsFiltered","_bInitComplete","_fnInitComplete","dataSrc","sAjaxDataProp","tableId","language","previousSearch","f","sFilter","searchFn","searchDelay","jqFilter","sSearchPlaceholder","_fnThrottle","ev","oInput","iForce","oPrevSearch","aoPrevSearch","fnSaveFilter","oFilter","fnRegex","bEscapeRegex","_fnFilter","_fnFilterColumn","_fnFilterCustom","filters","displayRows","merge","searchStr","smart","caseInsensitive","rpSearch","_fnFilterCreateSearch","invalidated","prevSearch","displayMaster","filtered","_fnFilterData","_sFilterRow","word","m","__filter_div","__filter_div_textContent","textContent","filterData","fomatters","wasInvalidated","innerText","_fnSearchToCamel","_fnSearchToHung","tid","sInfo","aoDrawCallback","_fnUpdateInfo","total","sInfoEmpty","sInfoFiltered","_fnInfoMacros","sInfoPostFix","fnInfoCallback","formatter","fnFormatNumber","all","ceil","iAjaxStart","deferLoading","_fnStringToCss","aData","_fnLengthChange","_fnLengthOverflow","menu","d2","lengths","Option","div","sLength","sLengthMenu","sPaginationType","plugin","pager","sPaging","p","visRecords","_fnPageChange","records","scrollY","captionSide","headerClone","footerClone","_div","scroller","sScrollWrapper","sScrollHead","border","sScrollHeadInner","sXInner","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","tableEl","tableStyle","ie67","dtHeaderCells","headerWidths","footerWidths","headerContent","footerContent","zeroOut","nSizer","paddingTop","paddingBottom","borderTopWidth","borderBottomWidth","scrollBarVis","scrollHeight","clientHeight","prependTo","_fnApplyToChildren","offsetHeight","nToSize","iOuterWidth","bScrolling","padding","scrollTop","an1","an2","nNode1","nNode2","nodeType","__re_html_remove","visibleColumns","tableWidthAttr","userInputs","styleWidth","_fnConvertToWidth","tmpTable","_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","nextSort","sSortAscending","sSortDescending","_fnSortListener","nextSortIdx","next","bSortMulti","sortIdx","oldSort","aLastSort","sortClass","sSortColumn","bSortClasses","customData","customSort","sSortDataType","state","oSavedState","fnStateSaveCallback","loaded","abStateLoad","duration","iStateDuration","oLoadedState","fnStateLoadCallback","level","msg","tn","console","log","sErrMode","errMode","alert","Error","mappedName","extender","breakRefs","which","sStore","callbackArr","eventName","reverse","Event","__apiStruct","__arrayProto","Array","ctxSettings","mixed","tables","_toSettings","count","alwaysNew","items","item","apiInst","_selector_row_indexes","apiSelector","lastIndexOf","pop","reduce","reduceRight","shift","toJQuery","scope","__dt_wrapper","struct","methodScoping","struc","methodExt","propExt","method","heir","pluralName","singularName","__table_selector","paging","__reload","resetPaging","_selector_run","selectFn","selectorType","_selector_opts","_selector_first","displayFiltered","displayFilteredMap","sel","selInt","cellIdx","rowObj","__row_selector","hash","thatIdx","loopRow","loopCells","newRows","modRows","__details_remove","_details","_detailsShow","__details_display","__details_events","drawEvent","colvisEvent","destroyEvent","_child_obj","_child_mth","created","colSpan","__details_add","__re_column_selector","__columnData","r1","r2","visColumns","jqResult","__column_selector","calc","__setColumnVis","rowSelector","columnSelector","allCells","fnSelector","__cell_selector","caseInsen","iThis","iThat","aThis","aThat","isDataTable","fnIsDataTable","is","foot","fnTables","camelToHungarian","jqRows","orig","jqTable","jqTbody","jqWrapper","removedMethod","sDestroyWidth","arg1","arg2","arg3","arg4","token","plural","resolved","toFormat","JSON","parse","sessionStorage","localStorage","getItem","setItem","stringify","builder","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","sPageButtonDisabled","sPageButtonActive","parsed","string","__numericReplace","decimalPlace","re1","re2","ts","sSortAsc","sSortDesc","jqueryui","sSortJUIWrapper","sSortIcon","sSortJUIAsc","sSortJUIDesc","__htmlEscapeEntities","number","thousands","precision","prefix","postfix","negative","flo","toFixed","abs","intPart","floatPart","_fnNodeToDataIndex","_fnNodeToColumnIndex","_fnCalculateEnd","dataTableSettings","dataTableExt"],"sourceRoot":""}